Fix NPE for server relaunch

be restored.

ModLoader compatibility is not yet assured, there are some wrapper classes that
need re-writing first

.gitattributes

@@ -1,7 +1 @@
-* text eol=lf
-*.bat text eol=crlf
-*.patch text
-*.png binary
-*.exe binary
-*.dll binary
-*.zip binary
+* text=auto

.gitignore

@@ -1,7 +1,12 @@
-*.DS_Store
-/logs/
-/*.pyc
-/forge-*/
-/patches-old/
-/mcp/
-/eclipse/
+/bin
+/minecraft_server
+/mods
+/fmlbuild.properties
+/fmlversion.properties
+/difflist.txt
+/.metadata/
+/eclipse/.metadata/
+/target
+fmlbranding.properties
+/fernflower.zip
+/commands.py.bck

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "fml"]
-	path = fml
-	url = https://github.com/MinecraftForge/FML.git

LICENSE-fml.txt

@@ -0,0 +1,467 @@
+This minecraft mod, Forge Mod Loader, including all parts herein, is licensed
+under the GNU LGPL v2.1 or later.
+
+Homepage: https://github.com/cpw/FML
+
+This software includes portions from the Apache Maven project at
+http://maven.apache.org/ specifically the ComparableVersion.java code. It is
+included based on guidelines at
+http://www.softwarefreedom.org/resources/2007/gpl-non-gpl-collaboration.html
+with notices intact. The only change is a non-functional change of package name.
+
+========
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS

MANIFEST.MF

@@ -1,6 +0,0 @@
-Manifest-Version: 1.0
-Ant-Version: Apache Ant 1.8.2
-Created-By: 1.7.0_09-b30 (Oracle Corporation)
-Main-Class: net.minecraft.server.MinecraftServer
-Class-Path: minecraft_server.jar
-

applypatches.py

@@ -0,0 +1,14 @@
+import os, sys
+                    
+def main():
+    fml_dir = os.path.abspath(sys.argv[1])
+    work_dir = os.path.normpath(sys.argv[2])
+    mcp_dir = os.path.normpath(sys.argv[3])
+    
+    sys.path.append(os.path.join(fml_dir, 'install'))
+    from fml import apply_fml_patches
+    
+    apply_fml_patches(fml_dir, mcp_dir, work_dir, False)
+        
+if __name__ == '__main__':
+    main()

build.py

@@ -1,34 +0,0 @@
-import os, os.path, sys
-from optparse import OptionParser
-
-forge_dir = os.path.dirname(os.path.abspath(__file__))
-mcp_dir = os.path.abspath('..')
-
-from forge import build_forge_dev
-
-def main():
-    
-    parser = OptionParser()
-    parser.add_option('-m', '--mcp-dir', action='store', dest='mcp_dir', help='MCP Path', default=None)
-    parser.add_option('-b', '--build', action='store', dest='build', help='Build number', default=None)
-    options, _ = parser.parse_args()
-    
-    build_num = 0
-    if not options.build is None:
-        try:
-            build_num = int(options.build)
-        except:
-            pass
-    
-    fml_dir = os.path.join(forge_dir, 'fml')
-    mcp_dir = os.path.join(forge_dir, 'mcp')
-
-    if not options.mcp_dir is None:
-        mcp_dir = os.path.abspath(options.mcp_dir)
-    elif os.path.isfile(os.path.join('..', 'runtime', 'commands.py')):
-        mcp_dir = os.path.abspath('..')
-        
-    sys.exit(build_forge_dev(mcp_dir, forge_dir, fml_dir, build_num))
-    
-if __name__ == '__main__':
-    main()

build.xml

@@ -0,0 +1,396 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- ======================================================================
+     30 Mar 2012 13:35:40
+
+     FML
+     The Forge Mod Loader
+
+     cpw
+     ====================================================================== -->
+<project name="FML" default="jenkinsbuild">
+  <description>The Forge Mod Loader</description>
+  <macrodef name="side">
+    <attribute name="prop" />
+    <attribute name="src" />
+    <attribute name="side" />
+    <sequential>
+      <property name="@{prop}" value="${@{side}.@{src}}" />
+      <condition property="is.client">
+        <equals arg1="@{side}" arg2="client" />
+      </condition>
+      <condition property="is.server">
+        <equals arg1="@{side}" arg2="server" />
+      </condition>
+    </sequential>
+  </macrodef>
+  <target name="writeversion" depends="buildenvsetup">
+    <exec executable="${python.exe}" dir="${basedir}" failonerror="true">
+      <arg value="${basedir}/getversion.py" />
+      <arg value="${mcp.home}" />
+    </exec>
+    <propertyfile file="fmlversion.properties">
+      <entry key="fmlbuild.build.number" type="int" value="${version.build}"/>
+    </propertyfile>
+  </target>
+
+  <target name="buildenvsetup">
+    <tstamp>
+      <format pattern="yyMMddHHmmss" property="timestamp" />
+    </tstamp>
+    <property environment="env" />
+    <property file="fmlbuild.properties" />
+    <property name="modname" value="fml" />
+    <condition property="dev.home" value="${env.WORKSPACE}" else="${default.dev.home}">
+      <isset property="env.WORKSPACE" />
+    </condition>
+    <condition property="mcp.home" value="${env.WORKSPACE}/mcpworkspace" else="${default.mcp.home}">
+      <isset property="env.WORKSPACE" />
+    </condition>
+    <condition property="python.exe" value="${mcp.home}/runtime/bin/python/python_mcp" else="python">
+      <os family="Windows" />
+    </condition>
+    <property name="mcp.obfoutput" location="${mcp.home}/reobf" />
+    <property name="client.mcp.obfoutput" location="${mcp.obfoutput}/minecraft" />
+    <property name="server.mcp.obfoutput" location="${mcp.obfoutput}/minecraft_server" />
+    <property name="mcp.srcdir" location="${mcp.home}/src" />
+    <property name="common.mcp.srcdir" location="${mcp.srcdir}/common" />
+    <property name="client.mcp.srcdir" location="${mcp.srcdir}/minecraft" />
+    <property name="server.mcp.srcdir" location="${mcp.srcdir}/minecraft_server" />
+    <property name="clean.mcp.srcdir" location="${mcp.home}/src-base" />
+    <property name="patch.mcp.srcdir" location="${mcp.home}/src-work" />
+    <property name="tmp.mcp.srcdir" location="${mcp.home}/src-tmp" />
+    <property name="renamed.mcp.srcdir" location="${mcp.home}/src-renamed" />
+    <property name="common.src.dir" location="${basedir}/common" />
+    <property name="client.src.dir" location="${basedir}/client" />
+    <property name="server.src.dir" location="${basedir}/server" />
+    <property name="patch.src.dir" location="${basedir}/patches" />
+    <property name="fml.conf.dir" location="${basedir}/conf" />
+    <condition property="version.build" value="${env.BUILD_NUMBER}" else="1">
+      <isset property="env.BUILD_NUMBER" />
+    </condition>
+  </target>
+
+  <target name="makeversion" depends="buildenvsetup">
+    <antcall target="writeversion" />
+    <property file="fmlversion.properties" />
+    <property name="build.number" value="${fmlbuild.major.number}.${fmlbuild.minor.number}.${fmlbuild.revision.number}" />
+    <property name="version.major" value="${fmlbuild.major.number}" />
+    <property name="version.minor" value="${fmlbuild.minor.number}" />
+    <property name="version.rev" value="${fmlbuild.revision.number}" />
+    <property name="version" value="${version.major}.${version.minor}.${version.rev}.${version.build}" />
+  </target>
+
+  <target name="clean" depends="buildenvsetup">
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${mcp.home}/runtime/cleanup.py" />
+      <arg value="-f" />
+    </exec>
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${mcp.home}/runtime/decompile.py" />
+      <arg value="-d" />
+      <arg value="-n" />
+    </exec>
+  </target>
+
+  <target name="buildandreobfmcp" depends="buildenvsetup,recompile">
+    <exec executable="${python.exe}" dir="${mcp.home}" failonerror="true">
+      <arg value="${mcp.home}/runtime/reobfuscate.py" />
+    </exec>
+  	<fail message="Reobfuscation failed">
+  		<condition>
+  	        <not>
+  	        	<and>
+  	        	  <available file="${mcp.home}/temp/server.md5"/>
+                  <available file="${mcp.home}/temp/server_reobf.md5"/>
+  	        	  <available file="${mcp.home}/temp/client.md5"/>
+                  <available file="${mcp.home}/temp/client_reobf.md5"/>
+  	        	</and>
+  	        </not>
+  		</condition>
+  	</fail>
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${basedir}/generatechangedfilelist.py"/>
+      <arg value="${mcp.home}"/>
+      <arg value="${basedir}/difflist.txt"/>
+    </exec>
+  </target>
+  
+  <target name="recompile" depends="buildenvsetup">
+    <exec executable="${python.exe}" dir="${mcp.home}" failonerror="true">
+      <arg value="${mcp.home}/runtime/recompile.py" />
+    </exec>
+  	<fail message="Compilation failed">
+  		<condition>
+  	        <not>
+  	        	<and>
+  	        	  <available file="${mcp.home}/bin/minecraft/net/minecraft/client/Minecraft.class"/>
+                  <available file="${mcp.home}/bin/minecraft_server/net/minecraft/server/MinecraftServer.class"/>
+  	        	</and>
+  	        </not>
+  		</condition>
+  	</fail>
+  </target>
+
+  <target name="merge-client" depends="buildenvsetup">
+    <copy todir="${client.mcp.srcdir}" overwrite="true" verbose="true">
+      <fileset dir="${client.src.dir}" includes="**/*.java" />
+    </copy>
+  </target>
+
+  <target name="merge-server" depends="buildenvsetup">
+    <copy todir="${server.mcp.srcdir}" overwrite="true" verbose="true">
+      <fileset dir="${server.src.dir}" includes="**/*.java" />
+    </copy>
+  </target>
+
+  <target name="merge-common">
+    <copy todir="${common.mcp.srcdir}" overwrite="true" verbose="true">
+      <fileset dir="${common.src.dir}" includes="**/*.java" />
+    </copy>
+  </target>
+  
+  <target name="merge-source" depends="buildenvsetup,merge-client,merge-server,merge-common" />
+
+  <target name="build-client" depends="buildenvsetup,merge-client,merge-common,buildandreobfmcp,makeversion">
+    <antcall target="extract-built-jar">
+      <param name="side" value="client" />
+    </antcall>
+  </target>
+
+  <target name="build-server" depends="buildenvsetup,merge-server,merge-common,buildandreobfmcp,makeversion">
+    <antcall target="extract-built-jar">
+      <param name="side" value="server" />
+    </antcall>
+  </target>
+
+  <target name="extract-built-jar">
+    <side prop="output" src="mcp.obfoutput" side="${side}" />
+    <property name="jarname" value="${modname}-${side}-${version}" />
+    <mkdir dir="${basedir}/target" />
+    <zip destfile="${basedir}/target/${jarname}.zip">
+      <fileset dir="${output}" includes="**/*.class" />
+      <zipfileset dir="${basedir}" includes="fmlversion.properties"/>
+      <zipfileset dir="${basedir}" includes="LICENSE-fml.txt" />
+      <zipfileset dir="${basedir}" includes="install/CREDITS-fml.txt" fullpath="CREDITS-fml.txt"/>
+      <zipfileset dir="${common.src.dir}" includes="*.cfg" />
+      <mappedresources>
+        <concat>
+          <fileset dir="${basedir}/install" includes="README.txt" />
+          <filterchain>
+            <replacetokens>
+              <token key="MAJOR" value="${version.major}" />
+              <token key="MINOR" value="${version.minor}" />
+              <token key="REV" value="${version.rev}" />
+              <token key="BUILD" value="${version.build}" />
+              <token key="MCVERSION" value="${version.minecraft}" />
+            </replacetokens>
+          </filterchain>
+        </concat>
+        <mergemapper to="README-fml.txt" />
+      </mappedresources>
+    </zip>
+  </target>
+
+  <target name="build-universal">
+    <property name="universal.jarname" value="${modname}-universal-${version}" />
+    <mkdir dir="${basedir}/target" />
+    <jar destfile="${basedir}/target/${universal.jarname}.zip">
+      <manifest>
+        <attribute name="Main-Class" value="net.minecraft.server.MinecraftServer"/>
+      </manifest>
+      <fileset dir="${server.mcp.obfoutput}" includes="**/*.class" />
+      <fileset dir="${client.mcp.obfoutput}" includes="**/*.class" />
+      <zipfileset dir="${basedir}" includes="fmlversion.properties"/>
+      <zipfileset dir="${basedir}" includes="LICENSE-fml.txt" />
+      <zipfileset dir="${basedir}" includes="install/CREDITS-fml.txt" fullpath="CREDITS-fml.txt"/>
+      <zipfileset dir="${common.src.dir}" includes="*.cfg" />
+      <mappedresources>
+        <concat>
+          <fileset dir="${basedir}/install" includes="README.txt" />
+          <filterchain>
+            <replacetokens>
+              <token key="MAJOR" value="${version.major}" />
+              <token key="MINOR" value="${version.minor}" />
+              <token key="REV" value="${version.rev}" />
+              <token key="BUILD" value="${version.build}" />
+              <token key="MCVERSION" value="${version.minecraft}" />
+            </replacetokens>
+          </filterchain>
+        </concat>
+        <mergemapper to="README-fml.txt" />
+      </mappedresources>
+    </jar>
+  </target>
+
+  <target name="build-source-pack" depends="makeversion">
+    <property name="srcpack.jarname" value="${modname}-src-${version}" />
+    <zip destfile="${basedir}/target/${srcpack.jarname}.zip">
+      <zipfileset dir="${basedir}" includes="LICENSE-fml.txt,difflist.txt,commands.patch,mcp_merge.cfg" prefix="fml" />
+      <zipfileset dir="${common.src.dir}" includes="**/*.java" prefix="fml/common" />
+      <zipfileset dir="${client.src.dir}" includes="**/*.java" prefix="fml/client" />
+      <zipfileset dir="${server.src.dir}" includes="**/*.java" prefix="fml/server" />
+      <zipfileset dir="${basedir}" includes="fmlversion.properties" prefix="fml/common" />
+      <zipfileset dir="${common.src.dir}" includes="*.cfg" prefix="fml/common" />
+      <zipfileset dir="${patch.src.dir}" includes="**/*.patch" prefix="fml/patches" />
+      <zipfileset dir="${fml.conf.dir}" prefix="fml/conf" />
+      <mappedresources>
+        <concat>
+          <fileset dir="${basedir}/install" includes="README.txt" />
+          <filterchain>
+            <replacetokens>
+              <token key="MAJOR" value="${version.major}" />
+              <token key="MINOR" value="${version.minor}" />
+              <token key="REV" value="${version.rev}" />
+              <token key="BUILD" value="${version.build}" />
+              <token key="MCVERSION" value="${version.minecraft}" />
+            </replacetokens>
+          </filterchain>
+        </concat>
+        <mergemapper to="fml/README-fml.txt" />
+      </mappedresources>
+      <zipfileset dir="${basedir}/install" excludes="README.txt,fml.pyc" prefix="fml" />
+    </zip>
+  </target>
+
+  <target name="build" depends="buildenvsetup,merge-server,merge-client,merge-common,build-server,build-client,build-universal,build-source-pack" />
+
+  <target name="jenkinsbuild" depends="buildenvsetup,jenkinsfmldecompile,patch,build"/>
+
+  <target name="patch" depends="buildenvsetup">
+    <exec executable="${python.exe}" dir="${basedir}">
+      <arg value="${basedir}/applypatches.py" />
+      <arg value="${basedir}" />
+      <arg value="${mcp.srcdir}" />
+      <arg value="${mcp.home}" />
+    </exec>
+
+  </target>
+
+  <target name="setupenvironment" depends="buildenvsetup">
+    <input message="This will clean the mcp environment at ${mcp.home} and backup any src-work folder there (src-base will be erased). Continue?" validargs="y,n" addproperty="do.continue" />
+    <condition property="do.not.continue">
+      <equals arg1="n" arg2="${do.continue}" />
+    </condition>
+    <fail if="do.not.continue">You have decided not to continue. This script will stop now.</fail>
+    <echo>Preparing the MCP environment at ${mcp.home}</echo>
+    <!--<exec executable="${python.exe}" dir="${basedir}">
+      <arg value="${basedir}/download_fernflower.py" />
+      <arg value="${mcp.home}"/>
+    </exec>-->
+  	<antcall target="fmldecompile"/>
+    <echo>Moving old patched sources at ${patch.mcp.srcdir} out of the way</echo>
+    <move todir="${mcp.home}/src-work${timestamp}" failonerror="false" verbose="true">
+      <fileset dir="${patch.mcp.srcdir}"/>
+    </move>
+    <echo>Deleting old patch references at ${clean.mcp.srcdir}</echo>
+    <delete dir="${clean.mcp.srcdir}" failonerror="false"/>
+    <echo>Creating new patch references at ${clean.mcp.srcdir}</echo>
+    <copy todir="${clean.mcp.srcdir}">
+      <fileset dir="${mcp.srcdir}"/>
+    </copy>
+    <antcall target="cleanargo"/>
+    <antcall target="patch"/>
+    <echo>Creating clean patched references at ${patch.mcp.srcdir}</echo>
+    <copy todir="${patch.mcp.srcdir}">
+      <fileset dir="${mcp.srcdir}"/>
+    </copy>
+    <antcall target="writeversion"/>
+    <echo>Setup complete! You should now be able to open ${basedir}/eclipse as a workspace in eclipse and import/refresh the FML-Server and FML-Client projects</echo>
+  </target>
+	
+  <target name="fmldecompile" depends="buildenvsetup">
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${mcp.home}/runtime/cleanup.py" />
+      <arg value="-f" />
+    </exec>
+    <exec executable="${python.exe}" dir="${basedir}">
+      <arg value="${basedir}/decompile.py" />
+      <arg value="${mcp.home}" />
+      <arg value="${basedir}" />
+    </exec>
+  </target>
+  
+  <target name="jenkinsfmldecompile" depends="buildenvsetup">
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${mcp.home}/runtime/cleanup.py" />
+      <arg value="-f" />
+    </exec>
+    <exec executable="${python.exe}" dir="${basedir}">
+      <arg value="${basedir}/decompile.py" />
+      <arg value="${mcp.home}" />
+      <arg value="${basedir}" />
+      <arg value="-no_gen_conf" />
+    </exec>
+  </target>
+
+  <target name="repatch" depends="buildenvsetup,checkpatches">
+    <echo>Moving old patched sources at ${mcp.home}/src-work out of the way</echo>
+    <move todir="${mcp.home}/src-work${timestamp}" failonerror="false" verbose="true">
+      <fileset dir="${patch.mcp.srcdir}"/>
+    </move>
+    <delete dir="${mcp.srcdir}"/>
+    <copy todir="${mcp.srcdir}">
+      <fileset dir="${clean.mcp.srcdir}"/>
+    </copy>
+
+    <antcall target="cleanargo"/>
+
+    <antcall target="patch"/>
+    <copy todir="${patch.mcp.srcdir}">
+      <fileset dir="${mcp.srcdir}"/>
+    </copy>
+  </target>
+  
+  <target name="repatchclean" depends="buildenvsetup">
+    <delete dir="${mcp.srcdir}"/>
+    <copy todir="${mcp.srcdir}">
+      <fileset dir="${clean.mcp.srcdir}"/>
+    </copy>
+
+    <antcall target="cleanargo"/>
+
+    <antcall target="patch"/>
+  </target>
+
+  <target name="cleanargo" depends="buildenvsetup">
+    <delete dir="${client.mcp.srcdir}/argo"/>
+  </target>
+
+  <target name="checkpatches" depends="buildenvsetup">
+    <uptodate property="checkUptodate.uptodate">
+      <srcfiles dir="${patch.mcp.srcdir}" includes="**/*.java">
+      	<present targetdir="${patch.src.dir}">
+      		<globmapper from="*.java" to="*.java.patch"/>
+      	</present>
+      </srcfiles>
+      <globmapper from="*.java" to="${patch.src.dir}/*.java.patch"/>
+    </uptodate>
+  	<fail unless="checkUptodate.uptodate">
+  		A patch is out of date. Update your patches!
+  	</fail>
+  </target>
+
+  <target name="updatepatches" depends="buildenvsetup">
+    <exec executable="${python.exe}" dir="${basedir}">
+      <arg value="${basedir}/update_patches.py" />
+      <arg value="${mcp.home}"/>
+      <arg value="${basedir}"/>
+    </exec>
+  </target>
+
+  <target name="makerenamedsource" depends="buildenvsetup,repatch,merge-client,merge-server,buildandreobfmcp">
+    <copy todir="${tmp.mcp.srcdir}">
+      <fileset dir="${mcp.srcdir}"/>
+    </copy>
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${mcp.home}/runtime/updatenames.py" />
+      <arg value="-f" />
+    </exec>
+    <copy todir="${renamed.mcp.srcdir}">
+      <fileset dir="${mcp.srcdir}"/>
+    </copy>
+    <move todir="${mcp.srcdir}">
+      <fileset dir="${tmp.mcp.srcdir}"/>
+    </move>
+  </target>
+</project>

bukkit/cpw/mods/fml/server/FMLBukkitHandler.java

@@ -0,0 +1,637 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package cpw.mods.fml.server;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Properties;
+import java.util.Random;
+import java.util.logging.Logger;
+
+import org.bukkit.Material;
+
+import net.minecraft.server.Block;
+import net.minecraft.server.Item;
+import net.minecraft.server.LocaleLanguage;
+import net.minecraft.server.MLProp;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.BaseMod;
+import net.minecraft.server.BiomeBase;
+import net.minecraft.server.EntityItem;
+import net.minecraft.server.EntityHuman;
+import net.minecraft.server.IChunkProvider;
+import net.minecraft.server.ICommandListener;
+import net.minecraft.server.IInventory;
+import net.minecraft.server.ItemStack;
+import net.minecraft.server.NetworkManager;
+import net.minecraft.server.Packet1Login;
+import net.minecraft.server.Packet250CustomPayload;
+import net.minecraft.server.Packet3Chat;
+import net.minecraft.server.BukkitRegistry;
+import net.minecraft.server.SidedProxy;
+import net.minecraft.server.World;
+import net.minecraft.server.WorldType;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.IFMLSidedHandler;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.ModMetadata;
+import cpw.mods.fml.common.ProxyInjector;
+import cpw.mods.fml.common.Side;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+import cpw.mods.fml.common.modloader.ModProperty;
+import cpw.mods.fml.common.registry.FMLRegistry;
+
+/**
+ * Handles primary communication from hooked code into the system
+ *
+ * The FML entry point is {@link #onPreLoad(MinecraftServer)} called from {@link MinecraftServer}
+ *
+ * Obfuscated code should focus on this class and other members of the "server" (or "client") code
+ *
+ * The actual mod loading is handled at arms length by {@link Loader}
+ *
+ * It is expected that a similar class will exist for each target environment: Bukkit and Client side.
+ *
+ * It should not be directly modified.
+ *
+ * @author cpw
+ *
+ */
+public class FMLBukkitHandler implements IFMLSidedHandler
+{
+    /**
+     * The singleton
+     */
+    private static final FMLBukkitHandler INSTANCE = new FMLBukkitHandler();
+
+    /**
+     * A reference to the server itself
+     */
+    private MinecraftServer server;
+
+    /**
+     * A handy list of the default overworld biomes
+     */
+    private BiomeBase[] defaultOverworldBiomes;
+
+	FMLBukkitProfiler profiler;
+
+    /**
+     * Called to start the whole game off from {@link MinecraftServer#startServer}
+     * @param minecraftServer
+     */
+    public void onPreLoad(MinecraftServer minecraftServer)
+    {
+        try
+        {
+            Class.forName("BaseModMp", false, getClass().getClassLoader());
+            MinecraftServer.log.severe(""
+                    + "Forge Mod Loader has detected that this server has an ModLoaderMP installed alongside Forge Mod Loader.\n"
+                    + "This will cause a serious problem with compatibility. To protect your worlds, this minecraft server will now shutdown.\n"
+                    + "You should follow the installation instructions of either Minecraft Forge of Forge Mod Loader and NOT install ModLoaderMP \n"
+                    + "into the minecraft_server.jar file "
+                    + "before this server will be allowed to start up.\n\nFailure to do so will simply result in more startup failures.\n\n"
+                    + "The authors of Minecraft Forge and Forge Mod Loader strongly suggest you talk to your mod's authors and get them to\nupdate their "
+                    + "requirements. ModLoaderMP is not compatible with Minecraft Forge on the server and they will need to update their mod\n"
+                    + "for Minecraft Forge and other server compatibility, unless they are Minecraft Forge mods, in which case they already\n"
+                    + "don't need ModLoaderMP and the mod author simply has failed to update his requirements and should be informed appropriately.\n\n"
+                    + "The authors of Forge Mod Loader would like to be compatible with ModLoaderMP but it is closed source and owned by SDK.\n"
+                    + "SDK, the author of ModLoaderMP, has a standing invitation to submit compatibility patches \n"
+                    + "to the open source community project that is Forge Mod Loader so that this incompatibility doesn't last. \n"
+                    + "Users who wish to enjoy mods of both types are "
+                    + "encouraged to request of SDK that he submit a\ncompatibility patch to the Forge Mod Loader project at \n"
+                    + "http://github.com/cpw/FML.\nPosting on the minecraft forums at\nhttp://www.minecraftforum.net/topic/86765- (the MLMP thread)\n"
+                    + "may encourage him in this effort. However, I ask that your requests be polite.\n"
+                    + "Now, the server has to shutdown so you can reinstall your minecraft_server.jar\nproperly, until such time as we can work together.");
+            throw new RuntimeException(
+                    "This FML based server has detected an installation of ModLoaderMP alongside. This will cause serious compatibility issues, so the server will now shut down.");
+        }
+        catch (ClassNotFoundException e)
+        {
+            // We're safe. continue
+        }
+        server = minecraftServer;
+        FMLCommonHandler.instance().beginLoading(this);
+        FMLRegistry.registerRegistry(new BukkitRegistry());
+        Loader.instance().loadMods();
+    }
+
+    /**
+	 * Called a bit later on during server initialization to finish loading mods
+	 */
+	public void onLoadComplete()
+	{
+	    Loader.instance().initializeMods();
+	    for (Item i : Item.byId) {
+	    	if (i!=null && Material.getMaterial(i.id).name().startsWith("X")) {
+	    		Material.setMaterialName(i.id, i.l());
+	    	}
+	    }
+	}
+
+	public void onWorldLoadTick()
+	{
+		FMLCommonHandler.instance().tickStart(EnumSet.of(TickType.WORLDLOAD));
+	}
+
+    /**
+     * Every tick just before world and other ticks occur
+     */
+    public void onPreWorldTick(World world)
+    {
+        FMLCommonHandler.instance().tickStart(EnumSet.of(TickType.WORLD),world);
+    }
+
+    /**
+     * Every tick just after world and other ticks occur
+     */
+    public void onPostWorldTick(World world)
+    {
+        FMLCommonHandler.instance().tickEnd(EnumSet.of(TickType.WORLD), world);
+    }
+
+    /**
+     * Get the server instance
+     *
+     * @return
+     */
+    public MinecraftServer getServer()
+    {
+        return server;
+    }
+
+    /**
+     * Get a handle to the server's logger instance
+     */
+    public Logger getMinecraftLogger()
+    {
+        return MinecraftServer.log;
+    }
+
+    /**
+     * Called from ChunkProviderServer when a chunk needs to be populated
+     *
+     * To avoid polluting the worldgen seed, we generate a new random from the world seed and
+     * generate a seed from that
+     *
+     * @param chunkProvider
+     * @param chunkX
+     * @param chunkZ
+     * @param world
+     * @param generator
+     */
+    public void onChunkPopulate(IChunkProvider chunkProvider, int chunkX, int chunkZ, World world, IChunkProvider generator)
+    {
+    	FMLCommonHandler.instance().handleWorldGeneration(chunkX, chunkZ, world.getSeed(), world, generator, chunkProvider);
+    }
+
+    /**
+     * Called from the furnace to lookup fuel values
+     *
+     * @param itemId
+     * @param itemDamage
+     * @return
+     */
+    public int fuelLookup(int itemId, int itemDamage)
+    {
+        int fv = 0;
+
+        for (ModContainer mod : Loader.getModList())
+        {
+            fv = Math.max(fv, mod.lookupFuelValue(itemId, itemDamage));
+        }
+
+        return fv;
+    }
+
+    /**
+     * Is the offered class and instance of BaseMod and therefore a ModLoader mod?
+     */
+    public boolean isModLoaderMod(Class<?> clazz)
+    {
+        return BaseMod.class.isAssignableFrom(clazz);
+    }
+
+    /**
+     * Load the supplied mod class into a mod container
+     */
+    public ModContainer loadBaseModMod(Class<?> clazz, File canonicalFile)
+    {
+        @SuppressWarnings("unchecked")
+        Class <? extends BaseMod > bmClazz = (Class <? extends BaseMod >) clazz;
+        return new ModLoaderModContainer(bmClazz, canonicalFile);
+    }
+
+    /**
+     * Called to notify that an item was picked up from the world
+     *
+     * @param entityItem
+     * @param entityPlayer
+     */
+    public void notifyItemPickup(EntityItem entityItem, EntityHuman entityPlayer)
+    {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsPickupNotification())
+            {
+                mod.getPickupNotifier().notifyPickup(entityItem, entityPlayer);
+            }
+        }
+    }
+
+    /**
+     * Raise an exception
+     *
+     * @param exception
+     * @param message
+     * @param stopGame
+     */
+    public void raiseException(Throwable exception, String message, boolean stopGame)
+    {
+        FMLCommonHandler.instance().getFMLLogger().throwing("FMLHandler", "raiseException", exception);
+        throw new RuntimeException(exception);
+    }
+
+    /**
+     * Attempt to dispense the item as an entity other than just as a the item itself
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param xVelocity
+     * @param zVelocity
+     * @param item
+     * @return
+     */
+    public boolean tryDispensingEntity(World world, double x, double y, double z, byte xVelocity, byte zVelocity, ItemStack item)
+    {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsToDispense() && mod.getDispenseHandler().dispense(x, y, z, xVelocity, zVelocity, world, item))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @return the instance
+     */
+    public static FMLBukkitHandler instance()
+    {
+        return INSTANCE;
+    }
+
+    /**
+     * Build a list of default overworld biomes
+     *
+     * @return
+     */
+    public BiomeBase[] getDefaultOverworldBiomes()
+    {
+        if (defaultOverworldBiomes == null)
+        {
+            ArrayList<BiomeBase> biomes = new ArrayList<BiomeBase>(20);
+
+            for (int i = 0; i < 23; i++)
+            {
+                if ("Sky".equals(BiomeBase.biomes[i].y) || "Hell".equals(BiomeBase.biomes[i].y))
+                {
+                    continue;
+                }
+
+                biomes.add(BiomeBase.biomes[i]);
+            }
+
+            defaultOverworldBiomes = new BiomeBase[biomes.size()];
+            biomes.toArray(defaultOverworldBiomes);
+        }
+
+        return defaultOverworldBiomes;
+    }
+
+    /**
+     * Called when an item is crafted
+     *
+     * @param player
+     * @param craftedItem
+     * @param craftingGrid
+     */
+    public void onItemCrafted(EntityHuman player, ItemStack craftedItem, IInventory craftingGrid)
+    {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsCraftingNotification())
+            {
+                mod.getCraftingHandler().onCrafting(player, craftedItem, craftingGrid);
+            }
+        }
+    }
+
+    /**
+     * Called when an item is smelted
+     *
+     * @param player
+     * @param smeltedItem
+     */
+    public void onItemSmelted(EntityHuman player, ItemStack smeltedItem)
+    {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsCraftingNotification())
+            {
+                mod.getCraftingHandler().onSmelting(player, smeltedItem);
+            }
+        }
+    }
+
+    /**
+     * Called when a chat packet is received
+     *
+     * @param chat
+     * @param player
+     * @return true if you want the packet to stop processing and not echo to the rest of the world
+     */
+    public boolean handleChatPacket(Packet3Chat chat, EntityHuman player)
+    {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsNetworkPackets() && mod.getNetworkHandler().onChat(chat, player))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Called when a packet 250 packet is received from the player
+     *
+     * @param packet
+     * @param player
+     */
+    public void handlePacket250(Packet250CustomPayload packet, EntityHuman player)
+    {
+        if ("REGISTER".equals(packet.tag) || "UNREGISTER".equals(packet.tag))
+        {
+            handleClientRegistration(packet, player);
+            return;
+        }
+
+        ModContainer mod = FMLCommonHandler.instance().getModForChannel(packet.tag);
+
+        if (mod != null)
+        {
+            mod.getNetworkHandler().onPacket250Packet(packet, player);
+        }
+    }
+
+    /**
+     * Handle register requests for packet 250 channels
+     *
+     * @param packet
+     */
+    private void handleClientRegistration(Packet250CustomPayload packet, EntityHuman player)
+    {
+        if (packet.data==null) {
+            return;
+        }
+        try
+        {
+            for (String channel : new String(packet.data, "UTF8").split("\0"))
+            {
+                // Skip it if we don't know it
+                if (FMLCommonHandler.instance().getModForChannel(channel) == null)
+                {
+                    continue;
+                }
+
+                if ("REGISTER".equals(packet.tag))
+                {
+                    FMLCommonHandler.instance().activateChannel(player, channel);
+                }
+                else
+                {
+                    FMLCommonHandler.instance().deactivateChannel(player, channel);
+                }
+            }
+        }
+        catch (UnsupportedEncodingException e)
+        {
+            getMinecraftLogger().warning("Received invalid registration packet");
+        }
+    }
+
+    /**
+     * Handle a login
+     *
+     * @param loginPacket
+     * @param networkManager
+     */
+    public void handleLogin(Packet1Login loginPacket, NetworkManager networkManager)
+    {
+        Packet250CustomPayload packet = new Packet250CustomPayload();
+        packet.tag = "REGISTER";
+        packet.data = FMLCommonHandler.instance().getPacketRegistry();
+        packet.length = packet.data.length;
+        if (packet.length>0) {
+            networkManager.queue(packet);
+        }
+    }
+
+    public void announceLogin(EntityHuman player) {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsPlayerTracking())
+            {
+                mod.getPlayerTracker().onPlayerLogin(player);
+            }
+        }
+    }
+
+    @Override
+    public File getMinecraftRootDirectory()
+    {
+        try {
+            return server.a(".").getCanonicalFile();
+        } catch (IOException ioe) {
+            return new File(".");
+        }
+    }
+
+    /**
+     * @param var2
+     * @return
+     */
+    public boolean handleServerCommand(String command, String player, ICommandListener listener)
+    {
+        for (ModContainer mod : Loader.getModList()) {
+            if (mod.wantsConsoleCommands() && mod.getConsoleHandler().handleCommand(command, player, listener)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @param player
+     */
+    public void announceLogout(EntityHuman player)
+    {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsPlayerTracking())
+            {
+                mod.getPlayerTracker().onPlayerLogout(player);
+            }
+        }
+    }
+
+    /**
+     * @param p_28168_1_
+     */
+    public void announceDimensionChange(EntityHuman player)
+    {
+        for (ModContainer mod : Loader.getModList())
+        {
+            if (mod.wantsPlayerTracking())
+            {
+                mod.getPlayerTracker().onPlayerChangedDimension(player);
+            }
+        }
+    }
+
+    /**
+     * @param biome
+     */
+    public void addBiomeToDefaultWorldGenerator(BiomeBase biome)
+    {
+        WorldType.NORMAL.addNewBiome(biome);
+    }
+
+    /**
+     * @param biome
+     */
+    public void removeBiomeFromDefaultWorldGenerator(BiomeBase biome)
+    {
+        WorldType.NORMAL.removeBiome(biome);
+    }
+
+	@Override
+	public Object getMinecraftInstance() {
+		return server;
+	}
+
+	@Override
+    public String getCurrentLanguage()
+    {
+        return LocaleLanguage.a().getCurrentLanguage();
+	}
+
+	@Override
+    public Properties getCurrentLanguageTable()
+    {
+        return LocaleLanguage.a().getCurrentLanguageTable();
+	}
+
+	@Override
+    public String getObjectName(Object instance)
+    {
+        String objectName;
+        if (instance instanceof Item) {
+            objectName=((Item)instance).getName();
+        } else if (instance instanceof Block) {
+            objectName=((Block)instance).getName();
+        } else if (instance instanceof ItemStack) {
+            objectName=Item.byId[((ItemStack)instance).id].a((ItemStack)instance);
+        } else {
+            throw new IllegalArgumentException(String.format("Illegal object for naming %s",instance));
+        }
+        objectName+=".name";
+        return objectName;
+	}
+
+	@Override
+	public ModMetadata readMetadataFrom(InputStream input, ModContainer mod) throws Exception {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public void profileStart(String profileLabel) {
+		if (profiler!=null)
+		{
+			profiler.start(profileLabel);
+		}
+	}
+
+	@Override
+	public void profileEnd() {
+		if (profiler!=null)
+		{
+			profiler.end();
+		}
+	}
+
+	@Override
+	public ModProperty getModLoaderPropertyFor(Field f) {
+		if (f.isAnnotationPresent(MLProp.class)) {
+            MLProp prop = f.getAnnotation(MLProp.class);
+            return new ModProperty(prop.info(), prop.min(), prop.max(), prop.name());
+        }
+        return null;
+	}
+
+	@Override
+	public List<String> getAdditionalBrandingInformation() {
+		return null;
+	}
+
+	@Override
+	public Side getSide() {
+		return Side.BUKKIT;
+	}
+
+	@Override
+	public ProxyInjector findSidedProxyOn(cpw.mods.fml.common.modloader.BaseMod mod) {
+        for (Field f : mod.getClass().getDeclaredFields())
+        {
+            if (f.isAnnotationPresent(SidedProxy.class))
+            {
+                SidedProxy sp = f.getAnnotation(SidedProxy.class);
+                return new ProxyInjector(sp.clientSide(), sp.serverSide(), sp.bukkitSide(), f);
+            }
+        }
+        return null;
+	}
+
+	public void onServerPostTick() {
+		FMLCommonHandler.instance().tickEnd(EnumSet.of(TickType.GAME));
+	}
+
+	public void onServerPreTick() {
+		FMLCommonHandler.instance().tickStart(EnumSet.of(TickType.GAME));
+	}
+}

bukkit/cpw/mods/fml/server/FMLBukkitProfiler.java

@@ -0,0 +1,131 @@
+package cpw.mods.fml.server;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multiset;
+import com.google.common.collect.Multiset.Entry;
+import com.google.common.collect.Multisets;
+import com.google.common.collect.TreeMultiset;
+import com.google.common.primitives.Ints;
+
+public class FMLBukkitProfiler {
+	private static FMLBukkitProfiler lastInstance;
+	private static long endTime;
+	private LinkedList<String> profiles = new LinkedList<String>();
+	private TreeMultiset<String> hitCounter = TreeMultiset.create();
+	private TreeMultiset<String> timings = TreeMultiset.create();
+	private long timestamp;
+
+	public static long beginProfiling(int seconds)
+	{
+		long now = System.currentTimeMillis();
+		if (lastInstance == null)
+		{
+			lastInstance = new FMLBukkitProfiler();
+			FMLBukkitHandler.instance().profiler = lastInstance;
+			endTime = now + seconds * 1000;
+		}
+		if (endTime > now)
+		{
+			return (endTime - now) / 1000;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+
+	public static long endProfiling()
+	{
+		FMLBukkitHandler.instance().profiler = null;
+		return endTime - System.currentTimeMillis();
+	}
+
+	public static void resetProfiling()
+	{
+		endProfiling();
+		lastInstance = null;
+	}
+
+	public void start(String profileLabel)
+	{
+		profiles.push(profileLabel);
+		timestamp = System.nanoTime();
+	}
+
+	public void end()
+	{
+		int timing = (int)((System.nanoTime() - timestamp)/1000L);
+		String label = Joiner.on('.').join(profiles);
+		profiles.pop();
+		hitCounter.add(label);
+		timings.add(label,timing);
+		if (System.currentTimeMillis()>endTime)
+		{
+			endProfiling();
+		}
+	}
+
+	public static String[] dumpProfileData(int count)
+	{
+		if (lastInstance == null)
+		{
+			return new String[] { "No profile data available" };
+		}
+
+		if (endTime > System.currentTimeMillis())
+		{
+			return new String[] { String.format("Timing is being gathered for another %d seconds", endTime - System.currentTimeMillis()) };
+		}
+		return lastInstance.profileData(count);
+	}
+
+	private String[] profileData(int count) {
+		List<Entry<String>> sortedTiming = getEntriesSortedByFrequency(timings, false);
+		ArrayList<String> timeLine = new ArrayList<String>();
+
+		double totalTime = timings.size();
+
+		for (Entry<String> hit : sortedTiming)
+		{
+			if (--count == 0)
+			{
+				break;
+			}
+			timeLine.add(String.format("%s : %d microseconds, %d invocations. %.2f %% of overall time",hit.getElement(), hit.getCount(), hitCounter.count(hit.getElement()), 100.0 * hit.getCount()/totalTime));
+		}
+		return timeLine.toArray(new String[0]);
+	}
+
+	/*
+	 * Code from http://stackoverflow.com/questions/4345633/simplest-way-to-iterate-through-a-multiset-in-the-order-of-element-frequency
+	 */
+	private enum EntryComp implements Comparator<Multiset.Entry<?>>{
+	    DESCENDING{
+	        @Override
+	        public int compare(final Entry<?> a, final Entry<?> b){
+	            return Ints.compare(b.getCount(), a.getCount());
+	        }
+	    },
+	    ASCENDING{
+	        @Override
+	        public int compare(final Entry<?> a, final Entry<?> b){
+	            return Ints.compare(a.getCount(), b.getCount());
+	        }
+	    },
+	}
+
+	private static <E> List<Entry<E>> getEntriesSortedByFrequency(final Multiset<E> ms, final boolean ascending) {
+	    final List<Entry<E>> entryList = Lists.newArrayList(ms.entrySet());
+	    Collections.sort(entryList, ascending ? EntryComp.ASCENDING : EntryComp.DESCENDING);
+	    return entryList;
+	}
+
+}

bukkit/net/minecraft/server/BaseMod.java

@@ -0,0 +1,409 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package net.minecraft.server;
+
+import java.util.Map;
+import java.util.Random;
+
+import org.bukkit.craftbukkit.generator.NetherChunkGenerator;
+import org.bukkit.craftbukkit.generator.NormalChunkGenerator;
+
+import cpw.mods.fml.common.TickType;
+
+public abstract class BaseMod implements cpw.mods.fml.common.modloader.BaseMod
+{
+    // CALLBACK MECHANISMS
+
+    /**
+     * @param minecraftInstance
+     * @return
+     */
+    public final boolean doTickInGame(TickType tick, boolean tickEnd, Object minecraftInstance, Object... data)
+    {
+        if (tick==TickType.GAME && tickEnd) {
+            return onTickInGame((MinecraftServer)minecraftInstance);
+        } else {
+            return true;
+        }
+    }
+
+    @Override
+    public final void onCrafting(Object... craftingParameters)
+    {
+        takenFromCrafting((EntityHuman)craftingParameters[0], (ItemStack)craftingParameters[1], (IInventory)craftingParameters[2]);
+    }
+
+    @Override
+    public final void onSmelting(Object... smeltingParameters)
+    {
+        takenFromFurnace((EntityHuman)smeltingParameters[0], (ItemStack)smeltingParameters[1]);
+    }
+
+    @Override
+    public final boolean dispense(double x, double y, double z, byte xVelocity, byte zVelocity, Object... data)
+    {
+        return dispenseEntity((World)data[0], x, y, z, xVelocity, zVelocity, (ItemStack)data[1]);
+    }
+
+    @Override
+    public final boolean onChat(Object... data)
+    {
+        return onChatMessageReceived((EntityHuman)data[1], (Packet3Chat)data[0]);
+    }
+
+    @Override
+    public final void onServerLogin(Object handler) {
+        // NOOP
+    }
+
+    public final void onServerLogout() {
+        // NOOP
+    }
+    @Override
+    public final void onPlayerLogin(Object player)
+    {
+        onClientLogin((EntityHuman) player);
+    }
+
+    @Override
+    public final void onPlayerLogout(Object player)
+    {
+        onClientLogout((EntityHuman)player);
+    }
+
+    @Override
+    public final void onPlayerChangedDimension(Object player)
+    {
+        onClientDimensionChanged((EntityHuman)player);
+    }
+
+    @Override
+    public final void onPacket250Packet(Object... data)
+    {
+        onPacket250Received((EntityHuman)data[1], (Packet250CustomPayload)data[0]);
+    }
+
+    @Override
+    public final void notifyPickup(Object... pickupData)
+    {
+        EntityItem item = (EntityItem) pickupData[0];
+        EntityHuman player = (EntityHuman) pickupData[1];
+        onItemPickup(player, item.itemStack);
+    }
+
+    @Override
+    public final void generate(Random random, int chunkX, int chunkZ, Object... additionalData)
+    {
+        World w = (World) additionalData[0];
+        IChunkProvider cp = (IChunkProvider) additionalData[1];
+
+        if (cp instanceof ChunkProviderHell || cp instanceof NetherChunkGenerator)
+        {
+            generateNether(w, random, chunkX << 4, chunkZ << 4);
+        }
+        else if (cp instanceof ChunkProviderGenerate || cp instanceof NormalChunkGenerator)
+        {
+            generateSurface(w, random, chunkX << 4, chunkZ << 4);
+        }
+    }
+
+    /**
+     * NO-OP on client side
+     */
+    @Override
+    public final boolean handleCommand(String command, Object... data)
+    {
+        return onServerCommand(command, (String)data[0], (ICommandListener)data[1]);
+    }
+    @Override
+    public void onRegisterAnimations() {
+    	// NOOP on servers
+    }
+
+    @Override
+    public void onRenderHarvest(@SuppressWarnings("rawtypes") Map renderers) {
+    	// NOOP on servers
+    }
+
+    // BASEMOD API
+    /**
+     * Override if you wish to provide a fuel item for the furnace and return the fuel value of the item
+     *
+     * @param id
+     * @param metadata
+     * @return
+     */
+    public int addFuel(int id, int metadata)
+    {
+        return 0;
+    }
+
+    public void addRenderer(Map<Class<? extends Entity>, Object> renderers)
+    {
+
+    }
+
+    /**
+     * Override if you wish to perform some action other than just dispensing the item from the dispenser
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param xVel
+     * @param zVel
+     * @param item
+     * @return
+     */
+    public boolean dispenseEntity(World world, double x, double y, double z, int xVel, int zVel, ItemStack item)
+    {
+        return false;
+    }
+
+    /**
+     * Override if you wish to generate Nether (Hell biome) blocks
+     *
+     * @param world
+     * @param random
+     * @param chunkX
+     * @param chunkZ
+     */
+    public void generateNether(World world, Random random, int chunkX, int chunkZ)
+    {
+    }
+
+    /**
+     * Override if you wish to generate Overworld (not hell or the end) blocks
+     *
+     * @param world
+     * @param random
+     * @param chunkX
+     * @param chunkZ
+     */
+    public void generateSurface(World world, Random random, int chunkX, int chunkZ)
+    {
+    }
+
+    /**
+     * Return the name of your mod. Defaults to the class name
+     *
+     * @return
+     */
+    public String getName()
+    {
+        return getClass().getSimpleName();
+    }
+
+    /**
+     * Get your mod priorities
+     *
+     * @return
+     */
+    public String getPriorities()
+    {
+        return "";
+    }
+
+    /**
+     * Return the version of your mod
+     *
+     * @return
+     */
+    public abstract String getVersion();
+
+    public void keyboardEvent(Object event)
+    {
+
+    }
+
+    /**
+     * Load your mod
+     */
+    public abstract void load();
+
+    /**
+     * Finish loading your mod
+     */
+    public void modsLoaded()
+    {
+    }
+
+    /**
+     * Handle item pickup
+     *
+     * @param player
+     * @param item
+     */
+    public void onItemPickup(EntityHuman player, ItemStack item)
+    {
+    }
+
+    /**
+     * Ticked every game tick if you have subscribed to tick events through {@link ModLoader#setInGameHook(BaseMod, boolean, boolean)}
+     *
+     * @param minecraftServer the server
+     * @return true to continue receiving ticks
+     */
+    public boolean onTickInGame(MinecraftServer minecraftServer)
+    {
+        return false;
+    }
+
+    public boolean onTickInGUI(float tick, Object game, Object gui)
+    {
+        return false;
+    }
+
+    /**
+     * Only implemented on the client side
+     * {@link #onChatMessageReceived(EntityPlayer, Packet3Chat)}
+     *
+     * @param text
+     */
+    public void receiveChatPacket(String text)
+    {
+
+    }
+
+    /**
+     * Only called on the client side
+     * {@link #onPacket250Received(EntityPlayer, Packet250CustomPayload)}
+     *
+     * @param packet
+     */
+    public void receiveCustomPacket(Packet250CustomPayload packet)
+    {
+
+    }
+
+    public void registerAnimation(Object game)
+    {
+
+    }
+
+    public void renderInvBlock(Object renderer, Block block, int metadata, int modelID)
+    {
+
+    }
+
+    public boolean renderWorldBlock(Object renderer, IBlockAccess world, int x, int y, int z, Block block, int modelID)
+    {
+        return false;
+
+    }
+
+    /**
+     * Called when someone crafts an item from a crafting table
+     *
+     * @param player
+     * @param item
+     * @param matrix
+     */
+    public void takenFromCrafting(EntityHuman player, ItemStack item, IInventory matrix)
+    {
+    }
+
+    /**
+     * Called when someone takes a smelted item from a furnace
+     *
+     * @param player
+     * @param item
+     */
+    public void takenFromFurnace(EntityHuman player, ItemStack item)
+    {
+    }
+
+    /**
+     * The identifier string for the mod- used in client<->server negotiation
+     */
+    @Override
+    public String toString()
+    {
+        return getName() + " " + getVersion();
+    }
+
+    /**
+     * Called when a 250 packet is received on a channel registered to this mod
+     *
+     * @param source
+     * @param payload
+     */
+    public void onPacket250Received(EntityHuman source, Packet250CustomPayload payload)
+    {
+    }
+
+    /**
+     * Called when a chat message is received. Return true to stop further processing
+     *
+     * @param source
+     * @param chat
+     * @return true if you want to consume the message so it is not available for further processing
+     */
+    public boolean onChatMessageReceived(EntityHuman source, Packet3Chat chat)
+    {
+        return false;
+    }
+    /**
+     * Called when a server command is received
+     * @param command
+     * @return true if you want to consume the message so it is not available for further processing
+     */
+    public boolean onServerCommand(String command, String sender, ICommandListener listener)
+    {
+        return false;
+    }
+
+    /**
+     * Called when a new client logs in.
+     *
+     * @param player
+     */
+    public void onClientLogin(EntityHuman player)
+    {
+    }
+
+    /**
+     * Called when a client logs out of the server.
+     *
+     * @param player
+     */
+    public void onClientLogout(EntityHuman player)
+    {
+
+    }
+
+    /**
+     *
+     * Called when a client changes dimensions on the server.
+     *
+     * @param player
+     */
+    public void onClientDimensionChanged(EntityHuman player)
+    {
+
+    }
+
+    // Spare client junk
+    // -------
+    // void addRenderer(Map<Class<? extends Entity>, Render> renderers);
+    // void registerAnimation(Minecraft game);
+    // void renderInvBlock(RenderBlocks renderer, Block block, int metadata, int modelID);
+    // boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelID);
+    // boolean onTickInGUI(float tick, Minecraft game, GuiScreen gui);
+    // void keyboardEvent(KeyBinding event);
+
+    @Override
+    public void keyBindingEvent(Object keybinding) {
+    	// NOOP on server
+    }
+}

bukkit/net/minecraft/server/BukkitRegistry.java

@@ -0,0 +1,164 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.List;
+
+import net.minecraft.src.BiomeGenBase;
+
+import cpw.mods.fml.common.registry.IMinecraftRegistry;
+import cpw.mods.fml.server.FMLBukkitHandler;
+
+public class BukkitRegistry implements IMinecraftRegistry
+{
+
+    @Override
+    public void addRecipe(net.minecraft.src.ItemStack output, Object... params)
+    {
+        CraftingManager.getInstance().registerShapedRecipe((ItemStack) output, params);
+    }
+
+    @Override
+    public void addShapelessRecipe(net.minecraft.src.ItemStack output, Object... params)
+    {
+        CraftingManager.getInstance().registerShapelessRecipe((ItemStack) output, params);
+    }
+
+    @SuppressWarnings("unchecked")
+	@Override
+    public void addRecipe(net.minecraft.src.IRecipe recipe)
+    {
+        CraftingManager.getInstance().getRecipies().add(recipe);
+    }
+
+    @Override
+    public void addSmelting(int input, net.minecraft.src.ItemStack output)
+    {
+        FurnaceRecipes.getInstance().registerRecipe(input, (ItemStack) output);
+    }
+
+    @Override
+    public void registerBlock(net.minecraft.src.Block block)
+    {
+        registerBlock(block, ItemBlock.class);
+    }
+
+    @Override
+    public void registerBlock(net.minecraft.src.Block block, Class <? extends net.minecraft.src.ItemBlock > itemclass)
+    {
+        try
+        {
+            assert block != null : "registerBlock: block cannot be null";
+            assert itemclass != null : "registerBlock: itemclass cannot be null";
+            int blockItemId = ((Block)block).id - 256;
+            itemclass.getConstructor(int.class).newInstance(blockItemId);
+        }
+        catch (Exception e)
+        {
+            //HMMM
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+	@Override
+    public void registerEntityID(Class <? extends net.minecraft.src.Entity > entityClass, String entityName, int id)
+    {
+        EntityTypes.addNewEntityListMapping((Class<? extends Entity>) entityClass, entityName, id);
+    }
+
+    @SuppressWarnings("unchecked")
+	@Override
+    public void registerEntityID(Class <? extends net.minecraft.src.Entity > entityClass, String entityName, int id, int backgroundEggColour, int foregroundEggColour)
+    {
+        EntityTypes.addNewEntityListMapping((Class<? extends Entity>) entityClass, entityName, id, backgroundEggColour, foregroundEggColour);
+    }
+
+    @SuppressWarnings("unchecked")
+	@Override
+    public void registerTileEntity(Class <? extends net.minecraft.src.TileEntity > tileEntityClass, String id)
+    {
+        TileEntity.addNewTileEntityMapping((Class<? extends TileEntity>) tileEntityClass, id);
+    }
+
+    @Override
+    public void addBiome(BiomeGenBase biome)
+    {
+    	FMLBukkitHandler.instance().addBiomeToDefaultWorldGenerator((BiomeBase) biome);
+    }
+
+    @Override
+    public void addSpawn(Class <? extends net.minecraft.src.EntityLiving > entityClass, int weightedProb, int min, int max, net.minecraft.src.EnumCreatureType typeOfCreature, BiomeGenBase... biomes)
+    {
+    	BiomeBase[] realBiomes=(BiomeBase[]) biomes;
+        for (BiomeBase biome : realBiomes)
+        {
+            @SuppressWarnings("unchecked")
+            List<BiomeMeta> spawns = ((BiomeBase)biome).getMobs((EnumCreatureType)typeOfCreature);
+
+            for (BiomeMeta entry : spawns)
+            {
+                //Adjusting an existing spawn entry
+                if (entry.a == entityClass)
+                {
+                    entry.d = weightedProb;
+                    entry.b = min;
+                    entry.c = max;
+                    break;
+                }
+            }
+
+            spawns.add(new BiomeMeta(entityClass, weightedProb, min, max));
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void addSpawn(String entityName, int weightedProb, int min, int max, net.minecraft.src.EnumCreatureType spawnList, BiomeGenBase... biomes)
+    {
+        Class <? extends Entity > entityClazz = EntityTypes.getEntityToClassMapping().get(entityName);
+
+        if (EntityLiving.class.isAssignableFrom(entityClazz))
+        {
+            addSpawn((Class <? extends net.minecraft.src.EntityLiving >) entityClazz, weightedProb, min, max, spawnList, biomes);
+        }
+    }
+
+    @Override
+    public void removeBiome(BiomeGenBase biome)
+    {
+    	FMLBukkitHandler.instance().removeBiomeFromDefaultWorldGenerator((BiomeBase)biome);
+    }
+
+    @Override
+    public void removeSpawn(Class <? extends net.minecraft.src.EntityLiving > entityClass, net.minecraft.src.EnumCreatureType typeOfCreature, BiomeGenBase... biomesO)
+    {
+    	BiomeBase[] biomes=(BiomeBase[]) biomesO;
+        for (BiomeBase biome : biomes)
+        {
+            @SuppressWarnings("unchecked")
+            List<BiomeMeta> spawns = ((BiomeBase)biome).getMobs((EnumCreatureType) typeOfCreature);
+
+            Iterator<BiomeMeta> entries = spawns.iterator();
+            while (entries.hasNext())
+            {
+            	BiomeMeta entry = entries.next();
+                if (entry.a == entityClass)
+                {
+                    entries.remove();
+                }
+            }
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void removeSpawn(String entityName, net.minecraft.src.EnumCreatureType spawnList, BiomeGenBase... biomes)
+    {
+        Class <? extends Entity > entityClazz = EntityTypes.getEntityToClassMapping().get(entityName);
+
+        if (EntityLiving.class.isAssignableFrom(entityClazz))
+        {
+            removeSpawn((Class <? extends net.minecraft.src.EntityLiving >) entityClazz, spawnList, biomes);
+        }
+    }
+
+}

bukkit/net/minecraft/server/MLProp.java

@@ -0,0 +1,48 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package net.minecraft.server;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import static java.lang.annotation.RetentionPolicy.*;
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * @author cpw
+ *
+ */
+@Retention(value = RUNTIME)
+@Target(value = FIELD)
+public @interface MLProp
+{
+    /**
+     * Adds additional help to top of configuration file.
+     */
+String info() default "";
+
+    /**
+     * Maximum value allowed if field is a number.
+     */
+    double max() default Double.MAX_VALUE;
+
+    /**
+     * Minimum value allowed if field is a number.
+     */
+    double min() default Double.MIN_VALUE;
+
+    /**
+     * Overrides the field name for property key.
+     */
+String name() default "";
+
+}

bukkit/net/minecraft/server/ModLoader.java

@@ -0,0 +1,780 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package net.minecraft.server;
+
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ReflectionHelper;
+import cpw.mods.fml.common.modloader.ModLoaderHelper;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+import cpw.mods.fml.common.registry.FMLRegistry;
+import cpw.mods.fml.server.FMLBukkitHandler;
+
+public class ModLoader
+{
+    /**
+     * Not used on the server.
+     *
+     * @param achievement
+     * @param name
+     * @param description
+     */
+    public static void addAchievementDesc(Achievement achievement, String name, String description)
+    {
+        String achName=achievement.getName();
+        addLocalization(achName, name);
+        addLocalization(achName+".desc", description);
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     *
+     * {@link FMLCommonHandler#fuelLookup(int, int)}
+     * 
+     * @param id
+     * @param metadata
+     * @return
+     */
+    @Deprecated
+    public static int addAllFuel(int id, int metadata)
+    {
+        return 0;
+    }
+
+    public static void addAllRenderers(Map<Class<? extends Entity>, Object> renderers)
+    {
+    }
+
+    public static void addAnimation(Object anim)
+    {
+    }
+
+    /**
+     * This method is unimplemented in server versions to date.
+     *
+     * @param armor
+     * @return
+     */
+    public static int addArmor(String armor)
+    {
+        return 0;
+    }
+
+    /**
+     * This method adds the supplied biome to the set of candidate biomes for the default world generator type.
+     *
+     * @param biome
+     */
+    public static void addBiome(BiomeBase biome)
+    {
+        FMLRegistry.addBiome(biome);
+    }
+
+    /**
+     * Add localization for the specified string
+     *
+     * @param key
+     * @param value
+     */
+    public static void addLocalization(String key, String value)
+    {
+        addLocalization(key, "en_US", value);
+    }
+
+    /**
+     * Add localization for the specified string
+     *
+     * @param key
+     * @param lang
+     * @param value
+     */
+    public static void addLocalization(String key, String lang, String value)
+    {
+        FMLCommonHandler.instance().addStringLocalization(key, lang, value);
+    }
+
+    /**
+     * Name the specified minecraft object with the supplied name
+     *
+     * @param instance
+     * @param name
+     */
+    public static void addName(Object instance, String name)
+    {
+        addName(instance,"en_US",name);
+    }
+
+    /**
+     * Unimplemented on the server as it does not generate names
+     *
+     * @param instance
+     * @param lang
+     * @param name
+     */
+    public static void addName(Object instance, String lang, String name)
+    {
+        FMLCommonHandler.instance().addNameForObject(instance, lang, name);
+    }
+
+    /**
+     * Unimplemented on the server as it does not render textures
+     * 
+     * @param fileToOverride
+     * @param fileToAdd
+     * @return
+     */
+    public static int addOverride(String fileToOverride, String fileToAdd)
+    {
+        return 0;
+    }
+
+    /**
+     * Unimplemented on the server as it does not render textures
+     * 
+     * @param path
+     * @param overlayPath
+     * @param index
+     */
+    public static void addOverride(String path, String overlayPath, int index)
+    {
+        // NOOP
+    }
+
+    /**
+     * Add a Shaped Recipe
+     *
+     * @param output
+     * @param params
+     */
+    public static void addRecipe(ItemStack output, Object... params)
+    {
+        FMLRegistry.addRecipe(output, params);
+    }
+
+    /**
+     * Add a shapeless recipe
+     *
+     * @param output
+     * @param params
+     */
+    public static void addShapelessRecipe(ItemStack output, Object... params)
+    {
+        FMLRegistry.addShapelessRecipe(output, params);
+    }
+
+    /**
+     * Add a new product to be smelted
+     *
+     * @param input
+     * @param output
+     */
+    public static void addSmelting(int input, ItemStack output)
+    {
+        FMLRegistry.addSmelting(input, output);
+    }
+
+    /**
+     * Add a mob to the spawn list
+     *
+     * @param entityClass
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     */
+    public static void addSpawn(Class <? extends EntityLiving > entityClass, int weightedProb, int min, int max, EnumCreatureType spawnList)
+    {
+        FMLRegistry.addSpawn(entityClass, weightedProb, min, max, spawnList, FMLBukkitHandler.instance().getDefaultOverworldBiomes());
+    }
+
+    /**
+     * Add a mob to the spawn list
+     * @param entityClass
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     * @param biomes
+     */
+    public static void addSpawn(Class <? extends EntityLiving > entityClass, int weightedProb, int min, int max, EnumCreatureType spawnList, BiomeBase... biomes)
+    {
+        FMLRegistry.addSpawn(entityClass, weightedProb, min, max, spawnList, biomes);
+    }
+
+    /**
+     * Add a mob to the spawn list
+     *
+     * @param entityName
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     */
+    public static void addSpawn(String entityName, int weightedProb, int min, int max, EnumCreatureType spawnList)
+    {
+        FMLRegistry.addSpawn(entityName, weightedProb, min, max, spawnList, FMLBukkitHandler.instance().getDefaultOverworldBiomes());
+    }
+
+    /**
+     * Add a mob to the spawn list
+     * @param entityName
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     * @param biomes
+     */
+    public static void addSpawn(String entityName, int weightedProb, int min, int max, EnumCreatureType spawnList, BiomeBase... biomes)
+    {
+        FMLRegistry.addSpawn(entityName, weightedProb, min, max, spawnList, biomes);
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLBukkitHandler#tryDispensingEntity(World, double, double, double, byte, byte, ItemStack)}
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param xVel
+     * @param zVel
+     * @param item
+     * @return
+     */
+    @Deprecated
+    public static boolean dispenseEntity(World world, double x, double y, double z, int xVel, int zVel, ItemStack item)
+    {
+        return false;
+    }
+
+    /**
+     * Remove a container and drop all the items in it on the ground around
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     */
+    public static void genericContainerRemoval(World world, int x, int y, int z)
+    {
+        TileEntity te = world.getTileEntity(x, y, z);
+
+        if (!(te instanceof IInventory))
+        {
+            return;
+        }
+
+        IInventory inv = (IInventory)te;
+
+        for (int l = 0; l < inv.getSize(); l++)
+        {
+            ItemStack itemstack = inv.getItem(l);
+
+            if (itemstack == null)
+            {
+                continue;
+            }
+
+            float f = world.random.nextFloat() * 0.8F + 0.1F;
+            float f1 = world.random.nextFloat() * 0.8F + 0.1F;
+            float f2 = world.random.nextFloat() * 0.8F + 0.1F;
+
+            while (itemstack.count > 0)
+            {
+                int i1 = world.random.nextInt(21) + 10;
+
+                if (i1 > itemstack.count)
+                {
+                    i1 = itemstack.count ;
+                }
+
+                itemstack.count  -= i1;
+                EntityItem entityitem = new EntityItem(world, (float)te.x + f, (float)te.y + f1, (float)te.z + f2, new ItemStack(itemstack.id, i1, itemstack.getData()));
+                float f3 = 0.05F;
+                entityitem.motX = (float)world.random.nextGaussian() * f3;
+                entityitem.motY = (float)world.random.nextGaussian() * f3 + 0.2F;
+                entityitem.motZ = (float)world.random.nextGaussian() * f3;
+
+                if (itemstack.hasTag())
+                {
+                    entityitem.itemStack.setTag((NBTTagCompound)itemstack.getTag().clone());
+                }
+
+                world.addEntity(entityitem);
+            }
+        }
+    }
+
+    /**
+     * Get a list of all BaseMod loaded into the system
+     * {@link ModLoaderModContainer#findAll}
+     *
+     * @return
+     */
+    public static List<BaseMod> getLoadedMods()
+    {
+        return ModLoaderModContainer.findAll(BaseMod.class);
+    }
+
+    /**
+     * Get a logger instance {@link FMLCommonHandler#getFMLLogger()}
+     *
+     * @return
+     */
+    public static Logger getLogger()
+    {
+        return FMLCommonHandler.instance().getFMLLogger();
+    }
+
+    public static Object getMinecraftInstance()
+    {
+        return getMinecraftServerInstance();
+    }
+
+    /**
+     * Get the minecraft server instance
+     * {@link FMLServerHandler#getServer()}
+     * @return
+     */
+    public static MinecraftServer getMinecraftServerInstance()
+    {
+        return FMLBukkitHandler.instance().getServer();
+    }
+    /**
+     * Get a value from a field using reflection
+     * {@link ReflectionHelper#getPrivateValue(Class, Object, int)}
+     *
+     * @param instanceclass
+     * @param instance
+     * @param fieldindex
+     * @return
+     */
+    public static <T, E> T getPrivateValue(Class <? super E > instanceclass, E instance, int fieldindex)
+    {
+        return ReflectionHelper.getPrivateValue(instanceclass, instance, fieldindex);
+    }
+
+    /**
+     * Get a value from a field using reflection
+     * {@link ReflectionHelper#getPrivateValue(Class, Object, String)}
+     * 
+     * @param instanceclass
+     * @param instance
+     * @param field
+     * @return
+     */
+    public static <T, E> T getPrivateValue(Class <? super E > instanceclass, E instance, String field)
+    {
+        return ReflectionHelper.getPrivateValue(instanceclass, instance, field);
+    }
+
+    /**
+     * Stubbed method on the server to return a unique model id
+     * 
+     */
+    public static int getUniqueBlockModelID(BaseMod mod, boolean inventoryRenderer)
+    {
+        return -1;
+    }
+
+    /**
+     * Get a new unique entity id
+     * {@link Entity#getNextId()}
+     *
+     * @return
+     */
+    public static int getUniqueEntityId()
+    {
+        return FMLCommonHandler.instance().nextUniqueEntityListId();
+    }
+
+    public static int getUniqueSpriteIndex(String path)
+    {
+        return -1;
+    }
+    
+    /**
+     * To properly implement packet 250 protocol you should always check your
+     * channel is active prior to sending the packet
+     * 
+     * @param player
+     * @param channel
+     * @return
+     */
+    public static boolean isChannelActive(EntityPlayer player, String channel)
+    {
+        return FMLCommonHandler.instance().isChannelActive(channel, player);
+    }
+
+    public static boolean isGUIOpen(Class<?> gui)
+    {
+        return false;
+    }
+
+    /**
+     * Is the named mod loaded?
+     * {@link Loader#isModLoaded(String)}
+     * 
+     * @param modname
+     * @return
+     */
+    public static boolean isModLoaded(String modname)
+    {
+        return Loader.isModLoaded(modname);
+    }
+
+    /**
+     * Implemented elsewhere
+     */
+    @Deprecated
+    public static void loadConfig()
+    {
+    }
+
+    public static Object loadImage(Object renderEngine, String path) throws Exception
+    {
+        return null;
+    }
+
+    /**
+     * Call in from elsewhere. Unimplemented here.
+     * @param player
+     * @param item
+     */
+    @Deprecated
+    public static void onItemPickup(EntityPlayer player, ItemStack item)
+    {
+    }
+    /**
+     * Call in from elsewhere. Unimplemented here.
+     */
+    @Deprecated
+    public static void onTick(float tick, Object game)
+    {
+    }
+
+    public static void openGUI(EntityPlayer player, Object gui)
+    {
+        // NOOP
+    }
+
+    @Deprecated
+    public static void populateChunk(IChunkProvider generator, int chunkX, int chunkZ, World world)
+    {
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLBukkitHandler#handlePacket250(Packet250CustomPayload, EntityHuman)}
+     *
+     * @param packet
+     */
+    @Deprecated
+    public static void receivePacket(Packet250CustomPayload packet)
+    {
+    }
+
+    @Deprecated
+    public static Object[] registerAllKeys(Object[] keys)
+    {
+        return keys;
+    }
+
+    @Deprecated
+    public static void registerAllTextureOverrides(Object cache)
+    {
+    }
+
+    /**
+     * Register a new block
+     * 
+     * @param block
+     */
+    public static void registerBlock(Block block)
+    {
+        FMLRegistry.registerBlock(block);
+    }
+
+    /**
+     * Register a new block
+     * 
+     * @param block
+     * @param itemclass
+     */
+    public static void registerBlock(Block block, Class <? extends ItemBlock > itemclass)
+    {
+        FMLRegistry.registerBlock(block, itemclass);
+    }
+
+    /**
+     * Register a new entity ID
+     * 
+     * @param entityClass
+     * @param entityName
+     * @param id
+     */
+    public static void registerEntityID(Class <? extends Entity > entityClass, String entityName, int id)
+    {
+        FMLRegistry.registerEntityID(entityClass, entityName, id);
+    }
+
+    /**
+     * Register a new entity ID
+     * 
+     * @param entityClass
+     * @param entityName
+     * @param id
+     * @param background
+     * @param foreground
+     */
+    public static void registerEntityID(Class <? extends Entity > entityClass, String entityName, int id, int background, int foreground)
+    {
+        FMLRegistry.registerEntityID(entityClass, entityName, id, background, foreground);
+    }
+
+    public static void registerKey(BaseMod mod, Object keyHandler, boolean allowRepeat)
+    {
+        // NOOP
+    }
+
+    /**
+     * Register the mod for packets on this channel. This only registers the
+     * channel with Forge Mod Loader, not with clients connecting- use
+     * BaseMod.onClientLogin to tell them about your custom channel
+     * {@link FMLCommonHandler#registerChannel(cpw.mods.fml.common.ModContainer, String)}
+     * 
+     * @param mod
+     * @param channel
+     */
+    public static void registerPacketChannel(BaseMod mod, String channel)
+    {
+        FMLCommonHandler.instance().registerChannel(ModLoaderModContainer.findContainerFor(mod), channel);
+    }
+
+    /**
+     * Register a new tile entity class
+     * 
+     * @param tileEntityClass
+     * @param id
+     */
+    public static void registerTileEntity(Class <? extends TileEntity > tileEntityClass, String id)
+    {
+        FMLRegistry.registerTileEntity(tileEntityClass, id);
+    }
+
+    public static void registerTileEntity(Class<? extends TileEntity> tileEntityClass, String id, Object renderer)
+    {
+        FMLRegistry.instance().registerTileEntity(tileEntityClass, id);
+    }
+
+    /**
+     * Remove a biome from the list of generated biomes
+     *  
+     * @param biome
+     */
+    public static void removeBiome(BiomeBase biome)
+    {
+        FMLRegistry.removeBiome(biome);
+    }
+
+    /**
+     * Remove a spawn
+     * 
+     * @param entityClass
+     * @param spawnList
+     */
+    public static void removeSpawn(Class <? extends EntityLiving > entityClass, EnumCreatureType spawnList)
+    {
+        FMLRegistry.removeSpawn(entityClass, spawnList, FMLBukkitHandler.instance().getDefaultOverworldBiomes());
+    }
+
+    /**
+     * Remove a spawn
+     * 
+     * @param entityClass
+     * @param spawnList
+     * @param biomes
+     */
+    public static void removeSpawn(Class <? extends EntityLiving > entityClass, EnumCreatureType spawnList, BiomeBase... biomes)
+    {
+        FMLRegistry.removeSpawn(entityClass, spawnList, biomes);
+    }
+
+    /**
+     * Remove a spawn
+     * 
+     * @param entityName
+     * @param spawnList
+     */
+    public static void removeSpawn(String entityName, EnumCreatureType spawnList)
+    {
+        FMLRegistry.removeSpawn(entityName, spawnList, FMLBukkitHandler.instance().getDefaultOverworldBiomes());
+    }
+
+    /**
+     * Remove a spawn
+     * 
+     * @param entityName
+     * @param spawnList
+     * @param biomes
+     */
+    public static void removeSpawn(String entityName, EnumCreatureType spawnList, BiomeBase... biomes)
+    {
+        FMLRegistry.removeSpawn(entityName, spawnList, biomes);
+    }
+
+    @Deprecated
+    public static boolean renderBlockIsItemFull3D(int modelID)
+    {
+        return false;
+    }
+
+    @Deprecated
+    public static void renderInvBlock(Object renderer, Block block, int metadata, int modelID)
+    {
+        // NOOP
+    }
+
+    @Deprecated
+    public static boolean renderWorldBlock(Object renderer, IBlockAccess world, int x, int y, int z, Block block, int modelID)
+    {
+        return false;
+    }
+
+    /**
+     * Configuration is handled elsewhere
+     * {@link ModLoaderModContainer}
+     */
+    @Deprecated
+    public static void saveConfig()
+    {
+    }
+
+    /**
+     * Send a chat message to the server
+     * {@link FMLServerHandler#handleChatPacket(Packet3Chat, EntityPlayer)}
+     * 
+     * @param text
+     */
+    @Deprecated
+    public static void serverChat(String text)
+    {
+        //TODO
+    }
+
+    @Deprecated
+    public static void serverLogin(Object handler, Packet1Login loginPacket)
+    {
+        //TODO
+    }
+
+    /**
+     * Indicate that you want to receive ticks
+     *
+     * @param mod receiving the events
+     * @param enable indicates whether you want to recieve them or not
+     * @param useClock Not used in server side: all ticks are sent on the server side (no render subticks)
+     */
+    public static void setInGameHook(BaseMod mod, boolean enable, boolean useClock)
+    {
+    	ModLoaderHelper.updateStandardTicks(mod, enable, useClock);
+    }
+
+    
+    public static void setInGUIHook(BaseMod mod, boolean enable, boolean useClock)
+    {
+        ModLoaderHelper.updateGUITicks(mod, enable, useClock);
+    }
+
+    /**
+     * Set a private field to a value using reflection
+     * {@link ReflectionHelper#setPrivateValue(Class, Object, int, Object)}
+     * 
+     * @param instanceclass
+     * @param instance
+     * @param fieldindex
+     * @param value
+     */
+    public static <T, E> void setPrivateValue(Class <? super T > instanceclass, T instance, int fieldindex, E value)
+    {
+        ReflectionHelper.setPrivateValue(instanceclass, instance, fieldindex, value);
+    }
+
+    /**
+     * Set a private field to a value using reflection
+     * {@link ReflectionHelper#setPrivateValue(Class, Object, String, Object)}
+     * 
+     * @param instanceclass
+     * @param instance
+     * @param field
+     * @param value
+     */
+    public static <T, E> void setPrivateValue(Class <? super T > instanceclass, T instance, String field, E value)
+    {
+        ReflectionHelper.setPrivateValue(instanceclass, instance, field, value);
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLBukkitHandler#onItemCrafted(EntityHuman, ItemStack, IInventory)}
+     * 
+     * @param player
+     * @param item
+     * @param matrix
+     */
+    @Deprecated
+    public static void takenFromCrafting(EntityHuman player, ItemStack item, IInventory matrix)
+    {
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLBukkitHandler#onItemSmelted(EntityHuman, ItemStack)}
+     * 
+     * @param player
+     * @param item
+     */
+    @Deprecated
+    public static void takenFromFurnace(EntityHuman player, ItemStack item)
+    {
+    }
+
+    /**
+     * Throw the offered exception. Likely will stop the game.
+     * {@link FMLBukkitHandler#raiseException(Throwable, String, boolean)}
+     * @param message
+     * @param e
+     */
+    public static void throwException(String message, Throwable e)
+    {
+        FMLBukkitHandler.instance().raiseException(e, message, true);
+    }
+
+    /**
+     * To properly implement packet 250 protocol you should always check your channel
+     * is active prior to sending the packet
+     *
+     * @param player
+     * @param channel
+     * @return
+     */
+    public static boolean isChannelActive(EntityHuman player, String channel)
+    {
+        return FMLCommonHandler.instance().isChannelActive(channel, player);
+    }
+}

bukkit/net/minecraft/server/SidedProxy.java

@@ -0,0 +1,46 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraft.server;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @author cpw
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface SidedProxy
+{
+    /**
+     * The name of the client side class to load and populate
+     * @return
+     */
+    String clientSide() default "";
+    
+    /**
+     * The name of the server side class to load and populate
+     * @return
+     */
+    String serverSide() default "";
+    
+    /**
+     * The name of the a special bukkit plugin class to load and populate
+     */
+    String bukkitSide() default "";
+}

bukkit/net/minecraft/src/BiomeGenBase.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface BiomeGenBase {
+
+}

bukkit/net/minecraft/src/Block.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface Block {
+
+}

bukkit/net/minecraft/src/Entity.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface Entity {
+
+}

bukkit/net/minecraft/src/EntityLiving.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface EntityLiving {
+
+}

bukkit/net/minecraft/src/EnumCreatureType.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface EnumCreatureType {
+
+}

bukkit/net/minecraft/src/IRecipe.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface IRecipe {
+
+}

bukkit/net/minecraft/src/ItemBlock.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface ItemBlock {
+
+}

bukkit/net/minecraft/src/ItemStack.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface ItemStack {
+
+}

bukkit/net/minecraft/src/TileEntity.java

@@ -0,0 +1,5 @@
+package net.minecraft.src;
+
+public interface TileEntity {
+
+}

changelog.py

@@ -1,89 +0,0 @@
-import os, os.path, sys, re
-import json, urllib2
-from pprint import pprint
-from urlparse import urlparse
-import base64
-import optparse, ast
-
-class PreemptiveBasicAuthHandler(urllib2.BaseHandler):
-	def __init__(self, password_mgr=None):
-		if password_mgr is None:
-			password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
-		self.passwd = password_mgr
-		self.add_password = self.passwd.add_password
-
-	def http_request(self,req):
-		uri = req.get_full_url()
-		user, pw = self.passwd.find_user_password(None,uri)
-		if pw is None: return req
-		raw = "%s:%s" % (user, pw)
-		auth = 'Basic %s' % base64.b64encode(raw).strip()
-		req.add_unredirected_header('Authorization', auth)
-		return req
-
-	def https_request(self,req):
-		return self.http_request(req)
-
-def getBuildInfo(url, current_version=None):
-	handler = PreemptiveBasicAuthHandler()
-	handler.add_password(None, 'jenkins.minecraftforge.net:81', 'console_script', 'fd584bffa72fcac12181f37f80001200')
-	file = urllib2.build_opener(handler).open(url)
-	data = file.read()
-	file.close()
-	data = ast.literal_eval(data)['allBuilds']
-	data = sorted(data, key=lambda key: key['number'], reverse=False)
-	
-	items = []
-	output = []
-	
-	for build in data:
-		build['actions'] = filter(lambda act: act is not None, build['actions'])
-		build['actions'] = filter(lambda act: 'text' in act, build['actions'])
-		build['actions'] = filter(lambda act: not ' ' in act['text'], build['actions'])
-		if len(build['actions']) == 0:
-			build['version'] = current_version
-			current_version = None
-		else:
-			build['version'] = build['actions'][0]['text']
-		build['items'] = build['changeSet']['items']
-		for item in build['items']:
-			item['author'] = item['author']['fullName']
-		if build['result'] != 'SUCCESS':
-			items += build['items']
-		else:
-			build['items'] = items + build['items']
-			items = []
-			output += [build]
-		build.pop('changeSet')
-		build.pop('actions')
-	return sorted(output, key=lambda key: key['number'], reverse=True)
-	
-def make_changelog(job_path, target_build, change_file, current_version=None):
-	builds = getBuildInfo('%s/api/python?tree=allBuilds[result,number,actions[text],changeSet[items[author[fullName],comment]]]&pretty=true' % job_path, current_version)
-	
-	log = [ "Changelog:" ]
-	
-	for build in builds:
-		if int(build['number']) > target_build: continue
-		if len(build['items']) == 0: continue
-		log.append('')
-		if build['version'] is None:
-			log.append('Build %s' % build['number'])
-		else:
-			log.append('Build %s' % build['version'])
-		for change in build['items']:
-			comments = filter(lambda cmt: len(cmt) > 0, change['comment'].split('\n'))
-			if len(comments) > 1:
-				log.append('\t' + change['author'])
-				for comment in comments:
-					log.append('\t\t' + comment)
-			elif len(comments) == 1:
-				log.append('\t%s: %s' % (change['author'], comments[0]))
-				
-	file = open(change_file, 'wb')
-	for line in log:
-		file.write('%s\n' % line)
-	file.close()
-	
-if __name__ == '__main__':
-	make_changelog("http://jenkins.minecraftforge.net:81/job/minecraftforge/", 70000, 'changelog.txt', 'pinecone')

cleanup_source.py

@@ -0,0 +1,43 @@
+import sys
+import os, os.path, shutil
+import fnmatch
+import re
+                    
+def main():
+    sys.stdout.flush()
+    for x in range(1, len(sys.argv)):
+        cleanup_source(sys.argv[x])
+        
+count = 0
+def cleanup_source(path):
+    path = os.path.normpath(path)
+    regex_cases_before = re.compile(r'((case|default).+\r?\n)\r?\n', re.MULTILINE) #Fixes newline after case before case body
+    regex_cases_after = re.compile(r'\r?\n(\r?\n[ \t]+(case|default))', re.MULTILINE) #Fixes newline after case body before new case
+    
+    def updatefile(src_file):
+        global count
+        tmp_file = src_file + '.tmp'
+        count = 0
+        with open(src_file, 'r') as fh:
+            buf = fh.read()
+            
+        def fix_cases(match):
+            global count
+            count += 1
+            return match.group(1)
+            
+        buf = regex_cases_before.sub(fix_cases, buf)
+        buf = regex_cases_after.sub(fix_cases, buf)
+        if count > 0:
+            with open(tmp_file, 'w') as fh:
+                fh.write(buf)
+            shutil.move(tmp_file, src_file)
+            
+    for path, _, filelist in os.walk(path, followlinks=True):
+        sub_dir = os.path.relpath(path, path)
+        for cur_file in fnmatch.filter(filelist, '*.java'):
+            src_file = os.path.normpath(os.path.join(path, cur_file))
+            updatefile(src_file)
+            
+if __name__ == '__main__':
+    main()

client/cpw/mods/fml/client/FMLClientHandler.java

@@ -0,0 +1,405 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package cpw.mods.fml.client;
+
+import static org.lwjgl.opengl.GL11.*;
+
+import java.awt.image.BufferedImage;
+import java.awt.Dimension;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Random;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.imageio.ImageIO;
+
+import org.lwjgl.opengl.GL11;
+
+import com.google.common.base.Throwables;
+import com.google.common.collect.ImmutableMap;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.src.BaseMod;
+import net.minecraft.src.BiomeGenBase;
+import net.minecraft.src.Block;
+import net.minecraft.src.CrashReport;
+import net.minecraft.src.Entity;
+import net.minecraft.src.EntityItem;
+import net.minecraft.src.EntityLiving;
+import net.minecraft.src.EntityPlayer;
+import net.minecraft.src.GameSettings;
+import net.minecraft.src.GuiScreen;
+import net.minecraft.src.IBlockAccess;
+import net.minecraft.src.IChunkProvider;
+import net.minecraft.src.IInventory;
+import net.minecraft.src.Item;
+import net.minecraft.src.ItemStack;
+import net.minecraft.src.KeyBinding;
+import net.minecraft.src.MLProp;
+import net.minecraft.src.ModTextureStatic;
+import net.minecraft.src.NetClientHandler;
+import net.minecraft.src.NetworkManager;
+import net.minecraft.src.Packet;
+import net.minecraft.src.Packet1Login;
+import net.minecraft.src.Packet250CustomPayload;
+import net.minecraft.src.Packet3Chat;
+import net.minecraft.src.Profiler;
+import net.minecraft.src.Render;
+import net.minecraft.src.RenderBlocks;
+import net.minecraft.src.RenderEngine;
+import net.minecraft.src.RenderManager;
+import net.minecraft.src.RenderPlayer;
+import net.minecraft.src.StringTranslate;
+import net.minecraft.src.TextureFX;
+import net.minecraft.src.TexturePackBase;
+import net.minecraft.src.World;
+import net.minecraft.src.WorldClient;
+import net.minecraft.src.WorldType;
+import argo.jdom.JdomParser;
+import argo.jdom.JsonNode;
+import cpw.mods.fml.client.modloader.ModLoaderClientHelper;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.client.registry.KeyBindingRegistry;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.DummyModContainer;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.FMLDummyContainer;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.IFMLSidedHandler;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.LoaderException;
+import cpw.mods.fml.common.LoaderState;
+import cpw.mods.fml.common.MetadataCollection;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.ModMetadata;
+import cpw.mods.fml.common.ProxyInjector;
+import cpw.mods.fml.common.ObfuscationReflectionHelper;
+import cpw.mods.fml.common.Side;
+import cpw.mods.fml.common.SidedProxy;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.common.modloader.ModLoaderHelper;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+import cpw.mods.fml.common.modloader.ModProperty;
+import cpw.mods.fml.common.network.EntitySpawnAdjustmentPacket;
+import cpw.mods.fml.common.network.EntitySpawnPacket;
+import cpw.mods.fml.common.registry.IEntityAdditionalSpawnData;
+import cpw.mods.fml.common.registry.IThrowableEntity;
+
+
+/**
+ * Handles primary communication from hooked code into the system
+ *
+ * The FML entry point is {@link #beginMinecraftLoading(MinecraftServer)} called from
+ * {@link MinecraftServer}
+ *
+ * Obfuscated code should focus on this class and other members of the "server"
+ * (or "client") code
+ *
+ * The actual mod loading is handled at arms length by {@link Loader}
+ *
+ * It is expected that a similar class will exist for each target environment:
+ * Bukkit and Client side.
+ *
+ * It should not be directly modified.
+ *
+ * @author cpw
+ *
+ */
+public class FMLClientHandler implements IFMLSidedHandler
+{
+    /**
+     * The singleton
+     */
+    private static final FMLClientHandler INSTANCE = new FMLClientHandler();
+
+    /**
+     * A reference to the server itself
+     */
+    private Minecraft client;
+
+
+    private boolean firstTick;
+    /**
+     * Called to start the whole game off from
+     * {@link MinecraftServer#startServer}
+     *
+     * @param minecraftServer
+     */
+
+    private DummyModContainer optifineContainer;
+
+    private boolean guiLoaded;
+
+    private boolean serverIsRunning;
+
+    public void beginMinecraftLoading(Minecraft minecraft)
+    {
+        if (minecraft.func_71355_q())
+        {
+            FMLLog.severe("DEMO MODE DETECTED, FML will not work. Finishing now.");
+            haltGame("FML will not run in demo mode", new RuntimeException());
+            return;
+        }
+
+        client = minecraft;
+        ObfuscationReflectionHelper.detectObfuscation(World.class);
+        TextureFXManager.instance().setClient(client);
+        FMLCommonHandler.instance().beginLoading(this);
+        new ModLoaderClientHelper(client);
+        try
+        {
+            Class<?> optifineConfig = Class.forName("Config", false, Loader.instance().getModClassLoader());
+            String optifineVersion = (String) optifineConfig.getField("VERSION").get(null);
+            Map<String,Object> dummyOptifineMeta = ImmutableMap.<String,Object>builder().put("name", "Optifine").put("version", optifineVersion).build();
+            ModMetadata optifineMetadata = MetadataCollection.from(getClass().getResourceAsStream("optifinemod.info")).getMetadataForId("optifine", dummyOptifineMeta);
+            optifineContainer = new DummyModContainer(optifineMetadata);
+            FMLLog.info("Forge Mod Loader has detected optifine %s, enabling compatibility features",optifineContainer.getVersion());
+        }
+        catch (Exception e)
+        {
+            optifineContainer = null;
+        }
+        try
+        {
+            Loader.instance().loadMods();
+        }
+        catch (LoaderException le)
+        {
+            haltGame("There was a severe problem during mod loading that has caused the game to fail", le);
+            return;
+        }
+    }
+
+    @Override
+    public void haltGame(String message, Throwable t)
+    {
+        client.func_71377_b(new CrashReport(message, t));
+        throw Throwables.propagate(t);
+    }
+    /**
+     * Called a bit later on during initialization to finish loading mods
+     * Also initializes key bindings
+     *
+     */
+    public void finishMinecraftLoading()
+    {
+        try
+        {
+            Loader.instance().initializeMods();
+        }
+        catch (LoaderException le)
+        {
+            haltGame("There was a severe problem during mod loading that has caused the game to fail", le);
+            return;
+        }
+        RenderingRegistry.instance().loadEntityRenderers((Map<Class<? extends Entity>, Render>)RenderManager.field_78727_a.field_78729_o);
+
+        KeyBindingRegistry.uploadKeyBindingsToGame(client.field_71474_y);
+
+        // Mark this as a "first tick"
+        firstTick = true;
+    }
+    /**
+     * Get the server instance
+     *
+     * @return
+     */
+    public Minecraft getClient()
+    {
+        return client;
+    }
+
+    /**
+     * Get a handle to the client's logger instance
+     * The client actually doesn't have one- so we return null
+     */
+    public Logger getMinecraftLogger()
+    {
+        return null;
+    }
+
+    /**
+     * @return the instance
+     */
+    public static FMLClientHandler instance()
+    {
+        return INSTANCE;
+    }
+
+    /**
+     * @param player
+     * @param gui
+     */
+    public void displayGuiScreen(EntityPlayer player, GuiScreen gui)
+    {
+        if (client.field_71439_g==player && gui != null) {
+            client.func_71373_a(gui);
+        }
+    }
+
+    @Override
+    public void profileStart(String profileLabel) {
+        client.field_71424_I.func_76320_a(profileLabel);
+    }
+
+    @Override
+    public void profileEnd() {
+        client.field_71424_I.func_76319_b();
+    }
+
+    /**
+     * @param mods
+     */
+    public void addSpecialModEntries(ArrayList<ModContainer> mods)
+    {
+        if (optifineContainer!=null) {
+            mods.add(optifineContainer);
+        }
+    }
+
+    @Override
+    public List<String> getAdditionalBrandingInformation()
+    {
+        if (optifineContainer!=null)
+        {
+            return Arrays.asList(String.format("Optifine %s",optifineContainer.getVersion()));
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    @Override
+    public Side getSide()
+    {
+        return Side.CLIENT;
+    }
+
+    public boolean hasOptifine()
+    {
+        return optifineContainer!=null;
+    }
+
+    @Override
+    public void showGuiScreen(Object clientGuiElement)
+    {
+        GuiScreen gui = (GuiScreen) clientGuiElement;
+        client.func_71373_a(gui);
+    }
+
+    @Override
+    public Entity spawnEntityIntoClientWorld(Class<? extends Entity> cls, EntitySpawnPacket packet)
+    {
+        WorldClient wc = client.field_71441_e;
+
+        try
+        {
+            Entity entity = (Entity)(cls.getConstructor(World.class).newInstance(wc));
+            if (entity instanceof IThrowableEntity)
+            {
+                Entity thrower = client.field_71439_g.field_70157_k == packet.throwerId ? client.field_71439_g : wc.func_73024_a(packet.throwerId);
+                ((IThrowableEntity)entity).setThrower(thrower);
+            }
+
+            entity.field_70118_ct = packet.rawX;
+            entity.field_70117_cu = packet.rawY;
+            entity.field_70116_cv = packet.rawZ;
+
+            Entity parts[] = entity.func_70021_al();
+            if (parts != null)
+            {
+                int i = packet.entityId - entity.field_70157_k;
+                for (int j = 0; j < parts.length; j++)
+                {
+                    parts[j].field_70157_k += i;
+                }
+            }
+
+            entity.field_70157_k = packet.entityId;
+            entity.func_70056_a(packet.scaledX, packet.scaledY, packet.scaledZ, packet.scaledYaw, packet.scaledPitch, 1);
+
+            if (entity instanceof EntityLiving)
+            {
+                ((EntityLiving)entity).field_70759_as = packet.scaledHeadYaw;
+            }
+
+            if (packet.metadata != null)
+            {
+                entity.func_70096_w().func_75687_a((List)packet.metadata);
+            }
+
+            if (packet.throwerId > 0)
+            {
+                entity.func_70016_h(packet.speedScaledX, packet.speedScaledY, packet.speedScaledZ);
+            }
+
+            if (entity instanceof IEntityAdditionalSpawnData)
+            {
+                ((IEntityAdditionalSpawnData)entity).readSpawnData(packet.dataStream);
+            }
+
+            wc.func_73027_a(packet.entityId, entity);
+            return entity;
+        }
+        catch (Exception e)
+        {
+            FMLLog.log(Level.SEVERE, e, "A severe problem occurred during the spawning of an entity");
+            throw Throwables.propagate(e);
+        }
+    }
+
+    @Override
+    public void adjustEntityLocationOnClient(EntitySpawnAdjustmentPacket packet)
+    {
+        Entity ent = client.field_71441_e.func_73024_a(packet.entityId);
+        ent.field_70118_ct = packet.serverX;
+        ent.field_70117_cu = packet.serverY;
+        ent.field_70116_cv = packet.serverZ;
+    }
+
+    @Override
+    public void beginServerLoading(MinecraftServer server)
+    {
+        // NOOP
+    }
+
+    @Override
+    public void finishServerLoading()
+    {
+        // NOOP
+    }
+
+    @Override
+    public MinecraftServer getServer()
+    {
+        return client.func_71401_C();
+    }
+}

client/cpw/mods/fml/client/FMLTextureFX.java

@@ -0,0 +1,69 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client;
+
+import java.awt.Dimension;
+import java.util.List;
+import java.util.logging.Logger;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+
+import net.minecraft.src.RenderEngine;
+import net.minecraft.src.TextureFX;
+import net.minecraft.src.TexturePackBase;
+
+public class FMLTextureFX extends TextureFX implements ITextureFX
+{
+    public int tileSizeBase = 16;
+    public int tileSizeSquare = 256;
+    public int tileSizeMask = 15;
+    public int tileSizeSquareMask = 255;
+    public boolean errored = false;
+    protected Logger log = FMLCommonHandler.instance().getFMLLogger();
+
+    public FMLTextureFX(int icon)
+    {
+        super(icon);
+    }
+
+    @Override public void setErrored(boolean err){ errored = err; }
+    @Override public boolean getErrored(){ return errored; }
+    @Override
+    public void onTexturePackChanged(RenderEngine engine, TexturePackBase texturepack, Dimension dimensions)
+    {
+        onTextureDimensionsUpdate(dimensions.width, dimensions.height);
+    }
+    @Override
+    public void onTextureDimensionsUpdate(int width, int height)
+    {
+        tileSizeBase = width >> 4;
+        tileSizeSquare = tileSizeBase * tileSizeBase;
+        tileSizeMask = tileSizeBase - 1;
+        tileSizeSquareMask = tileSizeSquare - 1;
+        setErrored(false);
+        setup();
+    }
+
+    protected void setup()
+    {
+        field_76852_a = new byte[tileSizeSquare << 2];
+    }
+
+    public boolean unregister(RenderEngine engine, List<TextureFX> effects)
+    {
+        effects.remove(this);
+        return true;
+    }
+}

client/cpw/mods/fml/client/GuiModList.java

@@ -0,0 +1,178 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client;
+
+import java.awt.Dimension;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.common.FMLModContainer;
+import cpw.mods.fml.common.FMLDummyContainer;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.FontRenderer;
+import net.minecraft.src.GuiButton;
+import net.minecraft.src.GuiScreen;
+import net.minecraft.src.GuiSmallButton;
+import net.minecraft.src.StringTranslate;
+import net.minecraft.src.Tessellator;
+
+/**
+ * @author cpw
+ *
+ */
+public class GuiModList extends GuiScreen
+{
+    private GuiScreen mainMenu;
+    private GuiSlotModList modList;
+    private int selected = -1;
+    private ModContainer selectedMod;
+    private int listWidth;
+    private ArrayList<ModContainer> mods;
+
+    /**
+     * @param guiMainMenu
+     */
+    public GuiModList(GuiScreen mainMenu)
+    {
+        this.mainMenu=mainMenu;
+        this.mods=new ArrayList<ModContainer>();
+        FMLClientHandler.instance().addSpecialModEntries(mods);
+        for (ModContainer mod : Loader.instance().getModList()) {
+            if (mod.getMetadata()!=null && mod.getMetadata().parentMod != null) {
+                continue;
+            }
+            mods.add(mod);
+        }
+    }
+
+    @Override
+    public void func_73866_w_()
+    {
+        for (ModContainer mod : mods) {
+            listWidth=Math.max(listWidth,getFontRenderer().func_78256_a(mod.getName()) + 10);
+            listWidth=Math.max(listWidth,getFontRenderer().func_78256_a(mod.getVersion()) + 10);
+        }
+        listWidth=Math.min(listWidth, 150);
+        StringTranslate translations = StringTranslate.func_74808_a();
+        this.field_73887_h.add(new GuiSmallButton(6, this.field_73880_f / 2 - 75, this.field_73881_g - 38, translations.func_74805_b("gui.done")));
+        this.modList=new GuiSlotModList(this, mods, listWidth);
+        this.modList.registerScrollButtons(this.field_73887_h, 7, 8);
+    }
+
+    @Override
+    protected void func_73875_a(GuiButton button) {
+        if (button.field_73742_g)
+        {
+            switch (button.field_73741_f)
+            {
+                case 6:
+                    this.field_73882_e.func_71373_a(this.mainMenu);
+                    return;
+            }
+        }
+        super.func_73875_a(button);
+    }
+
+    public int drawLine(String line, int offset, int shifty)
+    {
+        this.field_73886_k.func_78276_b(line, offset, shifty, 0xd7edea);
+        return shifty + 10;
+    }
+
+    @Override
+    public void func_73863_a(int p_571_1_, int p_571_2_, float p_571_3_)
+    {
+        this.modList.drawScreen(p_571_1_, p_571_2_, p_571_3_);
+        this.func_73732_a(this.field_73886_k, "Mod List", this.field_73880_f / 2, 16, 0xFFFFFF);
+        int offset = this.listWidth  + 20;
+        if (selectedMod != null) {
+            if (!selectedMod.getMetadata().autogenerated) {
+                int shifty = 35;
+                if (!selectedMod.getMetadata().logoFile.isEmpty())
+                {
+                    int texture = this.field_73882_e.field_71446_o.func_78341_b(selectedMod.getMetadata().logoFile);
+                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+                    this.field_73882_e.field_71446_o.func_78342_b(texture);
+                    Dimension dim = TextureFXManager.instance().getTextureDimensions(texture);
+                    int top = 32;
+                    Tessellator tess = Tessellator.field_78398_a;
+                    tess.func_78382_b();
+                    tess.func_78374_a(offset,             top + dim.height, field_73735_i, 0, 1);
+                    tess.func_78374_a(offset + dim.width, top + dim.height, field_73735_i, 1, 1);
+                    tess.func_78374_a(offset + dim.width, top,              field_73735_i, 1, 0);
+                    tess.func_78374_a(offset,             top,              field_73735_i, 0, 0);
+                    tess.func_78381_a();
+
+                    shifty += 65;
+                }
+                this.field_73886_k.func_78261_a(selectedMod.getMetadata().name, offset, shifty, 0xFFFFFF);
+                shifty += 12;
+
+                shifty = drawLine(String.format("Version: %s (%s)", selectedMod.getMetadata().version, selectedMod.getVersion()), offset, shifty);
+                shifty = drawLine(String.format("Mod State: %s", Loader.instance().getModState(selectedMod)), offset, shifty);
+                if (!selectedMod.getMetadata().credits.isEmpty()) {
+                   shifty = drawLine(String.format("Credits: %s", selectedMod.getMetadata().credits), offset, shifty);
+                }
+                shifty = drawLine(String.format("Authors: %s", selectedMod.getMetadata().getAuthorList()), offset, shifty);
+                shifty = drawLine(String.format("URL: %s", selectedMod.getMetadata().url), offset, shifty);
+                shifty = drawLine(selectedMod.getMetadata().childMods.isEmpty() ? "No child mods for this mod" : String.format("Child mods: %s", selectedMod.getMetadata().getChildModList()), offset, shifty);
+                this.getFontRenderer().func_78279_b(selectedMod.getMetadata().description, offset, shifty + 10, this.field_73880_f - offset - 20, 0xDDDDDD);
+            } else {
+                offset = ( this.listWidth + this.field_73880_f ) / 2;
+                this.func_73732_a(this.field_73886_k, selectedMod.getName(), offset, 35, 0xFFFFFF);
+                this.func_73732_a(this.field_73886_k, String.format("Version: %s",selectedMod.getVersion()), offset, 45, 0xFFFFFF);
+                this.func_73732_a(this.field_73886_k, String.format("Mod State: %s",Loader.instance().getModState(selectedMod)), offset, 55, 0xFFFFFF);
+                this.func_73732_a(this.field_73886_k, "No mod information found", offset, 65, 0xDDDDDD);
+                this.func_73732_a(this.field_73886_k, "Ask your mod author to provide a mod mcmod.info file", offset, 75, 0xDDDDDD);
+            }
+        }
+        super.func_73863_a(p_571_1_, p_571_2_, p_571_3_);
+    }
+
+    Minecraft getMinecraftInstance() {
+        return field_73882_e;
+    }
+
+    FontRenderer getFontRenderer() {
+        return field_73886_k;
+    }
+
+    /**
+     * @param var1
+     */
+    public void selectModIndex(int var1)
+    {
+        this.selected=var1;
+        if (var1>=0 && var1<=mods.size()) {
+            this.selectedMod=mods.get(selected);
+        } else {
+            this.selectedMod=null;
+        }
+    }
+
+    /**
+     * @param var1
+     * @return
+     */
+    public boolean modIndexSelected(int var1)
+    {
+        return var1==selected;
+    }
+}

client/cpw/mods/fml/client/GuiScrollingList.java

@@ -0,0 +1,398 @@
+package cpw.mods.fml.client;
+
+import java.util.List;
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.GuiButton;
+import net.minecraft.src.Tessellator;
+
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+
+public abstract class GuiScrollingList
+{
+    private final Minecraft client;
+    protected final int listWidth;
+    protected final int listHeight;
+    protected final int top;
+    protected final int bottom;
+    private final int right;
+    protected final int left;
+    protected final int slotHeight;
+    private int scrollUpActionId;
+    private int scrollDownActionId;
+    protected int mouseX;
+    protected int mouseY;
+    private float initialMouseClickY = -2.0F;
+    private float scrollFactor;
+    private float scrollDistance;
+    private int selectedIndex = -1;
+    private long lastClickTime = 0L;
+    private boolean field_25123_p = true;
+    private boolean field_27262_q;
+    private int field_27261_r;
+
+    public GuiScrollingList(Minecraft client, int width, int height, int top, int bottom, int left, int entryHeight)
+    {
+        this.client = client;
+        this.listWidth = width;
+        this.listHeight = height;
+        this.top = top;
+        this.bottom = bottom;
+        this.slotHeight = entryHeight;
+        this.left = left;
+        this.right = width + this.left;
+    }
+
+    public void func_27258_a(boolean p_27258_1_)
+    {
+        this.field_25123_p = p_27258_1_;
+    }
+
+    protected void func_27259_a(boolean p_27259_1_, int p_27259_2_)
+    {
+        this.field_27262_q = p_27259_1_;
+        this.field_27261_r = p_27259_2_;
+
+        if (!p_27259_1_)
+        {
+            this.field_27261_r = 0;
+        }
+    }
+
+    protected abstract int getSize();
+
+    protected abstract void elementClicked(int index, boolean doubleClick);
+
+    protected abstract boolean isSelected(int index);
+
+    protected int getContentHeight()
+    {
+        return this.getSize() * this.slotHeight + this.field_27261_r;
+    }
+
+    protected abstract void drawBackground();
+
+    protected abstract void drawSlot(int var1, int var2, int var3, int var4, Tessellator var5);
+
+    protected void func_27260_a(int p_27260_1_, int p_27260_2_, Tessellator p_27260_3_) {}
+
+    protected void func_27255_a(int p_27255_1_, int p_27255_2_) {}
+
+    protected void func_27257_b(int p_27257_1_, int p_27257_2_) {}
+
+    public int func_27256_c(int p_27256_1_, int p_27256_2_)
+    {
+        int var3 = this.listWidth / 2 - 110;
+        int var4 = this.listWidth / 2 + 110;
+        int var5 = p_27256_2_ - this.top - this.field_27261_r + (int)this.scrollDistance - 4;
+        int var6 = var5 / this.slotHeight;
+        return p_27256_1_ >= var3 && p_27256_1_ <= var4 && var6 >= 0 && var5 >= 0 && var6 < this.getSize() ? var6 : -1;
+    }
+
+    public void registerScrollButtons(List p_22240_1_, int p_22240_2_, int p_22240_3_)
+    {
+        this.scrollUpActionId = p_22240_2_;
+        this.scrollDownActionId = p_22240_3_;
+    }
+
+    private void applyScrollLimits()
+    {
+        int var1 = this.getContentHeight() - (this.bottom - this.top - 4);
+
+        if (var1 < 0)
+        {
+            var1 /= 2;
+        }
+
+        if (this.scrollDistance < 0.0F)
+        {
+            this.scrollDistance = 0.0F;
+        }
+
+        if (this.scrollDistance > (float)var1)
+        {
+            this.scrollDistance = (float)var1;
+        }
+    }
+
+    public void actionPerformed(GuiButton button)
+    {
+        if (button.field_73742_g)
+        {
+            if (button.field_73741_f == this.scrollUpActionId)
+            {
+                this.scrollDistance -= (float)(this.slotHeight * 2 / 3);
+                this.initialMouseClickY = -2.0F;
+                this.applyScrollLimits();
+            }
+            else if (button.field_73741_f == this.scrollDownActionId)
+            {
+                this.scrollDistance += (float)(this.slotHeight * 2 / 3);
+                this.initialMouseClickY = -2.0F;
+                this.applyScrollLimits();
+            }
+        }
+    }
+
+    public void drawScreen(int mouseX, int mouseY, float p_22243_3_)
+    {
+        this.mouseX = mouseX;
+        this.mouseY = mouseY;
+        this.drawBackground();
+        int listLength = this.getSize();
+        int scrollBarXStart = this.left + this.listWidth - 6;
+        int scrollBarXEnd = scrollBarXStart + 6;
+        int boxLeft = this.left;
+        int boxRight = scrollBarXStart-1;
+        int var10;
+        int var11;
+        int var13;
+        int var19;
+
+        if (Mouse.isButtonDown(0))
+        {
+            if (this.initialMouseClickY == -1.0F)
+            {
+                boolean var7 = true;
+
+                if (mouseY >= this.top && mouseY <= this.bottom)
+                {
+                    var10 = mouseY - this.top - this.field_27261_r + (int)this.scrollDistance - 4;
+                    var11 = var10 / this.slotHeight;
+
+                    if (mouseX >= boxLeft && mouseX <= boxRight && var11 >= 0 && var10 >= 0 && var11 < listLength)
+                    {
+                        boolean var12 = var11 == this.selectedIndex && System.currentTimeMillis() - this.lastClickTime < 250L;
+                        this.elementClicked(var11, var12);
+                        this.selectedIndex = var11;
+                        this.lastClickTime = System.currentTimeMillis();
+                    }
+                    else if (mouseX >= boxLeft && mouseX <= boxRight && var10 < 0)
+                    {
+                        this.func_27255_a(mouseX - boxLeft, mouseY - this.top + (int)this.scrollDistance - 4);
+                        var7 = false;
+                    }
+
+                    if (mouseX >= scrollBarXStart && mouseX <= scrollBarXEnd)
+                    {
+                        this.scrollFactor = -1.0F;
+                        var19 = this.getContentHeight() - (this.bottom - this.top - 4);
+
+                        if (var19 < 1)
+                        {
+                            var19 = 1;
+                        }
+
+                        var13 = (int)((float)((this.bottom - this.top) * (this.bottom - this.top)) / (float)this.getContentHeight());
+
+                        if (var13 < 32)
+                        {
+                            var13 = 32;
+                        }
+
+                        if (var13 > this.bottom - this.top - 8)
+                        {
+                            var13 = this.bottom - this.top - 8;
+                        }
+
+                        this.scrollFactor /= (float)(this.bottom - this.top - var13) / (float)var19;
+                    }
+                    else
+                    {
+                        this.scrollFactor = 1.0F;
+                    }
+
+                    if (var7)
+                    {
+                        this.initialMouseClickY = (float)mouseY;
+                    }
+                    else
+                    {
+                        this.initialMouseClickY = -2.0F;
+                    }
+                }
+                else
+                {
+                    this.initialMouseClickY = -2.0F;
+                }
+            }
+            else if (this.initialMouseClickY >= 0.0F)
+            {
+                this.scrollDistance -= ((float)mouseY - this.initialMouseClickY) * this.scrollFactor;
+                this.initialMouseClickY = (float)mouseY;
+            }
+        }
+        else
+        {
+            while (Mouse.next())
+            {
+                int var16 = Mouse.getEventDWheel();
+
+                if (var16 != 0)
+                {
+                    if (var16 > 0)
+                    {
+                        var16 = -1;
+                    }
+                    else if (var16 < 0)
+                    {
+                        var16 = 1;
+                    }
+
+                    this.scrollDistance += (float)(var16 * this.slotHeight / 2);
+                }
+            }
+
+            this.initialMouseClickY = -1.0F;
+        }
+
+        this.applyScrollLimits();
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glDisable(GL11.GL_FOG);
+        Tessellator var18 = Tessellator.field_78398_a;
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.client.field_71446_o.func_78341_b("/gui/background.png"));
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        float var17 = 32.0F;
+        var18.func_78382_b();
+        var18.func_78378_d(2105376);
+        var18.func_78374_a((double)this.left, (double)this.bottom, 0.0D, (double)((float)this.left / var17), (double)((float)(this.bottom + (int)this.scrollDistance) / var17));
+        var18.func_78374_a((double)this.right, (double)this.bottom, 0.0D, (double)((float)this.right / var17), (double)((float)(this.bottom + (int)this.scrollDistance) / var17));
+        var18.func_78374_a((double)this.right, (double)this.top, 0.0D, (double)((float)this.right / var17), (double)((float)(this.top + (int)this.scrollDistance) / var17));
+        var18.func_78374_a((double)this.left, (double)this.top, 0.0D, (double)((float)this.left / var17), (double)((float)(this.top + (int)this.scrollDistance) / var17));
+        var18.func_78381_a();
+//        boxRight = this.listWidth / 2 - 92 - 16;
+        var10 = this.top + 4 - (int)this.scrollDistance;
+
+        if (this.field_27262_q)
+        {
+            this.func_27260_a(boxRight, var10, var18);
+        }
+
+        int var14;
+
+        for (var11 = 0; var11 < listLength; ++var11)
+        {
+            var19 = var10 + var11 * this.slotHeight + this.field_27261_r;
+            var13 = this.slotHeight - 4;
+
+            if (var19 <= this.bottom && var19 + var13 >= this.top)
+            {
+                if (this.field_25123_p && this.isSelected(var11))
+                {
+                    var14 = boxLeft;
+                    int var15 = boxRight;
+                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+                    GL11.glDisable(GL11.GL_TEXTURE_2D);
+                    var18.func_78382_b();
+                    var18.func_78378_d(8421504);
+                    var18.func_78374_a((double)var14, (double)(var19 + var13 + 2), 0.0D, 0.0D, 1.0D);
+                    var18.func_78374_a((double)var15, (double)(var19 + var13 + 2), 0.0D, 1.0D, 1.0D);
+                    var18.func_78374_a((double)var15, (double)(var19 - 2), 0.0D, 1.0D, 0.0D);
+                    var18.func_78374_a((double)var14, (double)(var19 - 2), 0.0D, 0.0D, 0.0D);
+                    var18.func_78378_d(0);
+                    var18.func_78374_a((double)(var14 + 1), (double)(var19 + var13 + 1), 0.0D, 0.0D, 1.0D);
+                    var18.func_78374_a((double)(var15 - 1), (double)(var19 + var13 + 1), 0.0D, 1.0D, 1.0D);
+                    var18.func_78374_a((double)(var15 - 1), (double)(var19 - 1), 0.0D, 1.0D, 0.0D);
+                    var18.func_78374_a((double)(var14 + 1), (double)(var19 - 1), 0.0D, 0.0D, 0.0D);
+                    var18.func_78381_a();
+                    GL11.glEnable(GL11.GL_TEXTURE_2D);
+                }
+
+                this.drawSlot(var11, boxRight, var19, var13, var18);
+            }
+        }
+
+        GL11.glDisable(GL11.GL_DEPTH_TEST);
+        byte var20 = 4;
+        this.overlayBackground(0, this.top, 255, 255);
+        this.overlayBackground(this.bottom, this.listHeight, 255, 255);
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        GL11.glDisable(GL11.GL_ALPHA_TEST);
+        GL11.glShadeModel(GL11.GL_SMOOTH);
+        GL11.glDisable(GL11.GL_TEXTURE_2D);
+        var18.func_78382_b();
+        var18.func_78384_a(0, 0);
+        var18.func_78374_a((double)this.left, (double)(this.top + var20), 0.0D, 0.0D, 1.0D);
+        var18.func_78374_a((double)this.right, (double)(this.top + var20), 0.0D, 1.0D, 1.0D);
+        var18.func_78384_a(0, 255);
+        var18.func_78374_a((double)this.right, (double)this.top, 0.0D, 1.0D, 0.0D);
+        var18.func_78374_a((double)this.left, (double)this.top, 0.0D, 0.0D, 0.0D);
+        var18.func_78381_a();
+        var18.func_78382_b();
+        var18.func_78384_a(0, 255);
+        var18.func_78374_a((double)this.left, (double)this.bottom, 0.0D, 0.0D, 1.0D);
+        var18.func_78374_a((double)this.right, (double)this.bottom, 0.0D, 1.0D, 1.0D);
+        var18.func_78384_a(0, 0);
+        var18.func_78374_a((double)this.right, (double)(this.bottom - var20), 0.0D, 1.0D, 0.0D);
+        var18.func_78374_a((double)this.left, (double)(this.bottom - var20), 0.0D, 0.0D, 0.0D);
+        var18.func_78381_a();
+        var19 = this.getContentHeight() - (this.bottom - this.top - 4);
+
+        if (var19 > 0)
+        {
+            var13 = (this.bottom - this.top) * (this.bottom - this.top) / this.getContentHeight();
+
+            if (var13 < 32)
+            {
+                var13 = 32;
+            }
+
+            if (var13 > this.bottom - this.top - 8)
+            {
+                var13 = this.bottom - this.top - 8;
+            }
+
+            var14 = (int)this.scrollDistance * (this.bottom - this.top - var13) / var19 + this.top;
+
+            if (var14 < this.top)
+            {
+                var14 = this.top;
+            }
+
+            var18.func_78382_b();
+            var18.func_78384_a(0, 255);
+            var18.func_78374_a((double)scrollBarXStart, (double)this.bottom, 0.0D, 0.0D, 1.0D);
+            var18.func_78374_a((double)scrollBarXEnd, (double)this.bottom, 0.0D, 1.0D, 1.0D);
+            var18.func_78374_a((double)scrollBarXEnd, (double)this.top, 0.0D, 1.0D, 0.0D);
+            var18.func_78374_a((double)scrollBarXStart, (double)this.top, 0.0D, 0.0D, 0.0D);
+            var18.func_78381_a();
+            var18.func_78382_b();
+            var18.func_78384_a(8421504, 255);
+            var18.func_78374_a((double)scrollBarXStart, (double)(var14 + var13), 0.0D, 0.0D, 1.0D);
+            var18.func_78374_a((double)scrollBarXEnd, (double)(var14 + var13), 0.0D, 1.0D, 1.0D);
+            var18.func_78374_a((double)scrollBarXEnd, (double)var14, 0.0D, 1.0D, 0.0D);
+            var18.func_78374_a((double)scrollBarXStart, (double)var14, 0.0D, 0.0D, 0.0D);
+            var18.func_78381_a();
+            var18.func_78382_b();
+            var18.func_78384_a(12632256, 255);
+            var18.func_78374_a((double)scrollBarXStart, (double)(var14 + var13 - 1), 0.0D, 0.0D, 1.0D);
+            var18.func_78374_a((double)(scrollBarXEnd - 1), (double)(var14 + var13 - 1), 0.0D, 1.0D, 1.0D);
+            var18.func_78374_a((double)(scrollBarXEnd - 1), (double)var14, 0.0D, 1.0D, 0.0D);
+            var18.func_78374_a((double)scrollBarXStart, (double)var14, 0.0D, 0.0D, 0.0D);
+            var18.func_78381_a();
+        }
+
+        this.func_27257_b(mouseX, mouseY);
+        GL11.glEnable(GL11.GL_TEXTURE_2D);
+        GL11.glShadeModel(GL11.GL_FLAT);
+        GL11.glEnable(GL11.GL_ALPHA_TEST);
+        GL11.glDisable(GL11.GL_BLEND);
+    }
+
+    private void overlayBackground(int p_22239_1_, int p_22239_2_, int p_22239_3_, int p_22239_4_)
+    {
+        Tessellator var5 = Tessellator.field_78398_a;
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.client.field_71446_o.func_78341_b("/gui/background.png"));
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        float var6 = 32.0F;
+        var5.func_78382_b();
+        var5.func_78384_a(4210752, p_22239_4_);
+        var5.func_78374_a(0.0D, (double)p_22239_2_, 0.0D, 0.0D, (double)((float)p_22239_2_ / var6));
+        var5.func_78374_a((double)this.listWidth + 30, (double)p_22239_2_, 0.0D, (double)((float)(this.listWidth + 30) / var6), (double)((float)p_22239_2_ / var6));
+        var5.func_78384_a(4210752, p_22239_3_);
+        var5.func_78374_a((double)this.listWidth + 30, (double)p_22239_1_, 0.0D, (double)((float)(this.listWidth + 30) / var6), (double)((float)p_22239_1_ / var6));
+        var5.func_78374_a(0.0D, (double)p_22239_1_, 0.0D, 0.0D, (double)((float)p_22239_1_ / var6));
+        var5.func_78381_a();
+    }
+}

client/cpw/mods/fml/client/GuiSlotModList.java

@@ -0,0 +1,93 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client;
+
+import java.util.ArrayList;
+
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.LoaderState.ModState;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.ModMetadata;
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.GuiLanguage;
+import net.minecraft.src.GuiSlot;
+import net.minecraft.src.StringTranslate;
+import net.minecraft.src.Tessellator;
+
+/**
+ * @author cpw
+ *
+ */
+public class GuiSlotModList extends GuiScrollingList
+{
+    private GuiModList parent;
+    private ArrayList<ModContainer> mods;
+
+    public GuiSlotModList(GuiModList parent, ArrayList<ModContainer> mods, int listWidth)
+    {
+        super(parent.getMinecraftInstance(), listWidth, parent.field_73881_g, 32, parent.field_73881_g - 65 + 4, 10, 35);
+        this.parent=parent;
+        this.mods=mods;
+    }
+
+    @Override
+    protected int getSize()
+    {
+        return mods.size();
+    }
+
+    @Override
+    protected void elementClicked(int var1, boolean var2)
+    {
+        this.parent.selectModIndex(var1);
+    }
+
+    @Override
+    protected boolean isSelected(int var1)
+    {
+        return this.parent.modIndexSelected(var1);
+    }
+
+    @Override
+    protected void drawBackground()
+    {
+        this.parent.func_73873_v_();
+    }
+
+    @Override
+    protected int getContentHeight()
+    {
+        return (this.getSize()) * 35 + 1;
+    }
+
+    @Override
+    protected void drawSlot(int listIndex, int var2, int var3, int var4, Tessellator var5)
+    {
+        ModContainer mc=mods.get(listIndex);
+        if (Loader.instance().getModState(mc)==ModState.DISABLED)
+        {
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getName(), listWidth - 11), this.left + 3 , var3 + 2, 0xFF2222);
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getVersion(), listWidth - 11), this.left + 3 , var3 + 12, 0xFF2222);
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a("DISABLED", listWidth - 11), this.left + 3 , var3 + 22, 0xFF2222);
+        }
+        else
+        {
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getName(), listWidth - 11), this.left + 3 , var3 + 2, 0xFFFFFF);
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getVersion(), listWidth - 11), this.left + 3 , var3 + 12, 0xCCCCCC);
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getMetadata() !=null ? mc.getMetadata().getChildModCountString() : "Metadata not found", listWidth - 9), this.left + 3 , var3 + 22, 0xCCCCCC);
+        }
+    }
+
+}

client/cpw/mods/fml/client/ITextureFX.java

@@ -0,0 +1,30 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client;
+
+import java.awt.Dimension;
+
+import net.minecraft.src.*;
+
+public interface ITextureFX
+{
+    public void onTexturePackChanged(RenderEngine engine, TexturePackBase texturepack, Dimension dimensions);
+
+    public void onTextureDimensionsUpdate(int width, int height);
+    
+    public void setErrored(boolean errored);
+    
+    public boolean getErrored();
+}

client/cpw/mods/fml/client/OverrideInfo.java

@@ -0,0 +1,44 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client;
+
+import net.minecraft.src.TextureFX;
+
+class OverrideInfo
+{
+    public String texture;
+    public String override;
+    public int index;
+    public int imageIndex;
+    public TextureFX textureFX;
+    public boolean added;
+    
+    @Override
+    public boolean equals(Object obj)
+    {
+        try {
+            OverrideInfo inf=(OverrideInfo) obj;
+            return index==inf.index && imageIndex==inf.imageIndex;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+    
+    @Override
+    public int hashCode()
+    {
+        return index+imageIndex;
+    }
+}

client/cpw/mods/fml/client/SpriteHelper.java

@@ -0,0 +1,144 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client;
+
+import java.util.BitSet;
+import java.util.HashMap;
+import java.util.logging.Level;
+
+import net.minecraft.src.ModLoader;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.LoaderException;
+
+/**
+ * @author cpw
+ *
+ */
+public class SpriteHelper
+{
+    private static HashMap<String, BitSet> spriteInfo = new HashMap<String, BitSet>();
+
+    private static void initMCSpriteMaps() {
+        BitSet slots =
+                SpriteHelper.toBitSet(
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000011111100" +
+                "0000000011111111" +
+                "0000000011111000" +
+                "0000000111111100" +
+                "0000000111111000" +
+                "0000000000000000");
+        spriteInfo.put("/terrain.png", slots);
+
+        slots = SpriteHelper.toBitSet(
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000000000000000" +
+                "0000001000000000" +
+                "0000001110000000" +
+                "0000001000000000" +
+                "1111111010000000" +
+                "1111111010100000" +
+                "1111111111111100" +
+                "1111111111111111" +
+                "1111111111111111" +
+                "1111111111111111" +
+                "0000000000000000");
+        spriteInfo.put("/gui/items.png", slots);
+    }
+    /**
+     * Register a sprite map for ModTextureStatic, to allow for other mods to override
+     * your sprite page.
+     *
+     *
+     */
+    public static void registerSpriteMapForFile(String file, String spriteMap) {
+        if (spriteInfo.size() == 0) {
+            initMCSpriteMaps();
+        }
+        if (spriteInfo.containsKey(file)) {
+            FMLCommonHandler.instance().getFMLLogger().finer(String.format("Duplicate attempt to register a sprite file %s for overriding -- ignoring",file));
+            return;
+        }
+        spriteInfo.put(file, toBitSet(spriteMap));
+    }
+
+    public static int getUniqueSpriteIndex(String path)
+    {
+        if (!spriteInfo.containsKey("/terrain.png"))
+        {
+            initMCSpriteMaps();
+        }
+
+        BitSet slots = spriteInfo.get(path);
+
+        if (slots == null)
+        {
+            Exception ex = new Exception(String.format("Invalid getUniqueSpriteIndex call for texture: %s", path));
+            FMLLog.log(Level.SEVERE, ex, "A critical error has been detected with sprite overrides");
+            FMLCommonHandler.instance().raiseException(ex,"Invalid request to getUniqueSpriteIndex",true);
+        }
+
+        int ret = getFreeSlot(slots);
+
+        if (ret == -1)
+        {
+            Exception ex = new Exception(String.format("No more sprite indicies left for: %s", path));
+            FMLLog.log(Level.SEVERE, ex, "There are no sprite indicies left for %s", path);
+            FMLCommonHandler.instance().raiseException(ex,"No more sprite indicies left", true);
+        }
+        return ret;
+    }
+
+    public static BitSet toBitSet(String data)
+    {
+        BitSet ret = new BitSet(data.length());
+        for (int x = 0; x < data.length(); x++)
+        {
+            ret.set(x, data.charAt(x) == '1');
+        }
+        return ret;
+    }
+
+    public static int getFreeSlot(BitSet slots)
+    {
+        int next=slots.nextSetBit(0);
+        slots.clear(next);
+        return next;
+    }
+
+    /**
+     * @param textureToOverride
+     * @return
+     */
+    public static int freeSlotCount(String textureToOverride)
+    {
+        return spriteInfo.get(textureToOverride).cardinality();
+    }
+
+}

client/cpw/mods/fml/client/TextureFXManager.java

@@ -0,0 +1,347 @@
+package cpw.mods.fml.client;
+
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_2D;
+import static org.lwjgl.opengl.GL11.GL_TEXTURE_BINDING_2D;
+
+import java.awt.Dimension;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+
+import javax.imageio.ImageIO;
+
+import org.lwjgl.opengl.GL11;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.KeyBinding;
+import net.minecraft.src.ModTextureStatic;
+import net.minecraft.src.Profiler;
+import net.minecraft.src.RenderEngine;
+import net.minecraft.src.TextureFX;
+import net.minecraft.src.TexturePackBase;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
+
+public class TextureFXManager
+{
+    private static final TextureFXManager INSTANCE = new TextureFXManager();
+
+    private class TextureProperties
+    {
+        private int textureId;
+        private Dimension dim;
+    }
+
+    private Map<Integer,TextureProperties> textureProperties = Maps.newHashMap();
+    private Multimap<String, OverrideInfo> overrideInfo = ArrayListMultimap.create();
+    private HashSet<OverrideInfo> animationSet = new HashSet<OverrideInfo>();
+
+    private List<TextureFX> addedTextureFX = new ArrayList<TextureFX>();
+
+    private Minecraft client;
+    
+    void setClient(Minecraft client)
+    {
+        this.client = client;
+    }
+    
+    public boolean onUpdateTextureEffect(TextureFX effect)
+    {
+        ITextureFX ifx = (effect instanceof ITextureFX ? ((ITextureFX)effect) : null);
+
+        if (ifx != null && ifx.getErrored())
+        {
+            return false;
+        }
+
+        String name = effect.getClass().getSimpleName();
+        FMLClientHandler.instance().profileStart(name);
+
+        try
+        {
+            if (!FMLClientHandler.instance().hasOptifine())
+            {
+                effect.func_76846_a();
+            }
+        }
+        catch (Exception e)
+        {
+            FMLLog.warning("Texture FX %s has failed to animate. Likely caused by a texture pack change that they did not respond correctly to", name);
+            if (ifx != null)
+            {
+                ifx.setErrored(true);
+            }
+            FMLClientHandler.instance().profileEnd();
+            return false;
+        }
+        FMLClientHandler.instance().profileEnd();
+
+        if (ifx != null)
+        {
+            Dimension dim = getTextureDimensions(effect);
+            int target = ((dim.width >> 4) * (dim.height >> 4)) << 2;
+            if (effect.field_76852_a.length != target)
+            {
+                FMLLog.warning("Detected a texture FX sizing discrepancy in %s (%d, %d)", name, effect.field_76852_a.length, target);
+                ifx.setErrored(true);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //Quick and dirty image scaling, no smoothing or fanciness, meant for speed as it will be called every tick.
+    public void scaleTextureFXData(byte[] data, ByteBuffer buf, int target, int length)
+    {
+        int sWidth = (int)Math.sqrt(data.length / 4);
+        int factor = target / sWidth;
+        byte[] tmp = new byte[4];
+
+        buf.clear();
+
+        if (factor > 1)
+        {
+            for (int y = 0; y < sWidth; y++)
+            {
+                int sRowOff = sWidth * y;
+                int tRowOff = target * y * factor;
+                for (int x = 0; x < sWidth; x++)
+                {
+                    int sPos = (x + sRowOff) * 4;
+                    tmp[0] = data[sPos + 0];
+                    tmp[1] = data[sPos + 1];
+                    tmp[2] = data[sPos + 2];
+                    tmp[3] = data[sPos + 3];
+
+                    int tPosTop = (x * factor) + tRowOff;
+                    for (int y2 = 0; y2 < factor; y2++)
+                    {
+                        buf.position((tPosTop + (y2 * target)) * 4);
+                        for (int x2 = 0; x2 < factor; x2++)
+                        {
+                            buf.put(tmp);
+                        }
+                    }
+                }
+            }
+        }
+
+        buf.position(0).limit(length);
+    }
+
+    public void onPreRegisterEffect(TextureFX effect)
+    {
+        Dimension dim = getTextureDimensions(effect);
+        if (effect instanceof ITextureFX)
+        {
+            ((ITextureFX)effect).onTextureDimensionsUpdate(dim.width, dim.height);
+        }
+    }
+
+
+    public int getEffectTexture(TextureFX effect)
+    {
+        Integer id = effectTextures.get(effect);
+        if (id != null)
+        {
+            return id;
+        }
+
+        int old = GL11.glGetInteger(GL_TEXTURE_BINDING_2D);
+
+        effect.func_76845_a(client.field_71446_o);
+
+        id = GL11.glGetInteger(GL_TEXTURE_BINDING_2D);
+
+        GL11.glBindTexture(GL_TEXTURE_2D, old);
+
+        effectTextures.put(effect, id);
+
+        return id;
+    }
+
+    public void onTexturePackChange(RenderEngine engine, TexturePackBase texturepack, List<TextureFX> effects)
+    {
+        pruneOldTextureFX(texturepack, effects);
+
+        for (TextureFX tex : effects)
+        {
+            if (tex instanceof ITextureFX)
+            {
+                ((ITextureFX)tex).onTexturePackChanged(engine, texturepack, getTextureDimensions(tex));
+            }
+        }
+
+        loadTextures(texturepack);
+    }
+
+    private HashMap<Integer, Dimension> textureDims = new HashMap<Integer, Dimension>();
+    private IdentityHashMap<TextureFX, Integer> effectTextures = new IdentityHashMap<TextureFX, Integer>();
+    private TexturePackBase earlyTexturePack;
+    public void setTextureDimensions(int id, int width, int height, List<TextureFX> effects)
+    {
+        Dimension dim = new Dimension(width, height);
+        textureDims.put(id, dim);
+
+        for (TextureFX tex : effects)
+        {
+            if (getEffectTexture(tex) == id && tex instanceof ITextureFX)
+            {
+                ((ITextureFX)tex).onTextureDimensionsUpdate(width, height);
+            }
+        }
+    }
+
+    public Dimension getTextureDimensions(TextureFX effect)
+    {
+        return getTextureDimensions(getEffectTexture(effect));
+    }
+
+    public Dimension getTextureDimensions(int id)
+    {
+        return textureDims.get(id);
+    }
+
+    /**
+     * @param anim
+     */
+    public void addAnimation(TextureFX anim)
+    {
+        OverrideInfo info=new OverrideInfo();
+        info.index=anim.field_76850_b;
+        info.imageIndex=anim.field_76847_f;
+        info.textureFX=anim;
+        if (animationSet.contains(info)) {
+            animationSet.remove(info);
+        }
+        animationSet.add(info);
+    }
+
+
+    /**
+     * @param p_6531_1_
+     */
+    public void loadTextures(TexturePackBase texturePack)
+    {
+        registerTextureOverrides(client.field_71446_o);
+    }
+
+
+    public void registerTextureOverrides(RenderEngine renderer) {
+        for (ModContainer mod : Loader.instance().getActiveModList()) {
+            registerAnimatedTexturesFor(mod);
+        }
+
+        for (OverrideInfo animationOverride : animationSet) {
+            renderer.func_78355_a(animationOverride.textureFX);
+            addedTextureFX.add(animationOverride.textureFX);
+            FMLCommonHandler.instance().getFMLLogger().finer(String.format("Registered texture override %d (%d) on %s (%d)", animationOverride.index, animationOverride.textureFX.field_76850_b, animationOverride.textureFX.getClass().getSimpleName(), animationOverride.textureFX.field_76847_f));
+        }
+
+        for (String fileToOverride : overrideInfo.keySet()) {
+            for (OverrideInfo override : overrideInfo.get(fileToOverride)) {
+                try
+                {
+                    BufferedImage image=loadImageFromTexturePack(renderer, override.override);
+                    ModTextureStatic mts=new ModTextureStatic(override.index, 1, override.texture, image);
+                    renderer.func_78355_a(mts);
+                    addedTextureFX.add(mts);
+                    FMLCommonHandler.instance().getFMLLogger().finer(String.format("Registered texture override %d (%d) on %s (%d)", override.index, mts.field_76850_b, override.texture, mts.field_76847_f));
+                }
+                catch (IOException e)
+                {
+                    FMLCommonHandler.instance().getFMLLogger().throwing("FMLClientHandler", "registerTextureOverrides", e);
+                }
+            }
+        }
+    }
+
+    /**
+     * @param mod
+     */
+    private void registerAnimatedTexturesFor(ModContainer mod)
+    {
+    }
+
+    /**
+     * @param field_6539_c
+     */
+    public void onEarlyTexturePackLoad(TexturePackBase fallback)
+    {
+        if (client==null) {
+            // We're far too early- let's wait
+            this.earlyTexturePack = fallback;
+        } else {
+            loadTextures(fallback);
+        }
+    }
+
+
+    public void pruneOldTextureFX(TexturePackBase var1, List<TextureFX> effects)
+    {
+        ListIterator<TextureFX> li = addedTextureFX.listIterator();
+        while (li.hasNext())
+        {
+            TextureFX tex = li.next();
+            if (tex instanceof FMLTextureFX)
+            {
+                if (((FMLTextureFX)tex).unregister(client.field_71446_o, effects))
+                {
+                    li.remove();
+                }
+            }
+            else
+            {
+                effects.remove(tex);
+                li.remove();
+            }
+        }
+    }
+    public void addNewTextureOverride(String textureToOverride, String overridingTexturePath, int location) {
+        OverrideInfo info = new OverrideInfo();
+        info.index = location;
+        info.override = overridingTexturePath;
+        info.texture = textureToOverride;
+        overrideInfo.put(textureToOverride, info);
+        FMLLog.fine("Overriding %s @ %d with %s. %d slots remaining",textureToOverride, location, overridingTexturePath, SpriteHelper.freeSlotCount(textureToOverride));
+    }
+
+    /**
+     * @param renderEngine
+     * @param path
+     * @return
+     */
+    public BufferedImage loadImageFromTexturePack(RenderEngine renderEngine, String path) throws IOException
+    {
+        InputStream image=client.field_71418_C.func_77292_e().func_77532_a(path);
+        if (image==null) {
+            throw new RuntimeException(String.format("The requested image path %s is not found",path));
+        }
+        BufferedImage result=ImageIO.read(image);
+        if (result==null)
+        {
+            throw new RuntimeException(String.format("The requested image path %s appears to be corrupted",path));
+        }
+        return result;
+    }
+
+    public static TextureFXManager instance()
+    {
+        return INSTANCE;
+    }
+
+}

client/cpw/mods/fml/client/modloader/ModLoaderBlockRendererHandler.java

@@ -0,0 +1,85 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client.modloader;
+
+import net.minecraft.src.BaseMod;
+import net.minecraft.src.Block;
+import net.minecraft.src.IBlockAccess;
+import net.minecraft.src.RenderBlocks;
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+
+/**
+ * @author cpw
+ *
+ */
+public class ModLoaderBlockRendererHandler implements ISimpleBlockRenderingHandler
+{
+    private int renderId;
+    private boolean render3dInInventory;
+    private BaseMod mod;
+
+    /**
+     * @param mod
+     *
+     */
+    public ModLoaderBlockRendererHandler(int renderId, boolean render3dInInventory, BaseMod mod)
+    {
+        this.renderId=renderId;
+        this.render3dInInventory=render3dInInventory;
+        this.mod=mod;
+    }
+
+    @Override
+    public int getRenderId()
+    {
+        return renderId;
+    }
+
+    @Override
+    public boolean shouldRender3DInInventory()
+    {
+        return render3dInInventory;
+    }
+
+    /**
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param block
+     * @param modelId
+     * @param renderer
+     */
+    @Override
+    public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
+    {
+        return mod.renderWorldBlock(renderer, world, x, y, z, block, modelId);
+    }
+
+    /**
+     * @param block
+     * @param metadata
+     * @param modelID
+     * @param renderer
+     */
+    @Override
+    public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
+    {
+        mod.renderInvBlock(renderer, block, metadata, modelID);
+    }
+
+}

client/cpw/mods/fml/client/modloader/ModLoaderClientHelper.java

@@ -0,0 +1,63 @@
+package cpw.mods.fml.client.modloader;
+
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.google.common.collect.Maps;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.src.BaseMod;
+import net.minecraft.src.Entity;
+import net.minecraft.src.Render;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.modloader.IModLoaderSidedHelper;
+import cpw.mods.fml.common.modloader.ModLoaderHelper;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+
+public class ModLoaderClientHelper implements IModLoaderSidedHelper
+{
+
+    /**
+     * @param mod
+     * @param inventoryRenderer
+     * @return
+     */
+    public static int obtainBlockModelIdFor(BaseMod mod, boolean inventoryRenderer)
+    {
+        int renderId=RenderingRegistry.instance().getNextAvailableRenderId();
+        ModLoaderBlockRendererHandler bri=new ModLoaderBlockRendererHandler(renderId, inventoryRenderer, mod);
+        RenderingRegistry.instance().registerBlockHandler(bri);
+        return renderId;
+    }
+
+
+    public static void handleFinishLoadingFor(ModLoaderModContainer mc, Minecraft game)
+    {
+        BaseMod mod = (BaseMod) mc.getMod();
+
+        Map<Class<? extends Entity>, Render> renderers = Maps.newHashMap();
+
+        mod.addRenderer(renderers);
+
+        for (Entry<Class<? extends Entity>, Render> e : renderers.entrySet())
+        {
+            RenderingRegistry.instance().registerEntityRenderingHandler(e.getKey(), e.getValue());
+        }
+
+        mod.registerAnimation(game);
+    }
+
+    public ModLoaderClientHelper(Minecraft client)
+    {
+        this.client = client;
+        ModLoaderHelper.sidedHelper = this;
+    }
+
+    private Minecraft client;
+
+    @Override
+    public void finishModLoading(ModLoaderModContainer mc)
+    {
+        handleFinishLoadingFor(mc, client);
+    }
+}

client/cpw/mods/fml/client/modloader/ModLoaderKeyBindingHandler.java

@@ -0,0 +1,104 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package cpw.mods.fml.client.modloader;
+
+import java.util.EnumSet;
+
+import net.minecraft.src.KeyBinding;
+
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+
+import cpw.mods.fml.client.registry.KeyBindingRegistry;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+import cpw.mods.fml.common.registry.TickRegistry;
+
+/**
+ * @author cpw
+ *
+ */
+public class ModLoaderKeyBindingHandler extends KeyBindingRegistry.KeyHandler
+{
+    private ModLoaderModContainer modContainer;
+    private boolean downArmed;
+    private boolean upArmed;
+
+    /**
+     * @param keyHandler
+     * @param allowRepeat
+     * @param modContainer
+     */
+    public ModLoaderKeyBindingHandler(KeyBinding keyBinding, boolean allowRepeat, ModLoaderModContainer modContainer)
+    {
+        super(keyBinding, allowRepeat);
+        this.modContainer=modContainer;
+    }
+
+    public void onRenderEndTick()
+    {
+        ((net.minecraft.src.BaseMod)modContainer.getMod()).keyboardEvent(keyBinding);
+    }
+
+    @Override
+    public void keyDown(EnumSet<TickType> type, boolean end, boolean repeats)
+    {
+        if (!end)
+        {
+            return;
+        }
+        upArmed = false;
+        if (type.contains(TickType.CLIENT))
+        {
+            downArmed = true;
+        }
+        if (type.contains(TickType.RENDER) && downArmed)
+        {
+            onRenderEndTick();
+            downArmed = false;
+        }
+    }
+
+    @Override
+    public void keyUp(EnumSet<TickType> type, boolean end)
+    {
+        if (!end)
+        {
+            return;
+        }
+        downArmed = false;
+        if (type.contains(TickType.CLIENT))
+        {
+            upArmed = true;
+        }
+        if (type.contains(TickType.RENDER) && upArmed)
+        {
+            onRenderEndTick();
+            upArmed = false;
+        }
+    }
+
+    @Override
+    public EnumSet<TickType> ticks()
+    {
+        return EnumSet.of(TickType.CLIENT, TickType.RENDER);
+    }
+
+    @Override
+    public String getLabel()
+    {
+        return modContainer.getModId() +" KB "+keyBinding.field_74512_d;
+    }
+}

client/cpw/mods/fml/client/registry/ClientRegistry.java

@@ -0,0 +1,35 @@
+package cpw.mods.fml.client.registry;
+
+import java.util.Collections;
+
+import net.minecraft.src.BiomeGenBase;
+import net.minecraft.src.TileEntity;
+import net.minecraft.src.TileEntityRenderer;
+import net.minecraft.src.TileEntitySpecialRenderer;
+
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.common.ObfuscationReflectionHelper;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+public class ClientRegistry
+{
+    /**
+     * 
+     * Utility method for registering a tile entity and it's renderer at once - generally you should register them separately
+     * 
+     * @param tileEntityClass
+     * @param id
+     * @param specialRenderer
+     */
+    public static void registerTileEntity(Class <? extends TileEntity > tileEntityClass, String id, TileEntitySpecialRenderer specialRenderer)
+    {
+        GameRegistry.registerTileEntity(tileEntityClass, id);
+        bindTileEntitySpecialRenderer(tileEntityClass, specialRenderer);
+    }
+    
+    public static void bindTileEntitySpecialRenderer(Class <? extends TileEntity> tileEntityClass, TileEntitySpecialRenderer specialRenderer)
+    {
+        TileEntityRenderer.field_76963_a.field_76966_m.put(tileEntityClass, specialRenderer);
+        specialRenderer.func_76893_a(TileEntityRenderer.field_76963_a);
+    }
+}

client/cpw/mods/fml/client/registry/ISimpleBlockRenderingHandler.java

@@ -0,0 +1,16 @@
+package cpw.mods.fml.client.registry;
+
+import net.minecraft.src.Block;
+import net.minecraft.src.IBlockAccess;
+import net.minecraft.src.RenderBlocks;
+
+public interface ISimpleBlockRenderingHandler
+{
+    public abstract void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer);
+
+    public abstract boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer);
+
+    public abstract boolean shouldRender3DInInventory();
+
+    public abstract int getRenderId();
+}

client/cpw/mods/fml/client/registry/KeyBindingRegistry.java

@@ -0,0 +1,94 @@
+package cpw.mods.fml.client.registry;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+
+import com.google.common.collect.Lists;
+
+import net.minecraft.src.GameSettings;
+import net.minecraft.src.KeyBinding;
+
+import cpw.mods.fml.common.ITickHandler;
+import cpw.mods.fml.common.Side;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.common.registry.TickRegistry;
+
+public class KeyBindingRegistry
+{
+    public static abstract class KeyHandler implements ITickHandler
+    {
+        protected KeyBinding keyBinding;
+        protected boolean keyDown;
+        protected boolean repeating;
+
+        public KeyHandler(KeyBinding keyBinding, boolean repeating)
+        {
+            this.keyBinding = keyBinding;
+            this.repeating = repeating;
+        }
+
+        public KeyBinding getKeyBinding()
+        {
+            return this.keyBinding;
+        }
+
+        @Override
+        public final void tickStart(EnumSet<TickType> type, Object... tickData)
+        {
+            keyTick(type, false);
+        }
+
+        @Override
+        public final void tickEnd(EnumSet<TickType> type, Object... tickData)
+        {
+            keyTick(type, true);
+        }
+
+        private void keyTick(EnumSet<TickType> type, boolean tickEnd)
+        {
+            int keyCode = keyBinding.field_74512_d;
+            boolean state = (keyCode < 0 ? Mouse.isButtonDown(keyCode + 100) : Keyboard.isKeyDown(keyCode));
+            if (state != keyDown || (state && repeating))
+            {
+                if (state)
+                {
+                    keyDown(type, tickEnd, state!=keyDown);
+                }
+                else
+                {
+                    keyUp(type, tickEnd);
+                }
+                keyDown = state;
+            }
+        }
+
+        public abstract void keyDown(EnumSet<TickType> types, boolean tickEnd, boolean isRepeat);
+        public abstract void keyUp(EnumSet<TickType> types, boolean tickEnd);
+    }
+
+    private static List<KeyHandler> keyHandlers = Lists.newArrayList();
+
+    public static void registerKeyBinding(KeyHandler handler) {
+        keyHandlers.add(handler);
+        TickRegistry.registerTickHandler(handler, Side.CLIENT);
+    }
+
+    public static void uploadKeyBindingsToGame(GameSettings settings)
+    {
+        ArrayList<KeyBinding> harvestedBindings = Lists.newArrayList();
+        for (KeyHandler key : keyHandlers)
+        {
+            harvestedBindings.add(key.keyBinding);
+        }
+        KeyBinding[] modKeyBindings = harvestedBindings.toArray(new KeyBinding[harvestedBindings.size()]);
+        KeyBinding[] allKeys = new KeyBinding[settings.field_74324_K.length + modKeyBindings.length];
+        System.arraycopy(settings.field_74324_K, 0, allKeys, 0, settings.field_74324_K.length);
+        System.arraycopy(modKeyBindings, 0, allKeys, settings.field_74324_K.length, modKeyBindings.length);
+        settings.field_74324_K = allKeys;
+        settings.func_74300_a();
+    }
+}

client/cpw/mods/fml/client/registry/RenderingRegistry.java

@@ -0,0 +1,113 @@
+package cpw.mods.fml.client.registry;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.ObjectArrays;
+
+import net.minecraft.src.Block;
+import net.minecraft.src.Entity;
+import net.minecraft.src.IBlockAccess;
+import net.minecraft.src.Render;
+import net.minecraft.src.RenderBlocks;
+import net.minecraft.src.RenderPlayer;
+import cpw.mods.fml.client.modloader.ModLoaderBlockRendererHandler;
+import cpw.mods.fml.common.ObfuscationReflectionHelper;
+
+public class RenderingRegistry
+{
+    private static final RenderingRegistry INSTANCE = new RenderingRegistry();
+
+    private int nextRenderId = 30;
+
+    private Map<Integer, ISimpleBlockRenderingHandler> blockRenderers = Maps.newHashMap();
+
+    private List<EntityRendererInfo> entityRenderers = Lists.newArrayList();
+
+    public int addNewArmourRendererPrefix(String armor)
+    {
+        RenderPlayer.field_77110_j = ObjectArrays.concat(RenderPlayer.field_77110_j, armor);
+        return RenderPlayer.field_77110_j.length - 1;
+    }
+
+    public static RenderingRegistry instance()
+    {
+        return INSTANCE;
+    }
+
+    private class EntityRendererInfo
+    {
+        public EntityRendererInfo(Class<? extends Entity> target, Render renderer)
+        {
+            this.target = target;
+            this.renderer = renderer;
+        }
+        private Class<? extends Entity> target;
+        private Render renderer;
+    }
+
+    public void registerEntityRenderingHandler(Class<? extends Entity> entityClass, Render renderer)
+    {
+        entityRenderers.add(new EntityRendererInfo(entityClass, renderer));
+    }
+
+    public void registerBlockHandler(ISimpleBlockRenderingHandler handler)
+    {
+        blockRenderers.put(handler.getRenderId(), handler);
+    }
+
+    public int getNextAvailableRenderId()
+    {
+        return nextRenderId++;
+    }
+    /**
+     * @param renderer
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param block
+     * @param modelId
+     * @return
+     */
+    public boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelId)
+    {
+        if (!blockRenderers.containsKey(modelId)) { return false; }
+        ISimpleBlockRenderingHandler bri = blockRenderers.get(modelId);
+        return bri.renderWorldBlock(world, x, y, z, block, modelId, renderer);
+    }
+
+    /**
+     * @param renderer
+     * @param block
+     * @param metadata
+     * @param modelID
+     */
+    public void renderInventoryBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
+    {
+        if (!blockRenderers.containsKey(modelID)) { return; }
+        ISimpleBlockRenderingHandler bri = blockRenderers.get(modelID);
+        bri.renderInventoryBlock(block, metadata, modelID, renderer);
+    }
+
+    /**
+     * @param p_1219_0_
+     * @return
+     */
+    public boolean renderItemAsFull3DBlock(int modelId)
+    {
+        ISimpleBlockRenderingHandler bri = blockRenderers.get(modelId);
+        return bri != null && bri.shouldRender3DInInventory();
+    }
+
+    public void loadEntityRenderers(Map<Class<? extends Entity>, Render> rendererMap)
+    {
+        for (EntityRendererInfo info : entityRenderers)
+        {
+            rendererMap.put(info.target, info.renderer);
+        }
+    }
+}

client/ibxm/Channel.java

@@ -1,946 +0,0 @@
-
-package ibxm;
-
-public class Channel {
-	public int pattern_loop_row;
-
-	private Module module;
-	private Instrument instrument;
-	private Sample sample;
-	private int[] global_volume, current_note;
-	private boolean linear_periods, fast_volume_slides, key_on, silent;
-	private int sample_idx, sample_frac, step, left_gain, right_gain;
-	private int volume, panning, fine_tune, period, porta_period, key_add;
-	private int tremolo_speed, tremolo_depth, tremolo_tick, tremolo_wave, tremolo_add;
-	private int vibrato_speed, vibrato_depth, vibrato_tick, vibrato_wave, vibrato_add;
-	private int volume_slide_param, portamento_param, retrig_param;
-	private int volume_envelope_tick, panning_envelope_tick;
-	private int effect_tick, trigger_tick, fade_out_volume, random_seed;
-
-	private int log_2_sampling_rate;
-	private static final int LOG_2_29024 = LogTable.log_2( 29024 );
-	private static final int LOG_2_8287 = LogTable.log_2( 8287 );
-	private static final int LOG_2_8363 = LogTable.log_2( 8363 );
-	private static final int LOG_2_1712 = LogTable.log_2( 1712 );
-
-	private static final int[] sine_table = new int[] {
-		  0, 24 ,  49,  74,  97, 120, 141, 161, 180, 197, 212, 224, 235, 244, 250, 253,
-		255, 253, 250, 244, 235, 224, 212, 197, 180, 161, 141, 120,  97,  74,  49,  24
-	};
-
-	public Channel( Module mod, int sampling_rate, int[] global_vol ) {
-		module = mod;
-		global_volume = global_vol;
-		linear_periods = module.linear_periods;
-		fast_volume_slides = module.fast_volume_slides;
-		current_note = new int[ 5 ];
-		log_2_sampling_rate = LogTable.log_2( sampling_rate );
-	}
-	
-	public void reset() {
-		tremolo_speed = 0;
-		tremolo_depth = 0;
-		tremolo_wave = 0;
-		vibrato_speed = 0;
-		vibrato_depth = 0;
-		vibrato_wave = 0;
-		volume_slide_param = 0;
-		portamento_param = 0;
-		retrig_param = 0;
-		random_seed = 0xABC123;
-		instrument = module.get_instrument( 0 );
-		row( 48, 256, 0, 0, 0 );
-	}
-	
-	public void resample( int[] mixing_buffer, int frame_offset, int frames, int quality ) {
-		if( !silent ) {
-			switch( quality ) {
-				default:
-					sample.resample_nearest( sample_idx, sample_frac, step, left_gain, right_gain, mixing_buffer, frame_offset, frames );
-					break;
-				case 1:
-					sample.resample_linear( sample_idx, sample_frac, step, left_gain, right_gain, mixing_buffer, frame_offset, frames );
-					break;
-				case 2:
-					sample.resample_sinc( sample_idx, sample_frac, step, left_gain, right_gain, mixing_buffer, frame_offset, frames );
-					break;
-			}
-		}
-	}
-
-	public void update_sample_idx( int samples ) {
-		sample_frac += step * samples;
-		sample_idx += sample_frac >> IBXM.FP_SHIFT;
-		sample_frac &= IBXM.FP_MASK;
-	}
-	
-	public void set_volume( int vol ) {
-		if( vol < 0 ) {
-			vol = 0;
-		}
-		if( vol > 64 ) {
-			vol = 64;
-		}
-		volume = vol;
-	}
-	
-	public void set_panning( int pan ) {
-		if( pan < 0 ) {
-			pan = 0;
-		}
-		if( pan > 255 ) {
-			pan = 255;
-		}
-		panning = pan;
-	}
-	
-	public void row( int key, int inst_idx, int volume_column, int effect, int effect_param ) {
-		effect = effect & 0xFF;
-		if( effect >= 0x30 ) {
-			/* Effects above 0x30 are internal.*/
-			effect = 0;
-		}
-		if( effect == 0x00 && effect_param != 0 ) {
-			/* Arpeggio.*/
-			effect = 0x40;
-		}
-		if( effect == 0x0E ) {
-			/* Renumber 0x0Ex effect command.*/
-			effect = 0x30 + ( ( effect_param & 0xF0 ) >> 4 );
-			effect_param = effect_param & 0x0F;
-		}
-		if( effect == 0x21 ) {
-			/* Renumber 0x21x effect command.*/
-			effect = 0x40 + ( ( effect_param & 0xF0 ) >> 4 );
-			effect_param = effect_param & 0x0F;
-		}
-		current_note[ 0 ] = key;
-		current_note[ 1 ] = inst_idx;
-		current_note[ 2 ] = volume_column;
-		current_note[ 3 ] = effect;
-		current_note[ 4 ] = effect_param;
-		effect_tick = 0;		
-		trigger_tick += 1;
-		update_envelopes();
-		key_add = 0;
-		vibrato_add = 0;
-		tremolo_add = 0;
-		if( ! ( effect == 0x3D && effect_param > 0 ) ) {
-			/* Not note delay.*/
-			trigger( key, inst_idx, volume_column, effect );
-			/* Handle volume column.*/
-			switch( volume_column & 0xF0 ) {
-				case 0x00:
-					/* Do nothing.*/
-					break;
-				case 0x60:
-					/* Volume slide down.*/
-					break;
-				case 0x70:
-					/* Volume slide up.*/
-					break;
-				case 0x80:
-					/* Fine volume slide down.*/
-					set_volume( volume - ( volume_column & 0x0F ) );
-					break;
-				case 0x90:
-					/* Fine volume slide up.*/
-					set_volume( volume + ( volume_column & 0x0F ) );
-					break;
-				case 0xA0:
-					/* Set vibrato speed.*/
-					set_vibrato_speed( volume_column & 0x0F );
-					break;
-				case 0xB0:
-					/* Vibrato.*/
-					set_vibrato_depth( volume_column & 0x0F );
-					vibrato();
-					break;
-				case 0xC0:
-					/* Set panning.*/
-					set_panning( ( volume_column & 0x0F ) << 4 );
-					break;
-				case 0xD0:
-					/* Panning slide left.*/
-					break;
-				case 0xE0:
-					/* Panning slide right.*/
-					break;
-				case 0xF0:
-					/* Tone portamento.*/
-					set_portamento_param( volume_column & 0x0F );
-					break;
-				default:
-					/* Set volume.*/
-					set_volume( volume_column - 0x10 );
-					break;
-			}
-		}
-		if( instrument.vibrato_depth > 0 ) {
-			auto_vibrato();
-		}
-		switch( effect ) {
-			case 0x01:
-				/* Portmento Up.*/
-				set_portamento_param( effect_param );
-				portamento_up();
-				break;
-			case 0x02:
-				/* Portamento Down.*/
-				set_portamento_param( effect_param );
-				portamento_down();
-				break;
-			case 0x03:
-				/* Tone Portamento.*/
-				set_portamento_param( effect_param );
-				break;
-			case 0x04:
-				/* Vibrato.*/
-				set_vibrato_speed( ( effect_param & 0xF0 ) >> 4 );
-				set_vibrato_depth( effect_param & 0x0F );
-				vibrato();
-				break;
-			case 0x05:
-				/* Tone Portamento + Volume Slide.*/
-				set_volume_slide_param( effect_param );
-				volume_slide();
-				break;
-			case 0x06:
-				/* Vibrato + Volume Slide.*/
-				set_volume_slide_param( effect_param );
-				vibrato();
-				volume_slide();
-				break;
-			case 0x07:
-				/* Tremolo.*/
-				set_tremolo_speed( ( effect_param & 0xF0 ) >> 4 );
-				set_tremolo_depth( effect_param & 0x0F );
-				tremolo();
-				break;
-			case 0x08:
-				/* Set Panning.*/
-				set_panning( effect_param );
-				break;
-			case 0x09:
-				/* Set Sample Index.*/
-				set_sample_index( effect_param << 8 );
-				break;
-			case 0x0A:
-				/* Volume Slide.*/
-				set_volume_slide_param( effect_param );
-				volume_slide();
-				break;
-			case 0x0B:
-				/* Pattern Jump.*/
-				break;
-			case 0x0C:
-				/* Set volume.*/
-				set_volume( effect_param );
-				break;
-			case 0x0D:
-				/* Pattern Break.*/
-				break;
-			case 0x0E:
-				/* Extended Commands (See 0x30-0x3F).*/
-				break;
-			case 0x0F:
-				/* Set Speed/Tempo.*/
-				break;
-			case 0x10:
-				/* Set Global Volume.*/
-				set_global_volume( effect_param );
-				break;
-			case 0x11:
-				/* global Volume Slide.*/
-				set_volume_slide_param( effect_param );
-				break;
-			case 0x14:
-				/* Key Off*/
-				if( effect_param == 0 ) {
-					key_on = false;
-				}
-				break;
-			case 0x15:
-				/* Set Envelope Tick.*/
-				set_envelope_tick( effect_param );
-				break;
-			case 0x19:
-				/* Panning Slide.*/
-				set_volume_slide_param( effect_param );
-				break;
-			case 0x1B:
-				/* Retrig + Volume Slide.*/
-				set_retrig_param( effect_param );
-				retrig_volume_slide();
-				break;
-			case 0x1D:
-				/* Tremor.*/
-				set_retrig_param( effect_param );
-				tremor();
-				break;
-			case 0x24:
-				/* S3M Fine Vibrato.*/
-				set_vibrato_speed( ( effect_param & 0xF0 ) >> 4 );
-				set_vibrato_depth( effect_param & 0x0F );
-				fine_vibrato();
-				break;
-			case 0x25:
-				/* S3M Set Speed.*/
-				break;
-			case 0x30:
-				/* Amiga Set Filter.*/
-				break;
-			case 0x31:
-				/* Fine Portamento Up.*/
-				set_portamento_param( 0xF0 | effect_param );
-				portamento_up();
-				break;
-			case 0x32:
-				/* Fine Portamento Down.*/
-				set_portamento_param( 0xF0 | effect_param );
-				portamento_down();
-				break;
-			case 0x33:
-				/* Set Glissando Mode.*/
-				break;
-			case 0x34:
-				/* Set Vibrato Waveform.*/
-				set_vibrato_wave( effect_param );
-				break;
-			case 0x35:
-				/* Set Fine Tune.*/
-				break;
-			case 0x36:
-				/* Pattern Loop.*/
-				break;
-			case 0x37:
-				/* Set Tremolo Waveform.*/
-				set_tremolo_wave( effect_param );
-				break;
-			case 0x38:
-				/* Set Panning(Obsolete).*/
-				break;
-			case 0x39:
-				/* Retrig.*/
-				set_retrig_param( effect_param );
-				break;
-			case 0x3A:
-				/* Fine Volume Slide Up.*/
-				set_volume_slide_param( ( effect_param << 4 ) | 0x0F );
-				volume_slide();
-				break;
-			case 0x3B:
-				/* Fine Volume Slide Down.*/
-				set_volume_slide_param( 0xF0 | effect_param );
-				volume_slide();
-				break;
-			case 0x3C:
-				/* Note Cut.*/
-				if( effect_param == 0 ) {
-					set_volume( 0 );
-				}
-				break;
-			case 0x3D:
-				/* Note Delay.*/
-				break;
-			case 0x3E:
-				/* Pattern Delay.*/
-				break;
-			case 0x3F:
-				/* Invert Loop.*/
-				break;
-			case 0x40:
-				/* Arpeggio.*/
-				break;
-			case 0x41:
-				/* Extra Fine Porta Up.*/
-				set_portamento_param( 0xE0 | effect_param );
-				portamento_up();
-				break;
-			case 0x42:
-				/* Extra Fine Porta Down.*/
-				set_portamento_param( 0xE0 | effect_param );
-				portamento_down();
-				break;
-		}
-		calculate_amplitude();
-		calculate_frequency();
-	}
-
-	public void tick() {
-		int volume_column, effect, effect_param;
-		volume_column = current_note[ 2 ];
-		effect = current_note[ 3 ];
-		effect_param = current_note[ 4 ];
-		effect_tick += 1;
-		if( effect == 0x3D && effect_param == effect_tick ) {
-			/* Note delay.*/
-			row( current_note[ 0 ], current_note[ 1 ], volume_column, 0, 0 );
-		} else {
-			trigger_tick += 1;
-			vibrato_tick += 1;
-			tremolo_tick += 1;
-			update_envelopes();
-			key_add = 0;
-			vibrato_add = 0;
-			tremolo_add = 0;
-			if( instrument.vibrato_depth > 0 ) {
-				auto_vibrato();
-			}
-			switch( volume_column & 0xF0 ) {
-				case 0x60:
-					/* Volume Slide Down.*/
-					set_volume( volume - ( volume_column & 0x0F ) );
-					break;
-				case 0x70:
-					/* Volume Slide Up.*/
-					set_volume( volume + ( volume_column & 0x0F ) );
-					break;
-				case 0xB0:
-					/* Vibrato.*/
-					vibrato();
-					break;
-				case 0xD0:
-					/* Panning Slide Left.*/
-					set_panning( panning - ( volume_column & 0x0F ) );
-					break;
-				case 0xE0:
-					/* Panning Slide Right.*/
-					set_panning( panning + ( volume_column & 0x0F ) );
-					break;
-				case 0xF0:
-					/* Tone Portamento.*/
-					tone_portamento();
-					break;
-			}
-			switch( effect ) {
-				case 0x01:
-					/* Portamento Up.*/
-					portamento_up();
-					break;
-				case 0x02:
-					/* Portamento Down.*/
-					portamento_down();
-					break;
-				case 0x03:
-					/* Tone Portamento.*/
-					tone_portamento();
-					break;
-				case 0x04:
-					/* Vibrato.*/
-					vibrato();
-					break;
-				case 0x05:
-					/* Tone Portamento + Volume Slide.*/
-					tone_portamento();
-					volume_slide();
-					break;
-				case 0x06:
-					/* Vibrato + Volume Slide */
-					vibrato();
-					volume_slide();
-					break;
-				case 0x07:
-					/* Tremolo.*/
-					tremolo();
-					break;
-				case 0x0A:
-					/* Volume Slide.*/
-					volume_slide();
-					break;
-				case 0x11:
-					/* Global Volume Slide.*/
-					global_volume_slide();
-					break;
-				case 0x14:
-					/* Key off.*/
-					if( effect_tick == effect_param ) {
-						key_on = false;
-					}
-					break;
-				case 0x19:
-					/* Panning Slide.*/
-					panning_slide();
-					break;
-				case 0x1B:
-					/* Retrig + Volume Slide.*/
-					retrig_volume_slide();
-					break;
-				case 0x1D:
-					/* Tremor.*/
-					tremor();
-					break;
-				case 0x24:
-					/* S3M Fine Vibrato.*/
-					fine_vibrato();
-					break;
-				case 0x39:
-					/* Retrig.*/
-					retrig_volume_slide();
-					break;
-				case 0x3C:
-					/* Note Cut.*/
-					if( effect_tick == effect_param ) {
-						set_volume( 0 );
-					}
-					break;
-				case 0x40:
-					/* Arpeggio.*/
-					switch( effect_tick % 3 ) {
-						case 1:
-							key_add = ( effect_param & 0xF0 ) >> 4;
-							break;
-						case 2:
-							key_add = effect_param & 0x0F;
-							break;
-					}
-					break;
-			}
-		}
-		calculate_amplitude();
-		calculate_frequency();
-	}
-
-	private void set_vibrato_speed( int speed ) {
-		if( speed > 0 ) {
-			vibrato_speed = speed;
-		}
-	}
-
-	private void set_vibrato_depth( int depth ) {
-		if( depth > 0 ) {
-			vibrato_depth = depth;
-		}
-	}
-	
-	private void set_vibrato_wave( int wave ) {
-		if( wave < 0 || wave > 7 ) {
-			wave = 0;
-		}
-		vibrato_wave = wave;
-	}
-
-	private void set_tremolo_speed( int speed ) {
-		if( speed > 0 ) {
-			tremolo_speed = speed;
-		}
-	}
-
-	private void set_tremolo_depth( int depth ) {
-		if( depth > 0 ) {
-			tremolo_depth = depth;
-		}
-	}
-
-	private void set_tremolo_wave( int wave ) {
-		if( wave < 0 || wave > 7 ) {
-			wave = 0;
-		}
-		tremolo_wave = wave;
-	}
-
-	private void vibrato() {
-		int vibrato_phase;
-		vibrato_phase = vibrato_tick * vibrato_speed;
-		vibrato_add += waveform( vibrato_phase, vibrato_wave ) * vibrato_depth >> 5;
-	}
-
-	private void fine_vibrato() {
-		int vibrato_phase;
-		vibrato_phase = vibrato_tick * vibrato_speed;
-		vibrato_add += waveform( vibrato_phase, vibrato_wave ) * vibrato_depth >> 7;
-	}
-
-	private void tremolo() {
-		int tremolo_phase;
-		tremolo_phase = tremolo_tick * tremolo_speed;
-		tremolo_add += waveform( tremolo_phase, tremolo_wave ) * tremolo_depth >> 6;
-	}
-
-	private void set_portamento_param( int param ) {
-		if( param != 0 ) {
-			portamento_param = param;
-		}
-	}
-
-	private void tone_portamento() {
-		int new_period;
-		if( porta_period < period ) {
-			new_period = period - ( portamento_param << 2 );
-			if( new_period < porta_period ) {
-				new_period = porta_period;
-			}
-			set_period( new_period );
-		}
-		if( porta_period > period ) {
-			new_period = period + ( portamento_param << 2 );
-			if( new_period > porta_period ) {
-				new_period = porta_period;
-			}
-			set_period( new_period );
-		}
-	}
-	
-	private void portamento_up() {
-		if( ( portamento_param & 0xF0 ) == 0xE0 ) {
-			/* Extra-fine porta.*/
-			if( effect_tick == 0 ) {
-				set_period( period - ( portamento_param & 0x0F ) );
-			}	
-		} else if( ( portamento_param & 0xF0 ) == 0xF0 ) {
-			/* Fine porta.*/
-			if( effect_tick == 0 ) {
-				set_period( period - ( ( portamento_param & 0x0F ) << 2 ) );
-			}
-		} else {
-			/* Normal porta.*/
-			if( effect_tick > 0 ) {
-				set_period( period - ( portamento_param << 2 ) );
-			}
-		}
-	}
-	
-	private void portamento_down() {
-		if( ( portamento_param & 0xF0 ) == 0xE0 ) {
-			/* Extra-fine porta.*/
-			if( effect_tick == 0 ) {
-				set_period( period + ( portamento_param & 0x0F ) );
-			}	
-		} else if( ( portamento_param & 0xF0 ) == 0xF0 ) {
-			/* Fine porta.*/
-			if( effect_tick == 0 ) {
-				set_period( period + ( ( portamento_param & 0x0F ) << 2 ) );
-			}
-		} else {
-			/* Normal porta.*/
-			if( effect_tick > 0 ) {
-				set_period( period + ( portamento_param << 2 ) );
-			}
-		}
-	}
-
-	private void set_period( int p ) {
-		if( p < 32 ) {
-			p = 32;
-		}
-		if( p > 32768 ) {
-			p = 32768;
-		}
-		period = p;
-	}
-
-	private void set_global_volume( int vol ) {
-		if( vol < 0 ) {
-			vol = 0;
-		}
-		if( vol > 64 ) {
-			vol = 64;
-		}
-		global_volume[ 0 ] = vol;
-	}
-
-	private void set_volume_slide_param( int param ) {
-		if( param != 0 ) {
-			volume_slide_param = param;
-		}
-	}
-
-	private void global_volume_slide() {
-		int up, down;
-		up = ( volume_slide_param & 0xF0 ) >> 4;
-		down = volume_slide_param & 0x0F;
-		set_global_volume( global_volume[ 0 ] + up - down );
-	}
-
-	private void volume_slide() {
-		int up, down;
-		up = ( volume_slide_param & 0xF0 ) >> 4;
-		down = volume_slide_param & 0x0F;
-		if( down == 0x0F && up > 0 ) {
-			/* Fine slide up.*/
-			if( effect_tick == 0 ) {
-				set_volume( volume + up );
-			}
-		} else if( up == 0x0F && down > 0 ) {
-			/* Fine slide down.*/
-			if( effect_tick == 0 ) {
-				set_volume( volume - down );
-			}
-		} else {
-			/* Normal slide.*/
-			if( effect_tick > 0 || fast_volume_slides ) {
-				set_volume( volume + up - down );
-			}
-		}
-	}
-
-	private void panning_slide() {
-		int left, right;
-		left = ( volume_slide_param & 0xF0 ) >> 4;
-		right = volume_slide_param & 0x0F;
-		set_panning( panning - left + right );
-	}
-
-	private void set_retrig_param( int param ) {
-		if( param != 0 ) {
-			retrig_param = param;
-		}
-	}
-
-	private void tremor() {
-		int on_ticks, cycle_length, cycle_index;
-		on_ticks = ( ( retrig_param & 0xF0 ) >> 4 ) + 1;
-		cycle_length = on_ticks + ( retrig_param & 0x0F ) + 1;
-		cycle_index = trigger_tick % cycle_length;
-		if( cycle_index >= on_ticks ) {
-			tremolo_add = -64;
-		}
-	}
-
-	private void retrig_volume_slide() {
-		int retrig_volume, retrig_tick;
-		retrig_volume = ( retrig_param & 0xF0 ) >> 4;
-		retrig_tick = retrig_param & 0x0F;
-		if( retrig_tick > 0 && ( trigger_tick % retrig_tick ) == 0 ) {
-			set_sample_index( 0 );
-			switch( retrig_volume ) {
-				case 0x01:
-					set_volume( volume - 1 );
-					break;
-				case 0x02:
-					set_volume( volume - 2 );
-					break;
-				case 0x03:
-					set_volume( volume - 4 );
-					break;
-				case 0x04:
-					set_volume( volume - 8 );
-					break;
-				case 0x05:
-					set_volume( volume - 16 );
-					break;
-				case 0x06:
-					set_volume( volume - volume / 3 );
-					break;
-				case 0x07:
-					set_volume( volume / 2 );
-					break;
-				case 0x09:
-					set_volume( volume + 1 );
-					break;
-				case 0x0A:
-					set_volume( volume + 2 );
-					break;
-				case 0x0B:
-					set_volume( volume + 4 );
-					break;
-				case 0x0C:
-					set_volume( volume + 8 );
-					break;
-				case 0x0D:
-					set_volume( volume + 16 );
-					break;
-				case 0x0E:
-					set_volume( volume + volume / 2 );
-					break;
-				case 0x0F:
-					set_volume( volume * 2 );
-					break;
-			}
-		}
-	}
-
-	private void set_sample_index( int index ) {
-		if( index < 0 ) {
-			index = 0;
-		}
-		sample_idx = index;
-		sample_frac = 0;
-	}
-
-	private void set_envelope_tick( int tick ) {
-		volume_envelope_tick = tick;
-		panning_envelope_tick = tick;
-	}
-
-	private void trigger( int key, int instrument_idx, int volume_column, int effect ) {
-		if( instrument_idx > 0 ) {
-			instrument = module.get_instrument( instrument_idx );
-			sample = instrument.get_sample_from_key( key );
-			set_volume( sample.volume );
-			if( sample.set_panning ) {
-				set_panning( sample.panning );
-			}
-			set_envelope_tick( 0 );
-			fade_out_volume = 32768;
-			key_on = true;
-		}
-		if( key > 0 ) {
-			if( key < 97 ) {
-				porta_period = key_to_period( key );
-				if( effect != 0x03 && effect != 0x05 ) {
-					if( ( volume_column & 0xF0 ) != 0xF0 ) {
-						/* Not portamento.*/
-						trigger_tick = 0;
-						if( vibrato_wave < 4 ) {
-							vibrato_tick = 0;
-						}
-						if( tremolo_wave < 4 ) {
-							tremolo_tick = 0;
-						}
-						set_period( porta_period );
-						set_sample_index( 0 );
-					}
-				}
-			} else {
-				/* Key off.*/
-				key_on = false;
-			}
-		}
-	}
-
-	private void update_envelopes() {
-		Envelope envelope;
-		if( instrument.volume_envelope_active ) {
-			if( !key_on ) {
-				fade_out_volume -= instrument.volume_fade_out & 0xFFFF;
-				if( fade_out_volume < 0 ) {
-					fade_out_volume = 0;
-				}
-			}
-			envelope = instrument.get_volume_envelope();
-			volume_envelope_tick = envelope.next_tick( volume_envelope_tick, key_on );
-		}
-		if( instrument.panning_envelope_active ) {
-			envelope = instrument.get_panning_envelope();
-			panning_envelope_tick = envelope.next_tick( panning_envelope_tick, key_on );
-		}
-	}
-
-	private void auto_vibrato() {
-		int sweep, depth, rate;
-		sweep = instrument.vibrato_sweep & 0xFF;
-		depth = instrument.vibrato_depth & 0x0F;
-		rate = instrument.vibrato_rate & 0x3F;
-		if( trigger_tick < sweep ) {
-			depth = depth * trigger_tick / sweep;
-		}
-		vibrato_add += waveform( trigger_tick * rate, 0 ) * depth >> 9;
-	}
-
-	private int waveform( int phase, int wform ) {
-		int amplitude;
-		amplitude = 0;
-		switch( wform & 0x3 ) {
-			case 0:
-				/* Sine. */
-				if( ( phase & 0x20 ) == 0 ) {
-					amplitude =  sine_table[ phase & 0x1F ];
-				} else {
-					amplitude = -sine_table[ phase & 0x1F ];
-				}
-				break;
-			case 1:
-				/* Saw. */
-				if( ( phase & 0x20 ) == 0 ) {
-					amplitude =   ( phase & 0x1F ) << 3;
-				} else {
-					amplitude = ( ( phase & 0x1F ) << 3 ) - 255;
-				}
-				break;
-			case 2:
-				/* Square. */
-				if( ( phase & 0x20 ) == 0 ) {
-					amplitude =  255;
-				} else {
-					amplitude = -255;
-				}
-				break;
-			case 3:
-				/* Random. */
-				amplitude = ( random_seed >> 15 ) - 255;
-				random_seed = ( random_seed * 65 + 17 ) & 0xFFFFFF;
-				break;
-		}
-		return amplitude;
-	}
-
-	private int key_to_period( int key ) {
-		int octave, log_2_period, period_out;
-		octave = ( key << IBXM.FP_SHIFT ) / 12 + sample.transpose;
-		if( linear_periods ) {
-			period_out = 7744 - ( octave * 768 >> IBXM.FP_SHIFT );
-		} else {
-			log_2_period = LOG_2_29024 - octave;
-			period_out = LogTable.raise_2( log_2_period );
-			period_out = period_out >> ( IBXM.FP_SHIFT - 1 );
-			period_out = ( period_out >> 1 ) + ( period_out & 1 );
-		}
-		return period_out;
-	}
-
-	private void calculate_amplitude() {
-		int envelope_volume, tremolo_volume, amplitude;
-		int envelope_panning, mixer_panning, panning_range;
-		Envelope envelope;
-		envelope_volume = 0;
-		if( instrument.volume_envelope_active ) {
-			envelope = instrument.get_volume_envelope();
-			envelope_volume = envelope.calculate_ampl( volume_envelope_tick );
-		} else {
-			if( key_on ) {
-				envelope_volume = 64;
-			}
-		}
-		tremolo_volume = volume + tremolo_add;
-		if( tremolo_volume < 0 ) {
-			tremolo_volume = 0;
-		}
-		if( tremolo_volume > 64 ) {
-			tremolo_volume = 64;
-		}
-		amplitude = tremolo_volume << IBXM.FP_SHIFT - 6;
-		amplitude = amplitude * envelope_volume >> 6;
-		amplitude = amplitude * fade_out_volume >> 15;
-		amplitude = amplitude * global_volume[ 0 ] >> 6;
-		amplitude = amplitude * module.channel_gain >> IBXM.FP_SHIFT;
-		silent = sample.has_finished( sample_idx );
-		if( amplitude <= 0 ) {
-			silent = true;
-		} else {
-			envelope_panning = 32;
-			if( instrument.panning_envelope_active ) {
-				envelope = instrument.get_panning_envelope();
-				envelope_panning = envelope.calculate_ampl( panning_envelope_tick );
-			}
-			mixer_panning = ( panning & 0xFF ) << IBXM.FP_SHIFT - 8;
-			panning_range = IBXM.FP_ONE - mixer_panning;
-			if( panning_range > mixer_panning ) {
-				panning_range = mixer_panning;
-			}
-			mixer_panning = mixer_panning + ( panning_range * ( envelope_panning - 32 ) >> 5 );
-			left_gain = amplitude * ( IBXM.FP_ONE - mixer_panning ) >> IBXM.FP_SHIFT;
-			right_gain = amplitude * mixer_panning >> IBXM.FP_SHIFT;
-		}
-	}
-
-	private void calculate_frequency() {
-		int vibrato_period, log_2_freq;	
-		vibrato_period = period + vibrato_add;
-		if( vibrato_period < 32 ) {
-			vibrato_period = 32;
-		}
-		if( vibrato_period > 32768 ) {
-			vibrato_period = 32768;
-		}
-		if( linear_periods ) {
-			log_2_freq = LOG_2_8363 + ( 4608 - vibrato_period << IBXM.FP_SHIFT ) / 768;
-		} else {
-			log_2_freq = module.pal ? LOG_2_8287 : LOG_2_8363;
-			log_2_freq = log_2_freq + LOG_2_1712 - LogTable.log_2( vibrato_period );
-		}
-		log_2_freq += ( key_add << IBXM.FP_SHIFT ) / 12;
-		step = LogTable.raise_2( log_2_freq - log_2_sampling_rate );
-	}
-}
-

client/ibxm/Envelope.java

@@ -1,111 +0,0 @@
-
-package ibxm;
-
-public class Envelope {
-	public boolean sustain, looped;
-	private int sustain_tick, loop_start_tick, loop_end_tick;
-	private int[] ticks, ampls;
-
-	public Envelope() {
-		set_num_points( 1 );
-	}
-
-	public void set_num_points( int num_points ) {
-		int point;
-		if( num_points <= 0 ) {
-			num_points = 1;
-		}
-		ticks = new int[ num_points ];
-		ampls = new int[ num_points ];
-		set_point( 0, 0, 0, false );
-	}
-
-	/* When you set a point, all subsequent points are reset. */
-	public void set_point( int point, int tick, int ampl, boolean delta ) {
-		if( point >= 0 && point < ticks.length ) {
-			if( point == 0 ) {
-				tick = 0;
-			}
-			if( point > 0 ) {
-				if( delta ) tick += ticks[ point - 1 ];
-				if( tick <= ticks[ point - 1 ] ) {
-					System.out.println( "Envelope: Point not valid (" + tick + " <= " + ticks[ point - 1 ] + ")");
-					tick = ticks[ point - 1 ] + 1;
-				}
-			}
-			ticks[ point ] = tick;
-			ampls[ point ] = ampl;
-			point += 1;
-			while( point < ticks.length ) {
-				ticks[ point ] = ticks[ point - 1 ] + 1;
-				ampls[ point ] = 0;
-				point += 1;
-			}
-		}
-	}
-
-	public void set_sustain_point( int point ) {
-		if( point < 0 ) {
-			point = 0;
-		}
-		if( point >= ticks.length ) {
-			point = ticks.length - 1;
-		}
-		sustain_tick = ticks[ point ];
-	}
-
-	public void set_loop_points( int start, int end ) {
-		if( start < 0 ) {
-			start = 0;
-		}
-		if( start >= ticks.length ) {
-			start = ticks.length - 1;
-		}
-		if( end < start || end >= ticks.length ) {
-			end = start;
-		}
-		loop_start_tick = ticks[ start ];
-		loop_end_tick = ticks[ end ];
-	}
-
-	public int next_tick( int tick, boolean key_on ) {
-		tick = tick + 1;
-		if( looped && tick >= loop_end_tick ) {
-			tick = loop_start_tick;
-		}
-		if( sustain && key_on && tick >= sustain_tick ) {
-			tick = sustain_tick;
-		}
-		return tick;
-	}
-
-	public int calculate_ampl( int tick ) {
-		int idx, point, delta_t, delta_a, ampl;
-		ampl = ampls[ ticks.length - 1 ];
-		if( tick < ticks[ ticks.length - 1 ] ) {
-			point = 0;
-			for( idx = 1; idx < ticks.length; idx++ ) {
-				if( ticks[ idx ] <= tick ) {
-					point = idx;
-				}
-			}
-			delta_t = ticks[ point + 1 ] - ticks[ point ];
-			delta_a = ampls[ point + 1 ] - ampls[ point ];
-			ampl = ( delta_a << IBXM.FP_SHIFT ) / delta_t;
-			ampl = ampl * ( tick - ticks[ point ] ) >> IBXM.FP_SHIFT;
-			ampl = ampl + ampls[ point ];
-		}
-		return ampl;
-	}
-	
-	public void dump() {
-		int idx, tick;
-		for( idx = 0; idx < ticks.length; idx++ ) {
-			System.out.println( ticks[ idx ] + ", " + ampls[ idx ] );
-		}
-		for( tick = 0; tick < 222; tick++ ) {
-			System.out.print( calculate_ampl( tick ) + ", " );
-		}
-	}
-}
-

client/ibxm/FastTracker2.java

@@ -1,256 +0,0 @@
-
-package ibxm;
-
-import java.io.*;
-
-public class FastTracker2 {
-	public static boolean is_xm( byte[] header_60_bytes ) {
-		String xm_identifier;
-		xm_identifier = ascii_text( header_60_bytes, 0, 17 );
-		return xm_identifier.equals( "Extended Module: " );
-	}
-
-	public static Module load_xm( byte[] header_60_bytes, DataInput data_input ) throws IOException {
-		int xm_version, song_header_length, sequence_length;
-		int num_channels, num_patterns, num_instruments, xm_flags, idx;
-		byte[] structure_header, song_header;
-		boolean delta_env;
-		String tracker_name;
-		Instrument instrument;
-		Module module;
-		if( !is_xm( header_60_bytes ) ) {
-			throw new IllegalArgumentException( "Not an XM file!" );
-		}
-		xm_version = unsigned_short_le( header_60_bytes, 58 );
-		if( xm_version != 0x0104 ) {
-			throw new IllegalArgumentException( "Sorry, XM version " + xm_version + " is not supported!" );
-		}
-		module = new Module();
-		module.song_title = ascii_text( header_60_bytes, 17, 20 );
-		tracker_name = ascii_text( header_60_bytes, 38, 20 );
-		delta_env = tracker_name.startsWith( "DigiBooster Pro" );
-		structure_header = new byte[ 4 ];
-		data_input.readFully( structure_header );
-		song_header_length = int_le( structure_header, 0 );
-		song_header = new byte[ song_header_length ];
-		data_input.readFully( song_header, 4, song_header_length - 4 );
-		sequence_length = unsigned_short_le( song_header, 4 );
-		module.restart_sequence_index = unsigned_short_le( song_header, 6 );
-		num_channels = unsigned_short_le( song_header, 8 );
-		num_patterns = unsigned_short_le( song_header, 10 );
-		num_instruments = unsigned_short_le( song_header, 12 );
-		xm_flags = unsigned_short_le( song_header, 14 );
-		module.linear_periods = ( xm_flags & 0x1 ) == 0x1;
-		module.global_volume = 64;
-		module.channel_gain = IBXM.FP_ONE * 3 / 8;
-		module.default_speed = unsigned_short_le( song_header, 16 );
-		module.default_tempo = unsigned_short_le( song_header, 18 );
-		module.set_num_channels( num_channels );
-		for( idx = 0; idx < num_channels; idx++ ) {
-			module.set_initial_panning( idx, 128 );
-		}
-		module.set_sequence_length( sequence_length );		
-		for( idx = 0; idx < sequence_length; idx++ ) {
-			module.set_sequence( idx, song_header[ 20 + idx ] & 0xFF );
-		}
-		module.set_num_patterns( num_patterns );
-		for( idx = 0; idx < num_patterns; idx++ ) {
-			module.set_pattern( idx, read_xm_pattern( data_input, num_channels ) );
-		}
-		module.set_num_instruments( num_instruments );
-		for( idx = 1; idx <= num_instruments; idx++ ) {
-			try {
-				instrument = read_xm_instrument( data_input, delta_env );
-				module.set_instrument( idx, instrument );
-			} catch( EOFException e ) {
-				System.out.println( "Instrument " + idx + " is missing!" );
-			}
-		}
-		return module;
-	}
-
-	private static Pattern read_xm_pattern( DataInput data_input, int num_channels ) throws IOException {
-		int pattern_header_length, packing_type, num_rows, pattern_data_length;
-		byte[] structure_header, pattern_header, pattern_data;
-		Pattern pattern;
-		structure_header = new byte[ 4 ];
-		data_input.readFully( structure_header );
-		pattern_header_length = int_le( structure_header, 0 );
-		pattern_header = new byte[ pattern_header_length ];
-		data_input.readFully( pattern_header, 4, pattern_header_length - 4 );
-		packing_type = pattern_header[ 4 ];
-		if( packing_type != 0 ) {
-			throw new IllegalArgumentException( "Pattern packing type " + packing_type + " is not supported!" );
-		}
-		pattern = new Pattern();
-		pattern.num_rows = unsigned_short_le( pattern_header, 5 );
-		pattern_data_length = unsigned_short_le( pattern_header, 7 );
-		pattern_data = new byte[ pattern_data_length ];
-		data_input.readFully( pattern_data );		
-		pattern.set_pattern_data( pattern_data );
-		return pattern;
-	}
-	
-	private static Instrument read_xm_instrument( DataInput data_input, boolean delta_env ) throws IOException {
-		int instrument_header_length, num_samples, idx;
-		int env_tick, env_ampl, env_num_points, flags;
-		byte[] structure_header, instrument_header, sample_headers;
-		Instrument instrument;
-		Envelope envelope;
-		structure_header = new byte[ 4 ];
-		data_input.readFully( structure_header );
-		instrument_header_length = int_le( structure_header, 0 );
-		instrument_header = new byte[ instrument_header_length ];
-		data_input.readFully( instrument_header, 4, instrument_header_length - 4 );
-		instrument = new Instrument();
-		instrument.name = ascii_text( instrument_header, 4, 22 );
-		num_samples = unsigned_short_le( instrument_header, 27 );
-		if( num_samples > 0 ) {
-			instrument.set_num_samples( num_samples );
-			for( idx = 0; idx < 96; idx++ ) {
-				instrument.set_key_to_sample( idx + 1, instrument_header[ 33 + idx ] & 0xFF );
-			}
-			envelope = new Envelope();
-			env_num_points = instrument_header[ 225 ] & 0xFF;
-			envelope.set_num_points( env_num_points );
-			for( idx = 0; idx < env_num_points; idx++ ) {
-				env_tick = unsigned_short_le( instrument_header, 129 + idx * 4 );
-				env_ampl = unsigned_short_le( instrument_header, 131 + idx * 4 );
-				envelope.set_point( idx, env_tick, env_ampl, delta_env );
-			}
-			envelope.set_sustain_point( instrument_header[ 227 ] & 0xFF );
-			envelope.set_loop_points( instrument_header[ 228 ] & 0xFF, instrument_header[ 229 ] & 0xFF );
-			flags = instrument_header[ 233 ] & 0xFF;
-			instrument.volume_envelope_active = ( flags & 0x1 ) == 0x1;
-			envelope.sustain = ( flags & 0x2 ) == 0x2;
-			envelope.looped = ( flags & 0x4 ) == 0x4;
-			instrument.set_volume_envelope( envelope );
-			envelope = new Envelope();
-			env_num_points = instrument_header[ 226 ] & 0xFF;
-			envelope.set_num_points( env_num_points );
-			for( idx = 0; idx < env_num_points; idx++ ) {
-				env_tick = unsigned_short_le( instrument_header, 177 + idx * 4 );
-				env_ampl = unsigned_short_le( instrument_header, 179 + idx * 4 );
-				envelope.set_point( idx, env_tick, env_ampl, delta_env );
-			}
-			envelope.set_sustain_point( instrument_header[ 230 ] & 0xFF );
-			envelope.set_loop_points( instrument_header[ 231 ] & 0xFF, instrument_header[ 232 ] & 0xFF );
-			flags = instrument_header[ 234 ] & 0xFF;
-			instrument.panning_envelope_active = ( flags & 0x1 ) == 0x1;
-			envelope.sustain = ( flags & 0x2 ) == 0x2;
-			envelope.looped = ( flags & 0x4 ) == 0x4;
-			instrument.set_panning_envelope( envelope );
-			instrument.vibrato_type = instrument_header[ 235 ] & 0xFF;
-			instrument.vibrato_sweep = instrument_header[ 236 ] & 0xFF;
-			instrument.vibrato_depth = instrument_header[ 237 ] & 0xFF;
-			instrument.vibrato_rate = instrument_header[ 238 ] & 0xFF;
-			instrument.volume_fade_out = unsigned_short_le( instrument_header, 239 );
-			sample_headers = new byte[ num_samples * 40 ];
-			data_input.readFully( sample_headers );
-			for( idx = 0; idx < num_samples; idx++ ) {
-				instrument.set_sample( idx, read_xm_sample( sample_headers, idx, data_input ) );
-			}
-		}
-		return instrument;
-	}
-
-	private static Sample read_xm_sample( byte[] sample_headers, int sample_idx, DataInput data_input ) throws IOException {
-		int header_offset, sample_length, loop_start, loop_length;
-		int flags, in_idx, out_idx, sam, last_sam;
-		int fine_tune, relative_note;
-		boolean sixteen_bit, ping_pong;
-		byte[] raw_sample_data;
-		short[] decoded_sample_data;
-		Sample sample;
-		header_offset = sample_idx * 40;
-		sample = new Sample();
-		sample_length = int_le( sample_headers, header_offset );		
-		loop_start = int_le( sample_headers, header_offset + 4 );
-		loop_length = int_le( sample_headers, header_offset + 8 );
-		sample.volume = sample_headers[ header_offset + 12 ] & 0xFF;
-		fine_tune = sample_headers[ header_offset + 13 ];
-		fine_tune = ( fine_tune << IBXM.FP_SHIFT ) / 1536;
-		sample.set_panning = true;
-		flags = sample_headers[ header_offset + 14 ] & 0xFF;
-		if( ( flags & 0x03 ) == 0 ) {
-			loop_length = 0;
-		}
-		ping_pong = ( flags & 0x02 ) == 0x02;
-		sixteen_bit = ( flags & 0x10 ) == 0x10;
-		sample.panning = sample_headers[ header_offset + 15 ] & 0xFF;
-		relative_note = sample_headers[ header_offset + 16 ];
-		relative_note = ( relative_note << IBXM.FP_SHIFT ) / 12;
-		sample.transpose = relative_note + fine_tune;
-		sample.name = ascii_text( sample_headers, header_offset + 18, 22 );
-		raw_sample_data = new byte[ sample_length ];
-		try {
-			data_input.readFully( raw_sample_data );
-		} catch( EOFException e ) {
-			System.out.println( "Sample has been truncated!" );
-		}
-		in_idx = 0;
-		out_idx = 0;
-		sam = 0;
-		last_sam = 0;
-		if( sixteen_bit ) {
-			decoded_sample_data = new short[ sample_length >> 1 ];
-			while( in_idx < raw_sample_data.length ) {
-				sam = raw_sample_data[ in_idx ] & 0xFF;
-				sam = sam | ( ( raw_sample_data[ in_idx + 1 ] & 0xFF ) << 8 );
-				last_sam = last_sam + sam;
-				decoded_sample_data[ out_idx ] = ( short ) last_sam;
-				in_idx += 2;
-				out_idx += 1;
-			}
-			sample.set_sample_data( decoded_sample_data, loop_start >> 1, loop_length >> 1, ping_pong );
-		} else {
-			decoded_sample_data = new short[ sample_length ];
-			while( in_idx < raw_sample_data.length ) {
-				sam = raw_sample_data[ in_idx ] & 0xFF;
-				last_sam = last_sam + sam;
-				decoded_sample_data[ out_idx ] = ( short ) ( last_sam << 8 );
-				in_idx += 1;
-				out_idx += 1;
-			}
-			sample.set_sample_data( decoded_sample_data, loop_start, loop_length, ping_pong );
-		}
-		return sample;
-	}
-
-	private static int unsigned_short_le( byte[] buffer, int offset ) {
-		int value;
-		value = buffer[ offset ] & 0xFF;
-		value = value | ( ( buffer[ offset + 1 ] & 0xFF ) << 8 );
-		return value;
-	}
-
-	private static int int_le( byte[] buffer, int offset ) {
-		int value;
-		value = buffer[ offset ] & 0xFF;
-		value = value | ( ( buffer[ offset + 1 ] & 0xFF ) << 8 );
-		value = value | ( ( buffer[ offset + 2 ] & 0xFF ) << 16 );
-		value = value | ( ( buffer[ offset + 3 ] & 0x7F ) << 24 );
-		return value;
-	}
-	
-	private static String ascii_text( byte[] buffer, int offset, int length ) {
-		int idx, chr;
-		byte[] string_buffer;
-		String string;
-		string_buffer = new byte[ length ];
-		for( idx = 0; idx < length; idx++ ) {
-			chr = buffer[ offset + idx ];
-			if( chr < 32 ) {
-				chr = 32;
-			}
-			string_buffer[ idx ] = ( byte ) chr;
-		}
-		try {
-			string = new String( string_buffer, 0, length, "ISO-8859-1" );
-		} catch( UnsupportedEncodingException e ) {
-			string = "";
-		}
-		return string;
-	}
-}
-

client/ibxm/IBXM.java

@@ -1,343 +0,0 @@
-
-package ibxm;
-
-public class IBXM {
-	public static final String VERSION = "ibxm alpha 51 (c)2008 [email protected]";
-
-	public static final int FP_SHIFT = 15;
-	public static final int FP_ONE = 1 << FP_SHIFT;
-	public static final int FP_MASK = FP_ONE - 1;
-
-	private int sampling_rate, resampling_quality, volume_ramp_length;
-	private int tick_length_samples, current_tick_samples;
-	private int[] mixing_buffer, volume_ramp_buffer;
-
-	private Module module;
-	private Channel[] channels;
-	private int[] global_volume, note;
-	private int current_sequence_index, next_sequence_index;
-	private int current_row, next_row;
-	private int tick_counter, ticks_per_row;
-	private int pattern_loop_count, pattern_loop_channel;
-
-	public IBXM( int sample_rate ) {
-        
-/** MODIFIED 13 Oct 2009 by Paul Lamb **/
-//		System.out.println( VERSION );
-/***************************************/
-
-		if( sample_rate < 8000 ) {
-			sample_rate = 8000;
-		}
-		sampling_rate = sample_rate;
-		volume_ramp_length = sampling_rate >> 10;
-		volume_ramp_buffer = new int[ volume_ramp_length * 2 ];
-		mixing_buffer = new int[ sampling_rate / 6 ];
-		global_volume = new int[ 1 ];
-		note = new int[ 5 ];
-		set_module( new Module() );
-		set_resampling_quality( 1 );
-	}
-	
-	public void set_module( Module m ) {
-		int channel_idx;
-		module = m;
-		channels = new Channel[ module.get_num_channels() ];
-		for( channel_idx = 0; channel_idx < channels.length; channel_idx++ ) {
-			channels[ channel_idx ] = new Channel( module, sampling_rate, global_volume );
-		}
-		set_sequence_index( 0, 0 );
-	}
-
-	public void set_resampling_quality( int quality ) {
-		resampling_quality = quality;
-	}
-	
-	public int calculate_song_duration() {
-		int song_duration;
-		set_sequence_index( 0, 0 );
-		next_tick();
-		song_duration = tick_length_samples;
-		while( !next_tick() ) {
-			song_duration += tick_length_samples;
-		}
-		set_sequence_index( 0, 0 );
-		return song_duration;
-	}
-	
-	public void set_sequence_index( int sequence_index, int row ) {
-		int channel_idx;
-		global_volume[ 0 ] = 64;
-		for( channel_idx = 0; channel_idx < channels.length; channel_idx++ ) {
-			channels[ channel_idx ].reset();
-			channels[ channel_idx ].set_panning( module.get_initial_panning( channel_idx ) );
-		}
-		set_global_volume( module.global_volume );
-		set_speed( 6 );
-		set_speed( module.default_speed );
-		set_tempo( 125 );
-		set_tempo( module.default_tempo );
-		pattern_loop_count = -1;
-		next_sequence_index = sequence_index;
-		next_row = row;
-		tick_counter = 0;
-		current_tick_samples = tick_length_samples;
-		clear_vol_ramp_buffer();
-	}
-
-	public void seek( int sample_position ) {
-		int idx;
-		set_sequence_index( 0, 0 );
-		next_tick();
-		while( sample_position > tick_length_samples ) {
-			sample_position -= tick_length_samples;
-			next_tick();
-		}
-		mix_tick();
-		current_tick_samples = sample_position;
-	}
-
-	public void get_audio( byte[] output_buffer, int frames ) {
-		int output_idx, mix_idx, mix_end, count, amplitude;
-		output_idx = 0;
-		while( frames > 0 ) {
-			count = tick_length_samples - current_tick_samples;
-			if( count > frames ) {
-				count = frames;
-			}
-			mix_idx = current_tick_samples << 1;
-			mix_end = mix_idx + ( count << 1 ) - 1;
-			while( mix_idx <= mix_end ) {
-				amplitude = mixing_buffer[ mix_idx ];
-				if( amplitude > 32767 ) {
-					amplitude = 32767;
-				}
-				if( amplitude < -32768 ) {
-					amplitude = -32768;
-				}
-				output_buffer[ output_idx     ] = ( byte ) ( amplitude >> 8 );
-				output_buffer[ output_idx + 1 ] = ( byte ) ( amplitude & 0xFF );
-				output_idx += 2;
-				mix_idx += 1;
-			}
-			current_tick_samples = mix_idx >> 1;
-			frames -= count;
-			if( frames > 0 ) {
-				next_tick();
-				mix_tick();
-				current_tick_samples = 0;
-			}
-		}
-	}
-
-	private void mix_tick() {
-		int channel_idx, mix_idx, mix_len;
-		mix_idx = 0;
-		mix_len = tick_length_samples + volume_ramp_length << 1;
-		while( mix_idx < mix_len ) {
-			mixing_buffer[ mix_idx ] = 0;
-			mix_idx += 1;
-		}
-		for( channel_idx = 0; channel_idx < channels.length; channel_idx++ ) {
-			mix_len = tick_length_samples + volume_ramp_length;
-			channels[ channel_idx ].resample( mixing_buffer, 0, mix_len, resampling_quality );
-		}
-		volume_ramp();
-	}
-
-	private boolean next_tick() {
-		int channel_idx;
-		boolean song_end;
-		for( channel_idx = 0; channel_idx < channels.length; channel_idx++ ) {
-			channels[ channel_idx ].update_sample_idx( tick_length_samples );
-		}
-		tick_counter -= 1;
-		if( tick_counter <= 0 ) {
-			tick_counter = ticks_per_row;
-			song_end = next_row();
-		} else {
-			for( channel_idx = 0; channel_idx < channels.length; channel_idx++ ) {
-				channels[ channel_idx ].tick();
-			}
-			song_end = false;
-		}
-		return song_end;
-	}
-	
-	private boolean next_row() {
-		int channel_idx, effect, effect_param;
-		boolean song_end;
-		Pattern pattern;
-		song_end = false;
-		if( next_sequence_index < 0 ) {
-			/* Bad next sequence index.*/
-			next_sequence_index = 0;
-			next_row = 0;
-		}
-		if( next_sequence_index >= module.get_sequence_length() ) {
-			/* End of sequence.*/
-			song_end = true;
-			next_sequence_index = module.restart_sequence_index;
-			if( next_sequence_index < 0 ) {
-				next_sequence_index = 0;
-			}
-			if( next_sequence_index >= module.get_sequence_length() ) {
-				next_sequence_index = 0;
-			}
-			next_row = 0;
-		}
-		if( next_sequence_index < current_sequence_index ) {
-			/* Jump to previous pattern. */
-			song_end = true;
-		}
-		if( next_sequence_index == current_sequence_index ) {
-			if( next_row <= current_row ) {
-				if( pattern_loop_count < 0 ) {
-					/* Jump to previous row in the same pattern, but not a pattern loop. */
-					song_end = true;
-				}
-			}
-		}
-		current_sequence_index = next_sequence_index;
-		pattern = module.get_pattern_from_sequence( current_sequence_index );
-		if( next_row < 0 || next_row >= pattern.num_rows ) {
-			/* Bad next row.*/
-			next_row = 0;
-		}
-		current_row = next_row;
-		next_row = current_row + 1;
-		if( next_row >= pattern.num_rows ) {
-			next_sequence_index = current_sequence_index + 1;
-			next_row = 0;
-		}
-		for( channel_idx = 0; channel_idx < channels.length; channel_idx++ ) {
-			pattern.get_note( note, current_row * channels.length + channel_idx );
-			effect = note[ 3 ];
-			effect_param = note[ 4 ];
-			channels[ channel_idx ].row( note[ 0 ], note[ 1 ], note[ 2 ], effect, effect_param );
-			switch( effect ) {
-				case 0x0B:
-					/* Pattern Jump.*/
-					if( pattern_loop_count < 0 ) {
-						next_sequence_index = effect_param;
-						next_row = 0;
-					}
-					break;
-				case 0x0D:
-					/* Pattern Break.*/
-					if( pattern_loop_count < 0 ) {
-						next_sequence_index = current_sequence_index + 1;
-						next_row = ( effect_param >> 4 ) * 10 + ( effect_param & 0x0F );
-					}
-					break;
-				case 0x0E:
-					/* Extended.*/
-					switch( effect_param & 0xF0 ) {
-						case 0x60:
-							/* Pattern loop.*/
-							if( ( effect_param & 0x0F ) == 0 ) {
-								/* Set loop marker on this channel. */
-								channels[ channel_idx ].pattern_loop_row = current_row;
-							}
-							if( channels[ channel_idx ].pattern_loop_row < current_row ) {
-								/* Marker and parameter are valid. Begin looping. */
-								if( pattern_loop_count < 0 ) {
-									/* Not already looping, begin. */
-									pattern_loop_count = effect_param & 0x0F;
-									pattern_loop_channel = channel_idx;
-								}
-								if( pattern_loop_channel == channel_idx ) {
-									/* Loop in progress on this channel. Next iteration. */
-									if( pattern_loop_count == 0 ) {
-										/* Loop finished. */
-										/* Invalidate current marker. */
-										channels[ channel_idx ].pattern_loop_row = current_row + 1;
-									} else {
-										/* Count must be higher than zero. */
-										/* Loop and cancel any breaks on this row. */
-										next_row = channels[ channel_idx ].pattern_loop_row;
-										next_sequence_index = current_sequence_index;
-									}
-									pattern_loop_count -= 1;
-								}
-							}
-							break;
-						case 0xE0:
-							/* Pattern delay.*/
-							tick_counter += ticks_per_row * ( effect_param & 0x0F );
-							break;
-					}
-					break;
-				case 0x0F:
-					/* Set Speed/Tempo.*/
-					if( effect_param < 32 ) {
-						set_speed( effect_param );
-						tick_counter = ticks_per_row;
-					} else {
-						set_tempo( effect_param );
-					}
-					break;
-				case 0x25:
-					/* S3M Set Speed.*/
-					set_speed( effect_param );
-					tick_counter = ticks_per_row;
-					break;
-			}
-		}
-		return song_end;
-	}
-
-	private void set_global_volume( int volume ) {
-		if( volume < 0 ) {
-			volume = 0;
-		}
-		if( volume > 64 ) {
-			volume = 64;
-		}
-		global_volume[ 0 ] = volume;
-	}
-
-	private void set_speed( int speed ) {
-		if( speed > 0 && speed < 256 ) {
-			ticks_per_row = speed;
-		}
-	}
-
-	private void set_tempo( int bpm ) {
-		if( bpm > 31 && bpm < 256 ) {
-			tick_length_samples = ( sampling_rate * 5 ) / ( bpm * 2 );
-		}
-	}	
-
-	private void volume_ramp() {
-		int ramp_idx, next_idx, ramp_end;
-		int volume_ramp_delta, volume, sample;
-		sample = 0;
-		volume_ramp_delta = FP_ONE / volume_ramp_length;
-		volume = 0;
-		ramp_idx = 0;
-		next_idx = 2 * tick_length_samples;
-		ramp_end = volume_ramp_length * 2 - 1;
-		while( ramp_idx <= ramp_end ) {
-			sample = volume_ramp_buffer[ ramp_idx ] * ( FP_ONE - volume ) >> FP_SHIFT;
-			mixing_buffer[ ramp_idx ] = sample + ( mixing_buffer[ ramp_idx ] * volume >> FP_SHIFT );
-			volume_ramp_buffer[ ramp_idx ] = mixing_buffer[ next_idx + ramp_idx ];
-			sample = volume_ramp_buffer[ ramp_idx + 1 ] * ( FP_ONE - volume ) >> FP_SHIFT;
-			mixing_buffer[ ramp_idx + 1 ] = sample + ( mixing_buffer[ ramp_idx + 1 ] * volume >> FP_SHIFT );
-			volume_ramp_buffer[ ramp_idx + 1 ] = mixing_buffer[ next_idx + ramp_idx + 1 ];
-			volume += volume_ramp_delta;
-			ramp_idx += 2;
-		}
-	}
-	
-	private void clear_vol_ramp_buffer() {
-		int ramp_idx, ramp_end;
-		ramp_idx = 0;
-		ramp_end = volume_ramp_length * 2 - 1;
-		while( ramp_idx <= ramp_end ) {
-			volume_ramp_buffer[ ramp_idx ] = 0;
-			ramp_idx += 1;
-		}
-	}
-}
-

client/ibxm/Instrument.java

@@ -1,90 +0,0 @@
-
-package ibxm;
-
-public class Instrument {
-	public String name;
-	public int vibrato_type, vibrato_sweep;
-	public int vibrato_depth, vibrato_rate;
-	public boolean volume_envelope_active, panning_envelope_active;
-	public int volume_fade_out;
-	
-	private Envelope volume_envelope, panning_envelope;
-	private int[] key_to_sample;
-	private Sample[] samples;
-
-	public Instrument() {
-		name = "";
-		set_volume_envelope( new Envelope() );
-		set_panning_envelope( new Envelope() );
-		key_to_sample = new int[ 96 ];
-		set_num_samples( 1 );
-	}
-	
-	public Envelope get_volume_envelope() {
-		return volume_envelope;
-	}
-	
-	public void set_volume_envelope( Envelope envelope ) {
-		if( envelope != null ) {
-			volume_envelope = envelope;
-		}
-	}
-	
-	public Envelope get_panning_envelope() {
-		return panning_envelope;
-	}
-	
-	public void set_panning_envelope( Envelope envelope ) {
-		if( envelope != null ) {
-			panning_envelope = envelope;
-		}
-	}
-	
-	public Sample get_sample_from_key( int key ) {
-		int sample_idx;
-		sample_idx = 0;
-		if( key > 0 && key <= key_to_sample.length ) {
-			sample_idx = key_to_sample[ key - 1 ];
-		}
-		return get_sample( sample_idx );
-	}
-	
-	public void set_key_to_sample( int key, int sample ) {
-		if( key > 0 && key <= key_to_sample.length ) {
-			key_to_sample[ key - 1 ] = sample;
-		}
-	}
-	
-	public int get_num_samples() {
-		return samples.length;
-	}
-	
-	public void set_num_samples( int num_samples ) {
-		if( num_samples < 1 ) {
-			num_samples = 1;
-		}
-		samples = new Sample[ num_samples ];
-		set_sample( 0, null );
-	}
-	
-	public Sample get_sample( int sample_index ) {
-		Sample sample;
-		sample = null;
-		if( sample_index >= 0 && sample_index < samples.length ) {
-			sample = samples[ sample_index ];
-		}
-		if( sample == null ) {
-			sample = samples[ 0 ];
-		}
-		return sample;
-	}
-	
-	public void set_sample( int sample_index, Sample sample ) {
-		if( sample_index >= 0 && sample_index < samples.length ) {
-			samples[ sample_index ] = sample;
-		}
-		if( samples[ 0 ] == null ) {
-			samples[ 0 ] = new Sample();
-		}
-	}
-}

client/ibxm/LogTable.java

@@ -1,91 +0,0 @@
-
-package ibxm;
-
-/*
-	Base-2 Log and Exp functions, using linear-interpolated tables.
-*/
-public class LogTable {
-	private static final int TABLE_SHIFT = 7; // 128 points (+1 for interp)
-	private static final int INTERP_SHIFT = IBXM.FP_SHIFT - TABLE_SHIFT;
-	private static final int INTERP_MASK = ( 1 << INTERP_SHIFT ) - 1;
-
-	private static final int[] exp_2_table = {
-		32768, 32945, 33124, 33304, 33485, 33667, 33850, 34033,
-		34218, 34404, 34591, 34779, 34968, 35157, 35348, 35540,
-		35733, 35927, 36122, 36319, 36516, 36714, 36913, 37114,
-		37315, 37518, 37722, 37926, 38132, 38339, 38548, 38757,
-		38967, 39179, 39392, 39606, 39821, 40037, 40254, 40473,
-		40693, 40914, 41136, 41359, 41584, 41810, 42037, 42265,
-		42494, 42725, 42957, 43190, 43425, 43661, 43898, 44136,
-		44376, 44617, 44859, 45103, 45347, 45594, 45841, 46090,
-		46340, 46592, 46845, 47099, 47355, 47612, 47871, 48131,
-		48392, 48655, 48919, 49185, 49452, 49720, 49990, 50262,
-		50535, 50809, 51085, 51362, 51641, 51922, 52204, 52487,
-		52772, 53059, 53347, 53636, 53928, 54220, 54515, 54811,
-		55108, 55408, 55709, 56011, 56315, 56621, 56928, 57238,
-		57548, 57861, 58175, 58491, 58809, 59128, 59449, 59772,
-		60096, 60423, 60751, 61081, 61412, 61746, 62081, 62418,
-		62757, 63098, 63440, 63785, 64131, 64479, 64830, 65182,
-		65536
-	};
-
-	private static final int[] log_2_table = {
-		    0,   367,   732,  1095,  1454,  1811,  2165,  2517,
-		 2865,  3212,  3556,  3897,  4236,  4572,  4906,  5238,
-		 5568,  5895,  6220,  6542,  6863,  7181,  7497,  7812,
-		 8124,  8434,  8742,  9048,  9352,  9654,  9954, 10252,
-		10548, 10843, 11136, 11427, 11716, 12003, 12289, 12573,
-		12855, 13136, 13414, 13692, 13967, 14241, 14514, 14785,
-		15054, 15322, 15588, 15853, 16117, 16378, 16639, 16898,
-		17156, 17412, 17667, 17920, 18172, 18423, 18673, 18921,
-		19168, 19413, 19657, 19900, 20142, 20383, 20622, 20860,
-		21097, 21333, 21568, 21801, 22034, 22265, 22495, 22724,
-		22952, 23178, 23404, 23628, 23852, 24074, 24296, 24516,
-		24736, 24954, 25171, 25388, 25603, 25817, 26031, 26243,
-		26455, 26665, 26875, 27084, 27292, 27499, 27705, 27910,
-		28114, 28317, 28520, 28721, 28922, 29122, 29321, 29519,
-		29716, 29913, 30109, 30304, 30498, 30691, 30884, 31076,
-		31267, 31457, 31646, 31835, 32023, 32210, 32397, 32582,
-		32768
-	};
-
-	/*
-		Calculate log-base-2 of x (non-fixed-point).
-		A fixed point value is returned.
-	*/
-	public static int log_2( int x ) {
-		int shift;
-		/* Scale x to range 1.0 <= x < 2.0 */
-		shift = IBXM.FP_SHIFT;
-		while( x < IBXM.FP_ONE ) {
-			x <<= 1;
-			shift--;
-		}
-		while( x >= ( IBXM.FP_ONE << 1 ) ) {
-			x >>= 1;
-			shift++;
-		}
-		return ( IBXM.FP_ONE * shift ) + eval_table( log_2_table, x - IBXM.FP_ONE );
-	}
-
-	/*
-		Raise 2 to the power x (fixed point).
-		A fixed point value is returned.
-	*/
-	public static int raise_2( int x ) {
-		int y;
-		y = eval_table( exp_2_table, x & IBXM.FP_MASK ) << IBXM.FP_SHIFT;
-		return y >> IBXM.FP_SHIFT - ( x >> IBXM.FP_SHIFT );
-	}
-
-	private static int eval_table( int[] table, int x ) {
-		int table_idx, table_frac, c, m, y;
-		table_idx = x >> INTERP_SHIFT;
-		table_frac = x & INTERP_MASK;
-		c = table[ table_idx ];
-		m = table[ table_idx + 1 ] - c;
-		y = ( m * table_frac >> INTERP_SHIFT ) + c;
-		return y >> 15 - IBXM.FP_SHIFT;
-	}
-}
-

client/ibxm/Module.java

@@ -1,138 +0,0 @@
-
-package ibxm;
-
-public class Module {
-	public String song_title;
-	public boolean linear_periods, fast_volume_slides, pal;
-	public int global_volume, channel_gain;
-	public int default_speed, default_tempo;
-	public int restart_sequence_index;
-	
-	private int[] initial_panning, sequence;
-	private Pattern[] patterns;
-	private Instrument[] instruments;
-	
-	private Pattern default_pattern;
-	private Instrument default_instrument;
-	
-	public Module() {
-		song_title = IBXM.VERSION;
-		set_num_channels( 1 );
-		set_sequence_length( 1 );
-		set_num_patterns( 0 );
-		set_num_instruments( 0 );
-		default_pattern = new Pattern();
-		default_instrument = new Instrument();
-	}
-	
-	public int get_num_channels() {
-		return initial_panning.length;
-	}
-	
-	public void set_num_channels( int num_channels ) {
-		if( num_channels < 1 ) {
-			num_channels = 1;
-		}
-		initial_panning = new int[ num_channels ];
-	}
-	
-	public int get_initial_panning( int channel ) {
-		int panning;
-		panning = 128;
-		if( channel >= 0 && channel < initial_panning.length ) {
-			panning = initial_panning[ channel ];
-		}
-		return panning;
-	}
-	
-	public void set_initial_panning( int channel, int panning ) {
-		if( channel >= 0 && channel < initial_panning.length ) {
-			initial_panning[ channel ] = panning;
-		}
-	}
-	
-	public int get_sequence_length() {
-		return sequence.length;
-	}
-	
-	public void set_sequence_length( int sequence_length ) {
-		if( sequence_length < 0 ) {
-			sequence_length = 0;
-		}
-		sequence = new int[ sequence_length ];
-	}
-	
-	public void set_sequence( int sequence_index, int pattern_index ) {
-		if( sequence_index >= 0 && sequence_index < sequence.length ) {
-			sequence[ sequence_index ] = pattern_index;
-		}
-	}
-	
-	public int get_num_patterns() {
-		return patterns.length;
-	}
-	
-	public void set_num_patterns( int num_patterns ) {
-		if( num_patterns < 0 ) {
-			num_patterns = 0;
-		}
-		patterns = new Pattern[ num_patterns ];
-	}
-
-	public Pattern get_pattern_from_sequence( int sequence_index ) {
-		Pattern pattern;
-		pattern = default_pattern;
-		if( sequence_index >= 0 && sequence_index < sequence.length ) {
-			pattern = get_pattern( sequence[ sequence_index ] );
-		}
-		return pattern;
-	}
-
-	public Pattern get_pattern( int pattern_index ) {
-		Pattern pattern;
-		pattern = null;
-		if( pattern_index >= 0 && pattern_index < patterns.length ) {
-			pattern = patterns[ pattern_index ];
-		}
-		if( pattern == null ) {
-			pattern = default_pattern;
-		}
-		return pattern;
-	}
-
-	public void set_pattern( int pattern_index, Pattern pattern ) {
-		if( pattern_index >= 0 && pattern_index < patterns.length ) {
-			patterns[ pattern_index ] = pattern;
-		}
-	}
-	
-	public int get_num_instruments() {
-		return instruments.length;
-	}
-	
-	public void set_num_instruments( int num_instruments ) {
-		if( num_instruments < 0 ) {
-			num_instruments = 0;
-		}
-		instruments = new Instrument[ num_instruments ];
-	}
-	
-	public Instrument get_instrument( int instrument_index ) {
-		Instrument instrument;
-		instrument = null;
-		if( instrument_index > 0 && instrument_index <= instruments.length ) {
-			instrument = instruments[ instrument_index - 1 ];
-		}
-		if( instrument == null ) {
-			instrument = default_instrument;
-		}
-		return instrument;
-	}
-	
-	public void set_instrument( int instrument_index, Instrument instrument ) {
-		if( instrument_index > 0 && instrument_index <= instruments.length ) {
-			instruments[ instrument_index - 1 ] = instrument;
-		}
-	}
-}
-

client/ibxm/Pattern.java

@@ -1,61 +0,0 @@
-
-package ibxm;
-
-public class Pattern {
-	public int num_rows;
-	
-	private int data_offset, note_index;
-	private byte[] pattern_data;
-
-	public Pattern() {
-		num_rows = 1;
-		set_pattern_data( new byte[ 0 ] );
-	}
-	
-	public void set_pattern_data( byte[] data ) {
-		if( data != null ) {
-			pattern_data = data;
-		}
-		data_offset = 0;
-		note_index = 0;
-	}
-
-	public void get_note( int[] note, int index ) {
-		if( index < note_index ) {
-			note_index = 0;
-			data_offset = 0;
-		}
-		while( note_index <= index ) {
-			data_offset = next_note( data_offset, note );
-			note_index += 1;
-		}
-	}
-
-	public int next_note( int data_offset, int[] note ) {
-		int bitmask, field;
-		if( data_offset < 0 ) {
-			data_offset = pattern_data.length;
-		}
-		bitmask = 0x80;
-		if( data_offset < pattern_data.length ) {
-			bitmask = pattern_data[ data_offset ] & 0xFF;
-		}
-		if( ( bitmask & 0x80 ) == 0x80 ) {
-			data_offset += 1;
-		} else {
-			bitmask = 0x1F;
-		}
-		for( field = 0; field < 5; field++ ) {
-			note[ field ] = 0;
-			if( ( bitmask & 0x01 ) == 0x01 ) {
-				if( data_offset < pattern_data.length ) {
-					note[ field ] = pattern_data[ data_offset ] & 0xFF;
-					data_offset += 1;
-				}
-			}
-			bitmask = bitmask >> 1;
-		}
-		return data_offset;
-	}
-}
-

client/ibxm/Player.java

@@ -1,132 +0,0 @@
-
-package ibxm;
-
-import java.io.*;
-import javax.sound.sampled.*;
-
-public class Player {
-	private Thread play_thread;
-	private IBXM ibxm;
-	private Module module;
-	private int song_duration, play_position;
-	private boolean running, loop;
-	private byte[] output_buffer;
-	private SourceDataLine output_line;
-
-	/**
-		Simple command-line test player.
-	*/
-	public static void main( String[] args ) throws Exception {
-		if( args.length < 1 ) {
-			System.err.println( "Usage: java ibxm.Player <module file>" );
-			System.exit( 0 );
-		}
-		FileInputStream file_input_stream = new FileInputStream( args[ 0 ] );
-		Player player = new Player();
-		player.set_module( Player.load_module( file_input_stream ) );
-		file_input_stream.close();
-		player.play();
-	}
-	
-	/**
-		Decode the data in the specified InputStream into a Module instance.
-		@param input an InputStream containing the module file to be decoded.
-		@throws IllegalArgumentException if the data is not recognised as a module file.
-	*/
-	public static Module load_module( InputStream input ) throws IllegalArgumentException, IOException {
-		DataInputStream data_input_stream = new DataInputStream( input );
-		/* Check if data is in XM format.*/
-		byte[] xm_header = new byte[ 60 ];
-		data_input_stream.readFully( xm_header );
-		if( FastTracker2.is_xm( xm_header ) )
-			return FastTracker2.load_xm( xm_header, data_input_stream );
-		/* Check if data is in ScreamTracker 3 format.*/	
-		byte[] s3m_header = new byte[ 96 ];
-		System.arraycopy( xm_header, 0, s3m_header, 0, 60 );
-		data_input_stream.readFully( s3m_header, 60, 36 );
-		if( ScreamTracker3.is_s3m( s3m_header ) )
-			return ScreamTracker3.load_s3m( s3m_header, data_input_stream );
-		/* Check if data is in ProTracker format.*/
-		byte[] mod_header = new byte[ 1084 ];
-		System.arraycopy( s3m_header, 0, mod_header, 0, 96 );
-		data_input_stream.readFully( mod_header, 96, 988 );
-			return ProTracker.load_mod( mod_header, data_input_stream );
-	}
-
-	/**
-		Instantiate a new Player.
-	*/
-	public Player() throws LineUnavailableException {
-		ibxm = new IBXM( 48000 );
-		set_loop( true );
-		output_line = AudioSystem.getSourceDataLine( new AudioFormat( 48000, 16, 2, true, true ) );
-		output_buffer = new byte[ 1024 * 4 ];
-	}
-
-	/**
-		Set the Module instance to be played.
-	*/
-	public void set_module( Module m ) {
-		if( m != null ) module = m;
-		stop();
-		ibxm.set_module( module );
-		song_duration = ibxm.calculate_song_duration();
-	}
-	
-	/**
-		If loop is true, playback will continue indefinitely,
-		otherwise the module will play through once and stop.
-	*/
-	public void set_loop( boolean loop ) {
-		this.loop = loop;
-	}
-	
-	/**
-		Open the audio device and begin playback.
-		If a module is already playing it will be restarted.
-	*/
-	public void play() {
-		stop();
-		play_thread = new Thread( new Driver() );
-		play_thread.start();
-	}
-	
-	/**
-		Stop playback and close the audio device.
-	*/
-	public void stop() {
-		running = false;
-		if( play_thread != null ) {
-			try {
-				play_thread.join();
-			} catch( InterruptedException ie ) {}
-		}
-	}
-	
-	private class Driver implements Runnable {
-		public void run() {
-			if( running ) return;
-			try {
-				output_line.open();
-				output_line.start();
-				play_position = 0;
-				running = true;
-				while( running ) {
-					int frames = song_duration - play_position;
-					if( frames > 1024 ) frames = 1024;		
-					ibxm.get_audio( output_buffer, frames );
-					output_line.write( output_buffer, 0, frames * 4 );
-					play_position += frames;
-					if( play_position >= song_duration ) {
-						play_position = 0;
-						if( !loop ) running = false;
-					}
-				}
-				output_line.drain();
-				output_line.close();
-			} catch( LineUnavailableException lue ) {
-				lue.printStackTrace();
-			}
-		}
-	}
-}

client/ibxm/ProTracker.java

@@ -1,234 +0,0 @@
-package ibxm;
-
-import java.io.*;
-
-public class ProTracker {
-	public static boolean is_mod( byte[] header_1084_bytes ) {
-		boolean is_mod;
-		is_mod = false;
-		if( calculate_num_channels( header_1084_bytes ) > 0 ) {
-			is_mod = true;
-		}
-		return is_mod;
-	}
-
-	public static Module load_mod( byte[] header_1084_bytes, DataInput data_input ) throws IOException {
-		int num_channels, channel_idx, panning;
-		int sequence_length, restart_idx, sequence_idx;
-		int num_patterns, pattern_idx, instrument_idx;
-		Module module;
-		num_channels = calculate_num_channels( header_1084_bytes );
-		if( num_channels < 1 ) {
-			throw new IllegalArgumentException( "ProTracker: Unrecognised module format!" );
-		}
-		module = new Module();
-		module.song_title = ascii_text( header_1084_bytes, 0, 20 );
-		module.pal = ( num_channels == 4 );
-		module.global_volume = 64;
-		module.channel_gain = IBXM.FP_ONE * 3 / 8;
-		module.default_speed = 6;
-		module.default_tempo = 125;
-		module.set_num_channels( num_channels );
-		for( channel_idx = 0; channel_idx < num_channels; channel_idx++ ) {
-			panning = 64;
-			if( ( channel_idx & 0x03 ) == 0x01 || ( channel_idx & 0x03 ) == 0x02 ) {
-				panning = 192;
-			}
-			module.set_initial_panning( channel_idx, panning );
-		}
-		sequence_length = header_1084_bytes[ 950 ] & 0x7F;
-		restart_idx = header_1084_bytes[ 951 ] & 0x7F;
-		if( restart_idx >= sequence_length ) {
-			restart_idx = 0;
-		}
-		module.restart_sequence_index = restart_idx;
-		module.set_sequence_length( sequence_length );
-		for( sequence_idx = 0; sequence_idx < sequence_length; sequence_idx++ ) {
-			module.set_sequence( sequence_idx, header_1084_bytes[ 952 + sequence_idx ] & 0x7F );
-		}
-		num_patterns = calculate_num_patterns( header_1084_bytes );
-		module.set_num_patterns( num_patterns );
-		for( pattern_idx = 0; pattern_idx < num_patterns; pattern_idx++ ) {
-			module.set_pattern( pattern_idx, read_mod_pattern( data_input, num_channels ) );
-		}
-		module.set_num_instruments( 31 );
-		for( instrument_idx = 1; instrument_idx <= 31; instrument_idx++ ) {
-			module.set_instrument( instrument_idx, read_mod_instrument( header_1084_bytes, instrument_idx, data_input ) );
-		}
-		return module;
-	}
-
-	private static int calculate_num_patterns( byte[] module_header ) {
-		int num_patterns, order_entry, pattern_idx;
-		num_patterns = 0;
-		for( pattern_idx = 0; pattern_idx < 128; pattern_idx++ ) {
-			order_entry = module_header[ 952 + pattern_idx ] & 0x7F;
-			if( order_entry >= num_patterns ) {
-				num_patterns = order_entry + 1;
-			}
-		}
-		return num_patterns;
-	}
-	
-	private static int calculate_num_channels( byte[] module_header ) {
-		int num_channels;
-		switch( ( module_header[ 1082 ] << 8 ) | module_header[ 1083 ] ) {
-			case 0x4b2e: /* M.K. */
-			case 0x4b21: /* M!K! */
-			case 0x542e: /* N.T. */
-			case 0x5434: /* FLT4 */
-				num_channels = 4;
-				break;
-			case 0x484e: /* xCHN */
-				num_channels = module_header[ 1080 ] - 48;
-				break;
-			case 0x4348: /* xxCH */
-				num_channels = ( ( module_header[ 1080 ] - 48 ) * 10 ) + ( module_header[ 1081 ] - 48 );
-				break;
-			default:
-				/* Not recognised. */
-				num_channels = 0;
-				break;
-		}
-		return num_channels;
-	}
-
-	private static Pattern read_mod_pattern( DataInput data_input, int num_channels ) throws IOException {
-		int input_idx, output_idx;
-		int period, instrument, effect, effect_param;
-		Pattern pattern;
-		byte[] input_pattern_data, output_pattern_data;
-		pattern = new Pattern();
-		pattern.num_rows = 64;
-		input_pattern_data = new byte[ 64 * num_channels * 4 ];
-		output_pattern_data = new byte[ 64 * num_channels * 5 ];
-		data_input.readFully( input_pattern_data );
-		input_idx = 0;
-		output_idx = 0;
-		while( input_idx < input_pattern_data.length ) {
-			period = ( input_pattern_data[ input_idx ] & 0x0F ) << 8;
-			period = period | ( input_pattern_data[ input_idx + 1 ] & 0xFF );
-			output_pattern_data[ output_idx ] = to_key( period );
-			instrument = input_pattern_data[ input_idx ] & 0x10;
-			instrument = instrument | ( ( input_pattern_data[ input_idx + 2 ] & 0xF0 ) >> 4 );
-			output_pattern_data[ output_idx + 1 ] = ( byte ) instrument;
-			effect = input_pattern_data[ input_idx + 2 ] & 0x0F;
-			effect_param = input_pattern_data[ input_idx + 3 ] & 0xFF;
-			if( effect == 0x01 && effect_param == 0 ) {
-				/* Portamento up of zero has no effect. */
-				effect = 0;
-			}
-			if( effect == 0x02 && effect_param == 0 ) {
-				/* Portamento down of zero has no effect. */
-				effect = 0;
-			}
-			if( effect == 0x08 && num_channels == 4 ) {
-				/* Some Amiga mods use effect 0x08 for reasons other than panning.*/
-				effect = 0;
-				effect_param = 0;
-			}
-			if( effect == 0x0A && effect_param == 0 ) {
-				/* Volume slide of zero has no effect.*/
-				effect = 0;
-			}
-			if( effect == 0x05 && effect_param == 0 ) {
-				/* Porta + Volume slide of zero has no effect.*/
-				effect = 0x03;
-			}
-			if( effect == 0x06 && effect_param == 0 ) {
-				/* Vibrato + Volume slide of zero has no effect.*/
-				effect = 0x04;
-			}
-			output_pattern_data[ output_idx + 3 ] = ( byte ) effect;
-			output_pattern_data[ output_idx + 4 ] = ( byte ) effect_param;
-			input_idx += 4;
-			output_idx += 5;
-		}
-		pattern.set_pattern_data( output_pattern_data );
-		return pattern;
-	}
-
-	private static Instrument read_mod_instrument( byte[] mod_header, int idx, DataInput data_input ) throws IOException  {
-		int header_offset, sample_data_length;
-		int loop_start, loop_length, sample_idx, fine_tune;
-		Instrument instrument;
-		Sample sample;
-		byte[] raw_sample_data;
-		short[] sample_data;
-		header_offset = ( idx - 1 ) * 30 + 20;
-		instrument = new Instrument();
-		instrument.name = ascii_text( mod_header, header_offset, 22 );
-		sample = new Sample();
-		sample_data_length = unsigned_short_be( mod_header, header_offset + 22 ) << 1;
-		fine_tune = mod_header[ header_offset + 24 ] & 0x0F;
-		if( fine_tune > 7 ) {
-			fine_tune -= 16;
-		}
-		sample.transpose = ( fine_tune << IBXM.FP_SHIFT ) / 96;
-		sample.volume = mod_header[ header_offset + 25 ] & 0x7F;
-		loop_start = unsigned_short_be( mod_header, header_offset + 26 ) << 1;
-		loop_length = unsigned_short_be( mod_header, header_offset + 28 ) << 1;
-		if( loop_length < 4 ) {
-			loop_length = 0;
-		}
-		raw_sample_data = new byte[ sample_data_length ];
-		sample_data = new short[ sample_data_length ];
-		try {
-			data_input.readFully( raw_sample_data );
-		} catch( EOFException e ) {
-			System.out.println( "ProTracker: Instrument " + idx + " has samples missing." );
-		}
-		for( sample_idx = 0; sample_idx < raw_sample_data.length; sample_idx++ ) {
-			sample_data[ sample_idx ] = ( short ) ( raw_sample_data[ sample_idx ] << 8 );
-		}
-		sample.set_sample_data( sample_data, loop_start, loop_length, false );
-		instrument.set_num_samples( 1 );
-		instrument.set_sample( 0, sample );
-		return instrument;
-	}
-	
-	private static byte to_key( int period ) {
-		int oct, key;
-		if( period < 32 ) {
-			key = 0;
-		} else {
-			oct = LogTable.log_2( 7256 ) - LogTable.log_2( period );
-			if( oct < 0 ) {
-				key = 0;
-			} else {
-				key = oct * 12;
-				key = key >> ( IBXM.FP_SHIFT - 1 );
-				key = ( key >> 1 ) + ( key & 1 );
-			}
-		}
-		return ( byte ) key;
-	}
-
-	private static int unsigned_short_be( byte[] buf, int offset ) {
-		int value;
-		value = ( buf[ offset ] & 0xFF ) << 8;
-		value = value | ( buf[ offset + 1 ] & 0xFF );
-		return value;
-	}
-	
-	private static String ascii_text( byte[] buffer, int offset, int length ) {
-		int idx, chr;
-		byte[] string_buffer;
-		String string;
-		string_buffer = new byte[ length ];
-		for( idx = 0; idx < length; idx++ ) {
-			chr = buffer[ offset + idx ];
-			if( chr < 32 ) {
-				chr = 32;
-			}
-			string_buffer[ idx ] = ( byte ) chr;
-		}
-		try {
-			string = new String( string_buffer, 0, length, "ISO-8859-1" );
-		} catch( UnsupportedEncodingException e ) {
-			string = "";
-		}
-		return string;
-	}
-}
-

client/ibxm/Sample.java

@@ -1,239 +0,0 @@
-
-package ibxm;
-
-public class Sample {
-	public String name;
-	public boolean set_panning;
-	public int volume, panning;
-	public int transpose;
-	
-	private int loop_start, loop_length;
-	private short[] sample_data;
-
-	/* For the sinc interpolator.*/
-	private static final int POINT_SHIFT = 4;
-	private static final int POINTS = 1 << POINT_SHIFT;
-	private static final int OVERLAP = POINTS >> 1;
-	private static final int INTERP_SHIFT = IBXM.FP_SHIFT - 4;
-	private static final int INTERP_BITMASK = ( 1 << INTERP_SHIFT ) - 1;
-	private static final short[] sinc_table = {
-		 0, -7,  27, -71,  142, -227,  299,  32439,   299,  -227,  142,  -71,  27,  -7,  0,  0,
-		 0,  0,  -5,  36, -142,  450, -1439, 32224,  2302,  -974,  455, -190,  64, -15,  2,  0,
-		 0,  6, -33, 128, -391, 1042, -2894, 31584,  4540, -1765,  786, -318, 105, -25,  3,  0,
-		 0, 10, -55, 204, -597, 1533, -4056, 30535,  6977, -2573, 1121, -449, 148, -36,  5,  0,
-		-1, 13, -71, 261, -757, 1916, -4922, 29105,  9568, -3366, 1448, -578, 191, -47,  7,  0,
-		-1, 15, -81, 300, -870, 2185, -5498, 27328, 12263, -4109, 1749, -698, 232, -58,  9,  0,
-		-1, 15, -86, 322, -936, 2343, -5800, 25249, 15006, -4765, 2011, -802, 269, -68, 10,  0,
-		-1, 15, -87, 328, -957, 2394, -5849, 22920, 17738, -5298, 2215, -885, 299, -77, 12,  0,
-		 0, 14, -83, 319, -938, 2347, -5671, 20396, 20396, -5671, 2347, -938, 319, -83, 14,  0,
-		 0, 12, -77, 299, -885, 2215, -5298, 17738, 22920, -5849, 2394, -957, 328, -87, 15, -1,
-		 0, 10, -68, 269, -802, 2011, -4765, 15006, 25249, -5800, 2343, -936, 322, -86, 15, -1,
-		 0,  9, -58, 232, -698, 1749, -4109, 12263, 27328, -5498, 2185, -870, 300, -81, 15, -1,
-		 0,  7, -47, 191, -578, 1448, -3366,  9568, 29105, -4922, 1916, -757, 261, -71, 13, -1,
-		 0,  5, -36, 148, -449, 1121, -2573,  6977, 30535, -4056, 1533, -597, 204, -55, 10,  0,
-		 0,  3, -25, 105, -318,  786, -1765,  4540, 31584, -2894, 1042, -391, 128, -33,  6,  0,
-		 0,  2, -15,  64, -190,  455,  -974,  2302, 32224, -1439,  450, -142,  36,  -5,  0,  0,
-		 0,  0,  -7,  27,  -71,  142,  -227,   299, 32439,   299, -227,  142, -71,  27, -7,  0
-	};
-	
-	public Sample() {
-		name = "";
-		set_sample_data( new short[ 0 ], 0, 0, false );
-	}
-	
-	public void set_sample_data( short[] data, int loop_start, int loop_length, boolean ping_pong ) {
-		int offset;
-		short sample;		
-		if( loop_start < 0 ) {
-			loop_start = 0;
-		}
-		if( loop_start >= data.length ) {
-			loop_start = data.length - 1;
-		}
-		if( loop_start + loop_length > data.length ) {
-			loop_length = data.length - loop_start;
-		}
-		if( loop_length <= 1 ) {
-			sample_data = new short[ OVERLAP + data.length + OVERLAP * 3 ];
-			System.arraycopy( data, 0, sample_data, OVERLAP, data.length );
-			offset = 0;
-			while( offset < OVERLAP ) {
-				sample = sample_data[ OVERLAP + data.length - 1 ];
-				sample = ( short ) ( sample * ( OVERLAP - offset ) / OVERLAP );
-				sample_data[ OVERLAP + data.length + offset ] = sample;
-				offset += 1;
-			}
-			loop_start = OVERLAP + data.length + OVERLAP;
-			loop_length = 1;
-		} else {
-			if( ping_pong ) {
-				sample_data = new short[ OVERLAP + loop_start + loop_length * 2 + OVERLAP * 2 ];
-				System.arraycopy( data, 0, sample_data, OVERLAP, loop_start + loop_length );
-				offset = 0;
-				while( offset < loop_length ) {
-					sample = data[ loop_start + loop_length - offset - 1 ];
-					sample_data[ OVERLAP + loop_start + loop_length + offset ] = sample;
-					offset += 1;
-				}
-				loop_start = loop_start + OVERLAP;
-				loop_length = loop_length * 2;
-			} else {
-				sample_data = new short[ OVERLAP + loop_start + loop_length + OVERLAP * 2 ];
-				System.arraycopy( data, 0, sample_data, OVERLAP, loop_start + loop_length );
-				loop_start = loop_start + OVERLAP;
-			}
-			offset = 0;
-			while( offset < OVERLAP * 2 ) {
-				sample = sample_data[ loop_start + offset ];
-				sample_data[ loop_start + loop_length + offset ] = sample;
-				offset += 1;
-			}
-		}
-		this.loop_start = loop_start;
-		this.loop_length = loop_length;
-	}
-
-	public void resample_nearest(
-			int sample_idx, int sample_frac, int step, int left_gain, int right_gain,
-			int[] mix_buffer, int frame_offset, int frames ) {
-		int loop_end, offset, end, max_sample_idx;
-		sample_idx += OVERLAP;
-		loop_end = loop_start + loop_length - 1;
-		offset = frame_offset << 1;
-		end = ( frame_offset + frames - 1 ) << 1;
-		while( frames > 0 ) {
-			if( sample_idx > loop_end ) {
-				if( loop_length <= 1 ) {
-					break;
-				}
-				sample_idx = loop_start + ( sample_idx - loop_start ) % loop_length;
-			}
-			max_sample_idx = sample_idx + ( ( sample_frac + ( frames - 1 ) * step ) >> IBXM.FP_SHIFT );
-			if( max_sample_idx > loop_end ) {
-				while( sample_idx <= loop_end ) {
-					mix_buffer[ offset++ ] += sample_data[ sample_idx ] * left_gain >> IBXM.FP_SHIFT;
-					mix_buffer[ offset++ ] += sample_data[ sample_idx ] * right_gain >> IBXM.FP_SHIFT;
-					sample_frac += step;
-					sample_idx += sample_frac >> IBXM.FP_SHIFT;
-					sample_frac &= IBXM.FP_MASK;
-				}
-			} else {
-				while( offset <= end ) {
-					mix_buffer[ offset++ ] += sample_data[ sample_idx ] * left_gain >> IBXM.FP_SHIFT;
-					mix_buffer[ offset++ ] += sample_data[ sample_idx ] * right_gain >> IBXM.FP_SHIFT;
-					sample_frac += step;
-					sample_idx += sample_frac >> IBXM.FP_SHIFT;
-					sample_frac &= IBXM.FP_MASK;
-				}
-			}
-			frames = ( end - offset + 2 ) >> 1;
-		}
-	}
-
-	public void resample_linear(
-			int sample_idx, int sample_frac, int step, int left_gain, int right_gain,
-			int[] mix_buffer, int frame_offset, int frames ) {
-		int loop_end, offset, end, max_sample_idx, amplitude;
-		sample_idx += OVERLAP;
-		loop_end = loop_start + loop_length - 1;
-		offset = frame_offset << 1;
-		end = ( frame_offset + frames - 1 ) << 1;
-		while( frames > 0 ) {
-			if( sample_idx > loop_end ) {
-				if( loop_length <= 1 ) {
-					break;
-				}
-				sample_idx = loop_start + ( sample_idx - loop_start ) % loop_length;
-			}
-			max_sample_idx = sample_idx + ( ( sample_frac + ( frames - 1 ) * step ) >> IBXM.FP_SHIFT );
-			if( max_sample_idx > loop_end ) {
-				while( sample_idx <= loop_end ) {
-					amplitude = sample_data[ sample_idx ];
-					amplitude += ( sample_data[ sample_idx + 1 ] - amplitude ) * sample_frac >> IBXM.FP_SHIFT;
-					mix_buffer[ offset++ ] += amplitude * left_gain >> IBXM.FP_SHIFT;
-					mix_buffer[ offset++ ] += amplitude * right_gain >> IBXM.FP_SHIFT;
-					sample_frac += step;
-					sample_idx += sample_frac >> IBXM.FP_SHIFT;
-					sample_frac &= IBXM.FP_MASK;
-				}
-			} else {
-				while( offset <= end ) {
-					amplitude = sample_data[ sample_idx ];
-					amplitude += ( sample_data[ sample_idx + 1 ] - amplitude ) * sample_frac >> IBXM.FP_SHIFT;
-					mix_buffer[ offset++ ] += amplitude * left_gain >> IBXM.FP_SHIFT;
-					mix_buffer[ offset++ ] += amplitude * right_gain >> IBXM.FP_SHIFT;
-					sample_frac += step;
-					sample_idx += sample_frac >> IBXM.FP_SHIFT;
-					sample_frac &= IBXM.FP_MASK;
-				}
-			}
-			frames = ( end - offset + 2 ) >> 1;
-		}
-	}
-
-	public void resample_sinc(
-			int sample_idx, int sample_frac, int step, int left_gain, int right_gain,
-			int[] mix_buffer, int frame_offset, int frames ) {
-		int offset, end, loop_end, table_idx, a1, a2, amplitude;
-		loop_end = loop_start + loop_length - 1;
-		offset = frame_offset << 1;
-		end = ( frame_offset + frames - 1 ) << 1;
-		while( offset <= end ) {
-			if( sample_idx > loop_end ) {
-				if( loop_length <= 1 ) {
-					break;
-				}
-				sample_idx = loop_start + ( sample_idx - loop_start ) % loop_length;
-			}
-			table_idx = ( sample_frac >> INTERP_SHIFT ) << POINT_SHIFT;
-			a1  = sinc_table[ table_idx + 0  ] * sample_data[ sample_idx + 0  ] >> 15;
-			a1 += sinc_table[ table_idx + 1  ] * sample_data[ sample_idx + 1  ] >> 15;
-			a1 += sinc_table[ table_idx + 2  ] * sample_data[ sample_idx + 2  ] >> 15;
-			a1 += sinc_table[ table_idx + 3  ] * sample_data[ sample_idx + 3  ] >> 15;
-			a1 += sinc_table[ table_idx + 4  ] * sample_data[ sample_idx + 4  ] >> 15;
-			a1 += sinc_table[ table_idx + 5  ] * sample_data[ sample_idx + 5  ] >> 15;
-			a1 += sinc_table[ table_idx + 6  ] * sample_data[ sample_idx + 6  ] >> 15;
-			a1 += sinc_table[ table_idx + 7  ] * sample_data[ sample_idx + 7  ] >> 15;
-			a1 += sinc_table[ table_idx + 8  ] * sample_data[ sample_idx + 8  ] >> 15;
-			a1 += sinc_table[ table_idx + 9  ] * sample_data[ sample_idx + 9  ] >> 15;
-			a1 += sinc_table[ table_idx + 10 ] * sample_data[ sample_idx + 10 ] >> 15;
-			a1 += sinc_table[ table_idx + 11 ] * sample_data[ sample_idx + 11 ] >> 15;
-			a1 += sinc_table[ table_idx + 12 ] * sample_data[ sample_idx + 12 ] >> 15;
-			a1 += sinc_table[ table_idx + 13 ] * sample_data[ sample_idx + 13 ] >> 15;
-			a1 += sinc_table[ table_idx + 14 ] * sample_data[ sample_idx + 14 ] >> 15;
-			a1 += sinc_table[ table_idx + 15 ] * sample_data[ sample_idx + 15 ] >> 15;
-			a2  = sinc_table[ table_idx + 16 ] * sample_data[ sample_idx + 0  ] >> 15;
-			a2 += sinc_table[ table_idx + 17 ] * sample_data[ sample_idx + 1  ] >> 15;
-			a2 += sinc_table[ table_idx + 18 ] * sample_data[ sample_idx + 2  ] >> 15;
-			a2 += sinc_table[ table_idx + 19 ] * sample_data[ sample_idx + 3  ] >> 15;
-			a2 += sinc_table[ table_idx + 20 ] * sample_data[ sample_idx + 4  ] >> 15;
-			a2 += sinc_table[ table_idx + 21 ] * sample_data[ sample_idx + 5  ] >> 15;
-			a2 += sinc_table[ table_idx + 22 ] * sample_data[ sample_idx + 6  ] >> 15;
-			a2 += sinc_table[ table_idx + 23 ] * sample_data[ sample_idx + 7  ] >> 15;
-			a2 += sinc_table[ table_idx + 24 ] * sample_data[ sample_idx + 8  ] >> 15;
-			a2 += sinc_table[ table_idx + 25 ] * sample_data[ sample_idx + 9  ] >> 15;
-			a2 += sinc_table[ table_idx + 26 ] * sample_data[ sample_idx + 10 ] >> 15;
-			a2 += sinc_table[ table_idx + 27 ] * sample_data[ sample_idx + 11 ] >> 15;
-			a2 += sinc_table[ table_idx + 28 ] * sample_data[ sample_idx + 12 ] >> 15;
-			a2 += sinc_table[ table_idx + 29 ] * sample_data[ sample_idx + 13 ] >> 15;
-			a2 += sinc_table[ table_idx + 30 ] * sample_data[ sample_idx + 14 ] >> 15;
-			a2 += sinc_table[ table_idx + 31 ] * sample_data[ sample_idx + 15 ] >> 15;			
-			amplitude = a1 + ( ( a2 - a1 ) * ( sample_frac & INTERP_BITMASK ) >> INTERP_SHIFT );
-			mix_buffer[ offset ] += amplitude * left_gain >> IBXM.FP_SHIFT;
-			mix_buffer[ offset + 1 ] += amplitude * right_gain >> IBXM.FP_SHIFT;
-			offset += 2;
-			sample_frac += step;
-			sample_idx += sample_frac >> IBXM.FP_SHIFT;
-			sample_frac &= IBXM.FP_MASK;
-		}
-	}
-
-	public boolean has_finished( int sample_idx ) {
-		boolean finished;
-		finished = false;
-		if( loop_length <= 1 && sample_idx > loop_start ) {
-			finished = true;
-		}
-		return finished;
-	}
-}

client/ibxm/ScreamTracker3.java

@@ -1,489 +0,0 @@
-
-package ibxm;
-
-import java.io.*;
-
-public class ScreamTracker3 {
-	private static final int[] effect_map = new int[] {
-		0xFF,
-		0x25, /* A: Set Speed.*/
-		0x0B, /* B: Pattern Jump.*/
-		0x0D, /* C: Pattern Break.*/
-		0x0A, /* D: Volume Slide.*/
-		0x02, /* E: Portamento Down.*/
-		0x01, /* F: Portamento Up.*/
-		0x03, /* G: Tone Portamento.*/
-		0x04, /* H: Vibrato.*/
-		0x1D, /* I: Tremor.*/
-		0x00, /* J: Arpeggio.*/
-		0x06, /* K: Vibrato + Volume Slide.*/
-		0x05, /* L: Tone Portamento + Volume Slide.*/
-		0xFF, /* M: */
-		0xFF, /* N: */
-		0x09, /* O: Sample Offset.*/
-		0xFF, /* P: */
-		0x1B, /* Q: Retrig + Volume Slide.*/
-		0x07, /* R: Tremolo.*/
-		0x0E, /* S: Extended Effects.*/
-		0x0F, /* T: Set Tempo.*/
-		0x24, /* U: Fine Vibrato.*/
-		0x10, /* V: Set Global Volume. */
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-		0xFF, 0xFF, 0xFF, 0xFF
-	};
-
-	private static final int[] effect_s_map = new int[] {
-		0x00, /* 0: Set Filter.*/
-		0x03, /* 1: Glissando.*/
-		0x05, /* 2: Set Fine Tune.*/
-		0x04, /* 3: Set Vibrato Waveform.*/
-		0x07, /* 4: Set Tremolo Waveform.*/
-		0xFF, /* 5: */
-		0xFF, /* 6: */
-		0xFF, /* 7: */
-		0x08, /* 8: Set Panning.*/
-		0xFF, /* 9: */
-		0x09, /* A: Stereo Control.*/
-		0x06, /* B: Pattern Loop.*/
-		0x0C, /* C: Note Cut.*/
-		0x0D, /* D: Note Delay.*/
-		0x0E, /* E: Pattern Delay.*/
-		0x0F  /* F: Invert Loop.*/
-	};
-
-	public static boolean is_s3m( byte[] header_96_bytes ) {
-		String s3m_identifier;
-		s3m_identifier = ascii_text( header_96_bytes, 44, 4 );
-		return s3m_identifier.equals( "SCRM" );
-	}
-
-	public static Module load_s3m( byte[] header_96_bytes, DataInput data_input ) throws IOException {
-		int num_pattern_orders, num_instruments, num_patterns, num_channels;
-		int flags, tracker_version, master_volume, panning, channel_config, sequence_length;
-		int instrument_idx, pattern_idx, channel_idx, order_idx, panning_offset;
-		boolean signed_samples, stereo_mode, default_panning;
-		int[] channel_map, sequence;
-		byte[] s3m_file;
-		Module module;
-		Instrument instrument;
-		s3m_file = read_s3m_file( header_96_bytes, data_input );
-		module = new Module();
-		module.song_title = ascii_text( s3m_file, 0, 28 );
-		num_pattern_orders = get_num_pattern_orders( s3m_file );
-		num_instruments = get_num_instruments( s3m_file );
-		num_patterns = get_num_patterns( s3m_file );
-		flags = unsigned_short_le( s3m_file, 38 );
-		tracker_version = unsigned_short_le( s3m_file, 40 );
-		if( ( flags & 0x40 ) == 0x40 || tracker_version == 0x1300 ) {
-			module.fast_volume_slides = true;
-		}
-		signed_samples = false;
-		if( unsigned_short_le( s3m_file, 42 ) == 0x01 ) {
-			signed_samples = true;
-		}
-		module.global_volume = s3m_file[ 48 ] & 0xFF;
-		module.default_speed = s3m_file[ 49 ] & 0xFF;
-		module.default_tempo = s3m_file[ 50 ] & 0xFF;
-		master_volume = s3m_file[ 51 ] & 0x7F;
-		module.channel_gain = ( master_volume << IBXM.FP_SHIFT ) >> 7;
-		stereo_mode = ( s3m_file[ 51 ] & 0x80 ) == 0x80;
-		default_panning = ( s3m_file[ 53 ] & 0xFF ) == 0xFC;
-		channel_map = new int[ 32 ];
-		num_channels = 0;
-		for( channel_idx = 0; channel_idx < 32; channel_idx++ ) {
-			channel_config = s3m_file[ 64 + channel_idx ] & 0xFF;
-			channel_map[ channel_idx ] = -1;
-			if( channel_config < 16 ) {
-				channel_map[ channel_idx ] = num_channels;
-				num_channels += 1;
-			}
-		}
-		module.set_num_channels( num_channels );
-		panning_offset = 96 + num_pattern_orders + num_instruments * 2 + num_patterns * 2;
-		for( channel_idx = 0; channel_idx < 32; channel_idx++ ) {
-			if( channel_map[ channel_idx ] < 0 ) continue;
-			panning = 7;
-			if( stereo_mode ) {
-				panning = 12;
-				if( ( s3m_file[ 64 + channel_idx ] & 0xFF ) < 8 ) {
-					panning = 3;
-				}
-			}
-			if( default_panning ) {
-				flags = s3m_file[ panning_offset + channel_idx ] & 0xFF;
-				if( ( flags & 0x20 ) == 0x20 ) {
-					panning = flags & 0xF;
-				}
-			}
-			module.set_initial_panning( channel_map[ channel_idx ], panning * 17 );
-		}
-		sequence = read_s3m_sequence( s3m_file );
-		module.set_sequence_length( sequence.length );
-		for( order_idx = 0; order_idx < sequence.length; order_idx++ ) {
-			module.set_sequence( order_idx, sequence[ order_idx ] );
-		}
-		module.set_num_instruments( num_instruments );
-		for( instrument_idx = 0; instrument_idx < num_instruments; instrument_idx++ ) {
-			instrument = read_s3m_instrument( s3m_file, instrument_idx, signed_samples );
-			module.set_instrument( instrument_idx + 1, instrument );
-		}
-		module.set_num_patterns( num_patterns );
-		for( pattern_idx = 0; pattern_idx < num_patterns; pattern_idx++ ) {
-			module.set_pattern( pattern_idx, read_s3m_pattern( s3m_file, pattern_idx, channel_map ) );
-		}
-		return module;
-	}
-
-	private static int[] read_s3m_sequence( byte[] s3m_file ) {
-		int num_pattern_orders, sequence_length;
-		int sequence_idx, order_idx, pattern_order;
-		int[] sequence;
-		num_pattern_orders = get_num_pattern_orders( s3m_file );
-		sequence_length = 0;
-		for( order_idx = 0; order_idx < num_pattern_orders; order_idx++ ) {
-			pattern_order = s3m_file[ 96 + order_idx ] & 0xFF;
-			if( pattern_order == 255 ) {
-				break;
-			} else if( pattern_order < 254 ) {
-				sequence_length += 1;
-			}
-		}
-		sequence = new int[ sequence_length ];
-		sequence_idx = 0;
-		for( order_idx = 0; order_idx < num_pattern_orders; order_idx++ ) {
-			pattern_order = s3m_file[ 96 + order_idx ] & 0xFF;
-			if( pattern_order == 255 ) {
-				break;
-			} else if( pattern_order < 254 ) {
-				sequence[ sequence_idx ] = pattern_order;
-				sequence_idx += 1;
-			}
-		}
-		return sequence;
-	}
-
-	private static Instrument read_s3m_instrument( byte[] s3m_file, int instrument_idx, boolean signed_samples ) {
-		int instrument_offset;
-		int sample_data_offset, sample_data_length;
-		int loop_start, loop_length, c2_rate, sample_idx, amplitude;
-		boolean sixteen_bit;
-		Instrument instrument;
-		Sample sample;
-		short[] sample_data;
-		instrument_offset = get_instrument_offset( s3m_file, instrument_idx );
-		instrument = new Instrument();
-		instrument.name = ascii_text( s3m_file, instrument_offset + 48, 28 );
-		sample = new Sample();
-		if( s3m_file[ instrument_offset ] == 1 ) {
-			sample_data_length = get_sample_data_length( s3m_file, instrument_offset );
-			loop_start = unsigned_short_le( s3m_file, instrument_offset + 20 );
-			loop_length = unsigned_short_le( s3m_file, instrument_offset + 24 ) - loop_start;
-			sample.volume = s3m_file[ instrument_offset + 28 ] & 0xFF;
-			if( s3m_file[ instrument_offset + 30 ] != 0 ) {
-				throw new IllegalArgumentException( "ScreamTracker3: Packed samples not supported!" );
-			}
-			if( ( s3m_file[ instrument_offset + 31 ] & 0x01 ) == 0 ) {
-				loop_length = 0;
-			}
-			if( ( s3m_file[ instrument_offset + 31 ] & 0x02 ) != 0 ) {
-				throw new IllegalArgumentException( "ScreamTracker3: Stereo samples not supported!" );
-			}
-			sixteen_bit = ( s3m_file[ instrument_offset + 31 ] & 0x04 ) != 0;
-			c2_rate = unsigned_short_le( s3m_file, instrument_offset + 32 );
-			sample.transpose = LogTable.log_2( c2_rate ) - LogTable.log_2( 8363 );
-			sample_data_offset = get_sample_data_offset( s3m_file, instrument_offset );
-			if( sixteen_bit ) {
-				if( signed_samples ) {
-					throw new IllegalArgumentException( "ScreamTracker3: Signed 16-bit samples not supported!" );
-				}
-				sample_data_length >>= 1;
-				sample_data = new short[ sample_data_length ];
-				for( sample_idx = 0; sample_idx < sample_data_length; sample_idx++ ) {
-					amplitude  = s3m_file[ sample_data_offset + sample_idx * 2 ] & 0xFF;
-					amplitude |= ( s3m_file[ sample_data_offset + sample_idx * 2 + 1 ] & 0xFF ) << 8;
-					sample_data[ sample_idx ] = ( short ) ( amplitude - 32768 );
-				}
-			} else {
-				sample_data = new short[ sample_data_length ];
-				if( signed_samples ) {
-					for( sample_idx = 0; sample_idx < sample_data_length; sample_idx++ ) {
-						amplitude = s3m_file[ sample_data_offset + sample_idx ] << 8;
-						sample_data[ sample_idx ] = ( short ) amplitude;
-					}
-				} else {
-					for( sample_idx = 0; sample_idx < sample_data_length; sample_idx++ ) {
-						amplitude = ( s3m_file[ sample_data_offset + sample_idx ] & 0xFF ) << 8;
-						sample_data[ sample_idx ] = ( short ) ( amplitude - 32768 );
-					}
-				}
-			}
-			sample.set_sample_data( sample_data, loop_start, loop_length, false );
-		}
-		instrument.set_num_samples( 1 );
-		instrument.set_sample( 0, sample );
-		return instrument;
-	}
-	
-	private static Pattern read_s3m_pattern( byte[] s3m_file, int pattern_idx, int[] channel_map ) {
-		int pattern_offset;
-		int num_channels, num_notes;
-		int row_idx, channel_idx, note_idx;
-		int token, key, volume_column, effect, effect_param;
-		byte[] pattern_data;
-		Pattern pattern;
-		num_channels = 0;
-		for( channel_idx = 0; channel_idx < 32; channel_idx++ ) {
-			if( channel_map[ channel_idx ] >= num_channels ) {
-				num_channels = channel_idx + 1;
-			}
-		}
-		num_notes = num_channels * 64;
-		pattern_data = new byte[ num_notes * 5 ];
-		row_idx = 0;
-		pattern_offset = get_pattern_offset( s3m_file, pattern_idx ) + 2;
-		while( row_idx < 64 ) {
-			token = s3m_file[ pattern_offset ] & 0xFF;
-			pattern_offset += 1;
-			if( token > 0 ) {
-				channel_idx = channel_map[ token & 0x1F ];
-				note_idx = ( num_channels * row_idx + channel_idx ) * 5;
-				if( ( token & 0x20 ) == 0x20 ) {
-					/* Key + Instrument.*/
-					if( channel_idx >= 0 ) {
-						key = s3m_file[ pattern_offset ] & 0xFF;
-						if( key == 255 ) {
-							key = 0;
-						} else if( key == 254 ) {
-							key = 97;
-						} else {
-							key = ( ( key & 0xF0 ) >> 4 ) * 12 + ( key & 0x0F ) + 1;
-							while( key > 96 ) {
-								key = key - 12;
-							}
-						}
-						pattern_data[ note_idx ] = ( byte ) key;
-						pattern_data[ note_idx + 1 ] = s3m_file[ pattern_offset + 1 ];
-					}
-					pattern_offset += 2;
-				}
-				if( ( token & 0x40 ) == 0x40 ) {
-					/* Volume.*/
-					if( channel_idx >= 0 ) {
-						volume_column = ( s3m_file[ pattern_offset ] & 0xFF ) + 0x10;
-						pattern_data[ note_idx + 2 ] = ( byte ) volume_column;
-					}
-					pattern_offset += 1;
-				}
-				if( ( token & 0x80 ) == 0x80 ) {
-					/* Effect + Param.*/
-					if( channel_idx >= 0 ) {
-						effect = s3m_file[ pattern_offset ] & 0xFF;
-						effect_param = s3m_file[ pattern_offset + 1 ] & 0xFF;
-						effect = effect_map[ effect & 0x1F ];
-						if( effect == 0xFF ) {
-							effect = 0;
-							effect_param = 0;
-						}
-						if( effect == 0x0E ) {
-							effect = effect_s_map[ ( effect_param & 0xF0 ) >> 4 ];
-							effect_param = effect_param & 0x0F;
-							switch( effect ) {
-								case 0x08:
-									effect = 0x08;
-									effect_param = effect_param * 17;
-									break;
-								case 0x09:
-									effect = 0x08;
-									if( effect_param > 7 ) {
-										effect_param -= 8;
-									} else {
-										effect_param += 8;
-									}
-									effect_param = effect_param * 17;
-									break;
-								case 0xFF:
-									effect = 0;
-									effect_param = 0;
-									break;
-								default:
-									effect_param = ( ( effect & 0x0F ) << 4 ) | ( effect_param & 0x0F );
-									effect = 0x0E;
-									break;
-							}
-						}
-						pattern_data[ note_idx + 3 ] = ( byte ) effect;
-						pattern_data[ note_idx + 4 ] = ( byte ) effect_param;
-					}
-					pattern_offset += 2;
-				}
-			} else {
-				row_idx += 1;
-			}
-		}
-		pattern = new Pattern();
-		pattern.num_rows = 64;
-		pattern.set_pattern_data( pattern_data );
-		return pattern;
-	}
-
-	private static byte[] read_s3m_file( byte[] header_96_bytes, DataInput data_input ) throws IOException {
-		int s3m_file_length;
-		int num_pattern_orders, num_instruments, num_patterns;
-		int instrument_idx, pattern_idx;
-		int instrument_offset, sample_data_offset, pattern_offset;
-		byte[] s3m_file;
-		if( !is_s3m( header_96_bytes ) ) {
-			throw new IllegalArgumentException( "ScreamTracker3: Not an S3M file!" );
-		}
-		s3m_file = header_96_bytes;
-		s3m_file_length = header_96_bytes.length;
-		num_pattern_orders = get_num_pattern_orders( s3m_file );
-		num_instruments = get_num_instruments( s3m_file );
-		num_patterns = get_num_patterns( s3m_file );
-		s3m_file_length += num_pattern_orders;
-		s3m_file_length += num_instruments * 2;
-		s3m_file_length += num_patterns * 2;
-		/* Read enough of file to calculate the length.*/
-		s3m_file = read_more( s3m_file, s3m_file_length, data_input );
-		for( instrument_idx = 0; instrument_idx < num_instruments; instrument_idx++ ) {
-			instrument_offset = get_instrument_offset( s3m_file, instrument_idx );
-			instrument_offset += 80;
-			if( instrument_offset > s3m_file_length ) {
-				s3m_file_length = instrument_offset;
-			}
-		}
-		for( pattern_idx = 0; pattern_idx < num_patterns; pattern_idx++ ) {
-			pattern_offset = get_pattern_offset( s3m_file, pattern_idx );
-			pattern_offset += 2;
-			if( pattern_offset > s3m_file_length ) {
-				s3m_file_length = pattern_offset;
-			}
-		}
-		s3m_file = read_more( s3m_file, s3m_file_length, data_input );
-		/* Read rest of file.*/
-		for( instrument_idx = 0; instrument_idx < num_instruments; instrument_idx++ ) {
-			instrument_offset = get_instrument_offset( s3m_file, instrument_idx );
-			sample_data_offset = get_sample_data_offset( s3m_file, instrument_offset );
-			sample_data_offset += get_sample_data_length( s3m_file, instrument_offset );
-			if( sample_data_offset > s3m_file_length ) {
-				s3m_file_length = sample_data_offset;
-			}
-		}
-		for( pattern_idx = 0; pattern_idx < num_patterns; pattern_idx++ ) {
-			pattern_offset = get_pattern_offset( s3m_file, pattern_idx );
-			pattern_offset += get_pattern_length( s3m_file, pattern_offset );
-			pattern_offset += 2;
-			if( pattern_offset > s3m_file_length ) {
-				s3m_file_length = pattern_offset;
-			}
-		}
-		s3m_file = read_more( s3m_file, s3m_file_length, data_input );
-		return s3m_file;
-	}
-
-	private static int get_num_pattern_orders( byte[] s3m_file ) {
-		int num_pattern_orders;
-		num_pattern_orders = unsigned_short_le( s3m_file, 32 );
-		return num_pattern_orders;
-	}
-
-	private static int get_num_instruments( byte[] s3m_file ) {
-		int num_instruments;
-		num_instruments = unsigned_short_le( s3m_file, 34 );
-		return num_instruments;
-	}
-	
-	private static int get_num_patterns( byte[] s3m_file ) {
-		int num_patterns;
-		num_patterns = unsigned_short_le( s3m_file, 36 );
-		return num_patterns;
-	}
-
-	private static int get_instrument_offset( byte[] s3m_file, int instrument_idx ) {
-		int instrument_offset, pointer_offset;
-		pointer_offset = 96 + get_num_pattern_orders( s3m_file );
-		instrument_offset = unsigned_short_le( s3m_file, pointer_offset + instrument_idx * 2 ) << 4;
-		return instrument_offset;
-	}
-
-	private static int get_sample_data_offset( byte[] s3m_file, int instrument_offset ) {
-		int sample_data_offset;
-		sample_data_offset = 0;
-		if( s3m_file[ instrument_offset ] == 1 ) {
-			sample_data_offset = ( s3m_file[ instrument_offset + 13 ] & 0xFF ) << 20;
-			sample_data_offset |= unsigned_short_le( s3m_file, instrument_offset + 14 ) << 4;
-		}
-		return sample_data_offset;
-	}
-
-	private static int get_sample_data_length( byte[] s3m_file, int instrument_offset ) {
-		int sample_data_length;
-		boolean sixteen_bit;
-		sample_data_length = 0;
-		if( s3m_file[ instrument_offset ] == 1 ) {
-			sample_data_length = unsigned_short_le( s3m_file, instrument_offset + 16 );
-			sixteen_bit = ( s3m_file[ instrument_offset + 31 ] & 0x04 ) != 0;
-			if( sixteen_bit ) {
-				sample_data_length <<= 1;
-			}
-		}
-		return sample_data_length;
-	}
-
-	private static int get_pattern_offset( byte[] s3m_file, int pattern_idx ) {
-		int pattern_offset, pointer_offset;
-		pointer_offset = 96 + get_num_pattern_orders( s3m_file );
-		pointer_offset += get_num_instruments( s3m_file ) * 2;
-		pattern_offset = unsigned_short_le( s3m_file, pointer_offset + pattern_idx * 2 ) << 4;
-		return pattern_offset;
-	}
-
-	private static int get_pattern_length( byte[] s3m_file, int pattern_offset ) {
-		int pattern_length;
-		pattern_length = unsigned_short_le( s3m_file, pattern_offset );
-		return pattern_length;
-	}
-
-	private static byte[] read_more( byte[] old_data, int new_length, DataInput data_input ) throws IOException {
-		byte[] new_data;
-		new_data = old_data;
-		if( new_length > old_data.length ) {
-			new_data = new byte[ new_length ];
-			System.arraycopy( old_data, 0, new_data, 0, old_data.length );
-			try {
-				data_input.readFully( new_data, old_data.length, new_data.length - old_data.length );
-			} catch( EOFException e ) {
-				System.out.println( "ScreamTracker3: Module has been truncated!" );
-			}
-		}
-		return new_data;
-	}
-
-	private static int unsigned_short_le( byte[] buffer, int offset ) {
-		int value;
-		value = buffer[ offset ] & 0xFF;
-		value = value | ( ( buffer[ offset + 1 ] & 0xFF ) << 8 );
-		return value;
-	}
-
-	private static String ascii_text( byte[] buffer, int offset, int length ) {
-		int idx, chr;
-		byte[] string_buffer;
-		String string;
-		string_buffer = new byte[ length ];
-		for( idx = 0; idx < length; idx++ ) {
-			chr = buffer[ offset + idx ];
-			if( chr < 32 ) {
-				chr = 32;
-			}
-			string_buffer[ idx ] = ( byte ) chr;
-		}
-		try {
-			string = new String( string_buffer, 0, length, "ISO-8859-1" );
-		} catch( UnsupportedEncodingException e ) {
-			string = "";
-		}
-		return string;
-	}
-}
-

client/net/minecraft/src/BaseMod.java

@@ -0,0 +1,440 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package net.minecraft.src;
+
+import java.util.Map;
+import java.util.Random;
+
+import net.minecraft.client.Minecraft;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.common.IConsoleHandler;
+import cpw.mods.fml.common.ICraftingHandler;
+import cpw.mods.fml.common.IDispenseHandler;
+import cpw.mods.fml.common.INetworkHandler;
+import cpw.mods.fml.common.IPickupNotifier;
+import cpw.mods.fml.common.IPlayerTracker;
+import cpw.mods.fml.common.IWorldGenerator;
+import cpw.mods.fml.common.TickType;
+
+public abstract class BaseMod implements cpw.mods.fml.common.modloader.BaseModProxy
+{
+    // CALLBACK MECHANISMS
+
+    public final boolean doTickInGame(TickType tick, boolean tickEnd, Object... data)
+    {
+        Minecraft mc = FMLClientHandler.instance().getClient();
+        boolean hasWorld = true;
+        // World and render ticks
+        if (tickEnd && ( tick==TickType.RENDER || tick==TickType.CLIENT ) && hasWorld) {
+            return onTickInGame((Float) data[0], mc);
+        }
+        return true;
+    }
+
+    public final boolean doTickInGUI(TickType tick, boolean tickEnd, Object... data)
+    {
+        Minecraft mc = FMLClientHandler.instance().getClient();
+        if (tickEnd && ( tick==TickType.RENDER || tick==TickType.CLIENT)) {
+            return onTickInGUI((Float) data[0], mc, mc.field_71462_r);
+        }
+        return true;
+    }
+
+    /**
+     * @param minecraftInstance
+     * @return
+     *//*
+
+    *//**
+     * @param renderers
+     *//*
+    public final void onRenderHarvest(Map renderers)
+    {
+        addRenderer((Map<Class<? extends Entity>,Render>)renderers);
+
+    }
+
+    *//**
+     *
+     *//*
+    public final void onRegisterAnimations()
+    {
+        registerAnimation(FMLClientHandler.instance().getClient());
+    }
+
+    @Override
+    public final void onCrafting(Object... craftingParameters)
+    {
+        takenFromCrafting((EntityPlayer)craftingParameters[0], (ItemStack)craftingParameters[1], (IInventory)craftingParameters[2]);
+    }
+
+    @Override
+    public final void onSmelting(Object... smeltingParameters)
+    {
+        takenFromFurnace((EntityPlayer)smeltingParameters[0], (ItemStack)smeltingParameters[1]);
+    }
+
+    @Override
+    public final boolean dispense(double x, double y, double z, int xVelocity, int zVelocity, Object... data)
+    {
+        return dispenseEntity((World)data[0], x, y, z, xVelocity, zVelocity, (ItemStack)data[1]);
+    }
+
+    @Override
+    public final boolean onChat(Object... data)
+    {
+        receiveChatPacket(((Packet3Chat)data[0]).field_73476_b);
+        return true;
+    }
+
+
+    @Override
+    public final void onServerLogin(Object handler) {
+        serverConnect((NetClientHandler) handler);
+    }
+
+    public final void onServerLogout() {
+        serverDisconnect();
+    }
+
+    @Override
+    public final void onPlayerLogin(Object player)
+    {
+        onClientLogin((EntityPlayer) player);
+    }
+
+    @Override
+    public final void onPlayerLogout(Object player)
+    {
+        onClientLogout((EntityPlayer)player);
+    }
+
+    @Override
+    public final void onPlayerChangedDimension(Object player)
+    {
+        onClientDimensionChanged((EntityPlayer)player);
+    }
+
+    @Override
+    public final void onPacket250Packet(Object... data)
+    {
+        receiveCustomPacket((Packet250CustomPayload)data[0]);
+    }
+
+    @Override
+    public final void notifyPickup(Object... pickupData)
+    {
+        EntityItem item = (EntityItem) pickupData[0];
+        EntityPlayer player = (EntityPlayer) pickupData[1];
+        onItemPickup(player, item.field_70294_a);
+    }
+
+    @Override
+    public final void generate(Random random, int chunkX, int chunkZ, Object... additionalData)
+    {
+        World w = (World) additionalData[0];
+        IChunkProvider cp = (IChunkProvider) additionalData[1];
+
+        if (cp instanceof ChunkProviderGenerate)
+        {
+            generateSurface(w, random, chunkX << 4, chunkZ << 4);
+        }
+        else if (cp instanceof ChunkProviderHell)
+        {
+            generateNether(w, random, chunkX << 4, chunkZ << 4);
+        }
+    }
+
+    *//**
+     * NO-OP on client side
+     *//*
+    @Override
+    public final boolean handleCommand(String command, Object... data)
+    {
+        return false;
+    }
+
+*/    // BASEMOD API
+    /**
+     * Override if you wish to provide a fuel item for the furnace and return the fuel value of the item
+     *
+     * @param id
+     * @param metadata
+     * @return
+     */
+    public int addFuel(int id, int metadata)
+    {
+        return 0;
+    }
+
+    public void addRenderer(Map<Class<? extends Entity>, Render> renderers)
+    {
+
+    }
+
+    /**
+     * Override if you wish to perform some action other than just dispensing the item from the dispenser
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param xVel
+     * @param zVel
+     * @param item
+     * @return
+     */
+    public boolean dispenseEntity(World world, double x, double y, double z, int xVel, int zVel, ItemStack item)
+    {
+        return false;
+    }
+
+    /**
+     * Override if you wish to generate Nether (Hell biome) blocks
+     *
+     * @param world
+     * @param random
+     * @param chunkX
+     * @param chunkZ
+     */
+    public void generateNether(World world, Random random, int chunkX, int chunkZ)
+    {
+    }
+
+    /**
+     * Override if you wish to generate Overworld (not hell or the end) blocks
+     *
+     * @param world
+     * @param random
+     * @param chunkX
+     * @param chunkZ
+     */
+    public void generateSurface(World world, Random random, int chunkX, int chunkZ)
+    {
+    }
+
+    /**
+     * Return the name of your mod. Defaults to the class name
+     *
+     * @return
+     */
+    public String getName()
+    {
+        return getClass().getSimpleName();
+    }
+
+    /**
+     * Get your mod priorities
+     *
+     * @return
+     */
+    public String getPriorities()
+    {
+        return "";
+    }
+
+    /**
+     * Return the version of your mod
+     *
+     * @return
+     */
+    public abstract String getVersion();
+
+    public void keyboardEvent(KeyBinding event)
+    {
+
+    }
+
+    /**
+     * Load your mod
+     */
+    public abstract void load();
+
+    /**
+     * Finish loading your mod
+     */
+    public void modsLoaded()
+    {
+    }
+
+    /**
+     * Handle item pickup
+     *
+     * @param player
+     * @param item
+     */
+    public void onItemPickup(EntityPlayer player, ItemStack item)
+    {
+    }
+
+    /**
+     * Ticked every game tick if you have subscribed to tick events through {@link ModLoader#setInGameHook(BaseMod, boolean, boolean)}
+     *
+     * @param time the rendering subtick time (0.0-1.0)
+     * @param minecraftInstance the client
+     * @return true to continue receiving ticks
+     */
+    public boolean onTickInGame(float time, Minecraft minecraftInstance)
+    {
+        return false;
+    }
+
+    public boolean onTickInGUI(float tick, Minecraft game, GuiScreen gui)
+    {
+        return false;
+    }
+
+    /**
+     * Only implemented on the client side
+     * {@link #onChatMessageReceived(EntityPlayer, Packet3Chat)}
+     *
+     * @param text
+     */
+    @Override
+    public void receiveChatPacket(String text)
+    {
+        // TODO
+    }
+
+    /**
+     * Only called on the client side
+     * {@link #onPacket250Received(EntityPlayer, Packet250CustomPayload)}
+     *
+     * @param packet
+     */
+    @Override
+    public void receiveCustomPacket(Packet250CustomPayload packet)
+    {
+        // TODO
+    }
+
+    public void registerAnimation(Minecraft game)
+    {
+
+    }
+
+    public void renderInvBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
+    {
+
+    }
+
+    public boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelID)
+    {
+        return false;
+
+    }
+
+    @Override
+    public void serverConnect(NetHandler handler) {
+
+    }
+
+    @Override
+    public void serverDisconnect() {
+
+    }
+    /**
+     * Called when someone crafts an item from a crafting table
+     *
+     * @param player
+     * @param item
+     * @param matrix
+     */
+    public void takenFromCrafting(EntityPlayer player, ItemStack item, IInventory matrix)
+    {
+    }
+
+    /**
+     * Called when someone takes a smelted item from a furnace
+     *
+     * @param player
+     * @param item
+     */
+    public void takenFromFurnace(EntityPlayer player, ItemStack item)
+    {
+    }
+
+    /**
+     * The identifier string for the mod- used in client<->server negotiation
+     */
+    @Override
+    public String toString()
+    {
+        return getName() + " " + getVersion();
+    }
+
+    /**
+     * Called when a 250 packet is received on a channel registered to this mod
+     *
+     * @param source
+     * @param payload
+     */
+    @Override
+    public void onPacket250Received(EntityPlayer source, Packet250CustomPayload payload)
+    {
+    }
+
+    /**
+     * Called when a chat message is received. Return true to stop further processing
+     *
+     * @param source
+     * @param chat
+     * @return true if you want to consume the message so it is not available for further processing
+     */
+    public boolean onChatMessageReceived(EntityPlayer source, Packet3Chat chat)
+    {
+        return false;
+    }
+    /**
+     * Called when a server command is received
+     * @param command
+     * @return true if you want to consume the message so it is not available for further processing
+     */
+    public boolean onServerCommand(String command, String sender, Object listener)
+    {
+        return false;
+    }
+
+    /**
+     * Called when a new client logs in.
+     *
+     * @param player
+     */
+    @Override
+    public void onClientLogin(EntityPlayer player)
+    {
+    }
+
+    /**
+     * Called when a client logs out of the server.
+     *
+     * @param player
+     */
+    @Override
+    public void onClientLogout(NetworkManager mgr)
+    {
+
+    }
+
+    /**
+     *
+     * Called when a client changes dimensions on the server.
+     *
+     * @param player
+     */
+    public void onClientDimensionChanged(EntityPlayer player)
+    {
+
+    }
+
+}

client/net/minecraft/src/EntityRendererProxy.java

@@ -0,0 +1,36 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraft.src;
+
+import net.minecraft.client.Minecraft;
+
+public class EntityRendererProxy extends EntityRenderer
+{
+    public static final String fmlMarker = "This is an FML marker";
+    private Minecraft game;
+
+    public EntityRendererProxy(Minecraft minecraft)
+    {
+        super(minecraft);
+        game = minecraft;
+    }
+
+    @Override
+    public void func_78480_b(float tick)
+    {
+        super.func_78480_b(tick);
+        //This is where ModLoader does all of it's ticking
+    }
+}

client/net/minecraft/src/FMLRenderAccessLibrary.java

@@ -0,0 +1,91 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraft.src;
+
+import java.awt.Dimension;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.client.TextureFXManager;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.FMLLog;
+
+/**
+ *
+ * A static hook library for optifine and other basemod editing code to access FML functions
+ *
+ * @author cpw
+ *
+ */
+public class FMLRenderAccessLibrary
+{
+    public static Logger getLogger()
+    {
+        return FMLLog.getLogger();
+    }
+
+    public static void log(Level level, String message)
+    {
+        FMLLog.log(level, message);
+    }
+
+    public static void log(Level level, String message, Throwable throwable)
+    {
+        FMLLog.log(level, throwable, message);
+    }
+
+    public static void setTextureDimensions(int textureId, int width, int height, List<TextureFX> textureFXList)
+    {
+        TextureFXManager.instance().setTextureDimensions(textureId, width, height, textureFXList);
+    }
+
+    public static void preRegisterEffect(TextureFX textureFX)
+    {
+        TextureFXManager.instance().onPreRegisterEffect(textureFX);
+    }
+
+    public static boolean onUpdateTextureEffect(TextureFX textureFX)
+    {
+        return TextureFXManager.instance().onUpdateTextureEffect(textureFX);
+    }
+
+    public static Dimension getTextureDimensions(TextureFX textureFX)
+    {
+        return TextureFXManager.instance().getTextureDimensions(textureFX);
+    }
+
+    public static void onTexturePackChange(RenderEngine engine, TexturePackBase texturePack, List<TextureFX> textureFXList)
+    {
+        TextureFXManager.instance().onTexturePackChange(engine, texturePack, textureFXList);
+    }
+
+    public static boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelId)
+    {
+        return RenderingRegistry.instance().renderWorldBlock(renderer, world, x, y, z, block, modelId);
+    }
+
+    public static void renderInventoryBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
+    {
+        RenderingRegistry.instance().renderInventoryBlock(renderer, block, metadata, modelID);
+    }
+
+    public static boolean renderItemAsFull3DBlock(int modelId)
+    {
+        return RenderingRegistry.instance().renderItemAsFull3DBlock(modelId);
+    }
+}

client/net/minecraft/src/MLProp.java

@@ -0,0 +1,48 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package net.minecraft.src;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import static java.lang.annotation.RetentionPolicy.*;
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * @author cpw
+ * 
+ */
+@Retention(value = RUNTIME)
+@Target(value = FIELD)
+public @interface MLProp
+{
+    /**
+     * Adds additional help to top of configuration file.
+     */
+    String info() default "";
+
+    /**
+     * Maximum value allowed if field is a number.
+     */
+    double max() default Double.MAX_VALUE;
+
+    /**
+     * Minimum value allowed if field is a number.
+     */
+    double min() default Double.MIN_VALUE;
+
+    /**
+     * Overrides the field name for property key.
+     */
+    String name() default "";
+
+}

client/net/minecraft/src/ModLoader.java

@@ -0,0 +1,807 @@
+/*
+ * The FML Forge Mod Loader suite. Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package net.minecraft.src;
+
+import java.awt.image.BufferedImage;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.server.MinecraftServer;
+
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.client.SpriteHelper;
+import cpw.mods.fml.client.TextureFXManager;
+import cpw.mods.fml.client.modloader.ModLoaderClientHelper;
+import cpw.mods.fml.client.modloader.ModLoaderKeyBindingHandler;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.client.registry.KeyBindingRegistry;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.modloader.ModLoaderHelper;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+import cpw.mods.fml.common.network.NetworkRegistry;
+import cpw.mods.fml.common.network.Player;
+import cpw.mods.fml.common.registry.EntityRegistry;
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.common.registry.LanguageRegistry;
+import cpw.mods.fml.common.ObfuscationReflectionHelper;
+
+public class ModLoader
+{
+    public static final String fmlMarker = "This is an FML marker";
+    // TODO dirty workaround for millinaire
+    @Deprecated
+    public static final Map<String,Map<String,String>> localizedStrings=Collections.emptyMap();
+    /**
+     * Not used on the server.
+     *
+     * @param achievement
+     * @param name
+     * @param description
+     */
+    public static void addAchievementDesc(Achievement achievement, String name, String description)
+    {
+        String achName=achievement.func_75970_i();
+        addLocalization(achName, name);
+        addLocalization(achName+".desc", description);
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     *
+     * {@link FMLCommonHandler#fuelLookup(int, int)}
+     *
+     * @param id
+     * @param metadata
+     * @return
+     */
+    @Deprecated
+    public static int addAllFuel(int id, int metadata)
+    {
+        return 0;
+    }
+
+    @Deprecated
+    public static void addAllRenderers(Map<Class<? extends Entity>, Render> renderers)
+    {
+    }
+
+    public static void addAnimation(TextureFX anim)
+    {
+        TextureFXManager.instance().addAnimation(anim);
+    }
+
+    /**
+     * This method is unimplemented in server versions to date.
+     *
+     * @param armor
+     * @return
+     */
+    public static int addArmor(String armor)
+    {
+        return RenderingRegistry.instance().addNewArmourRendererPrefix(armor);
+    }
+
+    /**
+     * This method adds the supplied biome to the set of candidate biomes for the default world generator type.
+     *
+     * @param biome
+     */
+    public static void addBiome(BiomeGenBase biome)
+    {
+        GameRegistry.addBiome(biome);
+    }
+
+    /**
+     * Add localization for the specified string
+     *
+     * @param key
+     * @param value
+     */
+    public static void addLocalization(String key, String value)
+    {
+        addLocalization(key, "en_US", value);
+    }
+
+    /**
+     * Add localization for the specified string
+     *
+     * @param key
+     * @param lang
+     * @param value
+     */
+    public static void addLocalization(String key, String lang, String value)
+    {
+        LanguageRegistry.instance().addStringLocalization(key, lang, value);
+    }
+
+    /**
+     * Name the specified minecraft object with the supplied name
+     *
+     * @param instance
+     * @param name
+     */
+    public static void addName(Object instance, String name)
+    {
+        addName(instance,"en_US",name);
+    }
+
+    /**
+     * Unimplemented on the server as it does not generate names
+     *
+     * @param instance
+     * @param lang
+     * @param name
+     */
+    public static void addName(Object instance, String lang, String name)
+    {
+        LanguageRegistry.instance().addNameForObject(instance, lang, name);
+    }
+
+    /**
+     * Unimplemented on the server as it does not render textures
+     *
+     * @param fileToOverride
+     * @param fileToAdd
+     * @return
+     */
+    public static int addOverride(String fileToOverride, String fileToAdd)
+    {
+        int idx = SpriteHelper.getUniqueSpriteIndex(fileToOverride);
+        addOverride(fileToOverride, fileToAdd, idx);
+        return idx;
+    }
+
+    /**
+     * Unimplemented on the server as it does not render textures
+     *
+     * @param path
+     * @param overlayPath
+     * @param index
+     */
+    public static void addOverride(String path, String overlayPath, int index)
+    {
+        TextureFXManager.instance().addNewTextureOverride(path, overlayPath, index);
+    }
+
+    /**
+     * Add a Shaped Recipe
+     *
+     * @param output
+     * @param params
+     */
+    public static void addRecipe(ItemStack output, Object... params)
+    {
+        GameRegistry.addRecipe(output, params);
+    }
+
+    /**
+     * Add a shapeless recipe
+     *
+     * @param output
+     * @param params
+     */
+    public static void addShapelessRecipe(ItemStack output, Object... params)
+    {
+        GameRegistry.addShapelessRecipe(output, params);
+    }
+
+    /**
+     * Add a new product to be smelted
+     *
+     * @param input
+     * @param output
+     */
+    public static void addSmelting(int input, ItemStack output)
+    {
+        GameRegistry.addSmelting(input, output, 1.0f);
+    }
+
+    /**
+     * Add a mob to the spawn list
+     *
+     * @param entityClass
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     */
+    public static void addSpawn(Class<? extends EntityLiving> entityClass, int weightedProb, int min, int max, EnumCreatureType spawnList)
+    {
+        EntityRegistry.addSpawn(entityClass, weightedProb, min, max, spawnList, WorldType.base12Biomes);
+    }
+
+    /**
+     * Add a mob to the spawn list
+     *
+     * @param entityClass
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     * @param biomes
+     */
+    public static void addSpawn(Class<? extends EntityLiving> entityClass, int weightedProb, int min, int max, EnumCreatureType spawnList, BiomeGenBase... biomes)
+    {
+        EntityRegistry.addSpawn(entityClass, weightedProb, min, max, spawnList, biomes);
+    }
+
+    /**
+     * Add a mob to the spawn list
+     *
+     * @param entityName
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     */
+    public static void addSpawn(String entityName, int weightedProb, int min, int max, EnumCreatureType spawnList)
+    {
+        EntityRegistry.addSpawn(entityName, weightedProb, min, max, spawnList, WorldType.base12Biomes);
+    }
+
+    /**
+     * Add a mob to the spawn list
+     *
+     * @param entityName
+     * @param weightedProb
+     * @param min
+     * @param max
+     * @param spawnList
+     * @param biomes
+     */
+    public static void addSpawn(String entityName, int weightedProb, int min, int max, EnumCreatureType spawnList, BiomeGenBase... biomes)
+    {
+        EntityRegistry.addSpawn(entityName, weightedProb, min, max, spawnList, biomes);
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLClientHandler#tryDispensingEntity(World, double, double, double, byte, byte, ItemStack)}
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param xVel
+     * @param zVel
+     * @param item
+     * @return
+     */
+    @Deprecated
+    public static boolean dispenseEntity(World world, double x, double y, double z, int xVel, int zVel, ItemStack item)
+    {
+        return false;
+    }
+
+    /**
+     * Remove a container and drop all the items in it on the ground around
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     */
+    public static void genericContainerRemoval(World world, int x, int y, int z)
+    {
+/*        TileEntity te = world.func_603_b(x, y, z);
+
+        if (!(te instanceof IInventory))
+        {
+            return;
+        }
+
+        IInventory inv = (IInventory)te;
+
+        for (int l = 0; l < inv.func_469_c(); l++)
+        {
+            ItemStack itemstack = inv.func_468_c(l);
+
+            if (itemstack == null)
+            {
+                continue;
+            }
+
+            float f = world.field_1037_n.nextFloat() * 0.8F + 0.1F;
+            float f1 = world.field_1037_n.nextFloat() * 0.8F + 0.1F;
+            float f2 = world.field_1037_n.nextFloat() * 0.8F + 0.1F;
+
+            while (itemstack.field_1615_a > 0)
+            {
+                int i1 = world.field_1037_n.nextInt(21) + 10;
+
+                if (i1 > itemstack.field_1615_a)
+                {
+                    i1 = itemstack.field_1615_a;
+                }
+
+                itemstack.field_1615_a -= i1;
+                EntityItem entityitem = new EntityItem(world, (float)te.field_823_f + f, (float)te.field_822_g + f1, (float)te.field_821_h + f2, new ItemStack(itemstack.field_1617_c, i1, itemstack.func_21181_i()));
+                float f3 = 0.05F;
+                entityitem.field_608_an = (float) world.field_1037_n.nextGaussian() * f3;
+                entityitem.field_607_ao = (float) world.field_1037_n.nextGaussian() * f3 + 0.2F;
+                entityitem.field_606_ap = (float) world.field_1037_n.nextGaussian() * f3;
+
+                if (itemstack.func_40710_n())
+                {
+                    entityitem.field_801_a.func_40706_d((NBTTagCompound) itemstack.func_40709_o().func_40195_b());
+                }
+
+                world.func_674_a(entityitem);
+            }
+        }
+*/    }
+
+    /**
+     * Get a list of all BaseMod loaded into the system
+     * {@link ModLoaderModContainer#findAll}
+     *
+     * @return
+     */
+    public static List<BaseMod> getLoadedMods()
+    {
+        return ModLoaderModContainer.findAll(BaseMod.class);
+    }
+
+    /**
+     * Get a logger instance {@link FMLCommonHandler#getFMLLogger()}
+     *
+     * @return
+     */
+    public static Logger getLogger()
+    {
+        return FMLLog.getLogger();
+    }
+
+    public static Minecraft getMinecraftInstance()
+    {
+        return FMLClientHandler.instance().getClient();
+    }
+
+    /**
+     * This is not the server
+     * {@link FMLClientHandler#getServer()}
+     *
+     * @return
+     */
+    public static MinecraftServer getMinecraftServerInstance()
+    {
+        return FMLCommonHandler.instance().getMinecraftServerInstance();
+    }
+
+    /**
+     * Get a value from a field using reflection
+     * {@link ObfuscationReflectionHelper#getPrivateValue(Class, Object, int)}
+     *
+     * @param instanceclass
+     * @param instance
+     * @param fieldindex
+     * @return
+     */
+    public static <T, E> T getPrivateValue(Class<? super E> instanceclass, E instance, int fieldindex)
+    {
+        return ObfuscationReflectionHelper.getPrivateValue(instanceclass, instance, fieldindex);
+    }
+
+    /**
+     * Get a value from a field using reflection
+     * {@link ObfuscationReflectionHelper#getPrivateValue(Class, Object, String)}
+     *
+     * @param instanceclass
+     * @param instance
+     * @param field
+     * @return
+     */
+    public static <T, E> T getPrivateValue(Class<? super E> instanceclass, E instance, String field)
+    {
+        return ObfuscationReflectionHelper.getPrivateValue(instanceclass, instance, field);
+    }
+
+    /**
+     * Stubbed method on the server to return a unique model id
+     *
+     */
+    public static int getUniqueBlockModelID(BaseMod mod, boolean inventoryRenderer)
+    {
+        return ModLoaderClientHelper.obtainBlockModelIdFor(mod, inventoryRenderer);
+    }
+
+    /**
+     * Get a new unique entity id
+     * {@link Entity#getNextId()}
+     *
+     * @return
+     */
+    public static int getUniqueEntityId()
+    {
+        return EntityRegistry.findGlobalUniqueEntityId();
+    }
+
+    public static int getUniqueSpriteIndex(String path)
+    {
+        return SpriteHelper.getUniqueSpriteIndex(path);
+    }
+
+    /**
+     * To properly implement packet 250 protocol you should always check your
+     * channel is active prior to sending the packet
+     *
+     * @param player
+     * @param channel
+     * @return
+     */
+    public static boolean isChannelActive(EntityPlayer player, String channel)
+    {
+        return NetworkRegistry.instance().isChannelActive(channel, (Player)player);
+    }
+
+    public static boolean isGUIOpen(Class<? extends GuiScreen> gui)
+    {
+        return FMLClientHandler.instance().getClient().field_71462_r != null && FMLClientHandler.instance().getClient().field_71462_r.equals(gui);
+    }
+
+    /**
+     * Is the named mod loaded?
+     * {@link Loader#isModLoaded(String)}
+     *
+     * @param modname
+     * @return
+     */
+    public static boolean isModLoaded(String modname)
+    {
+        return Loader.isModLoaded(modname);
+    }
+
+    /**
+     * Implemented elsewhere
+     */
+    @Deprecated
+    public static void loadConfig()
+    {
+    }
+
+    public static BufferedImage loadImage(RenderEngine renderEngine, String path) throws Exception
+    {
+        return TextureFXManager.instance().loadImageFromTexturePack(renderEngine, path);
+    }
+
+    /**
+     * Call in from elsewhere. Unimplemented here.
+     * @param player
+     * @param item
+     */
+    @Deprecated
+    public static void onItemPickup(EntityPlayer player, ItemStack item)
+    {
+    }
+    /**
+     * Call in from elsewhere. Unimplemented here.
+     */
+    @Deprecated
+    public static void onTick(float tick, Minecraft game)
+    {
+    }
+
+    public static void openGUI(EntityPlayer player, GuiScreen gui)
+    {
+        FMLClientHandler.instance().displayGuiScreen(player, gui);
+    }
+
+    @Deprecated
+    public static void populateChunk(IChunkProvider generator, int chunkX, int chunkZ, World world)
+    {
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLServerHandler#handlePacket250(Packet250CustomPayload, EntityPlayer)}
+     *
+     * @param packet
+     */
+    @Deprecated
+    public static void receivePacket(Packet250CustomPayload packet)
+    {
+    }
+
+    @Deprecated
+    public static KeyBinding[] registerAllKeys(KeyBinding[] keys)
+    {
+        return keys;
+    }
+
+    @Deprecated
+    public static void registerAllTextureOverrides(RenderEngine cache)
+    {
+    }
+
+    /**
+     * Register a new block
+     *
+     * @param block
+     */
+    public static void registerBlock(Block block)
+    {
+        GameRegistry.registerBlock(block);
+    }
+
+    /**
+     * Register a new block
+     *
+     * @param block
+     * @param itemclass
+     */
+    public static void registerBlock(Block block, Class<? extends ItemBlock> itemclass)
+    {
+        GameRegistry.registerBlock(block, itemclass);
+    }
+
+    /**
+     * Register a new entity ID
+     *
+     * @param entityClass
+     * @param entityName
+     * @param id
+     */
+    public static void registerEntityID(Class<? extends Entity> entityClass, String entityName, int id)
+    {
+        EntityRegistry.registerGlobalEntityID(entityClass, entityName, id);
+    }
+
+    /**
+     * Register a new entity ID
+     *
+     * @param entityClass
+     * @param entityName
+     * @param id
+     * @param background
+     * @param foreground
+     */
+    public static void registerEntityID(Class<? extends Entity> entityClass, String entityName, int id, int background, int foreground)
+    {
+        EntityRegistry.registerGlobalEntityID(entityClass, entityName, id, background, foreground);
+    }
+
+    public static void registerKey(BaseMod mod, KeyBinding keyHandler, boolean allowRepeat)
+    {
+        ModLoaderModContainer mlmc=ModLoaderHelper.registerKeyHelper(mod);
+        KeyBindingRegistry.registerKeyBinding(new ModLoaderKeyBindingHandler(keyHandler, allowRepeat, mlmc));
+    }
+
+    /**
+     * Register the mod for packets on this channel.
+     * {@link FMLCommonHandler#registerChannel(cpw.mods.fml.common.ModContainer, String)}
+     *
+     * @param mod
+     * @param channel
+     */
+    public static void registerPacketChannel(BaseMod mod, String channel)
+    {
+        NetworkRegistry.instance().registerChannel(ModLoaderHelper.buildPacketHandlerFor(mod), channel);
+    }
+
+    /**
+     * Register a new tile entity class
+     *
+     * @param tileEntityClass
+     * @param id
+     */
+    public static void registerTileEntity(Class<? extends TileEntity> tileEntityClass, String id)
+    {
+        GameRegistry.registerTileEntity(tileEntityClass, id);
+    }
+
+    public static void registerTileEntity(Class<? extends TileEntity> tileEntityClass, String id, TileEntitySpecialRenderer renderer)
+    {
+        ClientRegistry.registerTileEntity(tileEntityClass, id, renderer);
+    }
+
+    /**
+     * Remove a biome from the list of generated biomes
+     *
+     * @param biome
+     */
+    public static void removeBiome(BiomeGenBase biome)
+    {
+        GameRegistry.removeBiome(biome);
+    }
+
+    /**
+     * Remove a spawn
+     *
+     * @param entityClass
+     * @param spawnList
+     */
+    public static void removeSpawn(Class<? extends EntityLiving> entityClass, EnumCreatureType spawnList)
+    {
+        EntityRegistry.removeSpawn(entityClass, spawnList, WorldType.base12Biomes);
+    }
+
+    /**
+     * Remove a spawn
+     *
+     * @param entityClass
+     * @param spawnList
+     * @param biomes
+     */
+    public static void removeSpawn(Class<? extends EntityLiving> entityClass, EnumCreatureType spawnList, BiomeGenBase... biomes)
+    {
+        EntityRegistry.removeSpawn(entityClass, spawnList, biomes);
+    }
+
+    /**
+     * Remove a spawn
+     *
+     * @param entityName
+     * @param spawnList
+     */
+    public static void removeSpawn(String entityName, EnumCreatureType spawnList)
+    {
+        EntityRegistry.removeSpawn(entityName, spawnList, WorldType.base12Biomes);
+    }
+
+    /**
+     * Remove a spawn
+     *
+     * @param entityName
+     * @param spawnList
+     * @param biomes
+     */
+    public static void removeSpawn(String entityName, EnumCreatureType spawnList, BiomeGenBase... biomes)
+    {
+        EntityRegistry.removeSpawn(entityName, spawnList, biomes);
+    }
+
+    @Deprecated
+    public static boolean renderBlockIsItemFull3D(int modelID)
+    {
+        return RenderingRegistry.instance().renderItemAsFull3DBlock(modelID);
+    }
+
+    @Deprecated
+    public static void renderInvBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
+    {
+        RenderingRegistry.instance().renderInventoryBlock(renderer, block, metadata, modelID);
+    }
+
+    @Deprecated
+    public static boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelID)
+    {
+        return RenderingRegistry.instance().renderWorldBlock(renderer, world, x, y, z, block, modelID);
+    }
+
+    /**
+     * Configuration is handled elsewhere
+     * {@link ModLoaderModContainer}
+     */
+    @Deprecated
+    public static void saveConfig()
+    {
+    }
+
+    public static void sendPacket(Packet packet) {
+        // TODO
+//        FMLClientHandler.instance().sendPacket(packet);
+    }
+    /**
+     * Send a chat message to the server
+     * {@link FMLClientHandler#handleChatPacket(Packet3Chat, EntityPlayer)}
+     *
+     * @param text
+     */
+    @Deprecated
+    public static void serverChat(String text)
+    {
+        //TODO
+    }
+
+    @Deprecated
+    public static void serverLogin(NetClientHandler handler, Packet1Login loginPacket)
+    {
+        //TODO
+    }
+
+    /**
+     * Indicate that you want to receive ticks
+     *
+     * @param mod receiving the events
+     * @param enable indicates whether you want to recieve them or not
+     * @param useClock don't receive render subticks, just world ticks
+     */
+    public static void setInGameHook(BaseMod mod, boolean enable, boolean useClock)
+    {
+        ModLoaderHelper.updateStandardTicks(mod, enable, useClock);
+    }
+
+
+    public static void setInGUIHook(BaseMod mod, boolean enable, boolean useClock)
+    {
+        ModLoaderHelper.updateGUITicks(mod, enable, useClock);
+    }
+
+    /**
+     * Set a private field to a value using reflection
+     * {@link ObfuscationReflectionHelper#setPrivateValue(Class, Object, int, Object)}
+     *
+     * @param instanceclass
+     * @param instance
+     * @param fieldindex
+     * @param value
+     */
+    public static <T, E> void setPrivateValue(Class<? super T> instanceclass, T instance, int fieldindex, E value)
+    {
+        ObfuscationReflectionHelper.setPrivateValue(instanceclass, instance, value, fieldindex);
+    }
+
+    /**
+     * Set a private field to a value using reflection
+     * {@link ObfuscationReflectionHelper#setPrivateValue(Class, Object, String, Object)}
+     *
+     * @param instanceclass
+     * @param instance
+     * @param field
+     * @param value
+     */
+    public static <T, E> void setPrivateValue(Class<? super T> instanceclass, T instance, String field, E value)
+    {
+        ObfuscationReflectionHelper.setPrivateValue(instanceclass, instance, value, field);
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLClientHandler#onItemCrafted(EntityPlayer, ItemStack, IInventory)}
+     *
+     * @param player
+     * @param item
+     * @param matrix
+     */
+    @Deprecated
+    public static void takenFromCrafting(EntityPlayer player, ItemStack item, IInventory matrix)
+    {
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     * {@link FMLClientHandler#onItemSmelted(EntityPlayer, ItemStack)}
+     *
+     * @param player
+     * @param item
+     */
+    @Deprecated
+    public static void takenFromFurnace(EntityPlayer player, ItemStack item)
+    {
+    }
+
+    /**
+     * Throw the offered exception. Likely will stop the game.
+     * {@link FMLClientHandler#raiseException(Throwable, String, boolean)}
+     *
+     * @param message
+     * @param e
+     */
+    public static void throwException(String message, Throwable e)
+    {
+        FMLCommonHandler.instance().raiseException(e, message, true);
+    }
+
+    public static void throwException(Throwable e)
+    {
+        throwException("Exception in ModLoader", e);
+    }
+}

client/net/minecraft/src/ModTextureAnimation.java

@@ -0,0 +1,128 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraft.src;
+
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.awt.image.ImageObserver;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.client.FMLTextureFX;
+import cpw.mods.fml.common.FMLCommonHandler;
+import static org.lwjgl.opengl.GL11.*;
+
+/**
+ * A texture override for animations, it takes a vertical image of 
+ * texture frames and constantly rotates them in the texture.
+ */
+public class ModTextureAnimation extends FMLTextureFX
+{
+    private final int tickRate;
+    private byte[][] images;
+    private int index = 0;
+    private int ticks = 0;
+    
+    private String targetTex = null;
+    private BufferedImage imgData = null;
+    
+    public ModTextureAnimation(int icon, int target, BufferedImage image, int tickCount)
+    {
+        this(icon, 1, target, image, tickCount);
+    }
+
+    public ModTextureAnimation(int icon, int size, int target, BufferedImage image, int tickCount)    
+    {
+        this(icon, size, (target == 0 ? "/terrain.png" : "/gui/items.png"), image, tickCount);
+    }
+    
+    public ModTextureAnimation(int icon, int size, String target, BufferedImage image, int tickCount)
+    {
+        super(icon);
+        RenderEngine re = FMLClientHandler.instance().getClient().field_71446_o;
+        
+        targetTex = target;
+        field_76849_e = size;
+        field_76847_f = re.func_78341_b(target);
+        
+        tickRate = tickCount;
+        ticks = tickCount;
+        imgData = image;
+    }
+    
+    @Override
+    public void setup()
+    {
+        super.setup();
+        
+        int sWidth  = imgData.getWidth();
+        int sHeight = imgData.getHeight();
+        int tWidth  = tileSizeBase;
+        int tHeight = tileSizeBase;
+        
+        
+        int frames = (int)Math.floor((double)(sHeight / sWidth));
+
+        if (frames < 1)
+        {
+            throw new IllegalArgumentException(String.format("Attempted to create a TextureAnimation with no complete frames: %dx%d", sWidth, sHeight));
+        }
+        else
+        {
+            images = new byte[frames][];
+            BufferedImage image = imgData;
+            
+            if (sWidth != tWidth)
+            {
+                BufferedImage b = new BufferedImage(tWidth, tHeight * frames, 6);
+                Graphics2D g = b.createGraphics();
+                g.drawImage(imgData, 0, 0, tWidth, tHeight * frames, 0, 0, sWidth, sHeight, (ImageObserver)null);
+                g.dispose();
+                image = b;
+            }
+
+            for (int frame = 0; frame < frames; frame++)
+            {
+                int[] pixels = new int[tileSizeSquare];
+                image.getRGB(0, tHeight * frame, tWidth, tHeight, pixels, 0, tWidth);
+                images[frame] = new byte[tileSizeSquare << 2];
+
+                for (int i = 0; i < pixels.length; i++)
+                {
+                    int i4 = i * 4;
+                    images[frame][i4 + 0] = (byte)(pixels[i] >> 16 & 255);
+                    images[frame][i4 + 1] = (byte)(pixels[i] >> 8  & 255);
+                    images[frame][i4 + 2] = (byte)(pixels[i] >> 0  & 255);
+                    images[frame][i4 + 3] = (byte)(pixels[i] >> 24 & 255);
+                }
+            }
+        }
+    }
+    
+    public void func_783_a()
+    {
+        if (++ticks >= tickRate)
+        {
+            if (++index >= images.length)
+            {
+                index = 0;
+            }
+
+            field_76852_a = images[index];
+            ticks = 0;
+        }
+    }
+}

client/net/minecraft/src/ModTextureStatic.java

@@ -0,0 +1,179 @@
+/*
+ * The FML Forge Mod Loader suite.
+ * Copyright (C) 2012 cpw
+ *
+ * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 2.1 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraft.src;
+
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.awt.image.ImageObserver;
+
+import org.lwjgl.opengl.GL11;
+
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.client.FMLTextureFX;
+import cpw.mods.fml.common.FMLCommonHandler;
+import static org.lwjgl.opengl.GL11.*;
+
+public class ModTextureStatic extends FMLTextureFX
+{
+    private boolean oldanaglyph = false;
+    private int[] pixels = null;
+    private String targetTex = null;
+    private int storedSize;
+    private BufferedImage overrideData = null;
+    private int needApply = 2;
+    
+    
+    public ModTextureStatic(int icon, int target, BufferedImage image)
+    {
+        this(icon, 1, target, image);
+    }
+
+    public ModTextureStatic(int icon, int size, int target, BufferedImage image)    
+    {
+        this(icon, size, (target == 0 ? "/terrain.png" : "/gui/items.png"), image);
+    }
+    
+    public ModTextureStatic(int icon, int size, String target, BufferedImage image)
+    {
+        super(icon);
+        RenderEngine re = FMLClientHandler.instance().getClient().field_71446_o;
+        
+        targetTex = target;
+        storedSize = size;
+        field_76849_e = size;
+        field_76847_f = re.func_78341_b(target);
+        overrideData = image;
+    }
+    
+    @Override
+    public void setup()
+    {
+        super.setup();
+        int sWidth  = overrideData.getWidth();
+        int sHeight = overrideData.getHeight();
+
+        pixels = new int[tileSizeSquare];
+        if (tileSizeBase == sWidth && tileSizeBase == sHeight)
+        {
+            overrideData.getRGB(0, 0, sWidth, sHeight, pixels, 0, sWidth);
+        }
+        else
+        {
+            BufferedImage tmp = new BufferedImage(tileSizeBase, tileSizeBase, 6);
+            Graphics2D gfx = tmp.createGraphics();
+            gfx.drawImage(overrideData, 0, 0, tileSizeBase, tileSizeBase, 0, 0, sWidth, sHeight, (ImageObserver)null);
+            tmp.getRGB(0, 0, tileSizeBase, tileSizeBase, pixels, 0, tileSizeBase);
+            gfx.dispose();
+        }
+
+        update();
+    }
+    
+    public void func_783_a()
+    {
+        if (oldanaglyph != field_76851_c)
+        {
+            update();
+        }
+        // This makes it so we only apply the texture to the target texture when we need to, 
+        //due to the fact that update is called when the Effect is first registered, we actually 
+        //need to wait for the next one. 
+        field_76849_e = (needApply == 0 ? 0 : storedSize);
+        if (needApply > 0)
+        {
+            needApply--;
+        }
+    }
+
+    public void func_782_a(RenderEngine p_782_1_)
+    {
+        GL11.glBindTexture(GL_TEXTURE_2D, p_782_1_.func_78341_b(targetTex));
+    }
+    
+    public void update()
+    {
+        needApply = 2;
+        for (int idx = 0; idx < pixels.length; idx++)
+        {
+            int i = idx * 4;
+            int a = pixels[idx] >> 24 & 255;
+            int r = pixels[idx] >> 16 & 255;
+            int g = pixels[idx] >> 8 & 255;
+            int b = pixels[idx] >> 0 & 255;
+
+            if (field_76851_c)
+            {
+                r = g = b = (r + g + b) / 3;
+            }
+
+            field_76852_a[i + 0] = (byte)r;
+            field_76852_a[i + 1] = (byte)g;
+            field_76852_a[i + 2] = (byte)b;
+            field_76852_a[i + 3] = (byte)a;
+        }
+
+        oldanaglyph = field_76851_c;
+    }
+    
+    //Implementation of http://scale2x.sourceforge.net/algorithm.html
+    public static BufferedImage scale2x(BufferedImage image)
+    {
+        int w = image.getWidth();
+        int h = image.getHeight();
+        BufferedImage tmp = new BufferedImage(w * 2, h * 2, 2);
+
+        for (int x = 0; x < h; ++x)
+        {
+            int x2 = x * 2;
+            for (int y = 0; y < w; ++y)
+            {
+                int y2 = y * 2;
+                int E = image.getRGB(y, x);
+                int D = (x == 0     ? E : image.getRGB(y,     x - 1));
+                int B = (y == 0     ? E : image.getRGB(y - 1, x    ));
+                int H = (y >= w - 1 ? E : image.getRGB(y + 1, x    ));
+                int F = (x >= h - 1 ? E : image.getRGB(y,     x + 1));
+
+                int e0, e1, e2, e3;
+
+                if (B != H && D != F)
+                {
+                    e0 = D == B ? D : E;
+                    e1 = B == F ? F : E;
+                    e2 = D == H ? D : E;
+                    e3 = H == F ? F : E;
+                }
+                else
+                {
+                    e0 = e1 = e2 = e3 = E;
+                }
+
+                tmp.setRGB(y2,     x2,     e0);
+                tmp.setRGB(y2 + 1, x2,     e1);
+                tmp.setRGB(y2,     x2 + 1, e2);
+                tmp.setRGB(y2 + 1, x2 + 1, e3);
+            }
+        }
+
+        return tmp;
+    }
+
+    
+    @Override
+    public String toString() 
+    {
+        return String.format("ModTextureStatic %s @ %d", targetTex, field_76850_b);
+    }
+}

client/net/minecraftforge/client/EnumHelperClient.java

@@ -1,44 +0,0 @@
-package net.minecraftforge.client;
-
-import net.minecraft.world.EnumGameType;
-import net.minecraft.util.EnumOS;
-import net.minecraft.client.settings.EnumOptions;
-import net.minecraft.item.EnumRarity;
-import net.minecraftforge.common.EnumHelper;
-
-public class EnumHelperClient extends EnumHelper
-{
-
-    private static Class[][] clentTypes =
-    {
-        {EnumGameType.class, int.class, String.class},
-        {EnumOptions.class, String.class, boolean.class, boolean.class},
-        {EnumOS.class},
-        {EnumRarity.class, int.class, String.class}
-    };
-    
-    public static EnumGameType addGameType(String name, int id, String displayName)
-    {
-        return addEnum(EnumGameType.class, name, id, displayName);
-    }
-    
-    public static EnumOptions addOptions(String name, String langName, boolean isSlider, boolean isToggle)
-    {
-        return addEnum(EnumOptions.class, name, langName, isSlider, isToggle);
-    }
-    
-    public static EnumOS addOS2(String name)
-    {
-        return addEnum(EnumOS.class, name);
-    }
-    
-    public static EnumRarity addRarity(String name, int color, String displayName)
-    {
-        return addEnum(EnumRarity.class, name, color, displayName);
-    }
-
-    public static <T extends Enum<? >> T addEnum(Class<T> enumType, String enumName, Object... paramValues)
-    {
-        return addEnum(clentTypes, enumType, enumName, paramValues);
-    }
-}

client/net/minecraftforge/client/ForgeHooksClient.java

@@ -1,286 +0,0 @@
-package net.minecraftforge.client;
-
-import java.util.HashMap;
-import java.util.Random;
-import java.util.TreeSet;
-
-import javax.imageio.ImageIO;
-
-import org.lwjgl.LWJGLException;
-import org.lwjgl.opengl.Display;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL12;
-import org.lwjgl.opengl.PixelFormat;
-
-import cpw.mods.fml.client.FMLClientHandler;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.block.Block;
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityLiving;
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemBlock;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.MathHelper;
-import net.minecraft.util.MovingObjectPosition;
-import net.minecraft.client.model.ModelBiped;
-import net.minecraft.client.renderer.RenderBlocks;
-import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.renderer.entity.RenderItem;
-import net.minecraft.client.renderer.texture.TextureManager;
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraftforge.client.IItemRenderer.ItemRenderType;
-import net.minecraftforge.client.event.DrawBlockHighlightEvent;
-import net.minecraftforge.client.event.RenderWorldLastEvent;
-import net.minecraftforge.client.event.TextureStitchEvent;
-import net.minecraftforge.common.MinecraftForge;
-import static net.minecraftforge.client.IItemRenderer.ItemRenderType.*;
-import static net.minecraftforge.client.IItemRenderer.ItemRendererHelper.*;
-
-public class ForgeHooksClient
-{
-    static TextureManager engine()
-    {
-        return FMLClientHandler.instance().getClient().renderEngine;
-    }
-
-    public static String getArmorTexture(Entity entity, ItemStack armor, String _default, int slot, int layer, String type)
-    {
-        String result = armor.getItem().getArmorTexture(armor, entity, slot, layer);
-        return result != null ? result : _default;
-    }
-
-    public static boolean renderEntityItem(EntityItem entity, ItemStack item, float bobing, float rotation, Random random, TextureManager engine, RenderBlocks renderBlocks)
-    {
-        IItemRenderer customRenderer = MinecraftForgeClient.getItemRenderer(item, ENTITY);
-        if (customRenderer == null)
-        {
-            return false;
-        }
-
-        if (customRenderer.shouldUseRenderHelper(ENTITY, item, ENTITY_ROTATION))
-        {
-            GL11.glRotatef(rotation, 0.0F, 1.0F, 0.0F);
-        }
-        if (!customRenderer.shouldUseRenderHelper(ENTITY, item, ENTITY_BOBBING))
-        {
-            GL11.glTranslatef(0.0F, -bobing, 0.0F);
-        }
-        boolean is3D = customRenderer.shouldUseRenderHelper(ENTITY, item, BLOCK_3D);
-
-        engine.func_110577_a(item.getItemSpriteNumber() == 0 ? TextureMap.field_110575_b : TextureMap.field_110576_c);
-        Block block = (item.itemID < Block.blocksList.length ? Block.blocksList[item.itemID] : null);
-        if (is3D || (block != null && RenderBlocks.renderItemIn3d(block.getRenderType())))
-        {
-            int renderType = (block != null ? block.getRenderType() : 1);
-            float scale = (renderType == 1 || renderType == 19 || renderType == 12 || renderType == 2 ? 0.5F : 0.25F);
-
-            if (RenderItem.renderInFrame)
-            {
-                GL11.glScalef(1.25F, 1.25F, 1.25F);
-                GL11.glTranslatef(0.0F, 0.05F, 0.0F);
-                GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);
-            }
-
-            GL11.glScalef(scale, scale, scale);
-            
-            int size = item.stackSize;
-            int count = (size > 40 ? 5 : (size > 20 ? 4 : (size > 5 ? 3 : (size > 1 ? 2 : 1))));
-
-            for(int j = 0; j < count; j++)
-            {
-                GL11.glPushMatrix();
-                if (j > 0)
-                {
-                    GL11.glTranslatef(
-                        ((random.nextFloat() * 2.0F - 1.0F) * 0.2F) / scale,
-                        ((random.nextFloat() * 2.0F - 1.0F) * 0.2F) / scale,
-                        ((random.nextFloat() * 2.0F - 1.0F) * 0.2F) / scale);
-                }
-                customRenderer.renderItem(ENTITY, item, renderBlocks, entity);
-                GL11.glPopMatrix();
-            }
-        }
-        else
-        {
-            GL11.glScalef(0.5F, 0.5F, 0.5F);
-            customRenderer.renderItem(ENTITY, item, renderBlocks, entity);
-        }
-        return true;
-    }
-
-    public static boolean renderInventoryItem(RenderBlocks renderBlocks, TextureManager engine, ItemStack item, boolean inColor, float zLevel, float x, float y)
-    {
-        IItemRenderer customRenderer = MinecraftForgeClient.getItemRenderer(item, INVENTORY);
-        if (customRenderer == null)
-        {
-            return false;
-        }
-
-        engine.func_110577_a(item.getItemSpriteNumber() == 0 ? TextureMap.field_110575_b : TextureMap.field_110576_c);
-        if (customRenderer.shouldUseRenderHelper(INVENTORY, item, INVENTORY_BLOCK))
-        {
-            GL11.glPushMatrix();
-            GL11.glTranslatef(x - 2, y + 3, -3.0F + zLevel);
-            GL11.glScalef(10F, 10F, 10F);
-            GL11.glTranslatef(1.0F, 0.5F, 1.0F);
-            GL11.glScalef(1.0F, 1.0F, -1F);
-            GL11.glRotatef(210F, 1.0F, 0.0F, 0.0F);
-            GL11.glRotatef(45F, 0.0F, 1.0F, 0.0F);
-
-            if(inColor)
-            {
-                int color = Item.itemsList[item.itemID].getColorFromItemStack(item, 0);
-                float r = (float)(color >> 16 & 0xff) / 255F;
-                float g = (float)(color >> 8 & 0xff) / 255F;
-                float b = (float)(color & 0xff) / 255F;
-                GL11.glColor4f(r, g, b, 1.0F);
-            }
-
-            GL11.glRotatef(-90F, 0.0F, 1.0F, 0.0F);
-            renderBlocks.useInventoryTint = inColor;
-            customRenderer.renderItem(INVENTORY, item, renderBlocks);
-            renderBlocks.useInventoryTint = true;
-            GL11.glPopMatrix();
-        }
-        else
-        {
-            GL11.glDisable(GL11.GL_LIGHTING);
-            GL11.glPushMatrix();
-            GL11.glTranslatef(x, y, -3.0F + zLevel);
-
-            if (inColor)
-            {
-                int color = Item.itemsList[item.itemID].getColorFromItemStack(item, 0);
-                float r = (float)(color >> 16 & 255) / 255.0F;
-                float g = (float)(color >> 8 & 255) / 255.0F;
-                float b = (float)(color & 255) / 255.0F;
-                GL11.glColor4f(r, g, b, 1.0F);
-            }
-
-            customRenderer.renderItem(INVENTORY, item, renderBlocks);
-            GL11.glPopMatrix();
-            GL11.glEnable(GL11.GL_LIGHTING);
-        }
-        return true;
-    }
-
-    public static void renderEquippedItem(ItemRenderType type, IItemRenderer customRenderer, RenderBlocks renderBlocks, EntityLivingBase entity, ItemStack item)
-    {
-        if (customRenderer.shouldUseRenderHelper(type, item, EQUIPPED_BLOCK))
-        {
-            GL11.glPushMatrix();
-            GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-            customRenderer.renderItem(type, item, renderBlocks, entity);
-            GL11.glPopMatrix();
-        }
-        else
-        {
-            GL11.glPushMatrix();
-            GL11.glEnable(GL12.GL_RESCALE_NORMAL);
-            GL11.glTranslatef(0.0F, -0.3F, 0.0F);
-            GL11.glScalef(1.5F, 1.5F, 1.5F);
-            GL11.glRotatef(50.0F, 0.0F, 1.0F, 0.0F);
-            GL11.glRotatef(335.0F, 0.0F, 0.0F, 1.0F);
-            GL11.glTranslatef(-0.9375F, -0.0625F, 0.0F);
-            customRenderer.renderItem(type, item, renderBlocks, entity);
-            GL11.glDisable(GL12.GL_RESCALE_NORMAL);
-            GL11.glPopMatrix();
-        }
-    }
-
-    //Optifine Helper Functions u.u, these are here specifically for Optifine
-    //Note: When using Optfine, these methods are invoked using reflection, which
-    //incurs a major performance penalty.
-    public static void orientBedCamera(Minecraft mc, EntityLivingBase entity)
-    {
-        int x = MathHelper.floor_double(entity.posX);
-        int y = MathHelper.floor_double(entity.posY);
-        int z = MathHelper.floor_double(entity.posZ);
-        Block block = Block.blocksList[mc.theWorld.getBlockId(x, y, z)];
-
-        if (block != null && block.isBed(mc.theWorld, x, y, z, entity))
-        {
-            int var12 = block.getBedDirection(mc.theWorld, x, y, z);
-            GL11.glRotatef((float)(var12 * 90), 0.0F, 1.0F, 0.0F);
-        }
-    }
-
-    public static boolean onDrawBlockHighlight(RenderGlobal context, EntityPlayer player, MovingObjectPosition target, int subID, ItemStack currentItem, float partialTicks)
-    {
-        return MinecraftForge.EVENT_BUS.post(new DrawBlockHighlightEvent(context, player, target, subID, currentItem, partialTicks));
-    }
-
-    public static void dispatchRenderLast(RenderGlobal context, float partialTicks)
-    {
-        MinecraftForge.EVENT_BUS.post(new RenderWorldLastEvent(context, partialTicks));
-    }
-
-    public static void onTextureStitchedPre(TextureMap map)
-    {
-        MinecraftForge.EVENT_BUS.post(new TextureStitchEvent.Pre(map));
-    }
-
-    public static void onTextureStitchedPost(TextureMap map)
-    {
-        MinecraftForge.EVENT_BUS.post(new TextureStitchEvent.Post(map));
-    }
-
-    /**
-     * This is added for Optifine's convenience. And to explode if a ModMaker is developing.
-     * @param texture
-     */
-    public static void onTextureLoadPre(String texture)
-    {
-        if (Tessellator.renderingWorldRenderer)
-        {
-            String msg = String.format("Warning: Texture %s not preloaded, will cause render glitches!", texture);
-            System.out.println(msg);
-            if (Tessellator.class.getPackage() != null)
-            {
-                if (Tessellator.class.getPackage().getName().startsWith("net.minecraft."))
-                {
-                    Minecraft mc = FMLClientHandler.instance().getClient();
-                    if (mc.ingameGUI != null)
-                    {
-                        mc.ingameGUI.getChatGUI().printChatMessage(msg);
-                    }
-                }
-            }
-        }
-    }
-
-    static int renderPass = -1;
-    public static void setRenderPass(int pass)
-    {
-        renderPass = pass;
-    }
-
-    public static ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemStack, int slotID, ModelBiped _default)
-    {
-        ModelBiped modelbiped = itemStack.getItem().getArmorModel(entityLiving, itemStack, slotID);
-        return modelbiped == null ? _default : modelbiped;
-    }
-
-    static int stencilBits = 0;
-    public static void createDisplay() throws LWJGLException
-    {
-        ImageIO.setUseCache(false); //Disable on-disc stream cache should speed up texture pack reloading.
-        PixelFormat format = new PixelFormat().withDepthBits(24);
-        try
-        {
-            //TODO: Figure out how to determine the max bits.
-            Display.create(format.withStencilBits(8));
-            stencilBits = 8;
-        }
-        catch(LWJGLException e)
-        {
-            Display.create(format);
-            stencilBits = 0;
-        }
-    }
-}

client/net/minecraftforge/client/GuiControlsScrollPanel.java

@@ -1,127 +0,0 @@
-package net.minecraftforge.client;
-
-import org.lwjgl.input.Mouse;
-import org.lwjgl.opengl.GL11;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.settings.GameSettings;
-import net.minecraft.client.gui.GuiControls;
-import net.minecraft.client.gui.GuiSlot;
-import net.minecraft.client.settings.KeyBinding;
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraft.util.EnumChatFormatting;
-
-public class GuiControlsScrollPanel extends GuiSlot
-{
-    private GuiControls controls;
-    private GameSettings options;
-    private Minecraft mc;
-    private String[] message;
-    private int _mouseX;
-    private int _mouseY;
-    private int selected = -1;
-
-    public GuiControlsScrollPanel(GuiControls controls, GameSettings options, Minecraft mc)
-    {
-        super(mc, controls.width, controls.height, 16, (controls.height - 32) + 4, 25);
-        this.controls = controls;
-        this.options = options;
-        this.mc = mc;
-    }
-
-    @Override
-    protected int getSize()
-    {
-        return options.keyBindings.length;
-    }
-
-    @Override
-    protected void elementClicked(int i, boolean flag)
-    {
-        if (!flag)
-        {
-            if (selected == -1)
-            {
-                selected = i;
-            }
-            else
-            {
-                options.setKeyBinding(selected, -100);
-                selected = -1;
-                KeyBinding.resetKeyBindingArrayAndHash();
-            }
-        }
-    }
-
-    @Override
-    protected boolean isSelected(int i)
-    {
-        return false;
-    }
-
-    @Override
-    protected void func_130003_c() {}
-
-    @Override
-    public void drawScreen(int mX, int mY, float f)
-    {
-        _mouseX = mX;
-        _mouseY = mY;
-
-        if (selected != -1 && !Mouse.isButtonDown(0) && Mouse.getDWheel() == 0)
-        {
-            if (Mouse.next() && Mouse.getEventButtonState())
-            {
-                System.out.println(Mouse.getEventButton());
-                options.setKeyBinding(selected, -100 + Mouse.getEventButton());
-                selected = -1;
-                KeyBinding.resetKeyBindingArrayAndHash();
-            }
-        }
-
-        super.drawScreen(mX, mY, f);
-    }
-
-    @Override
-    protected void drawSlot(int index, int xPosition, int yPosition, int l, Tessellator tessellator)
-    {
-        int width = 70;
-        int height = 20;
-        xPosition -= 20;
-        boolean flag = _mouseX >= xPosition && _mouseY >= yPosition && _mouseX < xPosition + width && _mouseY < yPosition + height;
-        int k = (flag ? 2 : 1);
-
-        mc.renderEngine.func_110577_a(TextureMap.field_110576_c);
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        controls.drawTexturedModalRect(xPosition, yPosition, 0, 46 + k * 20, width / 2, height);
-        controls.drawTexturedModalRect(xPosition + width / 2, yPosition, 200 - width / 2, 46 + k * 20, width / 2, height);
-        controls.drawString(mc.fontRenderer, options.getKeyBindingDescription(index), xPosition + width + 4, yPosition + 6, 0xFFFFFFFF);
-
-        boolean conflict = false;
-        for (int x = 0; x < options.keyBindings.length; x++)
-        {
-            if (x != index && options.keyBindings[x].keyCode == options.keyBindings[index].keyCode)
-            {
-                conflict = true;
-                break;
-            }
-        }
-
-        String str = (conflict ? EnumChatFormatting.RED : "") + options.getOptionDisplayString(index);
-        str = (index == selected ? EnumChatFormatting.WHITE + "> " + EnumChatFormatting.YELLOW + "??? " + EnumChatFormatting.WHITE + "<" : str);
-        controls.drawCenteredString(mc.fontRenderer, str, xPosition + (width / 2), yPosition + (height - 8) / 2, 0xFFFFFFFF);
-    }
-
-    public boolean keyTyped(char c, int i)
-    {
-        if (selected != -1)
-        {
-            options.setKeyBinding(selected, i);
-            selected = -1;
-            KeyBinding.resetKeyBindingArrayAndHash();
-            return false;
-        }
-        return true;
-    }
-}

client/net/minecraftforge/client/GuiIngameForge.java

@@ -1,871 +0,0 @@
-package net.minecraftforge.client;
-
-import static net.minecraftforge.client.event.RenderGameOverlayEvent.ElementType.*;
-
-import java.awt.Color;
-import java.util.ArrayList;
-import java.util.List;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.material.Material;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.client.gui.Gui;
-import net.minecraft.client.gui.GuiIngame;
-import net.minecraft.client.gui.GuiPlayerInfo;
-import net.minecraft.client.gui.ScaledResolution;
-import net.minecraft.client.multiplayer.NetClientHandler;
-import net.minecraft.client.renderer.RenderHelper;
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraft.client.resources.ResourceLocation;
-import net.minecraft.crash.CallableMinecraftVersion;
-import net.minecraft.entity.Entity;
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.SharedMonsterAttributes;
-import net.minecraft.entity.ai.attributes.AttributeInstance;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.potion.Potion;
-import net.minecraft.scoreboard.Score;
-import net.minecraft.scoreboard.ScoreObjective;
-import net.minecraft.scoreboard.ScorePlayerTeam;
-import net.minecraft.util.Direction;
-import net.minecraft.util.EnumChatFormatting;
-import net.minecraft.util.FoodStats;
-import net.minecraft.util.MathHelper;
-import net.minecraft.util.StatCollector;
-import net.minecraft.util.StringUtils;
-import net.minecraft.world.EnumSkyBlock;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraftforge.client.event.RenderGameOverlayEvent;
-import net.minecraftforge.client.event.RenderGameOverlayEvent.ElementType;
-import net.minecraftforge.common.ForgeHooks;
-import net.minecraftforge.common.MinecraftForge;
-
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL12;
-
-import cpw.mods.fml.common.FMLCommonHandler;
-
-public class GuiIngameForge extends GuiIngame
-{
-    private static final ResourceLocation VIGNETTE     = new ResourceLocation("textures/misc/vignette.png");
-    private static final ResourceLocation WIDGITS      = new ResourceLocation("textures/gui/widgets.png");
-    private static final ResourceLocation PUMPKIN_BLUR = new ResourceLocation("textures/misc/pumpkinblur.png");
-    
-    private static final int WHITE = 0xFFFFFF;
-
-    //Flags to toggle the rendering of certain aspects of the HUD, valid conditions
-    //must be met for them to render normally. If those conditions are met, but this flag
-    //is false, they will not be rendered.
-    public static boolean renderHelmet = true;
-    public static boolean renderPortal = true;
-    public static boolean renderHotbar = true;
-    public static boolean renderCrosshairs = true;
-    public static boolean renderBossHealth = true;
-    public static boolean renderHealth = true;
-    public static boolean renderArmor = true;
-    public static boolean renderFood = true;
-    public static boolean renderHealthMount = true;
-    public static boolean renderAir = true;
-    public static boolean renderExperiance = true;
-    public static boolean renderJumpBar = true;
-    public static boolean renderObjective = true;
-    
-    public static int left_height = 39;
-    public static int right_height = 39;
-
-    private ScaledResolution res = null;
-    private FontRenderer fontrenderer = null;
-    private RenderGameOverlayEvent eventParent;
-    private static final String MC_VERSION = (new CallableMinecraftVersion(null)).minecraftVersion();
-
-    public GuiIngameForge(Minecraft mc)
-    {
-        super(mc);
-    }
-
-    @Override
-    public void renderGameOverlay(float partialTicks, boolean hasScreen, int mouseX, int mouseY)
-    {
-        res = new ScaledResolution(mc.gameSettings, mc.displayWidth, mc.displayHeight);
-        eventParent = new RenderGameOverlayEvent(partialTicks, res, mouseX, mouseY);
-        int width = res.getScaledWidth();
-        int height = res.getScaledHeight();
-        renderHealthMount = mc.thePlayer.ridingEntity instanceof EntityLivingBase;
-        renderFood = mc.thePlayer.ridingEntity == null;
-        renderJumpBar = mc.thePlayer.func_110317_t();
-        
-        right_height = 39;
-        left_height = 39;
-
-        if (pre(ALL)) return;
-
-        fontrenderer = mc.fontRenderer;
-        mc.entityRenderer.setupOverlayRendering();
-        GL11.glEnable(GL11.GL_BLEND);
-
-        if (Minecraft.isFancyGraphicsEnabled())
-        {
-            renderVignette(mc.thePlayer.getBrightness(partialTicks), width, height);
-        }
-        else
-        {
-            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        }
-
-        if (renderHelmet) renderHelmet(res, partialTicks, hasScreen, mouseX, mouseY);
-
-        if (renderPortal && !mc.thePlayer.isPotionActive(Potion.confusion))
-        {
-            renderPortal(width, height, partialTicks);
-        }
-
-        if (!mc.playerController.enableEverythingIsScrewedUpMode())
-        {
-            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-            zLevel = -90.0F;
-            rand.setSeed((long)(updateCounter * 312871));
-
-            if (renderCrosshairs) renderCrosshairs(width, height);
-            if (renderBossHealth) renderBossHealth();
-            
-            if (this.mc.playerController.shouldDrawHUD())
-            {
-                if (renderHealth) renderHealth(width, height);
-                if (renderArmor)  renderArmor(width, height);
-                if (renderFood)   renderFood(width, height);
-                if (renderHealthMount) renderHealthMount(width, height);
-                if (renderAir)    renderAir(width, height);
-            }
-            if (renderHotbar) renderHotbar(width, height, partialTicks);
-        }
-
-        if (renderJumpBar)
-        {
-            renderJumpBar(width, height);
-        }
-        else if (renderExperiance) 
-        {
-            renderExperience(width, height);
-        }
-
-        renderSleepFade(width, height);
-        renderToolHightlight(width, height);
-        renderHUDText(width, height);
-        renderRecordOverlay(width, height, partialTicks);
-
-        ScoreObjective objective = mc.theWorld.getScoreboard().func_96539_a(1);
-        if (renderObjective && objective != null)
-        {
-            this.func_96136_a(objective, height, width, fontrenderer);
-        }
-
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glDisable(GL11.GL_ALPHA_TEST);
-
-        renderChat(width, height);
-
-        renderPlayerList(width, height);
-
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glEnable(GL11.GL_ALPHA_TEST);
-
-        post(ALL);
-    }
-
-    public ScaledResolution getResolution()
-    {
-        return res;
-    }
-
-    protected void renderHotbar(int width, int height, float partialTicks)
-    {
-        if (pre(HOTBAR)) return;
-        mc.mcProfiler.startSection("actionBar");
-
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        mc.renderEngine.func_110577_a(WIDGITS);
-
-        InventoryPlayer inv = mc.thePlayer.inventory;
-        drawTexturedModalRect(width / 2 - 91, height - 22, 0, 0, 182, 22);
-        drawTexturedModalRect(width / 2 - 91 - 1 + inv.currentItem * 20, height - 22 - 1, 0, 22, 24, 22);
-
-        GL11.glDisable(GL11.GL_BLEND);
-        GL11.glEnable(GL12.GL_RESCALE_NORMAL);
-        RenderHelper.enableGUIStandardItemLighting();
-
-        for (int i = 0; i < 9; ++i)
-        {
-            int x = width / 2 - 90 + i * 20 + 2;
-            int z = height - 16 - 3;
-            renderInventorySlot(i, x, z, partialTicks);
-        }
-
-        RenderHelper.disableStandardItemLighting();
-        GL11.glDisable(GL12.GL_RESCALE_NORMAL);
-        mc.mcProfiler.endSection();
-        post(HOTBAR);
-    }
-
-    protected void renderCrosshairs(int width, int height)
-    {
-        if (pre(CROSSHAIRS)) return;
-        bind(Gui.field_110324_m);
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_ONE_MINUS_DST_COLOR, GL11.GL_ONE_MINUS_SRC_COLOR);
-        drawTexturedModalRect(width / 2 - 7, height / 2 - 7, 0, 0, 16, 16);
-        GL11.glDisable(GL11.GL_BLEND);
-        post(CROSSHAIRS);
-    }
-
-    @Override
-    protected void renderBossHealth()
-    {
-        if (pre(BOSSHEALTH)) return;
-        mc.mcProfiler.startSection("bossHealth");
-        super.renderBossHealth();
-        mc.mcProfiler.endSection();
-        post(BOSSHEALTH);
-    }
-
-    private void renderHelmet(ScaledResolution res, float partialTicks, boolean hasScreen, int mouseX, int mouseY)
-    {
-        if (pre(HELMET)) return;
-
-        ItemStack itemstack = this.mc.thePlayer.inventory.armorItemInSlot(3);
-
-        if (this.mc.gameSettings.thirdPersonView == 0 && itemstack != null && itemstack.getItem() != null)
-        {
-            if (itemstack.itemID == Block.pumpkin.blockID)
-            {
-                renderPumpkinBlur(res.getScaledWidth(), res.getScaledHeight());
-            }
-            else
-            {
-                itemstack.getItem().renderHelmetOverlay(itemstack, mc.thePlayer, res, partialTicks, hasScreen, mouseX, mouseY);
-            }
-        }
-
-        post(HELMET);
-    }
-
-    protected void renderArmor(int width, int height)
-    {
-        if (pre(ARMOR)) return;
-        mc.mcProfiler.startSection("armor");
-
-        int left = width / 2 - 91;
-        int top = height - left_height;
-
-        int level = ForgeHooks.getTotalArmorValue(mc.thePlayer);
-        for (int i = 1; level > 0 && i < 20; i += 2)
-        {
-            if (i < level)
-            {
-                drawTexturedModalRect(left, top, 34, 9, 9, 9);
-            }
-            else if (i == level)
-            {
-                drawTexturedModalRect(left, top, 25, 9, 9, 9);
-            }
-            else if (i > level)
-            {
-                drawTexturedModalRect(left, top, 16, 9, 9, 9);
-            }
-            left += 8;
-        }
-        left_height += 10;
-
-        mc.mcProfiler.endSection();
-        post(ARMOR);
-    }
-
-    protected void renderPortal(int width, int height, float partialTicks)
-    {
-        if (pre(PORTAL)) return;
-
-        float f1 = mc.thePlayer.prevTimeInPortal + (mc.thePlayer.timeInPortal - mc.thePlayer.prevTimeInPortal) * partialTicks;
-
-        if (f1 > 0.0F)
-        {
-            func_130015_b(f1, width, height);
-        }
-
-        post(PORTAL);
-    }
-
-    protected void renderAir(int width, int height)
-    {
-        if (pre(AIR)) return;
-        mc.mcProfiler.startSection("air");
-        int left = width / 2 + 91;
-        int top = height - right_height;
-
-        if (mc.thePlayer.isInsideOfMaterial(Material.water))
-        {
-            int air = mc.thePlayer.getAir();
-            int full = MathHelper.ceiling_double_int((double)(air - 2) * 10.0D / 300.0D);
-            int partial = MathHelper.ceiling_double_int((double)air * 10.0D / 300.0D) - full;
-
-            for (int i = 0; i < full + partial; ++i)
-            {
-                drawTexturedModalRect(left - i * 8 - 9, top, (i < full ? 16 : 25), 18, 9, 9);
-            }
-            right_height += 10;
-        }
-
-        mc.mcProfiler.endSection();
-        post(AIR);
-    }
-
-    public void renderHealth(int width, int height)
-    {
-        bind(field_110324_m);
-        if (pre(HEALTH)) return;
-        mc.mcProfiler.startSection("health");
-
-        boolean highlight = mc.thePlayer.hurtResistantTime / 3 % 2 == 1;
-
-        if (mc.thePlayer.hurtResistantTime < 10)
-        {
-            highlight = false;
-        }
-
-        AttributeInstance attrMaxHealth = this.mc.thePlayer.func_110148_a(SharedMonsterAttributes.field_111267_a);
-        int health = MathHelper.ceiling_float_int(mc.thePlayer.func_110143_aJ());
-        int healthLast = MathHelper.ceiling_float_int(mc.thePlayer.prevHealth);
-        float healthMax = (float)attrMaxHealth.func_111126_e();
-        float absorb = this.mc.thePlayer.func_110139_bj();
-
-        int healthRows = MathHelper.ceiling_float_int((healthMax + absorb) / 2.0F / 10.0F);
-        int rowHeight = Math.max(10 - (healthRows - 2), 3);
-        
-        this.rand.setSeed((long)(updateCounter * 312871));
-        
-        int left = width / 2 - 91;
-        int top = height - left_height;
-        left_height += (healthRows * rowHeight);
-        if (rowHeight != 10) left_height += 10 - rowHeight;
-
-        int regen = -1;
-        if (mc.thePlayer.isPotionActive(Potion.regeneration))
-        {
-            regen = updateCounter % 25;
-        }
-        
-        final int TOP =  9 * (mc.theWorld.getWorldInfo().isHardcoreModeEnabled() ? 5 : 0);
-        final int BACKGROUND = (highlight ? 25 : 16);
-        int MARGIN = 16;
-        if (mc.thePlayer.isPotionActive(Potion.poison))      MARGIN += 36;
-        else if (mc.thePlayer.isPotionActive(Potion.wither)) MARGIN += 72;
-        float absorbRemaining = absorb;
-        
-        for (int i = MathHelper.ceiling_float_int((healthMax + absorb) / 2.0F) - 1; i >= 0; --i)
-        {
-            int b0 = (highlight ? 1 : 0);
-            int row = MathHelper.ceiling_float_int((float)(i + 1) / 10.0F) - 1;
-            int x = left + i % 10 * 8;
-            int y = top - row * rowHeight;
-
-            if (health <= 4) y += rand.nextInt(2);
-            if (i == regen) y -= 2;     
-
-            drawTexturedModalRect(x, y, BACKGROUND, TOP, 9, 9);
-
-            if (highlight)
-            {
-                if (i * 2 + 1 < healthLast)
-                    drawTexturedModalRect(x, y, MARGIN + 54, TOP, 9, 9); //6
-                else if (i * 2 + 1 == healthLast)
-                    drawTexturedModalRect(x, y, MARGIN + 63, TOP, 9, 9); //7
-            }
-
-            if (absorbRemaining > 0.0F)
-            {
-                if (absorbRemaining == absorb && absorb % 2.0F == 1.0F)
-                    drawTexturedModalRect(x, y, MARGIN + 153, TOP, 9, 9); //17
-                else
-                    drawTexturedModalRect(x, y, MARGIN + 144, TOP, 9, 9); //16
-                absorbRemaining -= 2.0F;
-            }
-            else
-            {
-                if (i * 2 + 1 < health)
-                    drawTexturedModalRect(x, y, MARGIN + 36, TOP, 9, 9); //4
-                else if (i * 2 + 1 == health)
-                    drawTexturedModalRect(x, y, MARGIN + 45, TOP, 9, 9); //5
-            }
-        }
-        
-        mc.mcProfiler.endSection();
-        post(HEALTH);
-    }
-
-    public void renderFood(int width, int height)
-    {
-        if (pre(FOOD)) return;
-        mc.mcProfiler.startSection("food");
-
-        int left = width / 2 + 91;
-        int top = height - right_height;
-        right_height += 10;
-        boolean unused = false;// Unused flag in vanilla, seems to be part of a 'fade out' mechanic
-
-        FoodStats stats = mc.thePlayer.getFoodStats();
-        int level = stats.getFoodLevel();
-        int levelLast = stats.getPrevFoodLevel();
-
-        for (int i = 0; i < 10; ++i)
-        {
-            int idx = i * 2 + 1;
-            int x = left - i * 8 - 9;
-            int y = top;
-            int icon = 16;
-            byte backgound = 0;
-
-            if (mc.thePlayer.isPotionActive(Potion.hunger))
-            {
-                icon += 36;
-                backgound = 13;
-            }
-            if (unused) backgound = 1; //Probably should be a += 1 but vanilla never uses this
-
-            if (mc.thePlayer.getFoodStats().getSaturationLevel() <= 0.0F && updateCounter % (level * 3 + 1) == 0)
-            {
-                y = top + (rand.nextInt(3) - 1);
-            }
-
-            drawTexturedModalRect(x, y, 16 + backgound * 9, 27, 9, 9);
-
-            if (unused)
-            {
-                if (idx < levelLast)
-                    drawTexturedModalRect(x, y, icon + 54, 27, 9, 9);
-                else if (idx == levelLast)
-                    drawTexturedModalRect(x, y, icon + 63, 27, 9, 9);
-            }
-
-            if (idx < level)
-                drawTexturedModalRect(x, y, icon + 36, 27, 9, 9);
-            else if (idx == level)
-                drawTexturedModalRect(x, y, icon + 45, 27, 9, 9);
-        }
-        mc.mcProfiler.endSection();
-        post(FOOD);
-    }
-
-    protected void renderSleepFade(int width, int height)
-    {
-        if (mc.thePlayer.getSleepTimer() > 0)
-        {
-            mc.mcProfiler.startSection("sleep");
-            GL11.glDisable(GL11.GL_DEPTH_TEST);
-            GL11.glDisable(GL11.GL_ALPHA_TEST);
-            int sleepTime = mc.thePlayer.getSleepTimer();
-            float opacity = (float)sleepTime / 100.0F;
-
-            if (opacity > 1.0F)
-            {
-                opacity = 1.0F - (float)(sleepTime - 100) / 10.0F;
-            }
-
-            int color = (int)(220.0F * opacity) << 24 | 1052704;
-            drawRect(0, 0, width, height, color);
-            GL11.glEnable(GL11.GL_ALPHA_TEST);
-            GL11.glEnable(GL11.GL_DEPTH_TEST);
-            mc.mcProfiler.endSection();
-        }
-    }
-
-    protected void renderExperience(int width, int height)
-    {
-        bind(field_110324_m);
-        if (pre(EXPERIENCE)) return;
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        
-        if (mc.playerController.func_78763_f())
-        {
-            mc.mcProfiler.startSection("expBar");
-            int cap = this.mc.thePlayer.xpBarCap();
-            int left = width / 2 - 91;
-    
-            if (cap > 0)
-            {
-                short barWidth = 182;
-                int filled = (int)(mc.thePlayer.experience * (float)(barWidth + 1));
-                int top = height - 32 + 3;
-                drawTexturedModalRect(left, top, 0, 64, barWidth, 5);
-    
-                if (filled > 0)
-                {
-                    drawTexturedModalRect(left, top, 0, 69, filled, 5);
-                }
-            }
-
-            this.mc.mcProfiler.endSection();
-            
-        
-            if (mc.playerController.func_78763_f() && mc.thePlayer.experienceLevel > 0)
-            {
-                mc.mcProfiler.startSection("expLevel");
-                boolean flag1 = false;
-                int color = flag1 ? 16777215 : 8453920;
-                String text = "" + mc.thePlayer.experienceLevel;
-                int x = (width - fontrenderer.getStringWidth(text)) / 2;
-                int y = height - 31 - 4;
-                fontrenderer.drawString(text, x + 1, y, 0);
-                fontrenderer.drawString(text, x - 1, y, 0);
-                fontrenderer.drawString(text, x, y + 1, 0);
-                fontrenderer.drawString(text, x, y - 1, 0);
-                fontrenderer.drawString(text, x, y, color);
-                mc.mcProfiler.endSection();
-            }
-        }
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-
-        post(EXPERIENCE);
-    }
-
-    protected void renderJumpBar(int width, int height)
-    {
-        bind(field_110324_m);
-        if (pre(JUMPBAR)) return;
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-        
-        mc.mcProfiler.startSection("jumpBar");
-        float charge = mc.thePlayer.func_110319_bJ();
-        final int barWidth = 182;
-        int x = (width / 2) - (barWidth / 2);
-        int filled = (int)(charge * (float)(barWidth + 1));
-        int top = height - 32 + 3;
-
-        drawTexturedModalRect(x, top, 0, 84, barWidth, 5);
-
-        if (filled > 0)
-        {
-            this.drawTexturedModalRect(x, top, 0, 89, filled, 5);
-        }
-
-        mc.mcProfiler.endSection();
-        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-
-        post(JUMPBAR);
-    }
-
-    protected void renderToolHightlight(int width, int height)
-    {
-        if (this.mc.gameSettings.heldItemTooltips)
-        {
-            mc.mcProfiler.startSection("toolHighlight");
-
-            if (this.remainingHighlightTicks > 0 && this.highlightingItemStack != null)
-            {
-                String name = this.highlightingItemStack.getDisplayName();
-
-                int opacity = (int)((float)this.remainingHighlightTicks * 256.0F / 10.0F);
-                if (opacity > 255) opacity = 255;
-
-                if (opacity > 0)
-                {
-                    int y = height - 59;
-                    if (!mc.playerController.shouldDrawHUD()) y += 14;
-
-                    GL11.glPushMatrix();
-                    GL11.glEnable(GL11.GL_BLEND);
-                    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-                    FontRenderer font = highlightingItemStack.getItem().getFontRenderer(highlightingItemStack);
-                    if (font != null)
-                    {
-                        int x = (width - font.getStringWidth(name)) / 2;
-                        font.drawStringWithShadow(name, x, y, WHITE | (opacity << 24));
-                    }
-                    else
-                    {
-                        int x = (width - fontrenderer.getStringWidth(name)) / 2;
-                        fontrenderer.drawStringWithShadow(name, x, y, WHITE | (opacity << 24));
-                    }
-                    GL11.glDisable(GL11.GL_BLEND);
-                    GL11.glPopMatrix();
-                }
-            }
-
-            mc.mcProfiler.endSection();
-        }
-    }
-
-    protected void renderHUDText(int width, int height)
-    {
-        mc.mcProfiler.startSection("forgeHudText");
-        ArrayList<String> left = new ArrayList<String>();
-        ArrayList<String> right = new ArrayList<String>();
-
-        if (mc.isDemo())
-        {
-            long time = mc.theWorld.getTotalWorldTime();
-            if (time >= 120500L)
-            {
-                right.add(StatCollector.translateToLocal("demo.demoExpired"));
-            }
-            else
-            {
-                right.add(String.format(StatCollector.translateToLocal("demo.remainingTime"), StringUtils.ticksToElapsedTime((int)(120500L - time))));
-            }
-        }
-
-
-        if (this.mc.gameSettings.showDebugInfo)
-        {
-            mc.mcProfiler.startSection("debug");
-            GL11.glPushMatrix();
-            left.add("Minecraft " + MC_VERSION + " (" + this.mc.debug + ")");
-            left.add(mc.debugInfoRenders());
-            left.add(mc.getEntityDebug());
-            left.add(mc.debugInfoEntities());
-            left.add(mc.getWorldProviderName());
-            left.add(null); //Spacer
-
-            long max = Runtime.getRuntime().maxMemory();
-            long total = Runtime.getRuntime().totalMemory();
-            long free = Runtime.getRuntime().freeMemory();
-            long used = total - free;
-
-            right.add("Used memory: " + used * 100L / max + "% (" + used / 1024L / 1024L + "MB) of " + max / 1024L / 1024L + "MB");
-            right.add("Allocated memory: " + total * 100L / max + "% (" + total / 1024L / 1024L + "MB)");
-
-            int x = MathHelper.floor_double(mc.thePlayer.posX);
-            int y = MathHelper.floor_double(mc.thePlayer.posY);
-            int z = MathHelper.floor_double(mc.thePlayer.posZ);
-            float yaw = mc.thePlayer.rotationYaw;
-            int heading = MathHelper.floor_double((double)(mc.thePlayer.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
-
-            left.add(String.format("x: %.5f (%d) // c: %d (%d)", mc.thePlayer.posX, x, x >> 4, x & 15));
-            left.add(String.format("y: %.3f (feet pos, %.3f eyes pos)", mc.thePlayer.boundingBox.minY, mc.thePlayer.posY));
-            left.add(String.format("z: %.5f (%d) // c: %d (%d)", mc.thePlayer.posZ, z, z >> 4, z & 15));
-            left.add(String.format("f: %d (%s) / %f", heading, Direction.directions[heading], MathHelper.wrapAngleTo180_float(yaw)));
-
-            if (mc.theWorld != null && mc.theWorld.blockExists(x, y, z))
-            {
-                Chunk chunk = this.mc.theWorld.getChunkFromBlockCoords(x, z);
-                left.add(String.format("lc: %d b: %s bl: %d sl: %d rl: %d",
-                  chunk.getTopFilledSegment() + 15,
-                  chunk.getBiomeGenForWorldCoords(x & 15, z & 15, mc.theWorld.getWorldChunkManager()).biomeName,
-                  chunk.getSavedLightValue(EnumSkyBlock.Block, x & 15, y, z & 15),
-                  chunk.getSavedLightValue(EnumSkyBlock.Sky, x & 15, y, z & 15),
-                  chunk.getBlockLightValue(x & 15, y, z & 15, 0)));
-            }
-            else
-            {
-                left.add(null);
-            }
-
-            left.add(String.format("ws: %.3f, fs: %.3f, g: %b, fl: %d", mc.thePlayer.capabilities.getWalkSpeed(), mc.thePlayer.capabilities.getFlySpeed(), mc.thePlayer.onGround, mc.theWorld.getHeightValue(x, z)));
-            right.add(null);
-            for (String s : FMLCommonHandler.instance().getBrandings().subList(1, FMLCommonHandler.instance().getBrandings().size()))
-            {
-                right.add(s);
-            }
-            GL11.glPopMatrix();
-            mc.mcProfiler.endSection();
-        }
-
-        RenderGameOverlayEvent.Text event = new RenderGameOverlayEvent.Text(eventParent, left, right);
-        if (!MinecraftForge.EVENT_BUS.post(event))
-        {
-            for (int x = 0; x < left.size(); x++)
-            {
-                String msg = left.get(x);
-                if (msg == null) continue;
-                fontrenderer.drawStringWithShadow(msg, 2, 2 + x * 10, WHITE);
-            }
-
-            for (int x = 0; x < right.size(); x++)
-            {
-                String msg = right.get(x);
-                if (msg == null) continue;
-                int w = fontrenderer.getStringWidth(msg);
-                fontrenderer.drawStringWithShadow(msg, width - w - 10, 2 + x * 10, WHITE);
-            }
-        }
-
-        mc.mcProfiler.endSection();
-        post(TEXT);
-    }
-
-    protected void renderRecordOverlay(int width, int height, float partialTicks)
-    {
-        if (recordPlayingUpFor > 0)
-        {
-            mc.mcProfiler.startSection("overlayMessage");
-            float hue = (float)recordPlayingUpFor - partialTicks;
-            int opacity = (int)(hue * 256.0F / 20.0F);
-            if (opacity > 255) opacity = 255;
-
-            if (opacity > 0)
-            {
-                GL11.glPushMatrix();
-                GL11.glTranslatef((float)(width / 2), (float)(height - 48), 0.0F);
-                GL11.glEnable(GL11.GL_BLEND);
-                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-                int color = (recordIsPlaying ? Color.HSBtoRGB(hue / 50.0F, 0.7F, 0.6F) & WHITE : WHITE);
-                fontrenderer.drawString(recordPlaying, -fontrenderer.getStringWidth(recordPlaying) / 2, -4, color | (opacity << 24));
-                GL11.glDisable(GL11.GL_BLEND);
-                GL11.glPopMatrix();
-            }
-
-            mc.mcProfiler.endSection();
-        }
-    }
-
-    protected void renderChat(int width, int height)
-    {
-        GL11.glPushMatrix();
-        GL11.glTranslatef(0.0F, (float)(height - 48), 0.0F);
-        mc.mcProfiler.startSection("chat");
-        persistantChatGUI.drawChat(updateCounter);
-        mc.mcProfiler.endSection();
-        GL11.glPopMatrix();
-    }
-
-    protected void renderPlayerList(int width, int height)
-    {
-        ScoreObjective scoreobjective = this.mc.theWorld.getScoreboard().func_96539_a(0);
-        NetClientHandler handler = mc.thePlayer.sendQueue;
-
-        if (mc.gameSettings.keyBindPlayerList.pressed && (!mc.isIntegratedServerRunning() || handler.playerInfoList.size() > 1 || scoreobjective != null))
-        {
-            this.mc.mcProfiler.startSection("playerList");
-            List players = handler.playerInfoList;
-            int maxPlayers = handler.currentServerMaxPlayers;
-            int rows = maxPlayers;
-            int columns = 1;
-
-            for (columns = 1; rows > 20; rows = (maxPlayers + columns - 1) / columns)
-            {
-                columns++;
-            }
-
-            int columnWidth = 300 / columns;
-
-            if (columnWidth > 150)
-            {
-                columnWidth = 150;
-            }
-
-            int left = (width - columns * columnWidth) / 2;
-            byte border = 10;
-            drawRect(left - 1, border - 1, left + columnWidth * columns, border + 9 * rows, Integer.MIN_VALUE);
-
-            for (int i = 0; i < maxPlayers; i++)
-            {
-                int xPos = left + i % columns * columnWidth;
-                int yPos = border + i / columns * 9;
-                drawRect(xPos, yPos, xPos + columnWidth - 1, yPos + 8, 553648127);
-                GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-                GL11.glEnable(GL11.GL_ALPHA_TEST);
-
-                if (i < players.size())
-                {
-                    GuiPlayerInfo player = (GuiPlayerInfo)players.get(i);
-                    ScorePlayerTeam team = mc.theWorld.getScoreboard().getPlayersTeam(player.name);
-                    String displayName = ScorePlayerTeam.func_96667_a(team, player.name);
-                    fontrenderer.drawStringWithShadow(displayName, xPos, yPos, 16777215);
-
-                    if (scoreobjective != null)
-                    {
-                        int endX = xPos + fontrenderer.getStringWidth(displayName) + 5;
-                        int maxX = xPos + columnWidth - 12 - 5;
-
-                        if (maxX - endX > 5)
-                        {
-                            Score score = scoreobjective.getScoreboard().func_96529_a(player.name, scoreobjective);
-                            String scoreDisplay = EnumChatFormatting.YELLOW + "" + score.func_96652_c();
-                            fontrenderer.drawStringWithShadow(scoreDisplay, maxX - fontrenderer.getStringWidth(scoreDisplay), yPos, 16777215);
-                        }
-                    }
-
-                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-
-                    mc.func_110434_K().func_110577_a(Gui.field_110324_m);
-                    int pingIndex = 4;
-                    int ping = player.responseTime;
-                    if (ping < 0) pingIndex = 5;
-                    else if (ping < 150) pingIndex = 0;
-                    else if (ping < 300) pingIndex = 1;
-                    else if (ping < 600) pingIndex = 2;
-                    else if (ping < 1000) pingIndex = 3;
-
-                    zLevel += 100.0F;
-                    drawTexturedModalRect(xPos + columnWidth - 12, yPos, 0, 176 + pingIndex * 8, 10, 8);
-                    zLevel -= 100.0F;
-                }
-            }
-        }
-    }
-
-    protected void renderHealthMount(int width, int height)
-    {
-        Entity tmp = mc.thePlayer.ridingEntity;
-        if (!(tmp instanceof EntityLivingBase)) return;
-
-        bind(field_110324_m);
-        
-        if (pre(HEALTHMOUNT)) return;
-        
-        boolean unused = false;
-        int left_align = width / 2 + 91;
-        
-        mc.mcProfiler.endStartSection("mountHealth");
-        EntityLivingBase mount = (EntityLivingBase)tmp;
-        int health = (int)Math.ceil((double)mount.func_110143_aJ());
-        float healthMax = mount.func_110138_aP();
-        int hearts = (int)(healthMax + 0.5F) / 2;
-
-        if (hearts > 30) hearts = 30;
-        
-        final int MARGIN = 52;
-        final int BACKGROUND = MARGIN + (unused ? 1 : 0);
-        final int HALF = MARGIN + 45;
-        final int FULL = MARGIN + 36;
-
-        for (int heart = 0; hearts > 0; heart += 20)
-        {
-            int top = height - right_height;
-            
-            int rowCount = Math.min(hearts, 10);
-            hearts -= rowCount;
-
-            for (int i = 0; i < rowCount; ++i)
-            {
-                int x = left_align - i * 8 - 9;
-                drawTexturedModalRect(x, top, BACKGROUND, 9, 9, 9);
-
-                if (i * 2 + 1 + heart < health)
-                    drawTexturedModalRect(x, top, FULL, 9, 9, 9);
-                else if (i * 2 + 1 + heart == health)
-                    drawTexturedModalRect(x, top, HALF, 9, 9, 9);
-            }
-
-            right_height += 10;
-        }
-        post(HEALTHMOUNT);
-    }
-
-    //Helper macros
-    private boolean pre(ElementType type)
-    {
-        return MinecraftForge.EVENT_BUS.post(new RenderGameOverlayEvent.Pre(eventParent, type));
-    }
-    private void post(ElementType type)
-    {
-        MinecraftForge.EVENT_BUS.post(new RenderGameOverlayEvent.Post(eventParent, type));
-    }
-    private void bind(ResourceLocation res)
-    {
-        mc.func_110434_K().func_110577_a(res);
-    }
-}

client/net/minecraftforge/client/IItemRenderer.java

@@ -1,137 +0,0 @@
-package net.minecraftforge.client;
-
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.entity.EntityLiving;
-import net.minecraft.item.ItemStack;
-import net.minecraft.client.renderer.RenderBlocks;
-
-public interface IItemRenderer
-{
-    public enum ItemRenderType
-    {
-        /** 
-         * Called to render an in-world item, e.g. one that has been thrown or
-         * dropped. The appropriate OpenGL transformations and scaling have already
-         * been applied, so Tessellator location (0,0,0) is the center of the
-         * EntityItem.
-         * 
-         * Data parameters:
-         * RenderBlocks render - The RenderBlocks instance
-         * EntityItem entity - The in-world item to be rendered
-         */
-        ENTITY, 
-        
-        /** 
-         * Called to render an item currently held in-hand by a living entity. If
-         * rendering as a 3D block, the item will be rotated to a 45-degree angle.
-         * To render a 2D texture with some thickness (like default items), see
-         * net.minecraft.src.ItemRenderer. In either case, rendering should be done
-         * in local coordinates from (0,0,0)-(1,1,1).
-         * 
-         * Data parameters:
-         * RenderBlocks render - The RenderBlocks instance
-         * EntityLiving entity - The entity holding this item
-         */
-        EQUIPPED, 
-        
-        /** 
-         * Called to render an item currently held in-hand by a living entity in
-         * first person. If rendering as a 3D block, the item will be rotated to a
-         * 45-degree angle. To render a 2D texture with some thickness, see
-         * net.minecraft.src.ItemRenderer. In either case, rendering should be done
-         * in local coordinates from (0,0,0)-(1,1,1).
-         * 
-         * Data parameters:
-         * RenderBlocks render - The RenderBlocks instance
-         * EntityLiving entity - The entity holding this item
-         */
-        EQUIPPED_FIRST_PERSON, 
-        
-        /** 
-         * Called to render an item in a GUI inventory slot. If rendering as a 3D
-         * block, the appropriate OpenGL translations and scaling have already been
-         * applied, and the rendering should be done in local coordinates from
-         * (0,0,0)-(1,1,1). If rendering as a 2D texture, the rendering should be in
-         * GUI pixel coordinates from (0, 0, 0)-(16, 16, 0).
-         * 
-         * Data parameters:
-         * RenderBlocks render - The RenderBlocks instance
-         */
-        INVENTORY,
-        
-        /**
-         * The render type used for when a ItemMap is rendered in first person, 
-         * All appropriate rotations have been applied, and the player's hands, 
-         * and the map BG are already rendered.
-         * 
-         * Data Parameters:
-         * EntityPlayer player - The player holding the map
-         * RenderEngine engine - The RenderEngine instance
-         * MapData mapData - The map data
-         */
-        FIRST_PERSON_MAP
-    }
-    
-    public enum ItemRendererHelper
-    {
-        /** 
-         * Determines if a rotation effect should be used when rendering an
-         * EntityItem, like most default blocks do.
-         */
-        ENTITY_ROTATION,
-        
-        /** 
-         * Determines if an up-and-down bobbing effect should be used when
-         * rendering an EntityItem, like most default items do.
-         */
-        ENTITY_BOBBING,
-
-        /** 
-         * Determines if the currently equipped item should be rendered as a 3D
-         * block or as a 2D texture.
-         */
-        EQUIPPED_BLOCK,
-        
-        /**
-         * Determines if the item should equate to a block that has 
-         * RenderBlocks.renderItemIn3d return true
-         */
-        BLOCK_3D,
-
-        /** 
-         * Determines if the item should be rendered in GUI inventory slots as a 3D
-         * block or as a 2D texture.
-         */
-        INVENTORY_BLOCK
-    }
-    
-    /** 
-     * Checks if this renderer should handle a specific item's render type
-     * @param item The item we are trying to render
-     * @param type A render type to check if this renderer handles
-     * @return true if this renderer should handle the given render type,
-     * otherwise false
-     */
-    public boolean handleRenderType(ItemStack item, ItemRenderType type);
-    
-    /**
-     * Checks if certain helper functionality should be executed for this renderer.
-     * See ItemRendererHelper for more info
-     * 
-     * @param type The render type
-     * @param item The ItemStack being rendered
-     * @param helper The type of helper functionality to be ran
-     * @return True to run the helper functionality, false to not.
-     */
-    public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper);
-    
-    /**
-     * Called to do the actual rendering, see ItemRenderType for details on when specific 
-     * types are run, and what extra data is passed into the data parameter.
-     * 
-     * @param type The render type
-     * @param item The ItemStack being rendered
-     * @param data Extra Type specific data
-     */
-    public void renderItem(ItemRenderType type, ItemStack item, Object... data);
-}

client/net/minecraftforge/client/IRenderContextHandler.java

@@ -1,17 +0,0 @@
-/*
- * This software is provided under the terms of the Minecraft Forge Public
- * License v1.0.
- */
-package net.minecraftforge.client;
-
-public interface IRenderContextHandler
-{
-    /** Run before the specified rendering context.
-     */
-    public void beforeRenderContext();
-
-    /** Run after the specified rendering context.
-     */
-    public void afterRenderContext();
-}
-

client/net/minecraftforge/client/IRenderHandler.java

@@ -1,12 +0,0 @@
-package net.minecraftforge.client;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.WorldClient;
-
-public abstract class IRenderHandler
-{
-    @SideOnly(Side.CLIENT)
-    public abstract void render(float partialTicks, WorldClient world, Minecraft mc);
-}

client/net/minecraftforge/client/MinecraftForgeClient.java

@@ -1,92 +0,0 @@
-/**
- * This software is provided under the terms of the Minecraft Forge Public
- * License v1.0.
- */
-
-package net.minecraftforge.client;
-
-import java.util.BitSet;
-
-import org.lwjgl.opengl.Display;
-
-import net.minecraft.block.Block;
-import net.minecraft.entity.Entity;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.client.renderer.RenderBlocks;
-import net.minecraft.world.World;
-import net.minecraftforge.client.IItemRenderer.ItemRenderType;
-import net.minecraftforge.common.MinecraftForge;
-
-public class MinecraftForgeClient
-{
-    private static IItemRenderer[] customItemRenderers = new IItemRenderer[Item.itemsList.length];
-
-    /**
-     * Register a custom renderer for a specific item. This can be used to
-     * render the item in-world as an EntityItem, when the item is equipped, or
-     * when the item is in an inventory slot.
-     * @param itemID The item ID (shifted index) to handle rendering.
-     * @param renderer The IItemRenderer interface that handles rendering for
-     * this item.
-     */
-    public static void registerItemRenderer(int itemID, IItemRenderer renderer)
-    {
-        customItemRenderers[itemID] = renderer;
-    }
-
-    public static IItemRenderer getItemRenderer(ItemStack item, ItemRenderType type)
-    {
-        IItemRenderer renderer = customItemRenderers[item.itemID];
-        if (renderer != null && renderer.handleRenderType(item, type))
-        {
-            return customItemRenderers[item.itemID];
-        }
-        return null;
-    }
-
-    public static int getRenderPass()
-    {
-        return ForgeHooksClient.renderPass;
-    }
-
-    public static int getStencilBits()
-    {
-        return ForgeHooksClient.stencilBits;
-    }
-
-
-    private static BitSet stencilBits = new BitSet(getStencilBits());
-    static
-    {
-        stencilBits.set(0,getStencilBits());
-    }
-
-    /**
-     * Reserve a stencil bit for use in rendering
-     *
-     * @return A bit or -1 if no further stencil bits are available
-     */
-    public static int reserveStencilBit()
-    {
-        int bit = stencilBits.nextSetBit(0);
-        if (bit >= 0)
-        {
-            stencilBits.clear(bit);
-        }
-        return bit;
-    }
-
-    /**
-     * Release the stencil bit for other use
-     *
-     * @param bit The bit from {@link #reserveStencilBit()}
-     */
-    public static void releaseStencilBit(int bit)
-    {
-        if (bit >= 0 && bit < getStencilBits())
-        {
-            stencilBits.set(bit);
-        }
-    }
-}

client/net/minecraftforge/client/event/ClientChatReceivedEvent.java

@@ -1,14 +0,0 @@
-package net.minecraftforge.client.event;
-
-import net.minecraftforge.event.Cancelable;
-import net.minecraftforge.event.Event;
-
-@Cancelable
-public class ClientChatReceivedEvent extends Event
-{
-    public String message;
-    public ClientChatReceivedEvent(String message)
-    {
-        this.message = message;
-    }
-}

client/net/minecraftforge/client/event/DrawBlockHighlightEvent.java

@@ -1,30 +0,0 @@
-package net.minecraftforge.client.event;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.MovingObjectPosition;
-import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraftforge.event.Cancelable;
-import net.minecraftforge.event.Event;
-
-@Cancelable
-public class DrawBlockHighlightEvent extends Event
-{
-    public final RenderGlobal context;
-    public final EntityPlayer player;
-    public final MovingObjectPosition target;
-    public final int subID;
-    public final ItemStack currentItem;
-    public final float partialTicks;
-    
-    public DrawBlockHighlightEvent(RenderGlobal context, EntityPlayer player, MovingObjectPosition target, int subID, ItemStack currentItem, float partialTicks)
-    {
-        this.context = context;
-        this.player = player;
-        this.target = target;
-        this.subID = subID;
-        this.currentItem = currentItem;
-        this.partialTicks= partialTicks;
-    }
-
-}

client/net/minecraftforge/client/event/RenderGameOverlayEvent.java

@@ -1,82 +0,0 @@
-package net.minecraftforge.client.event;
-
-import java.util.ArrayList;
-
-import net.minecraft.client.gui.ScaledResolution;
-import net.minecraftforge.event.Cancelable;
-import net.minecraftforge.event.Event;
-
-@Cancelable
-public class RenderGameOverlayEvent extends Event
-{
-    public static enum ElementType
-    {
-        ALL,
-        HELMET,
-        PORTAL,
-        CROSSHAIRS,
-        BOSSHEALTH,
-        ARMOR,
-        HEALTH,
-        FOOD,
-        AIR,
-        HOTBAR,
-        EXPERIENCE,
-        TEXT,
-        HEALTHMOUNT,
-        JUMPBAR
-    }
-
-    public final float partialTicks;
-    public final ScaledResolution resolution;
-    public final int mouseX;
-    public final int mouseY;
-    public final ElementType type;
-
-    public RenderGameOverlayEvent(float partialTicks, ScaledResolution resolution, int mouseX, int mouseY)
-    {
-        this.partialTicks = partialTicks;
-        this.resolution = resolution;
-        this.mouseX = mouseX;
-        this.mouseY = mouseY;
-        this.type = null;
-    }
-
-    private RenderGameOverlayEvent(RenderGameOverlayEvent parent, ElementType type)
-    {
-        this.partialTicks = parent.partialTicks;
-        this.resolution = parent.resolution;
-        this.mouseX = parent.mouseX;
-        this.mouseY = parent.mouseY;
-        this.type = type;
-    }
-
-    public static class Pre extends RenderGameOverlayEvent
-    {
-        public Pre(RenderGameOverlayEvent parent, ElementType type)
-        {
-            super(parent, type);
-        }
-    }
-
-    public static class Post extends RenderGameOverlayEvent
-    {
-        public Post(RenderGameOverlayEvent parent, ElementType type)
-        {
-            super(parent, type);
-        }
-        @Override public boolean isCancelable(){ return false; }
-    }
-
-    public static class Text extends Pre
-    {
-        public final ArrayList<String> left;
-        public final ArrayList<String> right;
-        public Text(RenderGameOverlayEvent parent, ArrayList<String> left, ArrayList<String> right)
-        {
-            super(parent, ElementType.TEXT);
-            this.left = left;
-            this.right = right;
-        }
-    }
-}

client/net/minecraftforge/client/event/RenderLivingEvent.java

@@ -1,33 +0,0 @@
-package net.minecraftforge.client.event;
-
-import net.minecraft.client.renderer.entity.RendererLivingEntity;
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraftforge.event.Cancelable;
-import net.minecraftforge.event.Event;
-
-public abstract class RenderLivingEvent extends Event
-{
-    public final EntityLivingBase entity;
-    public final RendererLivingEntity renderer;
-
-    public RenderLivingEvent(EntityLivingBase entity, RendererLivingEntity renderer)
-    {
-        this.entity = entity;
-        this.renderer = renderer;
-    }
-
-    public abstract static class Specials extends RenderLivingEvent
-    {
-        public Specials(EntityLivingBase entity, RendererLivingEntity renderer){ super(entity, renderer); }
-
-        @Cancelable
-        public static class Pre extends Specials
-        {
-            public Pre(EntityLivingBase entity, RendererLivingEntity renderer){ super(entity, renderer); }
-        }
-        public static class Post extends Specials
-        {
-            public Post(EntityLivingBase entity, RendererLivingEntity renderer){ super(entity, renderer); }
-        }
-    }
-}

client/net/minecraftforge/client/event/RenderPlayerEvent.java

@@ -1,72 +0,0 @@
-package net.minecraftforge.client.event;
-
-import net.minecraft.client.renderer.entity.RenderPlayer;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.event.Cancelable;
-import net.minecraftforge.event.entity.player.PlayerEvent;
-
-public abstract class RenderPlayerEvent extends PlayerEvent
-{
-    public final RenderPlayer renderer;
-
-    public RenderPlayerEvent(EntityPlayer player, RenderPlayer renderer)
-    {
-        super(player);
-        this.renderer = renderer;
-    }
-
-    @Cancelable
-    public static class Pre extends RenderPlayerEvent
-    {
-        public Pre(EntityPlayer player, RenderPlayer renderer){ super(player, renderer); }
-    }
-
-    public static class Post extends RenderPlayerEvent
-    {
-        public Post(EntityPlayer player, RenderPlayer renderer){ super(player, renderer); }
-    }
-    
-    public abstract static class Specials extends RenderPlayerEvent
-    {
-        public final float partialTicks;
-        public Specials(EntityPlayer player, RenderPlayer renderer, float partialTicks)
-        {
-            super(player, renderer);
-            this.partialTicks = partialTicks;
-        }
-
-        @Cancelable
-        public static class Pre extends Specials
-        {
-            public boolean renderHelmet = true;
-            public boolean renderCape = true;
-            public boolean renderItem = true;
-            public Pre(EntityPlayer player, RenderPlayer renderer, float partialTicks){ super(player, renderer, partialTicks); }
-        }
-
-        public static class Post extends Specials
-        {
-            public Post(EntityPlayer player, RenderPlayer renderer, float partialTicks){ super(player, renderer, partialTicks); }
-        }
-    }
-
-    public static class SetArmorModel extends RenderPlayerEvent
-    {
-        /**
-         * Setting this to any value besides -1 will result in the function being 
-         * Immediately exited with the return value specified.
-         */
-        public int result = -1;
-        public final int slot;
-        public final float partialTick;
-        public final ItemStack stack;
-        public SetArmorModel(EntityPlayer player, RenderPlayer renderer, int slot, float partialTick, ItemStack stack)
-        {
-            super(player, renderer);
-            this.slot = slot;
-            this.partialTick = partialTick;
-            this.stack = stack;
-        }
-    }
-}

client/net/minecraftforge/client/event/RenderWorldLastEvent.java

@@ -1,15 +0,0 @@
-package net.minecraftforge.client.event;
-
-import net.minecraft.client.renderer.RenderGlobal;
-import net.minecraftforge.event.Event;
-
-public class RenderWorldLastEvent extends Event
-{
-    public final RenderGlobal context;
-    public final float partialTicks;
-    public RenderWorldLastEvent(RenderGlobal context, float partialTicks)
-    {
-        this.context = context;
-        this.partialTicks = partialTicks;
-    }
-}

client/net/minecraftforge/client/event/TextureStitchEvent.java

@@ -1,35 +0,0 @@
-package net.minecraftforge.client.event;
-
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraftforge.event.Event;
-
-
-public class TextureStitchEvent extends Event
-{
-    public final TextureMap map;
-
-    public TextureStitchEvent(TextureMap map)
-    {
-        this.map = map;
-    }
-
-    /**
-     * Fired when the TextureMap is told to refresh it's stitched texture. 
-     * Called after the Stitched list is cleared, but before any blocks or items
-     * add themselves to the list.
-     */
-    public static class Pre extends TextureStitchEvent
-    {
-        public Pre(TextureMap map){ super(map); }
-    }
-
-    /**
-     * This event is fired once the texture map has loaded all textures and 
-     * stitched them together. All Icons should have there locations defined
-     * by the time this is fired.
-     */
-    public static class Post extends TextureStitchEvent
-    {
-        public Post(TextureMap map){ super(map); }
-    }
-}

client/net/minecraftforge/client/event/sound/PlayBackgroundMusicEvent.java

@@ -1,15 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-import net.minecraft.client.audio.SoundPoolEntry;
-
-/**
- * Raised when the SoundManager tries to play a Background Music file,
- * If you return null from this function it will prevent the sound from being played,
- * you can return a different entry if you want to change the sound being played.
- */
-public class PlayBackgroundMusicEvent extends SoundResultEvent
-{
-    public PlayBackgroundMusicEvent(SoundManager manager, SoundPoolEntry entry)
-    { super(manager, entry, null, 0.0f, 0.0f); }
-}

client/net/minecraftforge/client/event/sound/PlaySoundEffectEvent.java

@@ -1,10 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-import net.minecraft.client.audio.SoundPoolEntry;
-
-public class PlaySoundEffectEvent extends SoundResultEvent
-{
-    public PlaySoundEffectEvent(SoundManager manager, SoundPoolEntry source, String name, float volume, float pitch)
-    { super(manager, source, name, volume, pitch); }
-}

client/net/minecraftforge/client/event/sound/PlaySoundEffectSourceEvent.java

@@ -1,14 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-
-public class PlaySoundEffectSourceEvent extends SoundEvent
-{
-    public final SoundManager manager;
-    public final String name;
-    public PlaySoundEffectSourceEvent(SoundManager manager, String name)
-    {
-        this.manager = manager;
-        this.name = name;
-    }
-}

client/net/minecraftforge/client/event/sound/PlaySoundEvent.java

@@ -1,25 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-import net.minecraft.client.audio.SoundPoolEntry;
-
-/***
- * Raised when the SoundManager tries to play a normal sound,
- * dogs barking, footsteps, etc. THe majority of all sounds during normal game play.
- * 
- * If you return null from this function it will prevent the sound from being played,
- * you can return a different entry if you want to change the sound being played.
- */
-public class PlaySoundEvent extends SoundResultEvent
-{
-    public final float x;
-    public final float y;
-    public final float z;
-    public PlaySoundEvent(SoundManager manager, SoundPoolEntry source, String name, float x, float y, float z, float volume, float pitch)
-    { 
-        super(manager, source, name, volume, pitch);
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-}

client/net/minecraftforge/client/event/sound/PlaySoundSourceEvent.java

@@ -1,20 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-
-public class PlaySoundSourceEvent extends SoundEvent
-{
-    public final SoundManager manager;
-    public final String name;
-    public final float x;
-    public final float y;
-    public final float z;
-    public PlaySoundSourceEvent(SoundManager manager, String name, float x, float y, float z)
-    {
-        this.manager = manager;
-        this.name = name;
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-}

client/net/minecraftforge/client/event/sound/PlayStreamingEvent.java

@@ -1,26 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-import net.minecraft.client.audio.SoundPoolEntry;
-
-/**
- * Raised when the SoundManager tries to play a 'Streaming' file,
- * in vanilla it is only the Jukebox that uses this function.
- * 
- * If you return null from this function it will prevent the sound from being played,
- * you can return a different entry if you want to change the sound being played.
- * 
- */
-public class PlayStreamingEvent extends SoundResultEvent
-{
-    public final float x;
-    public final float y;
-    public final float z;
-    public PlayStreamingEvent(SoundManager manager, SoundPoolEntry source, String name, float x, float y, float z)
-    { 
-        super(manager, source, name, 0.0f, 0.0f);
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-}

client/net/minecraftforge/client/event/sound/PlayStreamingSourceEvent.java

@@ -1,20 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-
-public class PlayStreamingSourceEvent extends SoundEvent
-{
-    public final SoundManager manager;
-    public final String name;
-    public final float x;
-    public final float y;
-    public final float z;
-    public PlayStreamingSourceEvent(SoundManager manager, String name, float x, float y, float z)
-    {
-        this.manager = manager;
-        this.name = name;
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-}

client/net/minecraftforge/client/event/sound/SoundEvent.java

@@ -1,19 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.entity.Entity;
-import net.minecraft.client.audio.SoundManager;
-import net.minecraft.client.audio.SoundPoolEntry;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.event.Cancelable;
-import net.minecraftforge.event.Event;
-
-public class SoundEvent extends Event
-{
-    public SoundEvent(){}
-    
-    public static SoundPoolEntry getResult(SoundResultEvent event)
-    {
-        MinecraftForge.EVENT_BUS.post(event);
-        return event.result;
-    }
-}

client/net/minecraftforge/client/event/sound/SoundLoadEvent.java

@@ -1,16 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-
-/**
- * Raised by the SoundManager.loadSoundSettings, this would be a good place for 
- * adding your custom sounds to the SoundPool.
- */
-public class SoundLoadEvent extends SoundEvent
-{
-    public final SoundManager manager;
-    public SoundLoadEvent(SoundManager manager)
-    {
-        this.manager = manager;
-    }
-}

client/net/minecraftforge/client/event/sound/SoundResultEvent.java

@@ -1,24 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-import net.minecraft.client.audio.SoundPoolEntry;
-
-public abstract class SoundResultEvent extends SoundEvent
-{
-    public final SoundManager manager;
-    public final SoundPoolEntry source;
-    public final String name;
-    public final float volume;
-    public final float pitch;
-    public SoundPoolEntry result;
-    
-    public SoundResultEvent(SoundManager manager, SoundPoolEntry source, String name, float volume, float pitch)
-    {
-        this.manager = manager;
-        this.source = source;
-        this.name = name;
-        this.volume = volume;
-        this.pitch = pitch;
-        this.result = source;
-    }
-}

client/net/minecraftforge/client/event/sound/SoundSetupEvent.java

@@ -1,16 +0,0 @@
-package net.minecraftforge.client.event.sound;
-
-import net.minecraft.client.audio.SoundManager;
-
-/**
- * This event is raised by the SoundManager when it does its first setup of the 
- * SoundSystemConfig's codecs, use this function to add your own codecs.
- */
-public class SoundSetupEvent extends SoundEvent
-{
-    public final SoundManager manager;
-    public SoundSetupEvent(SoundManager manager)
-    {
-        this.manager = manager;
-    }
-}

client/net/minecraftforge/client/model/AdvancedModelLoader.java

@@ -1,82 +0,0 @@
-package net.minecraftforge.client.model;
-
-import java.io.InputStream;
-import java.net.URL;
-import java.util.Collection;
-import java.util.Map;
-
-import net.minecraftforge.client.model.obj.ObjModelLoader;
-
-import com.google.common.collect.Maps;
-
-import cpw.mods.fml.common.FMLLog;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-/**
- * Common interface for advanced model loading from files, based on file suffix
- * Model support can be queried through the {@link #getSupportedSuffixes()} method.
- * Instances can be created by calling {@link #loadModel(String)} with a class-loadable-path
- *
- * @author cpw
- *
- */
-@SideOnly(Side.CLIENT)
-public class AdvancedModelLoader {
-    private static Map<String, IModelCustomLoader> instances = Maps.newHashMap();
-
-    /**
-     * Register a new model handler
-     * @param modelHandler The model handler to register
-     */
-    public static void registerModelHandler(IModelCustomLoader modelHandler)
-    {
-        for (String suffix : modelHandler.getSuffixes())
-        {
-            instances.put(suffix, modelHandler);
-        }
-    }
-
-    /**
-     * Load the model from the supplied classpath resolvable resource name
-     * @param resourceName The resource name
-     * @return A model
-     * @throws IllegalArgumentException if the resource name cannot be understood
-     * @throws ModelFormatException if the underlying model handler cannot parse the model format
-     */
-    public static IModelCustom loadModel(String resourceName) throws IllegalArgumentException, ModelFormatException
-    {
-        int i = resourceName.lastIndexOf('.');
-        if (i == -1)
-        {
-            FMLLog.severe("The resource name %s is not valid", resourceName);
-            throw new IllegalArgumentException("The resource name is not valid");
-        }
-        String suffix = resourceName.substring(i+1);
-        IModelCustomLoader loader = instances.get(suffix);
-        if (loader == null)
-        {
-            FMLLog.severe("The resource name %s is not supported", resourceName);
-            throw new IllegalArgumentException("The resource name is not supported");
-        }
-
-        URL resource = AdvancedModelLoader.class.getResource(resourceName);
-        if (resource == null)
-        {
-            FMLLog.severe("The resource name %s could not be found", resourceName);
-            throw new IllegalArgumentException("The resource name could not be found");
-        }
-        return loader.loadInstance(resourceName, resource);
-    }
-
-    public static Collection<String> getSupportedSuffixes()
-    {
-        return instances.keySet();
-    }
-
-
-    static
-    {
-        registerModelHandler(new ObjModelLoader());
-    }
-}

client/net/minecraftforge/client/model/IModelCustom.java

@@ -1,9 +0,0 @@
-package net.minecraftforge.client.model;
-
-
-
-public interface IModelCustom {
-    String getType();
-    void renderAll();
-    void renderPart(String partName);
-}

client/net/minecraftforge/client/model/IModelCustomLoader.java

@@ -1,31 +0,0 @@
-package net.minecraftforge.client.model;
-
-import java.io.InputStream;
-import java.net.URL;
-
-/**
- * Instances of this class act as factories for their model type
- *
- * @author cpw
- *
- */
-public interface IModelCustomLoader {
-    /**
-     * Get the main type name for this loader
-     * @return the type name
-     */
-    String getType();
-    /**
-     * Get resource suffixes this model loader recognizes
-     * @return a list of suffixes
-     */
-    String[] getSuffixes();
-    /**
-     * Load a model instance from the supplied path
-     * @param resourceName The resource name to load
-     * @param resource The URL associated with the classloader resource
-     * @return A model instance
-     * @throws ModelFormatException if the model format is not correct
-     */
-    IModelCustom loadInstance(String resourceName, URL resource) throws ModelFormatException;
-}

client/net/minecraftforge/client/model/ModelFormatException.java

@@ -1,31 +0,0 @@
-package net.minecraftforge.client.model;
-
-/**
- * Thrown if there is a problem parsing the model
- *
- * @author cpw
- *
- */
-public class ModelFormatException extends RuntimeException {
-
-    public ModelFormatException()
-    {
-        super();
-    }
-
-    public ModelFormatException(String message, Throwable cause)
-    {
-        super(message, cause);
-    }
-
-    public ModelFormatException(String message)
-    {
-        super(message);
-    }
-
-    public ModelFormatException(Throwable cause)
-    {
-        super(cause);
-    }
-
-}

client/net/minecraftforge/client/model/obj/Face.java

@@ -1,84 +0,0 @@
-package net.minecraftforge.client.model.obj;
-
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.util.Vec3;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-@SideOnly(Side.CLIENT)
-public class Face
-{
-
-    public Vertex[] vertices;
-    public Vertex[] vertexNormals;
-    public Vertex faceNormal;
-    public TextureCoordinate[] textureCoordinates;
-
-    public void addFaceForRender(Tessellator tessellator)
-    {
-        addFaceForRender(tessellator, 0.0005F);
-    }
-
-    public void addFaceForRender(Tessellator tessellator, float textureOffset)
-    {
-        if (faceNormal == null)
-        {
-            faceNormal = this.calculateFaceNormal();
-        }
-
-        tessellator.setNormal(faceNormal.x, faceNormal.y, faceNormal.z);
-
-        float averageU = 0F;
-        float averageV = 0F;
-
-        if ((textureCoordinates != null) && (textureCoordinates.length > 0))
-        {
-            for (int i = 0; i < textureCoordinates.length; ++i)
-            {
-                averageU += textureCoordinates[i].u;
-                averageV += textureCoordinates[i].v;
-            }
-
-            averageU = averageU / textureCoordinates.length;
-            averageV = averageV / textureCoordinates.length;
-        }
-
-        float offsetU, offsetV;
-
-        for (int i = 0; i < vertices.length; ++i)
-        {
-
-            if ((textureCoordinates != null) && (textureCoordinates.length > 0))
-            {
-                offsetU = textureOffset;
-                offsetV = textureOffset;
-
-                if (textureCoordinates[i].u > averageU)
-                {
-                    offsetU = -offsetU;
-                }
-                if (textureCoordinates[i].v > averageV)
-                {
-                    offsetV = -offsetV;
-                }
-
-                tessellator.addVertexWithUV(vertices[i].x, vertices[i].y, vertices[i].z, textureCoordinates[i].u + offsetU, textureCoordinates[i].v + offsetV);
-            }
-            else
-            {
-                tessellator.addVertex(vertices[i].x, vertices[i].y, vertices[i].z);
-            }
-        }
-    }
-
-    public Vertex calculateFaceNormal()
-    {
-        Vec3 v1 = Vec3.createVectorHelper(vertices[1].x - vertices[0].x, vertices[1].y - vertices[0].y, vertices[1].z - vertices[0].z);
-        Vec3 v2 = Vec3.createVectorHelper(vertices[2].x - vertices[0].x, vertices[2].y - vertices[0].y, vertices[2].z - vertices[0].z);
-        Vec3 normalVector = null;
-
-        normalVector = v1.crossProduct(v2).normalize();
-
-        return new Vertex((float) normalVector.xCoord, (float) normalVector.yCoord, (float) normalVector.zCoord);
-    }
-}

client/net/minecraftforge/client/model/obj/GroupObject.java

@@ -1,54 +0,0 @@
-package net.minecraftforge.client.model.obj;
-
-import java.util.ArrayList;
-
-import net.minecraft.client.renderer.Tessellator;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-@SideOnly(Side.CLIENT)
-public class GroupObject
-{
-
-    public String name;
-    public ArrayList<Face> faces = new ArrayList<Face>();
-    public int glDrawingMode;
-
-    public GroupObject()
-    {
-        this("");
-    }
-
-    public GroupObject(String name)
-    {
-        this(name, -1);
-    }
-
-    public GroupObject(String name, int glDrawingMode)
-    {
-        this.name = name;
-        this.glDrawingMode = glDrawingMode;
-    }
-
-    public void render()
-    {
-        if (faces.size() > 0)
-        {
-            Tessellator tessellator = Tessellator.instance;
-            tessellator.startDrawing(glDrawingMode);
-            render(tessellator);
-            tessellator.draw();
-        }
-    }
-
-    public void render(Tessellator tessellator)
-    {
-        if (faces.size() > 0)
-        {
-            for (Face face : faces)
-            {
-                face.addFaceForRender(tessellator);
-            }
-        }
-    }
-}

client/net/minecraftforge/client/model/obj/ObjModelLoader.java

@@ -1,31 +0,0 @@
-package net.minecraftforge.client.model.obj;
-
-import java.io.InputStream;
-import java.net.URL;
-
-import net.minecraftforge.client.model.IModelCustom;
-import net.minecraftforge.client.model.IModelCustomLoader;
-import net.minecraftforge.client.model.ModelFormatException;
-
-public class ObjModelLoader implements IModelCustomLoader {
-
-    @Override
-    public String getType()
-    {
-        return "OBJ model";
-    }
-
-    private static final String[] types = { "obj" };
-    @Override
-    public String[] getSuffixes()
-    {
-        return types;
-    }
-
-    @Override
-    public IModelCustom loadInstance(String resourceName, URL resource) throws ModelFormatException
-    {
-        return new WavefrontObject(resourceName, resource);
-    }
-
-}

client/net/minecraftforge/client/model/obj/TextureCoordinate.java

@@ -1,23 +0,0 @@
-package net.minecraftforge.client.model.obj;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-@SideOnly(Side.CLIENT)
-public class TextureCoordinate
-{
-
-    public float u, v, w;
-
-    public TextureCoordinate(float u, float v)
-    {
-        this(u, v, 0F);
-    }
-
-    public TextureCoordinate(float u, float v, float w)
-    {
-        this.u = u;
-        this.v = v;
-        this.w = w;
-    }
-}

client/net/minecraftforge/client/model/obj/Vertex.java

@@ -1,23 +0,0 @@
-package net.minecraftforge.client.model.obj;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-@SideOnly(Side.CLIENT)
-public class Vertex
-{
-
-    public float x, y, z;
-
-    public Vertex(float x, float y)
-    {
-        this(x, y, 0F);
-    }
-
-    public Vertex(float x, float y, float z)
-    {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-}

client/net/minecraftforge/client/model/obj/WavefrontObject.java

@@ -1,583 +0,0 @@
-package net.minecraftforge.client.model.obj;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraftforge.client.model.IModelCustom;
-import net.minecraftforge.client.model.ModelFormatException;
-
-import org.lwjgl.opengl.GL11;
-
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-/**
- *  Wavefront Object importer
- *  Based heavily off of the specifications found at http://en.wikipedia.org/wiki/Wavefront_.obj_file
- */
-@SideOnly(Side.CLIENT)
-public class WavefrontObject implements IModelCustom
-{
-
-    private static Pattern vertexPattern = Pattern.compile("(v( (\\-){0,1}\\d+\\.\\d+){3,4} *\\n)|(v( (\\-){0,1}\\d+\\.\\d+){3,4} *$)");
-    private static Pattern vertexNormalPattern = Pattern.compile("(vn( (\\-){0,1}\\d+\\.\\d+){3,4} *\\n)|(vn( (\\-){0,1}\\d+\\.\\d+){3,4} *$)");
-    private static Pattern textureCoordinatePattern = Pattern.compile("(vt( (\\-){0,1}\\d+\\.\\d+){2,3} *\\n)|(vt( (\\-){0,1}\\d+\\.\\d+){2,3} *$)");
-    private static Pattern face_V_VT_VN_Pattern = Pattern.compile("(f( \\d+/\\d+/\\d+){3,4} *\\n)|(f( \\d+/\\d+/\\d+){3,4} *$)");
-    private static Pattern face_V_VT_Pattern = Pattern.compile("(f( \\d+/\\d+){3,4} *\\n)|(f( \\d+/\\d+){3,4} *$)");
-    private static Pattern face_V_VN_Pattern = Pattern.compile("(f( \\d+//\\d+){3,4} *\\n)|(f( \\d+//\\d+){3,4} *$)");
-    private static Pattern face_V_Pattern = Pattern.compile("(f( \\d+){3,4} *\\n)|(f( \\d+){3,4} *$)");
-    private static Pattern groupObjectPattern = Pattern.compile("([go]( [\\w\\d]+) *\\n)|([go]( [\\w\\d]+) *$)");
-
-    private static Matcher vertexMatcher, vertexNormalMatcher, textureCoordinateMatcher;
-    private static Matcher face_V_VT_VN_Matcher, face_V_VT_Matcher, face_V_VN_Matcher, face_V_Matcher;
-    private static Matcher groupObjectMatcher;
-
-    public ArrayList<Vertex> vertices = new ArrayList<Vertex>();
-    public ArrayList<Vertex> vertexNormals = new ArrayList<Vertex>();
-    public ArrayList<TextureCoordinate> textureCoordinates = new ArrayList<TextureCoordinate>();
-    public ArrayList<GroupObject> groupObjects = new ArrayList<GroupObject>();
-    private GroupObject currentGroupObject;
-    private String fileName;
-
-    public WavefrontObject(String fileName, URL resource) throws ModelFormatException
-    {
-        this.fileName = fileName;
-        loadObjModel(resource);
-    }
-
-    private void loadObjModel(URL fileURL) throws ModelFormatException
-    {
-        BufferedReader reader = null;
-        InputStream inputStream = null;
-
-        String currentLine = null;
-        int lineCount = 0;
-
-        try
-        {
-            inputStream = fileURL.openStream();
-            reader = new BufferedReader(new InputStreamReader(inputStream));
-
-            while ((currentLine = reader.readLine()) != null)
-            {
-                lineCount++;
-                currentLine = currentLine.replaceAll("\\s+", " ").trim();
-
-                if (currentLine.startsWith("#") || currentLine.length() == 0)
-                {
-                    continue;
-                }
-                else if (currentLine.startsWith("v "))
-                {
-                    Vertex vertex = parseVertex(currentLine, lineCount);
-                    if (vertex != null)
-                    {
-                        vertices.add(vertex);
-                    }
-                }
-                else if (currentLine.startsWith("vn "))
-                {
-                    Vertex vertex = parseVertexNormal(currentLine, lineCount);
-                    if (vertex != null)
-                    {
-                        vertexNormals.add(vertex);
-                    }
-                }
-                else if (currentLine.startsWith("vt "))
-                {
-                    TextureCoordinate textureCoordinate = parseTextureCoordinate(currentLine, lineCount);
-                    if (textureCoordinate != null)
-                    {
-                        textureCoordinates.add(textureCoordinate);
-                    }
-                }
-                else if (currentLine.startsWith("f "))
-                {
-
-                    if (currentGroupObject == null)
-                    {
-                        currentGroupObject = new GroupObject("Default");
-                    }
-
-                    Face face = parseFace(currentLine, lineCount);
-
-                    if (face != null)
-                    {
-                        currentGroupObject.faces.add(face);
-                    }
-                }
-                else if (currentLine.startsWith("g ") | currentLine.startsWith("o "))
-                {
-                    GroupObject group = parseGroupObject(currentLine, lineCount);
-
-                    if (group != null)
-                    {
-                        if (currentGroupObject != null)
-                        {
-                            groupObjects.add(currentGroupObject);
-                        }
-                    }
-
-                    currentGroupObject = group;
-                }
-            }
-
-            groupObjects.add(currentGroupObject);
-        }
-        catch (IOException e)
-        {
-            throw new ModelFormatException("IO Exception reading model format", e);
-        }
-        finally
-        {
-            try
-            {
-                reader.close();
-            }
-            catch (IOException e)
-            {
-                // hush
-            }
-
-            try
-            {
-                inputStream.close();
-            }
-            catch (IOException e)
-            {
-                // hush
-            }
-        }
-    }
-
-    public void renderAll()
-    {
-        Tessellator tessellator = Tessellator.instance;
-
-        if (currentGroupObject != null)
-        {
-            tessellator.startDrawing(currentGroupObject.glDrawingMode);
-        }
-        else
-        {
-            tessellator.startDrawing(GL11.GL_TRIANGLES);
-        }
-
-        for (GroupObject groupObject : groupObjects)
-        {
-            groupObject.render(tessellator);
-        }
-
-        tessellator.draw();
-    }
-
-    public void renderOnly(String... groupNames)
-    {
-        for (GroupObject groupObject : groupObjects)
-        {
-            for (String groupName : groupNames)
-            {
-                if (groupName.equalsIgnoreCase(groupObject.name))
-                {
-                    groupObject.render();
-                }
-            }
-        }
-    }
-
-    public void renderPart(String partName)
-    {
-        for (GroupObject groupObject : groupObjects)
-        {
-            if (partName.equalsIgnoreCase(groupObject.name))
-            {
-                groupObject.render();
-            }
-        }
-    }
-
-    public void renderAllExcept(String... excludedGroupNames)
-    {
-        for (GroupObject groupObject : groupObjects)
-        {
-            for (String excludedGroupName : excludedGroupNames)
-            {
-                if (!excludedGroupName.equalsIgnoreCase(groupObject.name))
-                {
-                    groupObject.render();
-                }
-            }
-        }
-    }
-
-    private Vertex parseVertex(String line, int lineCount) throws ModelFormatException
-    {
-        Vertex vertex = null;
-
-        if (isValidVertexLine(line))
-        {
-            line = line.substring(line.indexOf(" ") + 1);
-            String[] tokens = line.split(" ");
-
-            try
-            {
-                if (tokens.length == 2)
-                {
-                    return new Vertex(Float.parseFloat(tokens[0]), Float.parseFloat(tokens[1]));
-                }
-                else if (tokens.length == 3)
-                {
-                    return new Vertex(Float.parseFloat(tokens[0]), Float.parseFloat(tokens[1]), Float.parseFloat(tokens[2]));
-                }
-            }
-            catch (NumberFormatException e)
-            {
-                throw new ModelFormatException(String.format("Number formatting error at line %d",lineCount), e);
-            }
-        }
-        else
-        {
-            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
-        }
-
-        return vertex;
-    }
-
-    private Vertex parseVertexNormal(String line, int lineCount) throws ModelFormatException
-    {
-        Vertex vertexNormal = null;
-
-        if (isValidVertexNormalLine(line))
-        {
-            line = line.substring(line.indexOf(" ") + 1);
-            String[] tokens = line.split(" ");
-
-            try
-            {
-                if (tokens.length == 3)
-                    return new Vertex(Float.parseFloat(tokens[0]), Float.parseFloat(tokens[1]), Float.parseFloat(tokens[2]));
-            }
-            catch (NumberFormatException e)
-            {
-                throw new ModelFormatException(String.format("Number formatting error at line %d",lineCount), e);
-            }
-        }
-        else
-        {
-            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
-        }
-
-        return vertexNormal;
-    }
-
-    private TextureCoordinate parseTextureCoordinate(String line, int lineCount) throws ModelFormatException
-    {
-        TextureCoordinate textureCoordinate = null;
-
-        if (isValidTextureCoordinateLine(line))
-        {
-            line = line.substring(line.indexOf(" ") + 1);
-            String[] tokens = line.split(" ");
-
-            try
-            {
-                if (tokens.length == 2)
-                    return new TextureCoordinate(Float.parseFloat(tokens[0]), 1 - Float.parseFloat(tokens[1]));
-                else if (tokens.length == 3)
-                    return new TextureCoordinate(Float.parseFloat(tokens[0]), 1 - Float.parseFloat(tokens[1]), Float.parseFloat(tokens[2]));
-            }
-            catch (NumberFormatException e)
-            {
-                throw new ModelFormatException(String.format("Number formatting error at line %d",lineCount), e);
-            }
-        }
-        else
-        {
-            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
-        }
-
-        return textureCoordinate;
-    }
-
-    private Face parseFace(String line, int lineCount) throws ModelFormatException
-    {
-        Face face = null;
-
-        if (isValidFaceLine(line))
-        {
-            face = new Face();
-
-            String trimmedLine = line.substring(line.indexOf(" ") + 1);
-            String[] tokens = trimmedLine.split(" ");
-            String[] subTokens = null;
-
-            if (tokens.length == 3)
-            {
-                if (currentGroupObject.glDrawingMode == -1)
-                {
-                    currentGroupObject.glDrawingMode = GL11.GL_TRIANGLES;
-                }
-                else if (currentGroupObject.glDrawingMode != GL11.GL_TRIANGLES)
-                {
-                    throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Invalid number of points for face (expected 4, found " + tokens.length + ")");
-                }
-            }
-            else if (tokens.length == 4)
-            {
-                if (currentGroupObject.glDrawingMode == -1)
-                {
-                    currentGroupObject.glDrawingMode = GL11.GL_QUADS;
-                }
-                else if (currentGroupObject.glDrawingMode != GL11.GL_QUADS)
-                {
-                    throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Invalid number of points for face (expected 3, found " + tokens.length + ")");
-                }
-            }
-
-            // f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3 ...
-            if (isValidFace_V_VT_VN_Line(line))
-            {
-                face.vertices = new Vertex[tokens.length];
-                face.textureCoordinates = new TextureCoordinate[tokens.length];
-                face.vertexNormals = new Vertex[tokens.length];
-                
-                for (int i = 0; i < tokens.length; ++i)
-                {
-                    subTokens = tokens[i].split("/");
-
-                    face.vertices[i] = vertices.get(Integer.parseInt(subTokens[0]) - 1);
-                    face.textureCoordinates[i] = textureCoordinates.get(Integer.parseInt(subTokens[1]) - 1);
-                    face.vertexNormals[i] = vertexNormals.get(Integer.parseInt(subTokens[2]) - 1);
-                }
-
-                face.faceNormal = face.calculateFaceNormal();
-            }
-            // f v1/vt1 v2/vt2 v3/vt3 ...
-            else if (isValidFace_V_VT_Line(line))
-            {
-                face.vertices = new Vertex[tokens.length];
-                face.textureCoordinates = new TextureCoordinate[tokens.length];
-                
-                for (int i = 0; i < tokens.length; ++i)
-                {
-                    subTokens = tokens[i].split("/");
-
-                    face.vertices[i] = vertices.get(Integer.parseInt(subTokens[0]) - 1);
-                    face.textureCoordinates[i] = textureCoordinates.get(Integer.parseInt(subTokens[1]) - 1);
-                }
-
-                face.faceNormal = face.calculateFaceNormal();
-            }
-            // f v1//vn1 v2//vn2 v3//vn3 ...
-            else if (isValidFace_V_VN_Line(line))
-            {
-                face.vertices = new Vertex[tokens.length];
-                face.vertexNormals = new Vertex[tokens.length];
-                
-                for (int i = 0; i < tokens.length; ++i)
-                {
-                    subTokens = tokens[i].split("//");
-
-                    face.vertices[i] = vertices.get(Integer.parseInt(subTokens[0]) - 1);
-                    face.vertexNormals[i] = vertexNormals.get(Integer.parseInt(subTokens[1]) - 1);
-                }
-
-                face.faceNormal = face.calculateFaceNormal();
-            }
-            // f v1 v2 v3 ...
-            else if (isValidFace_V_Line(line))
-            {
-                face.vertices = new Vertex[tokens.length];
-                
-                for (int i = 0; i < tokens.length; ++i)
-                {
-                    face.vertices[i] = vertices.get(Integer.parseInt(tokens[i]) - 1);
-                }
-
-                face.faceNormal = face.calculateFaceNormal();
-            }
-            else
-            {
-                throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
-            }
-        }
-        else
-        {
-            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
-        }
-
-        return face;
-    }
-
-    private GroupObject parseGroupObject(String line, int lineCount) throws ModelFormatException
-    {
-        GroupObject group = null;
-
-        if (isValidGroupObjectLine(line))
-        {
-            String trimmedLine = line.substring(line.indexOf(" ") + 1);
-
-            if (trimmedLine.length() > 0)
-            {
-                group = new GroupObject(trimmedLine);
-            }
-        }
-        else
-        {
-            throw new ModelFormatException("Error parsing entry ('" + line + "'" + ", line " + lineCount + ") in file '" + fileName + "' - Incorrect format");
-        }
-
-        return group;
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid vertex
-     * @param line the line being validated
-     * @return true if the line is a valid vertex, false otherwise
-     */
-    private static boolean isValidVertexLine(String line)
-    {
-        if (vertexMatcher != null)
-        {
-            vertexMatcher.reset();
-        }
-
-        vertexMatcher = vertexPattern.matcher(line);
-        return vertexMatcher.matches();
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid vertex normal
-     * @param line the line being validated
-     * @return true if the line is a valid vertex normal, false otherwise
-     */
-    private static boolean isValidVertexNormalLine(String line)
-    {
-        if (vertexNormalMatcher != null)
-        {
-            vertexNormalMatcher.reset();
-        }
-
-        vertexNormalMatcher = vertexNormalPattern.matcher(line);
-        return vertexNormalMatcher.matches();
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid texture coordinate
-     * @param line the line being validated
-     * @return true if the line is a valid texture coordinate, false otherwise
-     */
-    private static boolean isValidTextureCoordinateLine(String line)
-    {
-        if (textureCoordinateMatcher != null)
-        {
-            textureCoordinateMatcher.reset();
-        }
-
-        textureCoordinateMatcher = textureCoordinatePattern.matcher(line);
-        return textureCoordinateMatcher.matches();
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid face that is described by vertices, texture coordinates, and vertex normals
-     * @param line the line being validated
-     * @return true if the line is a valid face that matches the format "f v1/vt1/vn1 ..." (with a minimum of 3 points in the face, and a maximum of 4), false otherwise
-     */
-    private static boolean isValidFace_V_VT_VN_Line(String line)
-    {
-        if (face_V_VT_VN_Matcher != null)
-        {
-            face_V_VT_VN_Matcher.reset();
-        }
-
-        face_V_VT_VN_Matcher = face_V_VT_VN_Pattern.matcher(line);
-        return face_V_VT_VN_Matcher.matches();
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid face that is described by vertices and texture coordinates
-     * @param line the line being validated
-     * @return true if the line is a valid face that matches the format "f v1/vt1 ..." (with a minimum of 3 points in the face, and a maximum of 4), false otherwise
-     */
-    private static boolean isValidFace_V_VT_Line(String line)
-    {
-        if (face_V_VT_Matcher != null)
-        {
-            face_V_VT_Matcher.reset();
-        }
-
-        face_V_VT_Matcher = face_V_VT_Pattern.matcher(line);
-        return face_V_VT_Matcher.matches();
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid face that is described by vertices and vertex normals
-     * @param line the line being validated
-     * @return true if the line is a valid face that matches the format "f v1//vn1 ..." (with a minimum of 3 points in the face, and a maximum of 4), false otherwise
-     */
-    private static boolean isValidFace_V_VN_Line(String line)
-    {
-        if (face_V_VN_Matcher != null)
-        {
-            face_V_VN_Matcher.reset();
-        }
-
-        face_V_VN_Matcher = face_V_VN_Pattern.matcher(line);
-        return face_V_VN_Matcher.matches();
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid face that is described by only vertices
-     * @param line the line being validated
-     * @return true if the line is a valid face that matches the format "f v1 ..." (with a minimum of 3 points in the face, and a maximum of 4), false otherwise
-     */
-    private static boolean isValidFace_V_Line(String line)
-    {
-        if (face_V_Matcher != null)
-        {
-            face_V_Matcher.reset();
-        }
-
-        face_V_Matcher = face_V_Pattern.matcher(line);
-        return face_V_Matcher.matches();
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid face of any of the possible face formats
-     * @param line the line being validated
-     * @return true if the line is a valid face that matches any of the valid face formats, false otherwise
-     */
-    private static boolean isValidFaceLine(String line)
-    {
-        return isValidFace_V_VT_VN_Line(line) || isValidFace_V_VT_Line(line) || isValidFace_V_VN_Line(line) || isValidFace_V_Line(line);
-    }
-
-    /***
-     * Verifies that the given line from the model file is a valid group (or object)
-     * @param line the line being validated
-     * @return true if the line is a valid group (or object), false otherwise
-     */
-    private static boolean isValidGroupObjectLine(String line)
-    {
-        if (groupObjectMatcher != null)
-        {
-            groupObjectMatcher.reset();
-        }
-
-        groupObjectMatcher = groupObjectPattern.matcher(line);
-        return groupObjectMatcher.matches();
-    }
-
-    @Override
-    public String getType()
-    {
-        return "obj";
-    }
-}

client/paulscode/sound/codecs/CodecIBXM.java

@@ -1,642 +0,0 @@
-package paulscode.sound.codecs;
-
-import java.io.DataInputStream;
-import java.io.InputStream;
-import java.io.IOException;
-import java.net.URL;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.ShortBuffer;
-import javax.sound.sampled.AudioFormat;
-
-import paulscode.sound.ICodec;
-import paulscode.sound.SoundBuffer;
-import paulscode.sound.SoundSystemConfig;
-import paulscode.sound.SoundSystemLogger;
-
-import ibxm.FastTracker2;
-import ibxm.IBXM;
-import ibxm.Module;
-import ibxm.ProTracker;
-import ibxm.ScreamTracker3;
-
-/**
- * The CodecIBXM class provides an ICodec interface for reading from MOD/S3M/XM
- * files via the IBXM library.
- *<b><i>   SoundSystem CodecIBXM Class License:</b></i><br><b><br>
- *    You are free to use this class for any purpose, commercial or otherwise.
- *    You may modify this class or source code, and distribute it any way you
- *    like, provided the following conditions are met:
- *<br>
- *    1) You may not falsely claim to be the author of this class or any
- *    unmodified portion of it.
- *<br>
- *    2) You may not copyright this class or a modified version of it and then
- *    sue me for copyright infringement.
- *<br>
- *    3) If you modify the source code, you must clearly document the changes
- *    made before redistributing the modified source code, so other users know
- *    it is not the original code.
- *<br>
- *    4) You are not required to give me credit for this class in any derived
- *    work, but if you do, you must also mention my website:
- *    http://www.paulscode.com
- *<br>
- *    5) I the author will not be responsible for any damages (physical,
- *    financial, or otherwise) caused by the use if this class or any portion
- *    of it.
- *<br>
- *    6) I the author do not guarantee, warrant, or make any representations,
- *    either expressed or implied, regarding the use of this class or any
- *    portion of it.
- * <br><br>
- *    Author: Paul Lamb
- * <br>
- *    http://www.paulscode.com
- *</b><br><br>
- *<b>
- *    This software is based on or using the IBXM library available from
- *    http://www.geocities.com/sunet2000/
- *</b><br><br>
- *<br><b>
- * IBXM is copyright (c) 2007, Martin Cameron, and is licensed under the BSD
- * License.
- *<br><br>
- * All rights reserved.
- *<br><br>
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *<br><br>
- * Redistributions of source code must retain the above copyright notice, this
- * list of conditions and the following disclaimer.  Redistributions in binary
- * form must reproduce the above copyright notice, this list of conditions and
- * the following disclaimer in the documentation and/or other materials
- * provided with the distribution.  Neither the name of mumart nor the names of
- * its contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- * <br><br>
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- * <br><br><br></b>
- */
-public class CodecIBXM implements ICodec
-{
-/**
- * Used to return a current value from one of the synchronized
- * boolean-interface methods.
- */
-    private static final boolean GET = false;
-
-/**
- * Used to set the value in one of the synchronized boolean-interface methods.
- */
-    private static final boolean SET = true;
-
-/**
- * Used when a parameter for one of the synchronized boolean-interface methods
- * is not aplicable.
- */
-    private static final boolean XXX = false;
-
-/**
- * True if there is no more data to read in.
- */
-    private boolean endOfStream = false;
-
-/**
- * True if the stream has finished initializing.
- */
-    private boolean initialized = false;
-
-/**
- * Format the converted audio will be in.
- */
-    private AudioFormat myAudioFormat = null;
-
-/**
- * True if the using library requires data read by this codec to be
- * reverse-ordered before returning it from methods read() and readAll().
- */
-    private boolean reverseBytes = false;
-
-/**
- * IBXM decoder.
- */
-    private IBXM ibxm;
-
-/**
- * Module instance to be played.
- */
-    private Module module;
-
-/**
- * Duration of the audio (in frames).
- */
-    private int songDuration;
-
-/**
- * Audio read position (in frames).
- */
-    private int playPosition;
-
-/**
- * Processes status messages, warnings, and error messages.
- */
-    private SoundSystemLogger logger;
-
-/**
- * Constructor:  Grabs a handle to the logger.
- */
-    public CodecIBXM()
-    {
-        logger = SoundSystemConfig.getLogger();
-    }
-
-/**
- * Tells this codec when it will need to reverse the byte order of
- * the data before returning it in the read() and readAll() methods.  The
- * IBXM library produces audio data in a format that some external audio
- * libraries require to be reversed.  Derivatives of the Library and Source
- * classes for audio libraries which require this type of data to be reversed
- * will call the reverseByteOrder() method.
- * @param b True if the calling audio library requires byte-reversal.
- */
-    public void reverseByteOrder( boolean b )
-    {
-        reverseBytes = b;
-    }
-
-/**
- * Prepares an audio stream to read from.  If another stream is already opened,
- * it will be closed and a new audio stream opened in its place.
- * @param url URL to an audio file to stream from.
- * @return False if an error occurred or if end of stream was reached.
- */
-    public boolean initialize( URL url )
-    {
-        initialized( SET, false );
-        cleanup();
-
-        if( url == null )
-        {
-            errorMessage( "url null in method 'initialize'" );
-            cleanup();
-            return false;
-        }
-
-        InputStream is = null;
-
-        try
-        {
-            is = url.openStream();
-        }
-        catch( IOException ioe )
-        {
-            errorMessage( "Unable to open stream in method 'initialize'" );
-            printStackTrace( ioe );
-            return false;
-        }
-
-        if( ibxm == null )
-            ibxm = new IBXM( 48000 );
-        if( myAudioFormat == null )
-            myAudioFormat = new AudioFormat( 48000, 16, 2, true, true );
-        
-        try
-        {
-            setModule( loadModule( is ) );
-        }
-        catch( IllegalArgumentException iae )
-        {
-            errorMessage( "Illegal argument in method 'initialize'" );
-            printStackTrace( iae );
-            if( is != null )
-            {
-                try
-                {
-                    is.close();
-                }
-                catch( IOException ioe )
-                {}
-            }
-            return false;
-        }
-        catch( IOException ioe )
-        {
-            errorMessage( "Error loading module in method 'initialize'" );
-            printStackTrace( ioe );
-            if( is != null )
-            {
-                try
-                {
-                    is.close();
-                }
-                catch( IOException ioe2 )
-                {}
-            }
-            return false;
-        }
-        
-        if( is != null )
-        {
-            try
-            {
-                is.close();
-            }
-            catch( IOException ioe )
-            {}
-        }
-
-        endOfStream( SET, false );
-        initialized( SET, true );
-        return true;
-    }
-
-/**
- * Returns false if the stream is busy initializing.
- * @return True if steam is initialized.
- */
-    public boolean initialized()
-    {
-        return initialized( GET, XXX );
-    }
-
-/**
- * Reads in one stream buffer worth of audio data.  See
- * {@link paulscode.sound.SoundSystemConfig SoundSystemConfig} for more
- * information about accessing and changing default settings.
- * @return The audio data wrapped into a SoundBuffer context.
- */
-    public SoundBuffer read()
-    {
-        if( endOfStream( GET, XXX ) )
-            return null;
-
-        if( module == null )
-        {
-            errorMessage( "Module null in method 'read'" );
-            return null;
-        }
-
-        // Check to make sure there is an audio format:
-        if( myAudioFormat == null )
-        {
-            errorMessage( "Audio Format null in method 'read'" );
-            return null;
-        }
-
-        int bufferFrameSize = (int) SoundSystemConfig.getStreamingBufferSize()
-                                    / 4;
-
-        int frames = songDuration - playPosition;
-        if( frames > bufferFrameSize )
-            frames = bufferFrameSize;
-
-        if( frames <= 0 )
-        {
-            endOfStream( SET, true );
-            return null;
-        }
-		byte[] outputBuffer = new byte[ frames * 4 ];
-
-        ibxm.get_audio( outputBuffer, frames );
-
-        playPosition += frames;
-        if( playPosition >= songDuration )
-        {
-            endOfStream( SET, true );
-        }
-
-        // Reverse the byte order if necessary:
-        if( reverseBytes )
-            reverseBytes( outputBuffer, 0, frames * 4 );
-
-        // Wrap the data into a SoundBuffer:
-        SoundBuffer buffer = new SoundBuffer( outputBuffer, myAudioFormat );
-
-        return buffer;
-    }
-
-/**
- * Reads in all the audio data from the stream (up to the default
- * "maximum file size".  See
- * {@link paulscode.sound.SoundSystemConfig SoundSystemConfig} for more
- * information about accessing and changing default settings.
- * @return the audio data wrapped into a SoundBuffer context.
- */
-    public SoundBuffer readAll()
-    {
-        if( module == null )
-        {
-            errorMessage( "Module null in method 'readAll'" );
-            return null;
-        }
-
-        // Check to make sure there is an audio format:
-        if( myAudioFormat == null )
-        {
-            errorMessage( "Audio Format null in method 'readAll'" );
-            return null;
-        }
-
-        int bufferFrameSize = (int) SoundSystemConfig.getFileChunkSize()
-                                    / 4;
-
-		byte[] outputBuffer = new byte[ bufferFrameSize * 4 ];
-
-        // Buffer to contain the audio data:
-        byte[] fullBuffer = null;
-        // frames of audio data:
-        int frames;
-        // bytes of audio data:
-        int totalBytes = 0;
-
-        while( (!endOfStream(GET, XXX)) &&
-               (totalBytes < SoundSystemConfig.getMaxFileSize()) )
-        {
-            frames = songDuration - playPosition;
-            if( frames > bufferFrameSize )
-                frames = bufferFrameSize;
-            ibxm.get_audio( outputBuffer, frames );
-            totalBytes += (frames * 4);
-
-            fullBuffer = appendByteArrays( fullBuffer, outputBuffer,
-                                           frames * 4 );
-
-            playPosition += frames;
-            if( playPosition >= songDuration )
-            {
-                endOfStream( SET, true );
-            }
-        }
-
-        // Reverse the byte order if necessary:
-        if( reverseBytes )
-            reverseBytes( fullBuffer, 0, totalBytes );
-
-        // Wrap the data into a SoundBuffer:
-        SoundBuffer buffer = new SoundBuffer( fullBuffer, myAudioFormat );
-
-        return buffer;
-    }
-
-/**
- * Returns false if there is still more data available to be read in.
- * @return True if end of stream was reached.
- */
-    public boolean endOfStream()
-    {
-        return endOfStream( GET, XXX );
-    }
-
-/**
- * Closes the audio stream and remove references to all instantiated objects.
- */
-    public void cleanup()
-    {
-//        if( ibxm != null )
-//            ibxm.seek( 0 );
-        playPosition = 0;
-    }
-
-/**
- * Returns the audio format of the data being returned by the read() and
- * readAll() methods.
- * @return Information wrapped into an AudioFormat context.
- */
-    public AudioFormat getAudioFormat()
-    {
-        return myAudioFormat;
-    }
-
-/**
- * Decodes the data in the specified InputStream into an instance of
- * ibxm.Module.
- * @param input an InputStream containing the module file to be decoded.
- * @throws IllegalArgumentException if the data is not recognised as a module file.
- */
-    private static Module loadModule( InputStream input )
-                                    throws IllegalArgumentException, IOException
-    {
-        DataInputStream data_input_stream = new DataInputStream( input );
-
-        // Check if data is in XM format:
-        byte[] xm_header = new byte[ 60 ];
-        data_input_stream.readFully( xm_header );
-        if( FastTracker2.is_xm( xm_header ) )
-            return FastTracker2.load_xm( xm_header, data_input_stream );
-
-        // Check if data is in ScreamTracker 3 format:
-        byte[] s3m_header = new byte[ 96 ];
-        System.arraycopy( xm_header, 0, s3m_header, 0, 60 );
-        data_input_stream.readFully( s3m_header, 60, 36 );
-        if( ScreamTracker3.is_s3m( s3m_header ) )
-            return ScreamTracker3.load_s3m( s3m_header, data_input_stream );
-
-        // Check if data is in ProTracker format:
-        byte[] mod_header = new byte[ 1084 ];
-        System.arraycopy( s3m_header, 0, mod_header, 0, 96 );
-        data_input_stream.readFully( mod_header, 96, 988 );
-        return ProTracker.load_mod( mod_header, data_input_stream );
-    }
-
-/**
- * Sets the Module instance to be played.
- */
-    private void setModule( Module m )
-    {
-        if( m != null )
-            module = m;
-        ibxm.set_module( module );
-        songDuration = ibxm.calculate_song_duration();
-    }
-
-/**
- * Internal method for synchronizing access to the boolean 'initialized'.
- * @param action GET or SET.
- * @param value New value if action == SET, or XXX if action == GET.
- * @return True if steam is initialized.
- */
-    private synchronized boolean initialized( boolean action, boolean value )
-    {
-        if( action == SET )
-            initialized = value;
-        return initialized;
-    }
-
-/**
- * Internal method for synchronizing access to the boolean 'endOfStream'.
- * @param action GET or SET.
- * @param value New value if action == SET, or XXX if action == GET.
- * @return True if end of stream was reached.
- */
-    private synchronized boolean endOfStream( boolean action, boolean value )
-    {
-        if( action == SET )
-            endOfStream = value;
-        return endOfStream;
-    }
-
-/**
- * Trims down the size of the array if it is larger than the specified
- * maximum length.
- * @param array Array containing audio data.
- * @param maxLength Maximum size this array may be.
- * @return New array.
- */
-    private static byte[] trimArray( byte[] array, int maxLength )
-    {
-        byte[] trimmedArray = null;
-        if( array != null && array.length > maxLength )
-        {
-            trimmedArray = new byte[maxLength];
-            System.arraycopy( array, 0, trimmedArray, 0, maxLength );
-        }
-        return trimmedArray;
-    }
-
-/**
- * Reverse-orders all bytes contained in the specified array.
- * @param buffer Array containing audio data.
- */
-    public static void reverseBytes( byte[] buffer )
-    {
-        reverseBytes( buffer, 0, buffer.length );
-    }
-
-/**
- * Reverse-orders the specified range of bytes contained in the specified array.
- * @param buffer Array containing audio data.
- * @param offset Array index to begin.
- * @param size number of bytes to reverse-order.
- */
-    public static void reverseBytes( byte[] buffer, int offset, int size )
-    {
-
-        byte b;
-        for( int i = offset; i < ( offset + size ); i += 2 )
-        {
-            b = buffer[i];
-            buffer[i] = buffer[i + 1];
-            buffer[i + 1] = b;
-        }
-    }
-
-/**
- * Converts sound bytes to little-endian format.
- * @param audio_bytes The original wave data
- * @param two_bytes_data For stereo sounds.
- * @return byte array containing the converted data.
- */
-    private static byte[] convertAudioBytes( byte[] audio_bytes,
-                                             boolean two_bytes_data )
-    {
-        ByteBuffer dest = ByteBuffer.allocateDirect( audio_bytes.length );
-        dest.order( ByteOrder.nativeOrder() );
-        ByteBuffer src = ByteBuffer.wrap( audio_bytes );
-        src.order( ByteOrder.LITTLE_ENDIAN );
-        if( two_bytes_data )
-        {
-            ShortBuffer dest_short = dest.asShortBuffer();
-            ShortBuffer src_short = src.asShortBuffer();
-            while( src_short.hasRemaining() )
-            {
-                dest_short.put(src_short.get());
-            }
-        }
-        else
-        {
-            while( src.hasRemaining() )
-            {
-                dest.put( src.get() );
-            }
-        }
-        dest.rewind();
-
-        if( !dest.hasArray() )
-        {
-            byte[] arrayBackedBuffer = new byte[dest.capacity()];
-            dest.get( arrayBackedBuffer );
-            dest.clear();
-
-            return arrayBackedBuffer;
-        }
-
-        return dest.array();
-    }
-
-/**
- * Creates a new array with the second array appended to the end of the first
- * array.
- * @param arrayOne The first array.
- * @param arrayTwo The second array.
- * @param length How many bytes to append from the second array.
- * @return Byte array containing information from both arrays.
- */
-    private static byte[] appendByteArrays( byte[] arrayOne, byte[] arrayTwo,
-                                            int length )
-    {
-        byte[] newArray;
-        if( arrayOne == null && arrayTwo == null )
-        {
-            // no data, just return
-            return null;
-        }
-        else if( arrayOne == null )
-        {
-            // create the new array, same length as arrayTwo:
-            newArray = new byte[ length ];
-            // fill the new array with the contents of arrayTwo:
-            System.arraycopy( arrayTwo, 0, newArray, 0, length );
-            arrayTwo = null;
-        }
-        else if( arrayTwo == null )
-        {
-            // create the new array, same length as arrayOne:
-            newArray = new byte[ arrayOne.length ];
-            // fill the new array with the contents of arrayOne:
-            System.arraycopy( arrayOne, 0, newArray, 0, arrayOne.length );
-            arrayOne = null;
-        }
-        else
-        {
-            // create the new array large enough to hold both arrays:
-            newArray = new byte[ arrayOne.length + length ];
-            System.arraycopy( arrayOne, 0, newArray, 0, arrayOne.length );
-            // fill the new array with the contents of both arrays:
-            System.arraycopy( arrayTwo, 0, newArray, arrayOne.length,
-                              length );
-            arrayOne = null;
-            arrayTwo = null;
-        }
-
-        return newArray;
-    }
-
-/**
- * Prints an error message.
- * @param message Message to print.
- */
-    private void errorMessage( String message )
-    {
-        logger.errorMessage( "CodecWav", message, 0 );
-    }
-
-/**
- * Prints an exception's error message followed by the stack trace.
- * @param e Exception containing the information to print.
- */
-    private void printStackTrace( Exception e )
-    {
-        logger.printStackTrace( e, 1 );
-    }
-}

commands.patch

@@ -0,0 +1,164 @@
+--- commands.py
++++ commands.py
+@@ -58,6 +58,8 @@
+ 
+ 
+ def reallyrmtree(path):
++    if os.path.isfile(os.path.join(path, 'asm-all-4.0.jar')): #Check if asm exists, indicating the libs folder, if so, don't delete it
++        return
+     if not sys.platform.startswith('win'):
+         if os.path.exists(path):
+             shutil.rmtree(path)
+@@ -582,6 +584,9 @@
+         self.has_astyle_cfg = False
+         if os.path.isfile(self.astyleconf):
+             self.has_astyle_cfg = True
++            
++        #FML Entries
++        self.srcshared = os.path.normpath(os.path.join(self.dirsrc, 'common'))
+ 
+     def creatergcfg(self, reobf=False, keep_lvt=False, keep_generics=False, rg_update=False):
+         """Create the files necessary for RetroGuard"""
+@@ -779,7 +784,8 @@
+         testlk = {CLIENT: self.testclient, SERVER: self.testserver}
+ 
+         if not os.path.exists(os.path.join(srclk[side], os.path.normpath(testlk[side] + '.java'))):
+-            return False
++            if not os.path.exists(os.path.join(self.srcshared, os.path.normpath(testlk[side] + '.java'))):
++                return False
+         return True
+ 
+     def checkbins(self, side):
+@@ -1039,6 +1045,7 @@
+             all_files = True
+             append_pattern = False
+         pkglist = filterdirs(pathsrclk[side], '*.java', append_pattern=append_pattern, all_files=all_files)
++        pkglist = pkglist + filterdirs(self.srcshared, '*.java', append_pattern=append_pattern, all_files=all_files) #FML, Add Common folder
+         dirs = ' '.join(pkglist)
+         classpath = os.pathsep.join(cplk[side])
+         forkcmd = self.cmdrecomp.format(classpath=classpath, sourcepath=pathsrclk[side], outpath=pathbinlk[side],
+@@ -1060,7 +1067,7 @@
+             raise
+ 
+     def startserver(self):
+-        classpath = [self.binserver] + self.cpathserver
++        classpath = [self.binserver, self.srcshared] + self.cpathserver
+         classpath = [os.path.join('..', p) for p in classpath]
+         classpath = os.pathsep.join(classpath)
+         os.chdir(self.dirjars)
+@@ -1068,7 +1075,7 @@
+         self.runmc(forkcmd)
+ 
+     def startclient(self):
+-        classpath = [self.binclient] + self.cpathclient
++        classpath = [self.binclient, self.srcshared] + self.cpathclient
+         classpath = [os.path.join('..', p) for p in classpath]
+         classpath = os.pathsep.join(classpath)
+         natives = os.path.join('..', self.dirnatives)
+@@ -1195,20 +1202,20 @@
+         with open(self.csvmethods, 'rb') as fh:
+             methodsreader = csv.DictReader(fh)
+             for row in methodsreader:
+-                if int(row['side']) == side:
++                if int(row['side']) == side or int(row['side']) == 2:
+                     if row['name'] != row['searge']:
+                         names['methods'][row['searge']] = row['name']
+         with open(self.csvfields, 'rb') as fh:
+             fieldsreader = csv.DictReader(fh)
+             for row in fieldsreader:
+-                if int(row['side']) == side:
++                if int(row['side']) == side or int(row['side']) == 2:
+                     if row['name'] != row['searge']:
+                         names['fields'][row['searge']] = row['name']
+         if self.has_param_csv:
+             with open(self.csvparams, 'rb') as fh:
+                 paramsreader = csv.DictReader(fh)
+                 for row in paramsreader:
+-                    if int(row['side']) == side:
++                    if int(row['side']) == side or int(row['side']) == 2:
+                         names['params'][row['param']] = row['name']
+ 
+         regexps = {
+@@ -1238,6 +1245,11 @@
+ 
+         # HINT: We pathwalk the sources
+         for path, _, filelist in os.walk(pathsrclk[side], followlinks=True):
++            for cur_file in fnmatch.filter(filelist, '*.java'):
++                updatefile(os.path.normpath(os.path.join(path, cur_file)))
++                
++        # FML, copy of the above, for the common folder
++        for path, _, filelist in os.walk(self.srcshared, followlinks=True):
+             for cur_file in fnmatch.filter(filelist, '*.java'):
+                 updatefile(os.path.normpath(os.path.join(path, cur_file)))
+         return True
+@@ -1320,12 +1332,14 @@
+         pathsrclk = {CLIENT: self.srcclient, SERVER: self.srcserver}
+ 
+         strip_comments(pathsrclk[side])
++        strip_comments(self.srcshared)
+ 
+     def process_cleanup(self, side):
+         """Do lots of random cleanups including stripping comments, trailing whitespace and extra blank lines"""
+         pathsrclk = {CLIENT: self.srcclient, SERVER: self.srcserver}
+ 
+         src_cleanup(pathsrclk[side], fix_imports=True, fix_unicode=True, fix_charval=True, fix_pi=True, fix_round=False)
++        src_cleanup(self.srcshared, fix_imports=True, fix_unicode=True, fix_charval=True, fix_pi=True, fix_round=False)
+ 
+     def process_javadoc(self, side):
+         """Add CSV descriptions to methods and fields as javadoc"""
+@@ -1334,6 +1348,21 @@
+         if not self.has_doc_csv:
+             self.logger.warning('!! javadoc disabled due to no csvs !!')
+             return False
++            
++        #FML Recall this function on the common folder
++        #Potential bug: If this is called without a subsiquent rename call, will cause double comments
++        if pathsrclk[side] != self.srcshared:
++            if side == CLIENT:
++                tmp = self.srcclient
++                self.srcclient = self.srcshared
++                self.process_javadoc(side)
++                self.srcclient = tmp
++            else:
++                tmp = self.srcserver
++                self.srcserver = self.srcshared
++                self.process_javadoc(side)
++                self.srcserver = tmp
++                
+ 
+         #HINT: We read the relevant CSVs
+         methodsreader = csv.DictReader(open(self.csvmethods, 'r'))
+@@ -1342,13 +1371,13 @@
+         methods = {}
+         for row in methodsreader:
+             #HINT: Only include methods that have a non-empty description
+-            if int(row['side']) == side and row['desc']:
++            if (int(row['side']) == side or int(row['side']) == 2) and row['desc']:
+                 methods[row['searge']] = row['desc'].replace('*/', '* /')
+ 
+         fields = {}
+         for row in fieldsreader:
+             #HINT: Only include fields that have a non-empty description
+-            if int(row['side']) == side and row['desc']:
++            if (int(row['side']) == side or int(row['side']) == 2) and row['desc']:
+                 fields[row['searge']] = row['desc'].replace('*/', '* /')
+ 
+         regexps = {
+@@ -1420,6 +1449,7 @@
+ 
+         # HINT: We create the list of source directories based on the list of packages
+         pkglist = filterdirs(pathsrclk[side], '*.java', append_pattern=True)
++        pkglist = pkglist + filterdirs(self.srcshared, '*.java', append_pattern=True) #FML, Add Common folder
+         dirs = ' '.join(pkglist)
+         forkcmd = self.cmdastyle.format(classes=dirs, conffile=self.astyleconf)
+         self.runcmd(forkcmd)
+@@ -1592,6 +1622,9 @@
+                 sys.exit(1)
+ 
+         for entry in newfiles:
++            if 'commands.py' in entry[0]: #FML, Disable updating of Commands.py
++                print 'Update to runtime/commands.py found, but disbled due to using fml'
++                continue
+             if entry[3] == 'U':
+                 self.logger.info('Retrieving file from server : %s', entry[0])
+                 cur_file = os.path.normpath(entry[0])