Functional client @ 1.6.1

Also download sources for public libraries, and atach them in eclipse. DOCUMENTATION!! YAYA!

.gitattributes

@@ -1,13 +1,9 @@
 * text eol=lf
 *.bat text eol=crlf
 *.patch text eol=lf
-*.java text eol=lf
-*.gradle text eol=crlf
 *.png binary
 *.exe binary
 *.dll binary
-*.jar binary
-*.lzma binary
 *.zip binary
 *.pyd binary
 *.cfg text eol=lf

.gitignore

@@ -1,23 +1,17 @@
-#eclipse
 /bin
-/.settings
-/.classpath
-
-#idea
-/.idea
-*.iml
-
-#gradle
-/build
-/.gradle
-
-#occupational hazards
-/eclipse/
-/repo/
-/buildSrc
-
-#Patch rejects
-*.rej
-/patches-/
-# FML changelog
-changelog.txt
+/minecraft_server
+/mods
+/fmlbuild.properties
+/fmlversion.properties
+/difflist.txt
+/target
+fmlbranding.properties
+/fernflower.zip
+/commands.py.bck
+/mcp*.zip
+/mcp
+/eclipse
+/deobfuscation_data*.zip
+/binpatch
+/mcp_data/
+/map_client.txt

.gitmodules

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

FML152.json

@@ -0,0 +1,69 @@
+{
+  "id": "FML152",
+  "time": "2013-03-20T12:00:00-04:00",
+  "releaseTime": "2013-03-20T12:00:00-04:00",
+  "type": "release",
+  "minecraftArguments": "${auth_player_name} ${auth_session} --gameDir ${game_directory} --assetsDir ${game_assets} --tweakClass cpw.mods.fml.common.launcher.FMLTweaker",
+    "libraries": [
+    {
+      "name": "cpw.mods:fml:5.2"
+    },
+    {
+      "name": "net.minecraft:launchwrapper:1.3"
+    },
+    {
+      "name": "net.sf.jopt-simple:jopt-simple:4.5"
+    },
+    {
+      "name": "argo:argo:2.25_fixed"
+    },
+    {
+      "name": "org.ow2.asm:asm-all:4.1"
+    },
+    {
+      "name": "org.lwjgl.lwjgl:lwjgl:2.9.0"
+    },
+    {
+      "name": "org.lwjgl.lwjgl:lwjgl_util:2.9.0"
+    },
+    {
+      "name": "net.java.jinput:jinput:2.0.5"
+    },
+    {
+      "name": "org.bouncycastle:bcprov-jdk15on:1.47"
+    },
+    {
+      "name": "com.google.guava:guava:14.0"
+    },
+    {
+      "name": "net.java.jutils:jutils:1.0.0"
+    },
+    {
+      "name": "org.lwjgl.lwjgl:lwjgl-platform:2.9.0",
+      "natives": {
+        "linux": "natives-linux",
+        "windows": "natives-windows",
+        "osx": "natives-osx"
+      },
+      "extract": {
+        "exclude": [
+          "META-INF/"
+        ]
+      }
+    },
+    {
+      "name": "net.java.jinput:jinput-platform:2.0.5",
+      "natives": {
+        "linux": "natives-linux",
+        "windows": "natives-windows",
+        "osx": "natives-osx"
+      },
+      "extract": {
+        "exclude": [
+          "META-INF/"
+        ]
+      }
+    }
+  ],
+  "mainClass": "net.minecraft.launchwrapper.Launch"
+}

LICENSE-fml.txt

@@ -0,0 +1,491 @@
+This minecraft mod, Forge Mod Loader, including all parts herein except as noted below,
+is licensed under the GNU LGPL v2.1 or later.
+
+Homepage: https://github.com/MinecraftForge/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.
+
+This software contains a partial repackaging of javaxdelta, a BSD licensed program for generating
+binary differences and applying them, sourced from the subversion at http://sourceforge.net/projects/javaxdelta/
+authored by genman, heikok, pivot.
+The only changes are to replace some Trove collection types with standard Java collections, and repackaged.
+
+
+=== MCP Data ===
+This software includes data from the Minecraft Coder Pack (MCP), with kind permission
+from them. The license to MCP data is not transitive - distribution of this data by
+third parties requires independent licensing from the MCP team. This data is not
+redistributable without permission from the MCP team.
+
+=== Sharing ===
+I grant permission for some parts of FML to be redistributed outside the terms of the LGPL, for the benefit of
+the minecraft modding community. All contributions to these parts should be licensed under the same additional grant.
+
+-- Runtime patcher --
+License is granted to redistribute the runtime patcher code (common/cpw/mods/fml/patcher and subdirectories) under
+any alternative open source license as classified by the OSI (http://opensource.org/licenses)
+
+-- ASM transformers --
+License is granted to redistribute the ASM transformer code (common/cpw/mods/fml/common/asm/ and subdirectories)
+under any alternative open source license as classified by the OSI (http://opensource.org/licenses)
+
+========
+
+                  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

MinecraftForge-Credits.txt

@@ -1,26 +0,0 @@
-* Eloraam *
-
-* FlowerChild *
-
-* Hawkye *
-
-* MALfunction84 *
-
-Submitted the sleep handler code for his mod (Somnia) and others to use.
-
-* Scokeev9 *
-
-Gave permission for ScotTools API to be integrated into MCF, and also supported the Forge by converting his mods to use it.
-
-ScotTools Background: ScotTools was an API that enabled modders to add blocks to harvesting levels (and many other ease-of-use features to create new tools), and the first tool API that used block material for block breaking efficiency which allowed blocks from mods that didn't use ScotTools API to break with the correct speed.
-
-* SpaceToad *
-
-* LexManos *
-
-* cpw *
-
-* Minecraft Coder Pack (MCP) *
-Forge Mod Loader and Minecraft Forge have permission to distribute and automatically download components of MCP and distribute MCP data files.
-This permission is not transitive and others wishing to redistribute the Minecraft Forge source independently should seek permission of MCP or
-remove the MCP data files and request their users to download MCP separately.

MinecraftForge-License.txt

@@ -1,70 +0,0 @@
-Minecraft Forge Public Licence
-==============================
-
-Version 1.0
-
-0. Definitions
---------------
-
-Minecraft: Denotes a copy of the Minecraft game licensed by Mojang AB
-
-User: Anybody that interract with the software in one of the following ways:
-   - play
-   - decompile
-   - recompile or compile
-   - modify
-
-Minecraft Forge: The Minecraft Forge code, in source form, class file form, as
-obtained in a standalone fashion or as part of a wider distribution.
-
-Dependency: Code required to have Minecraft Forge working properly. That can
-include dependencies required to compile the code as well as modifications in 
-the Minecraft sources that are required to have Minecraft Forge working.
-
-1. Scope
---------
-
-The present license is granted to any user of Minecraft Forge, for all files included 
-unless stated otherwise in the file itself. As a prerequisite, a user of Minecraft 
-Forge must own a legally aquired copy of Minecraft.
-
-2. Play rights
---------------
-
-The user of Minecraft Forge is allowed to install the software on a client or
-a server and to play it without restriction.
-
-3. Modification rights
-----------------------
-
-The user has the right to decompile the source code, look at either the 
-decompiled version or the original source code, and to modify it.
-
-4. Derivation rights
---------------------
-
-The user has the rights to derive code from Minecraft Forge, that is to say to
-write code that either extends Minecraft Forge class and interfaces, 
-instantiate the objects declared or calls the functions. This code is known as
-"derived" code, and can be licensed with conditions different from Minecraft
-Forge.
-
-
-5. Distribution rights
-----------------------
-
-The user of Minecraft Forge is allowed to redistribute Minecraft Forge in 
-partially, in totallity, or included in a distribution. When distributing 
-binaries or class files, the user must provide means to obtain the sources of
-the distributed version of Minecraft Forge at no costs. This includes the
-files as well as any dependency that the code may rely on, including patches to
-minecraft original sources.
-
-Modification of Minecraft Forge as well as dependencies, including patches to
-minecraft original sources, has to remain under the terms of the present
-license.
-
-The right to distribute Minecraft Forge does not extend to the right to distribute
-MCP data files included within Minecraft Forge. These are the property of the MCP
-project and should be removed from any customized distribution of Minecraft Forge
-or permission sought separately from the MCP team.

Paulscode IBXM Library License.txt

@@ -1,10 +0,0 @@
-IBXM is copyright (c) 2007, Martin Cameron, and is licensed under the BSD License.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-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.
-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.
-

Paulscode SoundSystem CodecIBXM License.txt

@@ -1,40 +0,0 @@
-SoundSystem CodecIBXM Class License:
-
-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:
-
-1) You may not falsely claim to be the author of this class or any
-   unmodified portion of it.
-2) You may not copyright this class or a modified version of it and then
-   sue me for copyright infringement.
-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.
-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
-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.
-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.
-
-Author: Paul Lamb
-http://www.paulscode.com
-
-
-This software is based on or using the IBXM library available from
-http://www.geocities.com/sunet2000/
-
-
-IBXM is copyright (c) 2007, Martin Cameron, and is licensed under the BSD License.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-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.
-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.

README.txt

@@ -1,31 +0,0 @@
-*** HOW TO INSTALL ***
-For Mod Users:
-
-Download the latest installer from http://files.minecraftforge.net and follow instructions given by the installer.
-
-
-For Mod Devs:
-
-Download the latest Forge source distribution from http://files.minecraftforge.net and unzip it to a folder.
-Open a command prompt, navigate to the directory where you unzipped the Forge sources, and run:
-If you have Gradle: gradle setupDevWorkspace
-If you DO NOT have Gradle installed:
-Windows: ./gradlew.bat setupDevWorkspace
-MacOS/Linux: ./gradlew setupDevWorkspace
-
-If you wish to use the Eclipse IDE, run gradle eclipse instead of gradle setupDevWorkspace, or install the Gradle plugin for Eclipse and import the Forge source folder as a Gradle project.
-
-
-For Contributors: (Note: This assumes you have Gradle installed. If you don't, use ./gradlew(.bat) instead of gradle.
-
-Clone this repository to a folder. 
-Open a command prompt and navigate to the folder where you cloned this repo.
-Run gradle setupForge to setup your development environment.
-
-To use Eclipse, point your Eclipse workspace at the eclipse folder inside the repo.
-
-
-Requirements (for both mod devs and contributors):
-  You must have a JDK installed and accessible.
-  If you do not wish to use the gradle wrapper, you can install Gradle from http://www.gradle.org/ .
- 

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.gradle

@@ -1,122 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-        mavenLocal()
-        maven {
-            name = "forge"
-            url = "http://files.minecraftforge.net/maven"
-        }
-        maven {
-            name = "sonatype"
-            url = "https://oss.sonatype.org/content/repositories/snapshots/"
-        }
-    }
-    dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
-    }
-}
-
-configurations {
-    deployJars
-}
-
-import static net.minecraftforge.gradle.dev.ForgeDevPlugin.*
-
-apply plugin: 'maven'
-apply plugin: 'forgedev'
-
-repositories {
-    mavenLocal()
-    flatDir {
-        name "fileRepo"
-        dirs "repo"
-    }
-}
-
-minecraft {
-    version = '1.7.2'
-    mcpVersion = '9.03'
-    fmlDir = projectDir.getAbsolutePath() + "/fml";
-    mainClass = 'cpw.mods.fml.relauncher.ServerLaunchWrapper'
-    tweakClass = 'cpw.mods.fml.common.launcher.FMLTweaker'
-    installerVersion = "1.4"
-}
-
-group = 'net.minecraftforge'
-version = getVersionFromJava(getProject(), 'src/main/java/net/minecraftforge/common/ForgeVersion.java')
-
-jenkins {
-    job = 'minecraftforge'
-}
-
-launch4j {
-    jreMinVersion = '1.6.0'
-}
-
-uploadArchives {
-    repositories {
-        add getProject().repositories.mavenLocal()
-    }
-    repositories.mavenDeployer {
-        configuration = configurations.deployJars
-
-        if (project.hasProperty("filesmaven")) {
-            logger.info('Publishing to files server')
-            repository(url: project.filesmaven.url) {
-                authentication(userName: project.filesmaven.username, privateKey: project.filesmaven.key)
-            }
-        } else {
-            logger.info('Publishing to repo folder')
-            repository(url: 'file://localhost/' + project.file('repo').getAbsolutePath())
-        }
-
-        pom {
-            groupId = project.group
-            version = project.version
-            artifactId = project.archivesBaseName
-        }
-        pom.project {
-            name project.archivesBaseName
-            packaging 'jar'
-            description 'Minecraft Forge API'
-            url 'https://github.com/MinecraftForge/MinecraftForge'
-
-            scm {
-                url 'https://github.com/MinecraftForge/MinecraftForge'
-                connection 'scm:git:git://github.com/MinecraftForge/MinecraftForge.git'
-                developerConnection 'scm:git:[email protected]:MinecraftForge/MinecraftForge.git'
-            }
-
-            issueManagement {
-                system 'github'
-                url 'https://github.com/MinecraftForge/MinecraftForge/issues'
-            }
-
-            licenses {
-                license {
-                    name 'Forge Public License'
-                    url 'https://raw.github.com/MinecraftForge/MinecraftForge/master/MinecraftForge-License.txt'
-                    distribution 'repo'
-                }
-            }
-
-            developers {
-                developer {
-                    id 'cpw'
-                    name 'cpw'
-                    roles { role 'developer' }
-                }
-                developer {
-                    id 'LexManos'
-                    name 'Lex Manos'
-                    roles { role 'developer' }
-                }
-                developer {
-                    id 'AbrarSyed'
-                    name 'Abrar Syed'
-                    roles { role 'contributor' }
-                }
-            }
-        }
-    }
-}

build.xml

@@ -0,0 +1,427 @@
+<?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>
+  <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}" />
+      <entry key="fmlbuild.deobfuscation.hash" type="string" value="${deobf.checksum}" />
+    </propertyfile>
+  </target>
+
+  <target name="buildenvsetup">
+    <tstamp>
+      <format pattern="yyMMddHHmmss" property="timestamp" />
+    </tstamp>
+    <property environment="env" />
+    <property name="modname" value="fml" />
+    <condition property="mcp.home" value="${env.WORKSPACE}/mcp" else="${basedir}/mcp">
+      <isset property="env.WORKSPACE" />
+    </condition>
+    <property name="fml.python.dir" location="${basedir}/python" />
+    <property name="fml.lzma.dir" location="${basedir}/lzmabin" />
+    <condition property="python.exe" value="${fml.python.dir}/python_fml" else="python">
+      <os family="Windows" />
+    </condition>
+    <condition property="lzma.exe" value="${fml.lzma.dir}/xz.exe" else="xz">
+      <os family="Windows" />
+    </condition>
+    <condition property="mcp.exists">
+      <available file="${mcp.home}/runtime/commands.py" />
+    </condition>
+    <condition property="signature.exists">
+      <available file="${env.JENKINS_HOME}/fmlsigned.properties" />
+    </condition>
+    <property name="mcp.obfoutput" location="${mcp.home}/reobf" />
+    <property name="client.mcp.obfoutput" location="${mcp.obfoutput}/minecraft" />
+    <property name="mcp.srcdir" location="${mcp.home}/src" />
+    <property name="client.mcp.srcdir" location="${mcp.srcdir}/minecraft" />
+    <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="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>
+    <available file="eclipse" property="eclipse.exists" />
+  </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.minecraft" value="${fmlbuild.mcversion}" />
+    <property name="version.branch" value="${fmlbuild.branch}" />
+    <property name="version" value="${version.major}.${version.minor}.${version.rev}.${version.build}" />
+  </target>
+
+  <target name="makeclean" depends="buildenvsetup" if="mcp.exists">
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${mcp.home}/runtime/cleanup.py" />
+      <arg value="-f" />
+    </exec>
+  </target>
+
+  <target name="clean" depends="buildenvsetup,makeclean" if="mcp.exists">
+    <exec executable="${python.exe}" dir="${mcp.home}">
+      <arg value="${basedir}/decompile.py" />
+      <arg value="--mcp-dir" />
+      <arg value="${mcp.home}" />
+      <arg value="--fml-dir" />
+      <arg value="${basedir}" />
+      <arg value="--gen-conf" />
+    </exec>
+  </target>
+
+  <target name="reobfuscate" 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/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>
+          <available file="${mcp.home}/bin/minecraft/net/minecraft/client/Minecraft.class" />
+        </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-common">
+    <copy todir="${client.mcp.srcdir}" overwrite="true" verbose="true">
+      <fileset dir="${common.src.dir}" includes="**/*.java" />
+    </copy>
+  </target>
+
+  <target name="merge-source" depends="buildenvsetup,merge-client,merge-common" />
+
+  <target name="build-universal" depends="buildenvsetup,merge-client,merge-common,reobfuscate,makeversion,makebinpatches">
+    <condition property="universal.jarname" value="${modname}-universal-${version.minecraft}-${version}" else="${modname}-universal-${version.minecraft}-${version}-${version.branch}">
+      <equals arg1="${version.branch}" arg2="master" />
+    </condition>
+
+    <mkdir dir="${basedir}/target" />
+    <jar destfile="${basedir}/target/${universal.jarname}.zip" duplicate="preserve">
+      <manifest>
+        <attribute name="Main-Class" value="cpw.mods.fml.relauncher.ServerLaunchWrapper" />
+        <attribute name="Class-Path" value="minecraft_server.jar:lib/guava-14.0-rc3.jar:lib/bcprov-jdk15on-148-src.zip:lib/asm-debug-all-4.1.jar:lib/scala-library.jar:lib/argo-3.2-src.jar" />
+      </manifest>
+      <fileset dir="${client.mcp.obfoutput}" includes="**/*.class" excludes="*.class,net/minecraft/**/*.class" />
+    </jar>
+    <antcall target="signjar" />
+    <zip update="true" destfile="${basedir}/target/${universal.jarname}.zip">
+      <fileset dir="${basedir}" includes="binpatches.pack.lzma,deobfuscation_data-${version.minecraft}.lzma"/>
+      <fileset dir="${client.mcp.obfoutput}" includes="*.class" />
+      <zipfileset dir="${basedir}" includes="fmlversion.properties" />
+      <zipfileset dir="${basedir}" includes="LICENSE-fml.txt" />
+      <zipfileset dir="${common.src.dir}" includes="mcpmod.info" />
+      <zipfileset dir="${client.src.dir}" includes="mcp.png" />
+      <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-source-pack" depends="makeversion">
+    <property name="srcpack.jarname" value="${modname}-src-${version.minecraft}-${version}-${version.branch}" />
+    <zip destfile="${basedir}/target/${srcpack.jarname}.zip">
+      <zipfileset dir="${basedir}" includes="LICENSE-fml.txt,difflist.txt,commands.patch,mcp_merge.cfg,mc_versions.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="${client.src.dir}" includes="mcp.png" prefix="fml/client" />
+      <zipfileset dir="${basedir}" includes="fmlversion.properties" prefix="fml/common" />
+      <zipfileset dir="${common.src.dir}" includes="*.cfg" prefix="fml/common" />
+      <zipfileset dir="${common.src.dir}" includes="mcpmod.info" prefix="fml/common" />
+      <zipfileset dir="${patch.src.dir}" includes="**/*.patch" prefix="fml/patches" />
+      <zipfileset dir="${fml.conf.dir}" prefix="fml/conf" />
+      <zipfileset dir="${fml.python.dir}" prefix="fml/python" />
+      <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-deobf-data" depends="makeversion">
+    <mkdir dir="build-tmp-deobf" />
+    <copy todir="build-tmp-deobf">
+      <mappedresources>
+        <fileset dir="${mcp.home}/conf" includes="packaged.srg" />
+        <globmapper from="packaged.srg" to="deobfuscation_data-${version.minecraft}" />
+      </mappedresources>
+    </copy>
+    <exec executable="${lzma.exe}">
+      <arg line="--format=lzma"/>
+      <arg line="build-tmp-deobf/deobfuscation_data-${version.minecraft}"/>
+      <arg line="-v"/>
+    </exec>
+    <copy todir="${basedir}">
+      <fileset dir="build-tmp-deobf" includes="*.lzma" />
+    </copy>
+    <antcall target="writeversion" />
+    <delete dir="build-tmp-deobf" />
+    <zip destfile="deobfuscation_data-${version.minecraft}.jar" basedir="${basedir}">
+      <include name="deobfuscation_data-${version.minecraft}.lzma"/>
+    </zip>
+  </target>
+
+  <target name="build" depends="buildenvsetup,merge-client,merge-common,build-deobf-data,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>
+    <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" />
+    <antcall target="makeeclipse" />
+    <echo>Setup complete! You should now be able to open ${basedir}/eclipse as a workspace in eclipse and import/refresh the FML project</echo>
+  </target>
+
+  <target name="fmldecompile" depends="buildenvsetup,makeclean">
+    <exec executable="${python.exe}" dir="${basedir}">
+      <arg value="${basedir}/decompile.py" />
+      <arg value="--mcp-dir" />
+      <arg value="${mcp.home}" />
+      <arg value="--fml-dir" />
+      <arg value="${basedir}" />
+      <arg value="--gen-conf" />
+    </exec>
+  </target>
+
+  <target name="jenkinsfmldecompile" depends="buildenvsetup,makeclean">
+    <exec executable="${python.exe}" dir="${basedir}">
+      <arg value="${basedir}/decompile.py" />
+      <arg value="--mcp-dir" />
+      <arg value="${mcp.home}" />
+      <arg value="--fml-dir" />
+      <arg value="${basedir}" />
+    </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" />
+    <delete dir="${client.mcp.srcdir}/org" />
+  </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="makeeclipse" depends="buildenvsetup" unless="eclipse.exists">
+    <echo>
+      Extracting fresh eclipse workspace to ${basedir}/eclipse
+    </echo>
+    <unzip src="${basedir}/eclipse-workspace-dev.zip" dest="${basedir}" />
+  </target>
+
+  <target name="makerenamedsource" depends="buildenvsetup,repatch,merge-client,merge-common,reobfuscate">
+    <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>
+  <target name="signjar" depends="buildenvsetup,makeversion" if="signature.exists">
+    <condition property="universal.jarname" value="${modname}-universal-${version.minecraft}-${version}" else="${modname}-universal-${version.minecraft}-${version}-${version.branch}">
+      <equals arg1="${version.branch}" arg2="master" />
+    </condition>
+    <property file="${env.JENKINS_HOME}/fmlsigned.properties" prefix="sign" />
+    <echo>${env.JENKINS_HOME} ${universal.jarname} ${sign.KEYPASS}</echo>
+    <signjar alias="FML" jar="${basedir}/target/${universal.jarname}.zip" keypass="${sign.KEYPASS}" keystore="${env.JENKINS_HOME}/${sign.KEYSTORE}" storepass="${sign.STOREPASS}" verbose="true" />
+  </target>
+  <target name="makebinpatches" depends="buildenvsetup,makeversion">
+    <path id="diffset.libs">
+      <pathelement path="${mcp.home}/jars/libraries/com/google/guava/guava/14.0/guava-14.0.jar"/>
+      <pathelement path="${mcp.home}/jars/libraries/org/ow2/asm/asm-all/4.1/asm-all-4.1.jar"/>
+      <pathelement path="${mcp.home}/jars/libraries/lzma/lzma/0.0.1/lzma-0.0.1.jar"/>
+      <pathelement path="${mcp.obfoutput}/minecraft"/>
+    </path>
+    <delete dir="${basedir}/binpatch" verbose="true"/>
+    <java classname="cpw.mods.fml.common.patcher.GenDiffSet" classpathref="diffset.libs">
+      <arg path="${mcp.home}/jars/versions/${version.minecraft}/${version.minecraft}.jar.backup"/>
+      <arg path="${mcp.obfoutput}/minecraft"/>
+      <arg path="${basedir}/deobfuscation_data-${version.minecraft}.lzma"/>
+      <arg path="${basedir}/binpatch/client"/>
+      <arg value="false"/>
+    </java>
+    <java classname="cpw.mods.fml.common.patcher.GenDiffSet"  classpathref="diffset.libs">
+      <arg path="${mcp.home}/jars/minecraft_server.${version.minecraft}.jar.backup"/>
+      <arg path="${mcp.obfoutput}/minecraft"/>
+      <arg path="${basedir}/deobfuscation_data-${version.minecraft}.lzma"/>
+      <arg path="${basedir}/binpatch/server"/>
+      <arg value="true"/>
+    </java>
+    <mkdir dir="binpatch-tmp"/>
+    <zip destfile="binpatch-tmp/binpatches.jar" basedir="${basedir}">
+      <include name="binpatch/**/*.binpatch"/>
+    </zip>
+    <apply executable="pack200">
+      <arg line="--no-gzip"/>
+      <arg line="binpatch-tmp/binpatches.pack"/>
+      <fileset dir="binpatch-tmp" includes="binpatches.jar"/>
+    </apply>
+    <apply executable="${lzma.exe}">
+      <arg line="--format=lzma"/>
+      <arg line="-v"/>
+      <fileset dir="binpatch-tmp" includes="binpatches.pack"/>
+    </apply>
+    <move file="binpatch-tmp/binpatches.pack.lzma" todir="${basedir}"/>
+    <delete dir="binpatch-tmp" failonerror="false"/>
+  </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 {
+
+}

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/CustomModLoadingErrorDisplayException.java

@@ -0,0 +1,55 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiErrorScreen;
+import cpw.mods.fml.common.IFMLHandledException;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+/**
+ * If a mod throws this exception during loading, it will be called back to render
+ * the error screen through the methods below. This error will not be cleared, and will
+ * not allow the game to carry on, but might be useful if your mod wishes to report
+ * a fatal configuration error in a pretty way.
+ *
+ * Throw this through a proxy. It won't work on the dedicated server environment.
+ * @author cpw
+ *
+ */
+@SideOnly(Side.CLIENT)
+public abstract class CustomModLoadingErrorDisplayException extends RuntimeException implements IFMLHandledException
+{
+    /**
+     * Called after the GUI is inited by the parent code. You can do extra stuff here, maybe?
+     *
+     * @param errorScreen The error screen we're painting
+     * @param fontRenderer A font renderer for you
+     */
+    public abstract void initGui(GuiErrorScreen errorScreen, FontRenderer fontRenderer);
+
+    /**
+     * Draw your error to the screen.
+     *
+     * <br/><em>Warning: Minecraft is in a deep error state.</em> <strong>All</strong> it can do is stop.
+     * Do not try and do anything involving complex user interaction here.
+     *
+     * @param errorScreen The error screen to draw to
+     * @param fontRenderer A font renderer for you
+     * @param mouseRelX Mouse X
+     * @param mouseRelY Mouse Y
+     * @param tickTime tick time
+     */
+    public abstract void drawScreen(GuiErrorScreen errorScreen, FontRenderer fontRenderer, int mouseRelX, int mouseRelY, float tickTime);
+}

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

@@ -0,0 +1,553 @@
+/*
+ * 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 java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.multiplayer.GuiConnecting;
+import net.minecraft.client.multiplayer.NetClientHandler;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.crash.CrashReport;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.NetHandler;
+import net.minecraft.network.packet.Packet;
+import net.minecraft.network.packet.Packet131MapData;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.World;
+
+import com.google.common.base.Throwables;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.MapDifference.ValueDifference;
+
+import cpw.mods.fml.client.modloader.ModLoaderClientHelper;
+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.DuplicateModsFoundException;
+import cpw.mods.fml.common.FMLCommonHandler;
+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.MetadataCollection;
+import cpw.mods.fml.common.MissingModsException;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.ModMetadata;
+import cpw.mods.fml.common.ObfuscationReflectionHelper;
+import cpw.mods.fml.common.WrongMinecraftVersionException;
+import cpw.mods.fml.common.network.EntitySpawnAdjustmentPacket;
+import cpw.mods.fml.common.network.EntitySpawnPacket;
+import cpw.mods.fml.common.network.ModMissingPacket;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import cpw.mods.fml.common.registry.GameData;
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.common.registry.IEntityAdditionalSpawnData;
+import cpw.mods.fml.common.registry.IThrowableEntity;
+import cpw.mods.fml.common.registry.ItemData;
+import cpw.mods.fml.common.registry.LanguageRegistry;
+import cpw.mods.fml.common.toposort.ModSortingException;
+import cpw.mods.fml.relauncher.Side;
+
+
+/**
+ * Handles primary communication from hooked code into the system
+ *
+ * The FML entry point is {@link #beginMinecraftLoading(Minecraft)} called from
+ * {@link Minecraft}
+ *
+ * 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 DummyModContainer optifineContainer;
+
+    private boolean guiLoaded;
+
+    private boolean serverIsRunning;
+
+    private MissingModsException modsMissing;
+
+    private ModSortingException modSorting;
+
+    private boolean loading;
+
+    private WrongMinecraftVersionException wrongMC;
+
+    private CustomModLoadingErrorDisplayException customError;
+
+	private DuplicateModsFoundException dupesFound;
+
+    private boolean serverShouldBeKilledQuietly;
+
+    /**
+     * Called to start the whole game off
+     *
+     * @param minecraft The minecraft instance being launched
+     */
+    public void beginMinecraftLoading(Minecraft minecraft)
+    {
+        client = 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;
+        }
+
+        loading = true;
+//        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"),"optifine").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 (WrongMinecraftVersionException wrong)
+        {
+            wrongMC = wrong;
+        }
+        catch (DuplicateModsFoundException dupes)
+        {
+        	dupesFound = dupes;
+        }
+        catch (MissingModsException missing)
+        {
+            modsMissing = missing;
+        }
+        catch (ModSortingException sorting)
+        {
+            modSorting = sorting;
+        }
+        catch (CustomModLoadingErrorDisplayException custom)
+        {
+            FMLLog.log(Level.SEVERE, custom, "A custom exception was thrown by a mod, the game will now halt");
+            customError = custom;
+        }
+        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
+     *
+     */
+    @SuppressWarnings("deprecation")
+    public void finishMinecraftLoading()
+    {
+        if (modsMissing != null || wrongMC != null || customError!=null || dupesFound!=null || modSorting!=null)
+        {
+            return;
+        }
+        try
+        {
+            Loader.instance().initializeMods();
+        }
+        catch (CustomModLoadingErrorDisplayException custom)
+        {
+            FMLLog.log(Level.SEVERE, custom, "A custom exception was thrown by a mod, the game will now halt");
+            customError = custom;
+            return;
+        }
+        catch (LoaderException le)
+        {
+            haltGame("There was a severe problem during mod loading that has caused the game to fail", le);
+            return;
+        }
+        LanguageRegistry.reloadLanguageTable();
+        RenderingRegistry.instance().loadEntityRenderers((Map<Class<? extends Entity>, Render>)RenderManager.field_78727_a.field_78729_o);
+
+        loading = false;
+        KeyBindingRegistry.instance().uploadKeyBindingsToGame(client.field_71474_y);
+    }
+
+    public void onInitializationComplete()
+    {
+        if (wrongMC != null)
+        {
+            client.func_71373_a(new GuiWrongMinecraft(wrongMC));
+        }
+        else if (modsMissing != null)
+        {
+            client.func_71373_a(new GuiModsMissing(modsMissing));
+        }
+        else if (dupesFound != null)
+        {
+        	client.func_71373_a(new GuiDupesFound(dupesFound));
+        }
+        else if (modSorting != null)
+        {
+            client.func_71373_a(new GuiSortingProblem(modSorting));
+        }
+		else if (customError != null)
+        {
+            client.func_71373_a(new GuiCustomModLoadingErrorScreen(customError));
+        }
+        else
+        {
+            // Force renderengine to reload and re-initialize all textures
+//            client.field_71446_o.func_78352_b();
+//            TextureFXManager.instance().loadTextures(client.field_71418_C.func_77292_e());
+        }
+    }
+    /**
+     * Get the server instance
+     */
+    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);
+        }
+    }
+
+    /**
+     * @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 ImmutableList.<String>of();
+        }
+    }
+
+    @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(EntityRegistration er, EntitySpawnPacket packet)
+    {
+        WorldClient wc = client.field_71441_e;
+
+        Class<? extends Entity> cls = er.getEntityClass();
+
+        try
+        {
+            Entity entity;
+            if (er.hasCustomSpawning())
+            {
+                entity = er.doCustomSpawning(packet);
+            }
+            else
+            {
+                entity = (Entity)(cls.getConstructor(World.class).newInstance(wc));
+                int offset = packet.entityId - entity.field_70157_k;
+                entity.field_70157_k = packet.entityId;
+                entity.func_70012_b(packet.scaledX, packet.scaledY, packet.scaledZ, packet.scaledYaw, packet.scaledPitch);
+                if (entity instanceof EntityLiving)
+                {
+                    ((EntityLiving)entity).field_70759_as = packet.scaledHeadYaw;
+                }
+
+                Entity parts[] = entity.func_70021_al();
+                if (parts != null)
+                {
+                    for (int j = 0; j < parts.length; j++)
+                    {
+                        parts[j].field_70157_k += offset;
+                    }
+                }
+            }
+
+            entity.field_70118_ct = packet.rawX;
+            entity.field_70117_cu = packet.rawY;
+            entity.field_70116_cv = packet.rawZ;
+
+            if (entity instanceof IThrowableEntity)
+            {
+                Entity thrower = client.field_71439_g.field_70157_k == packet.throwerId ? client.field_71439_g : wc.func_73045_a(packet.throwerId);
+                ((IThrowableEntity)entity).setThrower(thrower);
+            }
+
+            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_73045_a(packet.entityId);
+        if (ent != null)
+        {
+            ent.field_70118_ct = packet.serverX;
+            ent.field_70117_cu = packet.serverY;
+            ent.field_70116_cv = packet.serverZ;
+        }
+        else
+        {
+            FMLLog.fine("Attempted to adjust the position of entity %d which is not present on the client", packet.entityId);
+        }
+    }
+
+    @Override
+    public void beginServerLoading(MinecraftServer server)
+    {
+        serverShouldBeKilledQuietly = false;
+        // NOOP
+    }
+
+    @Override
+    public void finishServerLoading()
+    {
+        // NOOP
+    }
+
+    @Override
+    public MinecraftServer getServer()
+    {
+        return client.func_71401_C();
+    }
+
+    @Override
+    public void sendPacket(Packet packet)
+    {
+        if(client.field_71439_g != null)
+        {
+            client.field_71439_g.field_71174_a.func_72552_c(packet);
+        }
+    }
+
+    @Override
+    public void displayMissingMods(ModMissingPacket modMissingPacket)
+    {
+        client.func_71373_a(new GuiModsMissingForServer(modMissingPacket));
+    }
+
+    /**
+     * If the client is in the midst of loading, we disable saving so that custom settings aren't wiped out
+     */
+    public boolean isLoading()
+    {
+        return loading;
+    }
+
+    @Override
+    public void handleTinyPacket(NetHandler handler, Packet131MapData mapData)
+    {
+        ((NetClientHandler)handler).fmlPacket131Callback(mapData);
+    }
+
+    @Override
+    public void setClientCompatibilityLevel(byte compatibilityLevel)
+    {
+        NetClientHandler.setConnectionCompatibilityLevel(compatibilityLevel);
+    }
+
+    @Override
+    public byte getClientCompatibilityLevel()
+    {
+        return NetClientHandler.getConnectionCompatibilityLevel();
+    }
+
+    public void warnIDMismatch(MapDifference<Integer, ItemData> idDifferences, boolean mayContinue)
+    {
+        GuiIdMismatchScreen mismatch = new GuiIdMismatchScreen(idDifferences, mayContinue);
+        client.func_71373_a(mismatch);
+    }
+
+    public void callbackIdDifferenceResponse(boolean response)
+    {
+        if (response)
+        {
+            serverShouldBeKilledQuietly = false;
+            GameData.releaseGate(true);
+            client.continueWorldLoading();
+        }
+        else
+        {
+            serverShouldBeKilledQuietly = true;
+            GameData.releaseGate(false);
+            // Reset and clear the client state
+            client.func_71403_a((WorldClient)null);
+            client.func_71373_a(null);
+        }
+    }
+
+    @Override
+    public boolean shouldServerShouldBeKilledQuietly()
+    {
+        return serverShouldBeKilledQuietly;
+    }
+
+    @Override
+    public void disconnectIDMismatch(MapDifference<Integer, ItemData> s, NetHandler toKill, INetworkManager mgr)
+    {
+        boolean criticalMismatch = !s.entriesOnlyOnLeft().isEmpty();
+        for (Entry<Integer, ValueDifference<ItemData>> mismatch : s.entriesDiffering().entrySet())
+        {
+            ValueDifference<ItemData> vd = mismatch.getValue();
+            if (!vd.leftValue().mayDifferByOrdinal(vd.rightValue()))
+            {
+                criticalMismatch = true;
+            }
+        }
+
+        if (!criticalMismatch)
+        {
+            // We'll carry on with this connection, and just log a message instead
+            return;
+        }
+        // Nuke the connection
+        ((NetClientHandler)toKill).func_72553_e();
+        // Stop GuiConnecting
+        GuiConnecting.forceTermination((GuiConnecting)client.field_71462_r);
+        // pulse the network manager queue to clear cruft
+        mgr.func_74428_b();
+        // Nuke the world client
+        client.func_71403_a((WorldClient)null);
+        // Show error screen
+        warnIDMismatch(s, false);
+    }
+
+    /**
+     * Is this GUI type open?
+     *
+     * @param gui The type of GUI to test for
+     * @return if a GUI of this type is open
+     */
+    public boolean isGUIOpen(Class<? extends GuiScreen> gui)
+    {
+        return client.field_71462_r != null && client.field_71462_r.getClass().equals(gui);
+    }
+}

client/cpw/mods/fml/client/GuiCustomModLoadingErrorScreen.java

@@ -0,0 +1,39 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import net.minecraft.client.gui.GuiErrorScreen;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.WrongMinecraftVersionException;
+
+public class GuiCustomModLoadingErrorScreen extends GuiErrorScreen
+{
+    private CustomModLoadingErrorDisplayException customException;
+    public GuiCustomModLoadingErrorScreen(CustomModLoadingErrorDisplayException customException)
+    {
+        super(null,null);
+        this.customException = customException;
+    }
+    @Override
+    public void func_73866_w_()
+    {
+        super.func_73866_w_();
+        this.customException.initGui(this, field_73886_k);
+    }
+    @Override
+    public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_)
+    {
+        this.func_73873_v_();
+        this.customException.drawScreen(this, field_73886_k, p_73863_1_, p_73863_2_, p_73863_3_);
+    }
+}

client/cpw/mods/fml/client/GuiDupesFound.java

@@ -0,0 +1,58 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import java.io.File;
+import java.util.Map.Entry;
+
+import net.minecraft.client.gui.GuiErrorScreen;
+
+import cpw.mods.fml.common.DuplicateModsFoundException;
+import cpw.mods.fml.common.MissingModsException;
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+
+public class GuiDupesFound extends GuiErrorScreen
+{
+
+    private DuplicateModsFoundException dupes;
+
+    public GuiDupesFound(DuplicateModsFoundException dupes)
+    {
+        super(null,null);
+        this.dupes = dupes;
+    }
+
+    @Override
+    public void func_73866_w_()
+    {
+        super.func_73866_w_();
+    }
+    @Override
+    public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_)
+    {
+        this.func_73873_v_();
+        int offset = Math.max(85 - dupes.dupes.size() * 10, 10);
+        this.func_73732_a(this.field_73886_k, "Forge Mod Loader has found a problem with your minecraft installation", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, "You have mod sources that are duplicate within your system", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, "Mod Id : File name", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=5;
+        for (Entry<ModContainer, File> mc : dupes.dupes.entries())
+        {
+            offset+=10;
+            this.func_73732_a(this.field_73886_k, String.format("%s : %s", mc.getKey().getModId(), mc.getValue().getName()), this.field_73880_f / 2, offset, 0xEEEEEE);
+        }
+    }
+}

client/cpw/mods/fml/client/GuiIdMismatchScreen.java

@@ -0,0 +1,108 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import java.util.List;
+import java.util.Map.Entry;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiYesNo;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.StringTranslate;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.MapDifference.ValueDifference;
+
+import cpw.mods.fml.common.registry.ItemData;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+
+public class GuiIdMismatchScreen extends GuiYesNo {
+    private List<String> missingIds = Lists.newArrayList();
+    private List<String> mismatchedIds = Lists.newArrayList();
+    private boolean allowContinue;
+
+    public GuiIdMismatchScreen(MapDifference<Integer, ItemData> idDifferences, boolean allowContinue)
+    {
+        super(null,"ID mismatch", "Should I continue?", 1);
+        field_73942_a = this;
+        for (Entry<Integer, ItemData> entry : idDifferences.entriesOnlyOnLeft().entrySet())
+        {
+            missingIds.add(String.format("ID %d from Mod %s is missing", entry.getValue().getItemId(), entry.getValue().getModId(), entry.getValue().getItemType()));
+        }
+        for (Entry<Integer, ValueDifference<ItemData>> entry : idDifferences.entriesDiffering().entrySet())
+        {
+            ItemData world = entry.getValue().leftValue();
+            ItemData game = entry.getValue().rightValue();
+            mismatchedIds.add(String.format("ID %d is mismatched between world and game", world.getItemId()));
+        }
+        this.allowContinue = allowContinue;
+    }
+
+    @Override
+    public void func_73878_a(boolean choice, int p_73878_2_)
+    {
+        FMLClientHandler.instance().callbackIdDifferenceResponse(choice);
+    }
+
+    @Override
+    public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_)
+    {
+        this.func_73873_v_();
+        if (!allowContinue && field_73887_h.size() == 2)
+        {
+            field_73887_h.remove(0);
+        }
+        int offset = Math.max(85 - (missingIds.size() + mismatchedIds.size()) * 10, 30);
+        this.func_73732_a(this.field_73886_k, "Forge Mod Loader has found ID mismatches", this.field_73880_f / 2, 10, 0xFFFFFF);
+        this.func_73732_a(this.field_73886_k, "Complete details are in the log file", this.field_73880_f / 2, 20, 0xFFFFFF);
+        int maxLines = 20;
+        for (String s: missingIds) {
+            this.func_73732_a(this.field_73886_k, s, this.field_73880_f / 2, offset, 0xEEEEEE);
+            offset += 10;
+            maxLines --;
+            if (maxLines < 0) break;
+            if (offset >= this.field_73881_g - 30) break;
+        }
+        if (maxLines > 0 && offset < this.field_73881_g - 30)
+        {
+            for (String s: mismatchedIds) {
+                this.func_73732_a(this.field_73886_k, s, this.field_73880_f / 2, offset, 0xEEEEEE);
+                offset += 10;
+                maxLines --;
+                if (maxLines < 0) break;
+                if (offset >= this.field_73881_g - 30) break;
+            }
+        }
+        if (allowContinue)
+        {
+            this.func_73732_a(this.field_73886_k, "Do you wish to continue loading?", this.field_73880_f / 2, this.field_73881_g - 30, 0xFFFFFF);
+        }
+        else
+        {
+            this.func_73732_a(this.field_73886_k, "You cannot connect to this server", this.field_73880_f / 2, this.field_73881_g - 30, 0xFFFFFF);
+        }
+        // super.super. Grrr
+        for (int var4 = 0; var4 < this.field_73887_h.size(); ++var4)
+        {
+            GuiButton var5 = (GuiButton)this.field_73887_h.get(var4);
+            var5.field_73743_d = this.field_73881_g - 20;
+            if (!allowContinue)
+            {
+                var5.field_73746_c = this.field_73880_f / 2 - 75;
+                var5.field_73744_e = I18n.func_135053_a("gui.done");
+            }
+            var5.func_73737_a(this.field_73882_e, p_73863_1_, p_73863_2_);
+        }
+    }
+}

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

@@ -0,0 +1,200 @@
+/*
+ * 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 net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.GuiSmallButton;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.StringTranslate;
+
+import org.lwjgl.opengl.GL11;
+
+import com.google.common.base.Strings;
+
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.ModContainer;
+
+/**
+ * @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 mainMenu
+     */
+    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 && !Strings.isNullOrEmpty(mod.getMetadata().parent)) {
+                String parentMod = mod.getMetadata().parent;
+                ModContainer parentContainer = Loader.instance().getIndexedModList().get(parentMod);
+                if (parentContainer != null)
+                {
+                    mod.getMetadata().parentMod = parentContainer;
+                    parentContainer.getMetadata().childMods.add(mod);
+                    continue;
+                }
+            }
+            else 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);
+        this.field_73887_h.add(new GuiSmallButton(6, this.field_73880_f / 2 - 75, this.field_73881_g - 38, I18n.func_135053_a("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)
+    {
+        int r = 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) {
+            GL11.glEnable(GL11.GL_BLEND);
+            if (!selectedMod.getMetadata().autogenerated) {
+                int shifty = 35;
+                String logoFile = selectedMod.getMetadata().logoFile;
+                if (!logoFile.isEmpty())
+                {
+                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+                    // TODO
+//                    this.field_73882_e.field_71446_o.func_98187_b(logoFile);
+                    Dimension dim = TextureFXManager.instance().getTextureDimensions(logoFile);
+                    double scaleX = dim.width / 200.0;
+                    double scaleY = dim.height / 65.0;
+                    double scale = 1.0;
+                    if (scaleX > 1 || scaleY > 1)
+                    {
+                        scale = 1.0 / Math.max(scaleX, scaleY);
+                    }
+                    dim.width *= scale;
+                    dim.height *= scale;
+                    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.getDisplayVersion(), selectedMod.getVersion()), offset, shifty);
+                shifty = drawLine(String.format("Mod ID: '%s' Mod State: %s", selectedMod.getModId(), 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);
+                int rightSide = this.field_73880_f - offset - 20;
+                if (rightSide > 20)
+                {
+                    this.getFontRenderer().func_78279_b(selectedMod.getMetadata().description, offset, shifty + 10, rightSide, 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);
+            }
+            GL11.glDisable(GL11.GL_BLEND);
+        }
+        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;
+        }
+    }
+
+    public boolean modIndexSelected(int var1)
+    {
+        return var1==selected;
+    }
+}

client/cpw/mods/fml/client/GuiModsMissing.java

@@ -0,0 +1,62 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import net.minecraft.client.gui.GuiErrorScreen;
+import cpw.mods.fml.common.MissingModsException;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
+
+public class GuiModsMissing extends GuiErrorScreen
+{
+
+    private MissingModsException modsMissing;
+
+    public GuiModsMissing(MissingModsException modsMissing)
+    {
+        super(null,null);
+        this.modsMissing = modsMissing;
+    }
+
+    @Override
+    public void func_73866_w_()
+    {
+        super.func_73866_w_();
+    }
+    @Override
+    public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_)
+    {
+        this.func_73873_v_();
+        int offset = Math.max(85 - modsMissing.missingMods.size() * 10, 10);
+        this.func_73732_a(this.field_73886_k, "Forge Mod Loader has found a problem with your minecraft installation", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, "The mods and versions listed below could not be found", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=5;
+        for (ArtifactVersion v : modsMissing.missingMods)
+        {
+            offset+=10;
+            if (v instanceof DefaultArtifactVersion)
+            {
+                DefaultArtifactVersion dav =  (DefaultArtifactVersion)v;
+                if (dav.getRange() != null && dav.getRange().isUnboundedAbove())
+                {
+                    this.func_73732_a(this.field_73886_k, String.format("%s : minimum version required is %s", v.getLabel(), dav.getRange().getLowerBoundString()), this.field_73880_f / 2, offset, 0xEEEEEE);
+                    continue;
+                }
+            }
+            this.func_73732_a(this.field_73886_k, String.format("%s : %s", v.getLabel(), v.getRangeString()), this.field_73880_f / 2, offset, 0xEEEEEE);
+        }
+        offset+=20;
+        this.func_73732_a(this.field_73886_k, "The file 'ForgeModLoader-client-0.log' contains more information", this.field_73880_f / 2, offset, 0xFFFFFF);
+    }
+}

client/cpw/mods/fml/client/GuiModsMissingForServer.java

@@ -0,0 +1,64 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.GuiSmallButton;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.util.StringTranslate;
+import cpw.mods.fml.common.network.ModMissingPacket;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+
+public class GuiModsMissingForServer extends GuiScreen
+{
+    private ModMissingPacket modsMissing;
+
+    public GuiModsMissingForServer(ModMissingPacket modsMissing)
+    {
+        this.modsMissing = modsMissing;
+    }
+
+    @Override
+    public void func_73866_w_()
+    {
+        this.field_73887_h.add(new GuiSmallButton(1, this.field_73880_f / 2 - 75, this.field_73881_g - 38, I18n.func_135053_a("gui.done")));
+    }
+
+    @Override
+    protected void func_73875_a(GuiButton p_73875_1_)
+    {
+        if (p_73875_1_.field_73742_g && p_73875_1_.field_73741_f == 1)
+        {
+            FMLClientHandler.instance().getClient().func_71373_a(null);
+        }
+    }
+    @Override
+    public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_)
+    {
+        this.func_73873_v_();
+        int offset = Math.max(85 - modsMissing.getModList().size() * 10, 10);
+        this.func_73732_a(this.field_73886_k, "Forge Mod Loader could not connect to this server", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset += 10;
+        this.func_73732_a(this.field_73886_k, "The mods and versions listed below could not be found", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset += 10;
+        this.func_73732_a(this.field_73886_k, "They are required to play on this server", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset += 5;
+        for (ArtifactVersion v : modsMissing.getModList())
+        {
+            offset += 10;
+            this.func_73732_a(this.field_73886_k, String.format("%s : %s", v.getLabel(), v.getRangeString()), this.field_73880_f / 2, offset, 0xEEEEEE);
+        }
+        super.func_73863_a(p_73863_1_, p_73863_2_, p_73863_3_);
+    }
+}

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

@@ -0,0 +1,413 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import java.util.List;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Gui;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.renderer.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.left + 1;
+        int var4 = this.left + this.listWidth - 7;
+        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;
+        this.client.field_71446_o.func_110577_a(Gui.field_110325_k);
+        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;
+        this.client.field_71446_o.func_110577_a(Gui.field_110325_k);
+        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,87 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import java.util.ArrayList;
+
+import net.minecraft.client.renderer.Tessellator;
+
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.LoaderState.ModState;
+import cpw.mods.fml.common.ModContainer;
+
+/**
+ * @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 - 10), this.left + 3 , var3 + 2, 0xFF2222);
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getDisplayVersion(), listWidth - 10), this.left + 3 , var3 + 12, 0xFF2222);
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a("DISABLED", listWidth - 10), this.left + 3 , var3 + 22, 0xFF2222);
+        }
+        else
+        {
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getName(), listWidth - 10), this.left + 3 , var3 + 2, 0xFFFFFF);
+            this.parent.getFontRenderer().func_78276_b(this.parent.getFontRenderer().func_78269_a(mc.getDisplayVersion(), listWidth - 10), 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 - 10), this.left + 3 , var3 + 22, 0xCCCCCC);
+        }
+    }
+
+}

client/cpw/mods/fml/client/GuiSortingProblem.java

@@ -0,0 +1,48 @@
+package cpw.mods.fml.client;
+
+import cpw.mods.fml.common.ModContainer;
+import cpw.mods.fml.common.toposort.ModSortingException;
+import cpw.mods.fml.common.toposort.ModSortingException.SortingExceptionData;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
+import net.minecraft.client.gui.GuiScreen;
+
+public class GuiSortingProblem extends GuiScreen {
+    private ModSortingException modSorting;
+    private SortingExceptionData<ModContainer> failedList;
+
+    public GuiSortingProblem(ModSortingException modSorting)
+    {
+        this.modSorting = modSorting;
+        this.failedList = modSorting.getExceptionData();
+    }
+
+    @Override
+    public void func_73866_w_()
+    {
+        super.func_73866_w_();
+    }
+
+    @Override
+    public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_)
+    {
+        this.func_73873_v_();
+        int offset = Math.max(85 - (failedList.getVisitedNodes().size() + 3) * 10, 10);
+        this.func_73732_a(this.field_73886_k, "Forge Mod Loader has found a problem with your minecraft installation", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, "A mod sorting cycle was detected and loading cannot continue", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, String.format("The first mod in the cycle is %s", failedList.getFirstBadNode()), this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, "The remainder of the cycle involves these mods", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=5;
+        for (ModContainer mc : failedList.getVisitedNodes())
+        {
+            offset+=10;
+            this.func_73732_a(this.field_73886_k, String.format("%s : before: %s, after: %s", mc.toString(), mc.getDependants(), mc.getDependencies()), this.field_73880_f / 2, offset, 0xEEEEEE);
+        }
+        offset+=20;
+        this.func_73732_a(this.field_73886_k, "The file 'ForgeModLoader-client-0.log' contains more information", this.field_73880_f / 2, offset, 0xFFFFFF);
+    }
+
+}

client/cpw/mods/fml/client/GuiWrongMinecraft.java

@@ -0,0 +1,47 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import net.minecraft.client.gui.GuiErrorScreen;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.WrongMinecraftVersionException;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+
+public class GuiWrongMinecraft extends GuiErrorScreen
+{
+    private WrongMinecraftVersionException wrongMC;
+    public GuiWrongMinecraft(WrongMinecraftVersionException wrongMC)
+    {
+        super(null,null);
+        this.wrongMC = wrongMC;
+    }
+    @Override
+    public void func_73866_w_()
+    {
+        super.func_73866_w_();
+    }
+    @Override
+    public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_)
+    {
+        this.func_73873_v_();
+        int offset = 75;
+        this.func_73732_a(this.field_73886_k, "Forge Mod Loader has found a problem with your minecraft installation", this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, String.format("The mod listed below does not want to run in Minecraft version %s", Loader.instance().getMinecraftModContainer().getVersion()), this.field_73880_f / 2, offset, 0xFFFFFF);
+        offset+=5;
+        offset+=10;
+        this.func_73732_a(this.field_73886_k, String.format("%s (%s) wants Minecraft %s", wrongMC.mod.getName(), wrongMC.mod.getModId(), wrongMC.mod.acceptableMinecraftVersionRange()), this.field_73880_f / 2, offset, 0xEEEEEE);
+        offset+=20;
+        this.func_73732_a(this.field_73886_k, "The file 'ForgeModLoader-client-0.log' contains more information", this.field_73880_f / 2, offset, 0xFFFFFF);
+    }
+}

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

@@ -0,0 +1,142 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client;
+
+import java.awt.Dimension;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+
+import javax.imageio.ImageIO;
+
+import org.lwjgl.opengl.ContextCapabilities;
+import org.lwjgl.opengl.GLContext;
+
+import com.google.common.collect.Maps;
+
+import cpw.mods.fml.common.FMLLog;
+
+import net.minecraft.client.Minecraft;
+
+public class TextureFXManager
+{
+    private static final TextureFXManager INSTANCE = new TextureFXManager();
+
+    private Minecraft client;
+
+    private Map<Integer,TextureHolder> texturesById = Maps.newHashMap();
+    private Map<String, TextureHolder> texturesByName = Maps.newHashMap();
+
+//    private TextureHelper helper;
+
+    void setClient(Minecraft client)
+    {
+        this.client = client;
+    }
+//    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;
+    }
+
+    public void fixTransparency(BufferedImage loadedImage, String textureName)
+    {
+        if (textureName.matches("^/mob/.*_eyes.*.png$"))
+        {
+            for (int x = 0; x < loadedImage.getWidth(); x++) {
+                for (int y = 0; y < loadedImage.getHeight(); y++) {
+                    int argb = loadedImage.getRGB(x, y);
+                    if ((argb & 0xff000000) == 0 && argb != 0) {
+                        loadedImage.setRGB(x, y, 0);
+                    }
+                }
+            }
+        }
+    }
+    public void bindTextureToName(String name, int index)
+    {
+        TextureHolder holder = new TextureHolder();
+        holder.textureId = index;
+        holder.textureName = name;
+        texturesById.put(index,holder);
+        texturesByName.put(name,holder);
+    }
+
+    public void setTextureDimensions(int index, int j, int k)
+    {
+        TextureHolder holder = texturesById.get(index);
+        if (holder == null)
+        {
+            return;
+        }
+        holder.x = j;
+        holder.y = k;
+    }
+
+    private class TextureHolder {
+        private int textureId;
+        private String textureName;
+        private int x;
+        private int y;
+    }
+
+    public Dimension getTextureDimensions(String texture)
+    {
+        return texturesByName.containsKey(texture) ? new Dimension(texturesByName.get(texture).x, texturesByName.get(texture).y) : new Dimension(1,1);
+    }
+
+
+//    public TextureHelper getHelper()
+//    {
+//        if (helper == null)
+//        {
+//            ContextCapabilities capabilities = GLContext.getCapabilities();
+//            boolean has43 = false;
+//            try
+//            {
+//                has43 = capabilities.getClass().getField("GL_ARB_copy_image").getBoolean(capabilities);
+//            }
+//            catch (Exception e)
+//            {
+//                //e.printStackTrace();
+//                // NOOP - LWJGL needs updating
+//                FMLLog.info("Forge Mod Loader has detected an older LWJGL version, new advanced texture animation features are disabled");
+//            }
+////            if (has43 && Boolean.parseBoolean(System.getProperty("fml.useGL43","true")))
+////            {
+////                FMLLog.info("Using the new OpenGL 4.3 advanced capability for animations");
+////                helper = new OpenGL43TextureHelper();
+////            }
+////            else
+//            {
+//                FMLLog.info("Not using advanced OpenGL 4.3 advanced capability for animations : OpenGL 4.3 is %s", has43 ? "available" : "not available");
+////                helper = new CopySubimageTextureHelper();
+//            }
+//        }
+//        return helper;
+//    }
+}

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

@@ -0,0 +1,81 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client.modloader;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.src.BaseMod;
+import net.minecraft.world.IBlockAccess;
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+
+/**
+ * @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,190 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client.modloader;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.logging.Level;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.NetHandler;
+import net.minecraft.network.packet.Packet250CustomPayload;
+import net.minecraft.src.BaseMod;
+import net.minecraft.client.*;
+import net.minecraft.client.entity.EntityClientPlayerMP;
+import net.minecraft.client.multiplayer.NetClientHandler;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+
+import com.google.common.base.Equivalence;
+import com.google.common.base.Supplier;
+import com.google.common.base.Suppliers;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.MapDifference.ValueDifference;
+import com.google.common.collect.MapMaker;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.client.registry.KeyBindingRegistry;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.modloader.BaseModProxy;
+import cpw.mods.fml.common.modloader.IModLoaderSidedHelper;
+import cpw.mods.fml.common.modloader.ModLoaderHelper;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+import cpw.mods.fml.common.network.EntitySpawnPacket;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+
+public class ModLoaderClientHelper implements IModLoaderSidedHelper
+{
+    public static int obtainBlockModelIdFor(BaseMod mod, boolean inventoryRenderer)
+    {
+        int renderId=RenderingRegistry.getNextAvailableRenderId();
+        ModLoaderBlockRendererHandler bri=new ModLoaderBlockRendererHandler(renderId, inventoryRenderer, mod);
+        RenderingRegistry.registerBlockHandler(bri);
+        return renderId;
+    }
+
+
+    public static void handleFinishLoadingFor(ModLoaderModContainer mc, Minecraft game)
+    {
+        FMLLog.log(mc.getModId(), Level.FINE, "Handling post startup activities for ModLoader mod %s", mc.getModId());
+        BaseMod mod = (BaseMod) mc.getMod();
+
+        Map<Class<? extends Entity>, Render> renderers = Maps.newHashMap(RenderManager.field_78727_a.field_78729_o);
+
+        try
+        {
+            FMLLog.log(mc.getModId(), Level.FINEST, "Requesting renderers from basemod %s", mc.getModId());
+            mod.addRenderer(renderers);
+            FMLLog.log(mc.getModId(), Level.FINEST, "Received %d renderers from basemod %s", renderers.size(), mc.getModId());
+        }
+        catch (Exception e)
+        {
+            FMLLog.log(mc.getModId(), Level.SEVERE, e, "A severe problem was detected with the mod %s during the addRenderer call. Continuing, but expect odd results", mc.getModId());
+        }
+
+        MapDifference<Class<? extends Entity>, Render> difference = Maps.difference(RenderManager.field_78727_a.field_78729_o, renderers, Equivalence.identity());
+
+        for ( Entry<Class<? extends Entity>, Render> e : difference.entriesOnlyOnLeft().entrySet())
+        {
+            FMLLog.log(mc.getModId(), Level.WARNING, "The mod %s attempted to remove an entity renderer %s from the entity map. This will be ignored.", mc.getModId(), e.getKey().getName());
+        }
+
+        for (Entry<Class<? extends Entity>, Render> e : difference.entriesOnlyOnRight().entrySet())
+        {
+            FMLLog.log(mc.getModId(), Level.FINEST, "Registering ModLoader entity renderer %s as instance of %s", e.getKey().getName(), e.getValue().getClass().getName());
+            RenderingRegistry.registerEntityRenderingHandler(e.getKey(), e.getValue());
+        }
+
+        for (Entry<Class<? extends Entity>, ValueDifference<Render>> e : difference.entriesDiffering().entrySet())
+        {
+            FMLLog.log(mc.getModId(), Level.FINEST, "Registering ModLoader entity rendering override for %s as instance of %s", e.getKey().getName(), e.getValue().rightValue().getClass().getName());
+            RenderingRegistry.registerEntityRenderingHandler(e.getKey(), e.getValue().rightValue());
+        }
+
+        try
+        {
+            mod.registerAnimation(game);
+        }
+        catch (Exception e)
+        {
+            FMLLog.log(mc.getModId(), Level.SEVERE, e, "A severe problem was detected with the mod %s during the registerAnimation call. Continuing, but expect odd results", mc.getModId());
+        }
+    }
+
+    public ModLoaderClientHelper(Minecraft client)
+    {
+        this.client = client;
+        ModLoaderHelper.sidedHelper = this;
+        keyBindingContainers = Multimaps.newMultimap(Maps.<ModLoaderModContainer, Collection<ModLoaderKeyBindingHandler>>newHashMap(), new Supplier<Collection<ModLoaderKeyBindingHandler>>()
+        {
+            @Override
+            public Collection<ModLoaderKeyBindingHandler> get()
+            {
+                return Collections.singleton(new ModLoaderKeyBindingHandler());
+            }
+        });
+    }
+
+    private Minecraft client;
+    private static Multimap<ModLoaderModContainer, ModLoaderKeyBindingHandler> keyBindingContainers;
+
+    @Override
+    public void finishModLoading(ModLoaderModContainer mc)
+    {
+        handleFinishLoadingFor(mc, client);
+    }
+
+
+    public static void registerKeyBinding(BaseModProxy mod, KeyBinding keyHandler, boolean allowRepeat)
+    {
+        ModLoaderModContainer mlmc = (ModLoaderModContainer) Loader.instance().activeModContainer();
+        ModLoaderKeyBindingHandler handler = Iterables.getOnlyElement(keyBindingContainers.get(mlmc));
+        handler.setModContainer(mlmc);
+        handler.addKeyBinding(keyHandler, allowRepeat);
+        KeyBindingRegistry.registerKeyBinding(handler);
+    }
+
+
+    @Override
+    public Object getClientGui(BaseModProxy mod, EntityPlayer player, int ID, int x, int y, int z)
+    {
+        return ((net.minecraft.src.BaseMod)mod).getContainerGUI((EntityClientPlayerMP) player, ID, x, y, z);
+    }
+
+
+    @Override
+    public Entity spawnEntity(BaseModProxy mod, EntitySpawnPacket input, EntityRegistration er)
+    {
+        return ((net.minecraft.src.BaseMod)mod).spawnEntity(er.getModEntityId(), client.field_71441_e, input.scaledX, input.scaledY, input.scaledZ);
+    }
+
+
+    @Override
+    public void sendClientPacket(BaseModProxy mod, Packet250CustomPayload packet)
+    {
+        ((net.minecraft.src.BaseMod)mod).clientCustomPayload(client.field_71439_g.field_71174_a, packet);
+    }
+
+    private Map<INetworkManager,NetHandler> managerLookups = new MapMaker().weakKeys().weakValues().makeMap();
+    @Override
+    public void clientConnectionOpened(NetHandler netClientHandler, INetworkManager manager, BaseModProxy mod)
+    {
+        managerLookups.put(manager, netClientHandler);
+        ((BaseMod)mod).clientConnect((NetClientHandler)netClientHandler);
+    }
+
+
+    @Override
+    public boolean clientConnectionClosed(INetworkManager manager, BaseModProxy mod)
+    {
+        if (managerLookups.containsKey(manager))
+        {
+            ((BaseMod)mod).clientDisconnect((NetClientHandler) managerLookups.get(manager));
+            return true;
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,110 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client.modloader;
+
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+
+import org.lwjgl.input.Mouse;
+
+import com.google.common.collect.ObjectArrays;
+import com.google.common.primitives.Booleans;
+
+import net.minecraft.client.settings.KeyBinding;
+import cpw.mods.fml.client.registry.KeyBindingRegistry;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+
+/**
+ * @author cpw
+ *
+ */
+public class ModLoaderKeyBindingHandler extends KeyBindingRegistry.KeyHandler
+{
+    private ModLoaderModContainer modContainer;
+    private List<KeyBinding> helper;
+    private boolean[] active = new boolean[0];
+    private boolean[] mlRepeats = new boolean[0];
+    private boolean[] armed = new boolean[0];
+
+    public ModLoaderKeyBindingHandler()
+    {
+        super(new KeyBinding[0], new boolean[0]);
+    }
+
+    void setModContainer(ModLoaderModContainer modContainer)
+    {
+        this.modContainer = modContainer;
+    }
+
+    public void fireKeyEvent(KeyBinding kb)
+    {
+        ((net.minecraft.src.BaseMod)modContainer.getMod()).keyboardEvent(kb);
+    }
+
+    @Override
+    public void keyDown(EnumSet<TickType> type, KeyBinding kb, boolean end, boolean repeats)
+    {
+        if (!end)
+        {
+            return;
+        }
+        int idx = helper.indexOf(kb);
+        if (type.contains(TickType.CLIENT))
+        {
+            armed[idx] = true;
+        }
+        if (armed[idx] && type.contains(TickType.RENDER) && (!active[idx] || mlRepeats[idx]))
+        {
+            fireKeyEvent(kb);
+            active[idx] = true;
+            armed[idx] = false;
+        }
+    }
+
+    @Override
+    public void keyUp(EnumSet<TickType> type, KeyBinding kb, boolean end)
+    {
+        if (!end)
+        {
+            return;
+        }
+        int idx = helper.indexOf(kb);
+        active[idx] = false;
+    }
+
+    @Override
+    public EnumSet<TickType> ticks()
+    {
+        return EnumSet.of(TickType.CLIENT, TickType.RENDER);
+    }
+
+    @Override
+    public String getLabel()
+    {
+        return modContainer.getModId() +" KB "+keyBindings[0].field_74512_d;
+    }
+
+    void addKeyBinding(KeyBinding binding, boolean repeats)
+    {
+        this.keyBindings = ObjectArrays.concat(this.keyBindings, binding);
+        this.repeatings = new boolean[this.keyBindings.length];
+        Arrays.fill(this.repeatings, true);
+        this.active = new boolean[this.keyBindings.length];
+        this.armed = new boolean[this.keyBindings.length];
+        this.mlRepeats = Booleans.concat(this.mlRepeats, new boolean[] { repeats });
+        this.keyDown = new boolean[this.keyBindings.length];
+        this.helper = Arrays.asList(this.keyBindings);
+    }
+}

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

@@ -0,0 +1,41 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client.registry;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+import net.minecraft.client.renderer.tileentity.TileEntityRenderer;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.tileentity.TileEntity;
+
+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,28 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client.registry;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.world.IBlockAccess;
+
+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,199 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client.registry;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.Set;
+
+import net.minecraft.client.settings.GameSettings;
+import net.minecraft.client.settings.KeyBinding;
+
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+
+import cpw.mods.fml.common.ITickHandler;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.common.registry.TickRegistry;
+import cpw.mods.fml.relauncher.Side;
+
+public class KeyBindingRegistry
+{
+    /**
+     * Register a KeyHandler to the game. This handler will be called on certain tick events
+     * if any of its key is inactive or has recently changed state
+     *
+     * @param handler
+     */
+    public static void registerKeyBinding(KeyHandler handler) {
+        instance().keyHandlers.add(handler);
+        if (!handler.isDummy)
+        {
+            TickRegistry.registerTickHandler(handler, Side.CLIENT);
+        }
+    }
+
+
+    /**
+     * Extend this class to register a KeyBinding and recieve callback
+     * when the key binding is triggered
+     *
+     * @author cpw
+     *
+     */
+    public static abstract class KeyHandler implements ITickHandler
+    {
+        protected KeyBinding[] keyBindings;
+        protected boolean[] keyDown;
+        protected boolean[] repeatings;
+        private boolean isDummy;
+
+        /**
+         * Pass an array of keybindings and a repeat flag for each one
+         *
+         * @param keyBindings
+         * @param repeatings
+         */
+        public KeyHandler(KeyBinding[] keyBindings, boolean[] repeatings)
+        {
+            assert keyBindings.length == repeatings.length : "You need to pass two arrays of identical length";
+            this.keyBindings = keyBindings;
+            this.repeatings = repeatings;
+            this.keyDown = new boolean[keyBindings.length];
+        }
+
+
+        /**
+         * Register the keys into the system. You will do your own keyboard management elsewhere. No events will fire
+         * if you use this method
+         *
+         * @param keyBindings
+         */
+        public KeyHandler(KeyBinding[] keyBindings)
+        {
+            this.keyBindings = keyBindings;
+            this.isDummy = true;
+        }
+
+        public KeyBinding[] getKeyBindings()
+        {
+            return this.keyBindings;
+        }
+
+        /**
+         * Not to be overridden - KeyBindings are tickhandlers under the covers
+         */
+        @Override
+        public final void tickStart(EnumSet<TickType> type, Object... tickData)
+        {
+            keyTick(type, false);
+        }
+
+        /**
+         * Not to be overridden - KeyBindings are tickhandlers under the covers
+         */
+        @Override
+        public final void tickEnd(EnumSet<TickType> type, Object... tickData)
+        {
+            keyTick(type, true);
+        }
+
+        private void keyTick(EnumSet<TickType> type, boolean tickEnd)
+        {
+            for (int i = 0; i < keyBindings.length; i++)
+            {
+                KeyBinding keyBinding = keyBindings[i];
+                int keyCode = keyBinding.field_74512_d;
+                boolean state = (keyCode < 0 ? Mouse.isButtonDown(keyCode + 100) : Keyboard.isKeyDown(keyCode));
+                if (state != keyDown[i] || (state && repeatings[i]))
+                {
+                    if (state)
+                    {
+                        keyDown(type, keyBinding, tickEnd, state!=keyDown[i]);
+                    }
+                    else
+                    {
+                        keyUp(type, keyBinding, tickEnd);
+                    }
+                    if (tickEnd)
+                    {
+                        keyDown[i] = state;
+                    }
+                }
+
+            }
+        }
+
+        /**
+         * Called when the key is first in the down position on any tick from the {@link #ticks()}
+         * set. Will be called subsequently with isRepeat set to true
+         *
+         * @see #keyUp(EnumSet, KeyBinding, boolean)
+         *
+         * @param types the type(s) of tick that fired when this key was first down
+         * @param tickEnd was it an end or start tick which fired the key
+         * @param isRepeat is it a repeat key event
+         */
+        public abstract void keyDown(EnumSet<TickType> types, KeyBinding kb, boolean tickEnd, boolean isRepeat);
+        /**
+         * Fired once when the key changes state from down to up
+         *
+         * @see #keyDown(EnumSet, KeyBinding, boolean, boolean)
+         *
+         * @param types the type(s) of tick that fired when this key was first down
+         * @param tickEnd was it an end or start tick which fired the key
+         */
+        public abstract void keyUp(EnumSet<TickType> types, KeyBinding kb, boolean tickEnd);
+
+
+        /**
+         * This is the list of ticks for which the key binding should trigger. The only
+         * valid ticks are client side ticks, obviously.
+         *
+         * @see cpw.mods.fml.common.ITickHandler#ticks()
+         */
+        public abstract EnumSet<TickType> ticks();
+    }
+
+    private static final KeyBindingRegistry INSTANCE = new KeyBindingRegistry();
+
+    private Set<KeyHandler> keyHandlers = Sets.newLinkedHashSet();
+
+    @Deprecated
+    public static KeyBindingRegistry instance()
+    {
+        return INSTANCE;
+    }
+
+
+    public void uploadKeyBindingsToGame(GameSettings settings)
+    {
+        ArrayList<KeyBinding> harvestedBindings = Lists.newArrayList();
+        for (KeyHandler key : keyHandlers)
+        {
+            for (KeyBinding kb : key.keyBindings)
+            {
+                harvestedBindings.add(kb);
+            }
+        }
+        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,176 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.client.registry;
+
+import java.util.List;
+import java.util.Map;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.entity.*;
+import net.minecraft.entity.Entity;
+import net.minecraft.world.IBlockAccess;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.ObjectArrays;
+
+import cpw.mods.fml.client.TextureFXManager;
+
+/**
+ * @author cpw
+ *
+ */
+public class RenderingRegistry
+{
+    private static final RenderingRegistry INSTANCE = new RenderingRegistry();
+
+    private int nextRenderId = 40;
+
+    private Map<Integer, ISimpleBlockRenderingHandler> blockRenderers = Maps.newHashMap();
+
+    private List<EntityRendererInfo> entityRenderers = Lists.newArrayList();
+
+    /**
+     * Add a new armour prefix to the RenderPlayer
+     *
+     * @param armor
+     */
+    public static int addNewArmourRendererPrefix(String armor)
+    {
+        RenderBiped.field_82424_k = ObjectArrays.concat(RenderBiped.field_82424_k, armor);
+        return RenderBiped.field_82424_k.length - 1;
+    }
+
+    /**
+     * Register an entity rendering handler. This will, after mod initialization, be inserted into the main
+     * render map for entities
+     *
+     * @param entityClass
+     * @param renderer
+     */
+    public static void registerEntityRenderingHandler(Class<? extends Entity> entityClass, Render renderer)
+    {
+        instance().entityRenderers.add(new EntityRendererInfo(entityClass, renderer));
+    }
+
+    /**
+     * Register a simple block rendering handler
+     *
+     * @param handler
+     */
+    public static void registerBlockHandler(ISimpleBlockRenderingHandler handler)
+    {
+        instance().blockRenderers.put(handler.getRenderId(), handler);
+    }
+
+    /**
+     * Register the simple block rendering handler
+     * This version will not call getRenderId on the passed in handler, instead using the supplied ID, so you
+     * can easily re-use the same rendering handler for multiple IDs
+     *
+     * @param renderId
+     * @param handler
+     */
+    public static void registerBlockHandler(int renderId, ISimpleBlockRenderingHandler handler)
+    {
+        instance().blockRenderers.put(renderId, handler);
+    }
+    /**
+     * Get the next available renderId from the block render ID list
+     */
+    public static int getNextAvailableRenderId()
+    {
+        return instance().nextRenderId++;
+    }
+
+    /**
+     * Add a texture override for the given path and return the used index
+     *
+     * @param fileToOverride
+     * @param fileToAdd
+     */
+    @Deprecated
+    public static int addTextureOverride(String fileToOverride, String fileToAdd)
+    {
+        return -1;
+    }
+
+    /**
+     * Add a texture override for the given path and index
+     *
+     * @param path
+     * @param overlayPath
+     * @param index
+     */
+    public static void addTextureOverride(String path, String overlayPath, int index)
+    {
+//        TextureFXManager.instance().addNewTextureOverride(path, overlayPath, index);
+    }
+
+    /**
+     * Get and reserve a unique texture index for the supplied path
+     *
+     * @param path
+     */
+    @Deprecated
+    public static int getUniqueTextureIndex(String path)
+    {
+        return -1;
+    }
+
+    @Deprecated public static RenderingRegistry instance()
+    {
+        return INSTANCE;
+    }
+
+    private static 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 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);
+    }
+
+    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);
+    }
+
+    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);
+            info.renderer.func_76976_a(RenderManager.field_78727_a);
+        }
+    }
+}

client/net/minecraft/src/BaseMod.java

@@ -0,0 +1,456 @@
+/*
+ * 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 static cpw.mods.fml.relauncher.Side.CLIENT;
+
+import java.util.Map;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.*;
+import net.minecraft.client.entity.EntityClientPlayerMP;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.multiplayer.NetClientHandler;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.NetServerHandler;
+import net.minecraft.network.packet.NetHandler;
+import net.minecraft.network.packet.Packet250CustomPayload;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.common.FMLLog;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.relauncher.SideOnly;
+
+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 = mc.field_71441_e != null;
+        // 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();
+
+        boolean hasWorld = mc.field_71441_e != null;
+
+        if (tickEnd && ( tick==TickType.RENDER || ( tick==TickType.CLIENT && hasWorld))) {
+            return onTickInGUI((Float) data[0], mc, mc.field_71462_r);
+        }
+        return true;
+    }
+
+   /*
+    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);
+        }
+    }
+
+    @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
+     */
+    public int addFuel(int id, int metadata)
+    {
+        return 0;
+    }
+
+    @SideOnly(CLIENT)
+    public void addRenderer(Map<Class<? extends Entity>, Render> renderers)
+    {
+    }
+
+    /**
+     * 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)
+    {
+    }
+
+    /**
+     * Callback to return a gui screen to display
+     * @param player
+     * @param containerID
+     * @param x
+     * @param y
+     * @param z
+     */
+    @SideOnly(CLIENT)
+    public GuiContainer getContainerGUI(EntityClientPlayerMP player, int containerID, int x, int y, int z)
+    {
+        return null;
+    }
+
+    /**
+     * Return the name of your mod. Defaults to the class name
+     */
+    public String getName()
+    {
+        return getClass().getSimpleName();
+    }
+
+    /**
+     * Get your mod priorities
+     */
+    public String getPriorities()
+    {
+        return "";
+    }
+
+    /**
+     * Return the version of your mod
+     */
+    public abstract String getVersion();
+
+    @SideOnly(CLIENT)
+    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
+     */
+    @SideOnly(CLIENT)
+    public boolean onTickInGame(float time, Minecraft minecraftInstance)
+    {
+        return false;
+    }
+
+    public boolean onTickInGame(MinecraftServer minecraftServer)
+    {
+        return false;
+    }
+
+    @SideOnly(CLIENT)
+    public boolean onTickInGUI(float tick, Minecraft game, GuiScreen gui)
+    {
+        return false;
+    }
+
+    /**
+     * Only implemented on the client side
+     * {@link #serverChat(NetServerHandler, String)}
+     *
+     * @param text
+     */
+    @Override
+    public void clientChat(String text)
+    {
+    }
+
+    /**
+     * Called when a client connects
+     * @param handler
+     */
+    @SideOnly(CLIENT)
+    public void clientConnect(NetClientHandler handler)
+    {
+
+    }
+
+    /**
+     * Called when the client disconnects
+     * @param handler
+     */
+    @SideOnly(CLIENT)
+    public void clientDisconnect(NetClientHandler handler)
+    {
+
+    }
+    /**
+     * Called client side to receive a custom payload for this mod
+     * 
+     * NOTE: this method is not provided in Risugami's implementation of BaseMod!
+     *
+     * @param packet
+     */
+    @Override
+    public void receiveCustomPacket(Packet250CustomPayload packet)
+    {
+    }
+
+    @SideOnly(CLIENT)
+    public void registerAnimation(Minecraft game)
+    {
+
+    }
+
+    @SideOnly(CLIENT)
+    public void renderInvBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
+    {
+
+    }
+
+    @SideOnly(CLIENT)
+    public boolean renderWorldBlock(RenderBlocks renderer, IBlockAccess world, int x, int y, int z, Block block, int modelID)
+    {
+        return false;
+
+    }
+    /*
+     * NOTE: this method is not provided in Risugami's implementation of BaseMod!
+     */
+    @Override
+    public void serverConnect(NetHandler handler) {
+
+    }
+
+    @Override
+    public void serverCustomPayload(NetServerHandler handler, Packet250CustomPayload packet)
+    {
+
+    }
+
+    /*
+     * NOTE: this method is not provided in Risugami's implementation of BaseMod!
+     */
+    @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 chat message is received. Return true to stop further processing
+     */
+    @Override
+    public void serverChat(NetServerHandler source, String message)
+    {
+    }
+    /**
+     * Called when a new client logs in.
+     * 
+     * NOTE: this method is not provided in Risugami's implementation of BaseMod!
+     *
+     * @param player
+     */
+    @Override
+    public void onClientLogin(EntityPlayer player)
+    {
+    }
+
+    /**
+     * Called when a client logs out of the server.
+     * 
+     * NOTE: this method is not provided in Risugami's implementation of BaseMod!
+     */
+    @Override
+    public void onClientLogout(INetworkManager mgr)
+    {
+
+    }
+
+    /**
+     * Spawn the entity of the supplied type, if it is your mod's
+     */
+    @SideOnly(CLIENT)
+    public Entity spawnEntity(int entityId, World world, double scaledX, double scaledY, double scaledZ)
+    {
+        return null;
+    }
+
+    public void clientCustomPayload(NetClientHandler handler, Packet250CustomPayload packet)
+    {
+
+    }
+
+}

client/net/minecraft/src/EntityRendererProxy.java

@@ -0,0 +1,35 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package net.minecraft.src;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.EntityRenderer;
+
+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,76 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package net.minecraft.src;
+
+import java.awt.Dimension;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.world.IBlockAccess;
+
+import cpw.mods.fml.client.TextureFXManager;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+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()
+    {
+        Logger l = Logger.getLogger("FMLRenderAccessLibrary");
+        l.setParent(FMLLog.getLogger());
+        return l;
+    }
+
+    public static void log(Level level, String message)
+    {
+        FMLLog.log("FMLRenderAccessLibrary", level, message);
+    }
+
+    public static void log(Level level, String message, Throwable throwable)
+    {
+        FMLLog.log(level, throwable, message);
+    }
+
+    @SuppressWarnings("deprecation")
+    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);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static void renderInventoryBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
+    {
+        RenderingRegistry.instance().renderInventoryBlock(renderer, block, metadata, modelID);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static boolean renderItemAsFull3DBlock(int modelId)
+    {
+        return RenderingRegistry.instance().renderItemAsFull3DBlock(modelId);
+    }
+
+//    public static void doTextureCopy(Texture atlas, Texture source, int targetX, int targetY)
+//    {
+//        TextureFXManager.instance().getHelper().doTextureCopy(atlas, source, targetX, targetY);
+//    }
+}

client/net/minecraft/src/MLProp.java

@@ -0,0 +1,49 @@
+/*
+ * 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 static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * @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,916 @@
+/*
+ * 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 static cpw.mods.fml.relauncher.Side.CLIENT;
+
+import java.awt.image.BufferedImage;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockDispenser;
+import net.minecraft.client.*;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.multiplayer.NetClientHandler;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.command.ICommand;
+import net.minecraft.dispenser.IBehaviorDispenseItem;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.NetServerHandler;
+import net.minecraft.network.packet.Packet;
+import net.minecraft.network.packet.Packet1Login;
+import net.minecraft.network.packet.Packet250CustomPayload;
+import net.minecraft.server.*;
+import net.minecraft.stats.Achievement;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldType;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraft.world.chunk.IChunkProvider;
+import cpw.mods.fml.client.FMLClientHandler;
+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.ObfuscationReflectionHelper;
+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.PacketDispatcher;
+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.relauncher.SideOnly;
+import cpw.mods.fml.server.FMLServerHandler;
+
+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();
+
+    /**
+     * Adds localization info for an achievement, Not used on the server.
+     *
+     * @param achievement The achievement to name
+     * @param name The name
+     * @param description The 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 GameRegistry#getFuelValue(ItemStack)}
+     *
+     * @param id The Item ID
+     * @param metadata The Item Metadata
+     * @return The fuel strength, in ticks, 0 if unhandled
+     */
+    @Deprecated
+    public static int addAllFuel(int id, int metadata)
+    {
+        return 0;
+    }
+
+    @Deprecated
+    @SideOnly(CLIENT)
+    public static void addAllRenderers(Map<Class<? extends Entity>, Render> renderers)
+    {
+    }
+
+    /**
+     * Adds a new prefix to the armor texture list
+     *
+     * {@link RenderingRegistry#addNewArmourRendererPrefix(String)}
+     *
+     * @param armor The new armor prefix
+     * @return The new armor index
+     */
+    @SideOnly(CLIENT)
+    public static int addArmor(String armor)
+    {
+        return RenderingRegistry.addNewArmourRendererPrefix(armor);
+    }
+
+    /**
+     * This method adds the supplied biome to the set of candidate biomes for the default world generator type.
+     *
+     * @param biome The biome to add
+     */
+    public static void addBiome(BiomeGenBase biome)
+    {
+        GameRegistry.addBiome(biome);
+    }
+
+    public static void addEntityTracker(BaseMod mod, Class<? extends Entity> entityClass, int entityTypeId, int updateRange, int updateInterval, boolean sendVelocityInfo)
+    {
+        ModLoaderHelper.buildEntityTracker(mod, entityClass, entityTypeId, updateRange, updateInterval, sendVelocityInfo);
+    }
+
+    public static void addCommand(ICommand command)
+    {
+        ModLoaderHelper.addCommand(command);
+    }
+
+    /**
+     * Add a behaviour to the dispenser
+     *
+     * @param item
+     * @param behavior
+     */
+    public static void addDispenserBehavior(Item item, IBehaviorDispenseItem behavior)
+    {
+    	BlockDispenser.field_82527_a.func_82595_a(item, behavior);
+    }
+    /**
+     * Add localization for the specified string
+     *
+     * @param key Key
+     * @param value Value
+     */
+    public static void addLocalization(String key, String value)
+    {
+        addLocalization(key, "en_US", value);
+    }
+
+    /**
+     * Add localization for the specified string
+     *
+     * @param key Key
+     * @param lang Language identifier
+     * @param value 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 Item to name
+     * @param name The name to give it
+     */
+    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 Item to name
+     * @param lang Languge identifier
+     * @param name Name to give it
+     */
+    public static void addName(Object instance, String lang, String name)
+    {
+        LanguageRegistry.instance().addNameForObject(instance, lang, name);
+    }
+
+    /**
+     * Attempts to register a small image to be applied to a larger texture image,
+     * typically how old ModLoader mods add custom Item/Block textures.
+     *
+     * Forge mods should use setTextureFile in Item/Block
+     *
+     * Will return the icon index it was applied to.
+     *
+     * Unimplemented on the server as it does not render textures
+     *
+     * @param fileToOverride The texture to apply the new image to
+     * @param fileToAdd The new image
+     * @return The 'icon index' in the main image that the new image will be applied to
+     */
+    @Deprecated
+    @SideOnly(CLIENT)
+    public static int addOverride(String fileToOverride, String fileToAdd)
+    {
+        return RenderingRegistry.addTextureOverride(fileToOverride, fileToAdd);
+    }
+
+    /**
+     * Attempts to register a small image to be applied to a larger texture image,
+     * typically how old ModLoader mods add custom Item/Block textures.
+     *
+     * Forge mods should use setTextureFile in Item/Block
+     *
+     * Unimplemented on the server as it does not render textures
+     *
+     * @param path The texture to apply the new image to
+     * @param overlayPath The new image
+     * @param index Where on the texture to apply it
+     */
+    @SideOnly(CLIENT)
+    public static void addOverride(String path, String overlayPath, int index)
+    {
+        RenderingRegistry.addTextureOverride(path, overlayPath, index);
+    }
+
+    /**
+     * Add a Shaped Recipe
+     *
+     * @param output The result
+     * @param params The input
+     */
+    public static void addRecipe(ItemStack output, Object... params)
+    {
+        GameRegistry.addRecipe(output, params);
+    }
+
+    /**
+     * Add a shapeless recipe
+     *
+     * @param output The result
+     * @param params The input
+     */
+    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 new product to be smelted
+     *
+     * @param input
+     * @param output
+     */
+    public static void addSmelting(int input, ItemStack output, float experience)
+    {
+        GameRegistry.addSmelting(input, output, experience);
+    }
+    /**
+     * 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);
+    }
+
+    public static void addTrade(int profession, TradeEntry entry)
+    {
+        ModLoaderHelper.registerTrade(profession, entry);
+    }
+    /**
+     * Send a packet from the client
+     * @param packet
+     */
+    public static void clientSendPacket(Packet packet)
+    {
+        PacketDispatcher.sendPacketToServer(packet);
+    }
+
+    /**
+     * This method is a call in hook from modified external code. Implemented elsewhere.
+     *
+     * @param world
+     * @param x
+     * @param y
+     * @param z
+     * @param xVel
+     * @param zVel
+     * @param item
+     * @return Always false, not implemented here
+     */
+    @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 A list containing all loaded ModLoader mods
+     */
+    public static List<BaseMod> getLoadedMods()
+    {
+        return ModLoaderModContainer.findAll(BaseMod.class);
+    }
+
+    /**
+     * Get a logger instance {@link FMLCommonHandler#getFMLLogger()}
+     *
+     * @return The current logger
+     */
+    public static Logger getLogger()
+    {
+        return FMLLog.getLogger();
+    }
+
+    @SideOnly(CLIENT)
+    public static Minecraft getMinecraftInstance()
+    {
+        return FMLClientHandler.instance().getClient();
+    }
+
+    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 The value in the specified field.
+     */
+    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 The value in the specified field.
+     */
+    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
+     *
+     */
+    @SideOnly(CLIENT)
+    public static int getUniqueBlockModelID(BaseMod mod, boolean inventoryRenderer)
+    {
+        return ModLoaderClientHelper.obtainBlockModelIdFor(mod, inventoryRenderer);
+    }
+
+    /**
+     * Get a new unique entity id
+     * {@link EntityRegistry#findGlobalUniqueEntityId()}
+     *
+     * @return A unique entity ID
+     */
+    public static int getUniqueEntityId()
+    {
+        return EntityRegistry.findGlobalUniqueEntityId();
+    }
+
+    @Deprecated
+    @SideOnly(CLIENT)
+    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 If the channel is registered to the current connection.
+     */
+    public static boolean isChannelActive(EntityPlayer player, String channel)
+    {
+        return NetworkRegistry.instance().isChannelActive(channel, (Player)player);
+    }
+
+    @SideOnly(CLIENT)
+    public static boolean isGUIOpen(Class<? extends GuiScreen> gui)
+    {
+        return FMLClientHandler.instance().isGUIOpen(gui);
+    }
+
+    /**
+     * Is the named mod loaded?
+     * {@link Loader#isModLoaded(String)}
+     *
+     * @param modname
+     * @return If the specified mod is loaded
+     */
+    public static boolean isModLoaded(String modname)
+    {
+        return Loader.isModLoaded(modname);
+    }
+
+    /**
+     * Implemented elsewhere
+     */
+    @Deprecated
+    public static void loadConfig()
+    {
+    }
+
+//    @SideOnly(CLIENT)
+//    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
+    @SideOnly(CLIENT)
+    public static void onTick(float tick, Minecraft game)
+    {
+    }
+
+    @SideOnly(CLIENT)
+    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.
+     *
+     * @param packet
+     */
+    @Deprecated
+    public static void receivePacket(Packet250CustomPayload packet)
+    {
+    }
+
+    @Deprecated
+    @SideOnly(CLIENT)
+    public static KeyBinding[] registerAllKeys(KeyBinding[] keys)
+    {
+        return keys;
+    }
+
+//    @Deprecated
+//    @SideOnly(CLIENT)
+//    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);
+    }
+
+    public static void registerContainerID(BaseMod mod, int id)
+    {
+        ModLoaderHelper.buildGuiHelper(mod, id);
+    }
+    /**
+     * 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);
+    }
+
+    @SideOnly(CLIENT)
+    public static void registerKey(BaseMod mod, KeyBinding keyHandler, boolean allowRepeat)
+    {
+        ModLoaderClientHelper.registerKeyBinding(mod, keyHandler, allowRepeat);
+    }
+
+    /**
+     * Register the mod for packets on this channel.
+     * {@link NetworkRegistry#registerChannel(IPacketHandler, 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);
+    }
+
+    @SideOnly(CLIENT)
+    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
+    @SideOnly(CLIENT)
+    public static boolean renderBlockIsItemFull3D(int modelID)
+    {
+        return RenderingRegistry.instance().renderItemAsFull3DBlock(modelID);
+    }
+
+    @Deprecated
+    @SideOnly(CLIENT)
+    public static void renderInvBlock(RenderBlocks renderer, Block block, int metadata, int modelID)
+    {
+        RenderingRegistry.instance().renderInventoryBlock(renderer, block, metadata, modelID);
+    }
+
+    @Deprecated
+    @SideOnly(CLIENT)
+    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()
+    {
+    }
+
+    /**
+     * Send a packet from client to server
+     *
+     * @param packet
+     */
+    public static void sendPacket(Packet packet) {
+        PacketDispatcher.sendPacketToServer(packet);
+    }
+    /**
+     * Send a chat message to the server
+     *
+     * @param text
+     */
+    @Deprecated
+    public static void serverChat(String text)
+    {
+    }
+
+    @Deprecated
+    @SideOnly(CLIENT)
+    public static void serverLogin(NetClientHandler handler, Packet1Login loginPacket)
+    {
+    }
+
+    public static void serverSendPacket(NetServerHandler handler, Packet packet)
+    {
+        if (handler != null)
+        {
+            PacketDispatcher.sendPacketToPlayer(packet, (Player)handler.getPlayer());
+        }
+    }
+    public static void serverOpenWindow(EntityPlayerMP player, Container container, int ID, int x, int y, int z)
+    {
+        ModLoaderHelper.openGui(ID, player, container, x, y, z);
+    }
+
+    /**
+     * 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.
+     *
+     * @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.
+     *
+     * @param player
+     * @param item
+     */
+    @Deprecated
+    public static void takenFromFurnace(EntityPlayer player, ItemStack item)
+    {
+    }
+
+    /**
+     * Throw the offered exception. Likely will stop the game.
+     *
+     * @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/TradeEntry.java

@@ -0,0 +1,42 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package net.minecraft.src;
+
+/**
+ * Compatibility class for ModLoader -- do not use
+ *
+ * @author cpw
+ *
+ */
+public class TradeEntry
+{
+    public final int id;
+    public float chance;
+    public boolean buying;
+    public int min = 0;
+    public int max = 0;
+
+    public TradeEntry(int id, float chance, boolean buying, int min, int max)
+    {
+        this.id = id;
+        this.chance = chance;
+        this.buying = buying;
+        this.min = min;
+        this.max = max;
+    }
+
+    public TradeEntry(int id, float chance, boolean buying)
+    {
+        this(id, chance, buying, 0, 0);
+    }
+}

commands.patch

@@ -0,0 +1,87 @@
+--- commands.py
++++ commands.py
+@@ -139,6 +139,8 @@
+             fieldnames = csvreader.fieldnames
+     return set(fieldnames)
+ 
++def commands_sanity_check():
++    print '    Commands patch applied successfully'
+ 
+ class Commands(object):
+     """Contains the commands and initialisation for a full mcp run"""
+@@ -943,6 +945,8 @@
+         binlk = {CLIENT: self.binclient, SERVER: self.binserver}
+         testlk = {CLIENT: self.testclient, SERVER: self.testserver}
+ 
++        if side == SERVER and not os.path.exists(os.path.join(binlk[side], os.path.normpath(testlk[side] + '.class'))):
++            return self.checkbins(CLIENT)
+         if not os.path.exists(os.path.join(binlk[side], os.path.normpath(testlk[side] + '.class'))):
+             return False
+         return True
+@@ -1274,6 +1278,9 @@
+         pathbinlk = {CLIENT: self.binclient, SERVER: self.binserver}
+         pathsrclk = {CLIENT: self.srcclient, SERVER: self.srcserver}
+         pathlog = {CLIENT: self.clientrecomplog, SERVER: self.serverrecomplog}
++        
++        if side == SERVER: #Warn about server because FML recombines it into client
++            self.logger.info('Server side recompiling might be skipped, this is normal, do not complain to FML/Forge team about server side.')
+ 
+         if not os.path.exists(pathbinlk[side]):
+             os.makedirs(pathbinlk[side])
+@@ -1331,7 +1338,7 @@
+             raise
+ 
+     def startserver(self):
+-        classpath = [self.binserver] + self.cpathserver
++        classpath = [self.binclient, self.srcclient] + self.cpathserver
+         classpath = [os.path.join('..', p) for p in classpath]
+         classpath = os.pathsep.join(classpath)
+         os.chdir(self.dirjars)
+@@ -1339,7 +1346,7 @@
+         self.runmc(forkcmd)
+ 
+     def startclient(self):
+-        classpath = [self.binclient] + self.cpathclient
++        classpath = [self.binclient, self.srcclient] + self.cpathclient
+         classpath = [os.path.join('..', p) for p in classpath]
+         classpath = os.pathsep.join(classpath)
+         natives = os.path.join('..', self.dirnatives)
+@@ -1696,7 +1703,7 @@
+         self.runcmd(forkcmd)
+         return True
+ 
+-    def gathermd5s(self, side, reobf=False):
++    def gathermd5s(self, side, reobf=False, skip_fml=False):
+         if not reobf:
+             md5lk = {CLIENT: self.md5client, SERVER: self.md5server}
+         else:
+@@ -1711,6 +1718,9 @@
+                     class_path = ''
+                 else:
+                     class_path += '/'
++                if skip_fml:
++                    if class_path.startswith('cpw/'):
++                        continue
+                 for class_file in fnmatch.filter(filelist, '*.class'):
+                     class_name = class_path + os.path.splitext(class_file)[0]
+                     bin_file = os.path.normpath(os.path.join(path, class_file))
+@@ -1883,6 +1893,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])
+@@ -1903,6 +1916,9 @@
+         md5reoblk = {CLIENT: self.md5reobfclient, SERVER: self.md5reobfserver}
+         outpathlk = {CLIENT: self.srcmodclient, SERVER: self.srcmodserver}
+         src = {CLIENT: self.srcclient, SERVER: self.srcserver}
++        
++        if side == SERVER: #Noop out server side stuff
++            return
+ 
+         # HINT: We need a table for the old md5 and the new ones
+         md5table = {}

common/cpw/mods/fml/common/BukkitPluginRef.java

@@ -0,0 +1,41 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Declare a variable to be populated by a Bukkit Plugin proxy instance if the bukkit coremod
+ * is available. It can only be applied to field typed as {@link BukkitProxy}
+ * Generally it should be used in conjunction with {@link Mod#bukkitPlugin()} specifying the
+ * plugin to load.
+ *
+ * @author cpw
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface BukkitPluginRef
+{
+    /**
+     * A reference (possibly version specific) to a Bukkit Plugin by name, using the name@versionbound
+     * specification. If this is a bukkit enabled environment the field annotated by this
+     * will be populated with a {@link BukkitProxy} instance if possible. This proxy will be gotten by
+     * reflectively calling the "getModProxy" method on the bukkit plugin instance.
+     * @return The name of the plugin which we will inject into this field
+     */
+    String value();
+}

common/cpw/mods/fml/common/BukkitProxy.java

@@ -0,0 +1,24 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+/**
+ * A marker interface for retrieving a proxy to a bukkit plugin.
+ * Fields associated with {@link BukkitPluginRef} annotations should
+ * declare this type and cast down if the target is available (not null)
+ * @author cpw
+ *
+ */
+public interface BukkitProxy
+{
+}

common/cpw/mods/fml/common/CertificateHelper.java

@@ -0,0 +1,68 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.nio.ByteBuffer;
+import java.security.MessageDigest;
+import java.security.cert.Certificate;
+
+public class CertificateHelper {
+
+    private static final String HEXES = "0123456789abcdef";
+
+    public static String getFingerprint(Certificate certificate)
+    {
+        if (certificate == null)
+        {
+            return "NO VALID CERTIFICATE FOUND";
+        }
+        try
+        {
+            MessageDigest md = MessageDigest.getInstance("SHA-1");
+            byte[] der = certificate.getEncoded();
+            md.update(der);
+            byte[] digest = md.digest();
+            return hexify(digest);
+        }
+        catch (Exception e)
+        {
+            return null;
+        }
+    }
+
+    public static String getFingerprint(ByteBuffer buffer)
+    {
+        try
+        {
+            MessageDigest digest = MessageDigest.getInstance("SHA-1");
+            digest.update(buffer);
+            byte[] chksum = digest.digest();
+            return hexify(chksum);
+        }
+        catch (Exception e)
+        {
+            return null;
+        }
+    }
+
+    private static String hexify(byte[] chksum)
+    {
+        final StringBuilder hex = new StringBuilder( 2 * chksum.length );
+        for ( final byte b : chksum ) {
+          hex.append(HEXES.charAt((b & 0xF0) >> 4))
+             .append(HEXES.charAt((b & 0x0F)));
+        }
+        return hex.toString();
+    }
+
+}

common/cpw/mods/fml/common/DummyModContainer.java

@@ -0,0 +1,178 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.File;
+import java.security.cert.Certificate;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.eventbus.EventBus;
+
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
+import cpw.mods.fml.common.versioning.VersionRange;
+
+public class DummyModContainer implements ModContainer
+{
+    private ModMetadata md;
+    private ArtifactVersion processedVersion;
+    private String label;
+
+    public DummyModContainer(ModMetadata md)
+    {
+        this.md = md;
+    }
+
+    public DummyModContainer(String label)
+    {
+        this.label = label;
+    }
+    public DummyModContainer()
+    {
+    }
+
+    @Override
+    public void bindMetadata(MetadataCollection mc)
+    {
+    }
+
+    @Override
+    public List<ArtifactVersion> getDependants()
+    {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ArtifactVersion> getDependencies()
+    {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public Set<ArtifactVersion> getRequirements()
+    {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public ModMetadata getMetadata()
+    {
+        return md;
+    }
+
+    @Override
+    public Object getMod()
+    {
+        return null;
+    }
+
+    @Override
+    public String getModId()
+    {
+        return md.modId;
+    }
+
+    @Override
+    public String getName()
+    {
+        return md.name;
+    }
+
+    @Override
+    public String getSortingRules()
+    {
+        return "";
+    }
+
+    @Override
+    public File getSource()
+    {
+        return null;
+    }
+
+    @Override
+    public String getVersion()
+    {
+        return md.version;
+    }
+
+    public boolean matches(Object mod)
+    {
+        return false;
+    }
+
+    @Override
+    public void setEnabledState(boolean enabled)
+    {
+    }
+
+    @Override
+    public boolean registerBus(EventBus bus, LoadController controller)
+    {
+        return false;
+    }
+
+    @Override
+    public ArtifactVersion getProcessedVersion()
+    {
+        if (processedVersion == null)
+        {
+            processedVersion = new DefaultArtifactVersion(getModId(), getVersion());
+        }
+        return processedVersion;
+    }
+
+    @Override
+    public boolean isImmutable()
+    {
+        return false;
+    }
+
+    @Override
+    public boolean isNetworkMod()
+    {
+        return false;
+    }
+
+    @Override
+    public String getDisplayVersion()
+    {
+        return md.version;
+    }
+    @Override
+    public VersionRange acceptableMinecraftVersionRange()
+    {
+        return Loader.instance().getMinecraftModContainer().getStaticVersionRange();
+    }
+
+    @Override
+    public Certificate getSigningCertificate()
+    {
+        return null;
+    }
+
+    @Override
+    public String toString()
+    {
+        return md != null ? getModId() : "Dummy Container ("+label+") @" + System.identityHashCode(this);
+    }
+
+    @Override
+    public Map<String, String> getCustomModProperties()
+    {
+        return EMPTY_PROPERTIES;
+    }
+}

common/cpw/mods/fml/common/DuplicateModsFoundException.java

@@ -0,0 +1,28 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.File;
+import java.util.List;
+
+import com.google.common.collect.SetMultimap;
+
+public class DuplicateModsFoundException extends LoaderException {
+
+	public SetMultimap<ModContainer,File> dupes;
+
+	public DuplicateModsFoundException(SetMultimap<ModContainer, File> dupes) {
+		this.dupes = dupes;
+	}
+
+}

common/cpw/mods/fml/common/FMLCommonHandler.java

@@ -0,0 +1,489 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import net.minecraft.crash.CrashReport;
+import net.minecraft.crash.CrashReportCategory;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.NetHandler;
+import net.minecraft.network.packet.Packet131MapData;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.ServerListenThread;
+import net.minecraft.server.ThreadMinecraftServer;
+import net.minecraft.server.dedicated.DedicatedServer;
+import net.minecraft.world.World;
+import net.minecraft.world.storage.SaveHandler;
+import net.minecraft.world.storage.WorldInfo;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Objects;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import com.google.common.collect.Lists;
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.MapMaker;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import cpw.mods.fml.common.network.EntitySpawnAdjustmentPacket;
+import cpw.mods.fml.common.network.EntitySpawnPacket;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import cpw.mods.fml.common.registry.ItemData;
+import cpw.mods.fml.common.registry.TickRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.server.FMLServerHandler;
+
+
+/**
+ * The main class for non-obfuscated hook handling code
+ *
+ * Anything that doesn't require obfuscated or client/server specific code should
+ * go in this handler
+ *
+ * It also contains a reference to the sided handler instance that is valid
+ * allowing for common code to access specific properties from the obfuscated world
+ * without a direct dependency
+ *
+ * @author cpw
+ *
+ */
+public class FMLCommonHandler
+{
+    /**
+     * The singleton
+     */
+    private static final FMLCommonHandler INSTANCE = new FMLCommonHandler();
+    /**
+     * The delegate for side specific data and functions
+     */
+    private IFMLSidedHandler sidedDelegate;
+
+    private List<IScheduledTickHandler> scheduledClientTicks = Lists.newArrayList();
+    private List<IScheduledTickHandler> scheduledServerTicks = Lists.newArrayList();
+    private Class<?> forge;
+    private boolean noForge;
+    private List<String> brandings;
+    private List<ICrashCallable> crashCallables = Lists.newArrayList(Loader.instance().getCallableCrashInformation());
+    private Set<SaveHandler> handlerSet = Sets.newSetFromMap(new MapMaker().weakKeys().<SaveHandler,Boolean>makeMap());
+
+
+
+    public void beginLoading(IFMLSidedHandler handler)
+    {
+        sidedDelegate = handler;
+        FMLLog.log("MinecraftForge", Level.INFO, "Attempting early MinecraftForge initialization");
+        callForgeMethod("initialize");
+        callForgeMethod("registerCrashCallable");
+        FMLLog.log("MinecraftForge", Level.INFO, "Completed early MinecraftForge initialization");
+    }
+
+    public void rescheduleTicks(Side side)
+    {
+        TickRegistry.updateTickQueue(side.isClient() ? scheduledClientTicks : scheduledServerTicks, side);
+    }
+    public void tickStart(EnumSet<TickType> ticks, Side side, Object ... data)
+    {
+        List<IScheduledTickHandler> scheduledTicks = side.isClient() ? scheduledClientTicks : scheduledServerTicks;
+
+        if (scheduledTicks.size()==0)
+        {
+            return;
+        }
+        for (IScheduledTickHandler ticker : scheduledTicks)
+        {
+            EnumSet<TickType> ticksToRun = EnumSet.copyOf(Objects.firstNonNull(ticker.ticks(), EnumSet.noneOf(TickType.class)));
+            ticksToRun.retainAll(ticks);
+            if (!ticksToRun.isEmpty())
+            {
+                ticker.tickStart(ticksToRun, data);
+            }
+        }
+    }
+
+    public void tickEnd(EnumSet<TickType> ticks, Side side, Object ... data)
+    {
+        List<IScheduledTickHandler> scheduledTicks = side.isClient() ? scheduledClientTicks : scheduledServerTicks;
+
+        if (scheduledTicks.size()==0)
+        {
+            return;
+        }
+        for (IScheduledTickHandler ticker : scheduledTicks)
+        {
+            EnumSet<TickType> ticksToRun = EnumSet.copyOf(Objects.firstNonNull(ticker.ticks(), EnumSet.noneOf(TickType.class)));
+            ticksToRun.retainAll(ticks);
+            if (!ticksToRun.isEmpty())
+            {
+                ticker.tickEnd(ticksToRun, data);
+            }
+        }
+    }
+
+    /**
+     * @return the instance
+     */
+    public static FMLCommonHandler instance()
+    {
+        return INSTANCE;
+    }
+    /**
+     * Find the container that associates with the supplied mod object
+     * @param mod
+     */
+    public ModContainer findContainerFor(Object mod)
+    {
+        return Loader.instance().getReversedModObjectList().get(mod);
+    }
+    /**
+     * Get the forge mod loader logging instance (goes to the forgemodloader log file)
+     * @return The log instance for the FML log file
+     */
+    public Logger getFMLLogger()
+    {
+        return FMLLog.getLogger();
+    }
+
+    public Side getSide()
+    {
+        return sidedDelegate.getSide();
+    }
+
+    /**
+     * Return the effective side for the context in the game. This is dependent
+     * on thread analysis to try and determine whether the code is running in the
+     * server or not. Use at your own risk
+     */
+    public Side getEffectiveSide()
+    {
+        Thread thr = Thread.currentThread();
+        if ((thr instanceof ThreadMinecraftServer) || (thr instanceof ServerListenThread))
+        {
+            return Side.SERVER;
+        }
+
+        return Side.CLIENT;
+    }
+    /**
+     * Raise an exception
+     */
+    public void raiseException(Throwable exception, String message, boolean stopGame)
+    {
+        FMLLog.log(Level.SEVERE, exception, "Something raised an exception. The message was '%s'. 'stopGame' is %b", message, stopGame);
+        if (stopGame)
+        {
+            getSidedDelegate().haltGame(message,exception);
+        }
+    }
+
+
+    private Class<?> findMinecraftForge()
+    {
+        if (forge==null && !noForge)
+        {
+            try {
+                forge = Class.forName("net.minecraftforge.common.MinecraftForge");
+            } catch (Exception ex) {
+                noForge = true;
+            }
+        }
+        return forge;
+    }
+
+    private Object callForgeMethod(String method)
+    {
+        if (noForge)
+            return null;
+        try
+        {
+            return findMinecraftForge().getMethod(method).invoke(null);
+        }
+        catch (Exception e)
+        {
+            // No Forge installation
+            return null;
+        }
+    }
+
+    public void computeBranding()
+    {
+        if (brandings == null)
+        {
+            Builder brd = ImmutableList.<String>builder();
+            brd.add(Loader.instance().getMCVersionString());
+            brd.add(Loader.instance().getMCPVersionString());
+            brd.add("FML v"+Loader.instance().getFMLVersionString());
+            String forgeBranding = (String) callForgeMethod("getBrandingVersion");
+            if (!Strings.isNullOrEmpty(forgeBranding))
+            {
+                brd.add(forgeBranding);
+            }
+            if (sidedDelegate!=null)
+            {
+            	brd.addAll(sidedDelegate.getAdditionalBrandingInformation());
+            }
+            if (Loader.instance().getFMLBrandingProperties().containsKey("fmlbranding"))
+            {
+                brd.add(Loader.instance().getFMLBrandingProperties().get("fmlbranding"));
+            }
+            int tModCount = Loader.instance().getModList().size();
+            int aModCount = Loader.instance().getActiveModList().size();
+            brd.add(String.format("%d mod%s loaded, %d mod%s active", tModCount, tModCount!=1 ? "s" :"", aModCount, aModCount!=1 ? "s" :"" ));
+            brandings = brd.build();
+        }
+    }
+    public List<String> getBrandings()
+    {
+        if (brandings == null)
+        {
+            computeBranding();
+        }
+        return ImmutableList.copyOf(brandings);
+    }
+
+    public IFMLSidedHandler getSidedDelegate()
+    {
+        return sidedDelegate;
+    }
+
+    public void onPostServerTick()
+    {
+        tickEnd(EnumSet.of(TickType.SERVER), Side.SERVER);
+    }
+
+    /**
+     * Every tick just after world and other ticks occur
+     */
+    public void onPostWorldTick(Object world)
+    {
+        tickEnd(EnumSet.of(TickType.WORLD), Side.SERVER, world);
+    }
+
+    public void onPreServerTick()
+    {
+        tickStart(EnumSet.of(TickType.SERVER), Side.SERVER);
+    }
+
+    /**
+     * Every tick just before world and other ticks occur
+     */
+    public void onPreWorldTick(Object world)
+    {
+        tickStart(EnumSet.of(TickType.WORLD), Side.SERVER, world);
+    }
+
+    public void onWorldLoadTick(World[] worlds)
+    {
+        rescheduleTicks(Side.SERVER);
+        for (World w : worlds)
+        {
+            tickStart(EnumSet.of(TickType.WORLDLOAD), Side.SERVER, w);
+        }
+    }
+
+    public boolean handleServerAboutToStart(MinecraftServer server)
+    {
+        return Loader.instance().serverAboutToStart(server);
+    }
+
+    public boolean handleServerStarting(MinecraftServer server)
+    {
+        return Loader.instance().serverStarting(server);
+    }
+
+    public void handleServerStarted()
+    {
+        Loader.instance().serverStarted();
+    }
+
+    public void handleServerStopping()
+    {
+        Loader.instance().serverStopping();
+    }
+
+    public MinecraftServer getMinecraftServerInstance()
+    {
+        return sidedDelegate.getServer();
+    }
+
+    public void showGuiScreen(Object clientGuiElement)
+    {
+        sidedDelegate.showGuiScreen(clientGuiElement);
+    }
+
+    public Entity spawnEntityIntoClientWorld(EntityRegistration registration, EntitySpawnPacket entitySpawnPacket)
+    {
+        return sidedDelegate.spawnEntityIntoClientWorld(registration, entitySpawnPacket);
+    }
+
+    public void adjustEntityLocationOnClient(EntitySpawnAdjustmentPacket entitySpawnAdjustmentPacket)
+    {
+        sidedDelegate.adjustEntityLocationOnClient(entitySpawnAdjustmentPacket);
+    }
+
+    public void onServerStart(DedicatedServer dedicatedServer)
+    {
+        FMLServerHandler.instance();
+        sidedDelegate.beginServerLoading(dedicatedServer);
+    }
+
+    public void onServerStarted()
+    {
+        sidedDelegate.finishServerLoading();
+    }
+
+
+    public void onPreClientTick()
+    {
+        tickStart(EnumSet.of(TickType.CLIENT), Side.CLIENT);
+
+    }
+
+    public void onPostClientTick()
+    {
+        tickEnd(EnumSet.of(TickType.CLIENT), Side.CLIENT);
+    }
+
+    public void onRenderTickStart(float timer)
+    {
+        tickStart(EnumSet.of(TickType.RENDER), Side.CLIENT, timer);
+    }
+
+    public void onRenderTickEnd(float timer)
+    {
+        tickEnd(EnumSet.of(TickType.RENDER), Side.CLIENT, timer);
+    }
+
+    public void onPlayerPreTick(EntityPlayer player)
+    {
+        Side side = player instanceof EntityPlayerMP ? Side.SERVER : Side.CLIENT;
+        tickStart(EnumSet.of(TickType.PLAYER), side, player);
+    }
+
+    public void onPlayerPostTick(EntityPlayer player)
+    {
+        Side side = player instanceof EntityPlayerMP ? Side.SERVER : Side.CLIENT;
+        tickEnd(EnumSet.of(TickType.PLAYER), side, player);
+    }
+
+    public void registerCrashCallable(ICrashCallable callable)
+    {
+        crashCallables.add(callable);
+    }
+
+    public void enhanceCrashReport(CrashReport crashReport, CrashReportCategory category)
+    {
+        for (ICrashCallable call: crashCallables)
+        {
+            category.func_71500_a(call.getLabel(), call);
+        }
+    }
+
+    public void handleTinyPacket(NetHandler handler, Packet131MapData mapData)
+    {
+        sidedDelegate.handleTinyPacket(handler, mapData);
+    }
+
+    public void handleWorldDataSave(SaveHandler handler, WorldInfo worldInfo, NBTTagCompound tagCompound)
+    {
+        for (ModContainer mc : Loader.instance().getModList())
+        {
+            if (mc instanceof InjectedModContainer)
+            {
+                WorldAccessContainer wac = ((InjectedModContainer)mc).getWrappedWorldAccessContainer();
+                if (wac != null)
+                {
+                    NBTTagCompound dataForWriting = wac.getDataForWriting(handler, worldInfo);
+                    tagCompound.func_74766_a(mc.getModId(), dataForWriting);
+                }
+            }
+        }
+    }
+
+    public void handleWorldDataLoad(SaveHandler handler, WorldInfo worldInfo, NBTTagCompound tagCompound)
+    {
+        if (getEffectiveSide()!=Side.SERVER)
+        {
+            return;
+        }
+        if (handlerSet.contains(handler))
+        {
+            return;
+        }
+        handlerSet.add(handler);
+        Map<String,NBTBase> additionalProperties = Maps.newHashMap();
+        worldInfo.setAdditionalProperties(additionalProperties);
+        for (ModContainer mc : Loader.instance().getModList())
+        {
+            if (mc instanceof InjectedModContainer)
+            {
+                WorldAccessContainer wac = ((InjectedModContainer)mc).getWrappedWorldAccessContainer();
+                if (wac != null)
+                {
+                    wac.readData(handler, worldInfo, additionalProperties, tagCompound.func_74775_l(mc.getModId()));
+                }
+            }
+        }
+    }
+
+    public boolean shouldServerBeKilledQuietly()
+    {
+        if (sidedDelegate == null)
+        {
+            return false;
+        }
+        return sidedDelegate.shouldServerShouldBeKilledQuietly();
+    }
+
+    public void disconnectIDMismatch(MapDifference<Integer, ItemData> serverDifference, NetHandler toKill, INetworkManager network)
+    {
+        sidedDelegate.disconnectIDMismatch(serverDifference, toKill, network);
+    }
+
+    public void handleServerStopped()
+    {
+        MinecraftServer server = getMinecraftServerInstance();
+        Loader.instance().serverStopped();
+        // FORCE the internal server to stop: hello optifine workaround!
+        if (server!=null) ObfuscationReflectionHelper.setPrivateValue(MinecraftServer.class, server, false, "field_71316_v", "u", "serverStopped");
+    }
+
+    public String getModName()
+    {
+        List<String> modNames = Lists.newArrayListWithExpectedSize(3);
+        modNames.add("fml");
+        if (!noForge)
+        {
+            modNames.add("forge");
+        }
+
+        if (Loader.instance().getFMLBrandingProperties().containsKey("snooperbranding"))
+        {
+            modNames.add(Loader.instance().getFMLBrandingProperties().get("snooperbranding"));
+        }
+        return Joiner.on(',').join(modNames);
+    }
+}

common/cpw/mods/fml/common/FMLDummyContainer.java

@@ -0,0 +1,126 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.security.cert.Certificate;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.world.storage.SaveHandler;
+import net.minecraft.world.storage.WorldInfo;
+
+import com.google.common.eventbus.EventBus;
+
+import cpw.mods.fml.common.registry.GameData;
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.common.registry.ItemData;
+
+/**
+ * @author cpw
+ *
+ */
+public class FMLDummyContainer extends DummyModContainer implements WorldAccessContainer
+{
+    public FMLDummyContainer()
+    {
+        super(new ModMetadata());
+        ModMetadata meta = getMetadata();
+        meta.modId="FML";
+        meta.name="Forge Mod Loader";
+        meta.version=Loader.instance().getFMLVersionString();
+        meta.credits="Made possible with help from many people";
+        meta.authorList=Arrays.asList("cpw, LexManos");
+        meta.description="The Forge Mod Loader provides the ability for systems to load mods " +
+                    "from the file system. It also provides key capabilities for mods to be able " +
+                    "to cooperate and provide a good modding environment. " +
+                    "The mod loading system is compatible with ModLoader, all your ModLoader " +
+                    "mods should work.";
+        meta.url="https://github.com/MinecraftForge/FML/wiki";
+        meta.updateUrl="https://github.com/MinecraftForge/FML/wiki";
+        meta.screenshots=new String[0];
+        meta.logoFile="";
+    }
+
+    @Override
+    public boolean registerBus(EventBus bus, LoadController controller)
+    {
+        return true;
+    }
+
+    @Override
+    public NBTTagCompound getDataForWriting(SaveHandler handler, WorldInfo info)
+    {
+        NBTTagCompound fmlData = new NBTTagCompound();
+        NBTTagList list = new NBTTagList();
+        for (ModContainer mc : Loader.instance().getActiveModList())
+        {
+            NBTTagCompound mod = new NBTTagCompound();
+            mod.func_74778_a("ModId", mc.getModId());
+            mod.func_74778_a("ModVersion", mc.getVersion());
+            list.func_74742_a(mod);
+        }
+        fmlData.func_74782_a("ModList", list);
+        NBTTagList itemList = new NBTTagList();
+        GameData.writeItemData(itemList);
+        fmlData.func_74782_a("ModItemData", itemList);
+        return fmlData;
+    }
+
+    @Override
+    public void readData(SaveHandler handler, WorldInfo info, Map<String, NBTBase> propertyMap, NBTTagCompound tag)
+    {
+        if (tag.func_74764_b("ModList"))
+        {
+            NBTTagList modList = tag.func_74761_m("ModList");
+            for (int i = 0; i < modList.func_74745_c(); i++)
+            {
+                NBTTagCompound mod = (NBTTagCompound) modList.func_74743_b(i);
+                String modId = mod.func_74779_i("ModId");
+                String modVersion = mod.func_74779_i("ModVersion");
+                ModContainer container = Loader.instance().getIndexedModList().get(modId);
+                if (container == null)
+                {
+                    FMLLog.log("fml.ModTracker", Level.SEVERE, "This world was saved with mod %s which appears to be missing, things may not work well", modId);
+                    continue;
+                }
+                if (!modVersion.equals(container.getVersion()))
+                {
+                    FMLLog.log("fml.ModTracker", Level.INFO, "This world was saved with mod %s version %s and it is now at version %s, things may not work well", modId, modVersion, container.getVersion());
+                }
+            }
+        }
+        if (tag.func_74764_b("ModItemData"))
+        {
+            NBTTagList modList = tag.func_74761_m("ModItemData");
+            Set<ItemData> worldSaveItems = GameData.buildWorldItemData(modList);
+            GameData.validateWorldSave(worldSaveItems);
+        }
+        else
+        {
+            GameData.validateWorldSave(null);
+        }
+    }
+
+
+    @Override
+    public Certificate getSigningCertificate()
+    {
+        Certificate[] certificates = getClass().getProtectionDomain().getCodeSource().getCertificates();
+        return certificates != null ? certificates[0] : null;
+    }
+}

common/cpw/mods/fml/common/FMLLog.java

@@ -0,0 +1,80 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class FMLLog
+{
+    private static cpw.mods.fml.relauncher.FMLRelaunchLog coreLog = cpw.mods.fml.relauncher.FMLRelaunchLog.log;
+
+    public static void log(String logChannel, Level level, String format, Object... data)
+    {
+        coreLog.log(logChannel, level, format, data);
+    }
+
+    public static void log(Level level, String format, Object... data)
+    {
+        coreLog.log(level, format, data);
+    }
+
+    public static void log(String logChannel, Level level, Throwable ex, String format, Object... data)
+    {
+        coreLog.log(logChannel, level, ex, format, data);
+    }
+
+    public static void log(Level level, Throwable ex, String format, Object... data)
+    {
+        coreLog.log(level, ex, format, data);
+    }
+
+    public static void severe(String format, Object... data)
+    {
+        log(Level.SEVERE, format, data);
+    }
+
+    public static void warning(String format, Object... data)
+    {
+        log(Level.WARNING, format, data);
+    }
+
+    public static void info(String format, Object... data)
+    {
+        log(Level.INFO, format, data);
+    }
+
+    public static void fine(String format, Object... data)
+    {
+        log(Level.FINE, format, data);
+    }
+
+    public static void finer(String format, Object... data)
+    {
+        log(Level.FINER, format, data);
+    }
+
+    public static void finest(String format, Object... data)
+    {
+        log(Level.FINEST, format, data);
+    }
+    public static Logger getLogger()
+    {
+        return coreLog.getLogger();
+    }
+
+    public static void makeLog(String logChannel)
+    {
+        coreLog.makeLog(logChannel);
+    }
+}

common/cpw/mods/fml/common/FMLModContainer.java

@@ -0,0 +1,598 @@
+/*
+ * 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.common;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.security.cert.Certificate;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipInputStream;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicates;
+import com.google.common.base.Strings;
+import com.google.common.base.Throwables;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.SetMultimap;
+import com.google.common.collect.Sets;
+import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.Subscribe;
+
+import cpw.mods.fml.common.Mod.CustomProperty;
+import cpw.mods.fml.common.Mod.Instance;
+import cpw.mods.fml.common.Mod.Metadata;
+import cpw.mods.fml.common.discovery.ASMDataTable;
+import cpw.mods.fml.common.discovery.ASMDataTable.ASMData;
+import cpw.mods.fml.common.event.FMLConstructionEvent;
+import cpw.mods.fml.common.event.FMLEvent;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLInterModComms.IMCEvent;
+import cpw.mods.fml.common.event.FMLFingerprintViolationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.event.FMLServerAboutToStartEvent;
+import cpw.mods.fml.common.event.FMLServerStartedEvent;
+import cpw.mods.fml.common.event.FMLServerStartingEvent;
+import cpw.mods.fml.common.event.FMLServerStoppedEvent;
+import cpw.mods.fml.common.event.FMLServerStoppingEvent;
+import cpw.mods.fml.common.event.FMLStateEvent;
+import cpw.mods.fml.common.network.FMLNetworkHandler;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
+import cpw.mods.fml.common.versioning.VersionParser;
+import cpw.mods.fml.common.versioning.VersionRange;
+
+public class FMLModContainer implements ModContainer
+{
+    private Mod modDescriptor;
+    private Object modInstance;
+    private File source;
+    private ModMetadata modMetadata;
+    private String className;
+    private Map<String, Object> descriptor;
+    private boolean enabled = true;
+    private String internalVersion;
+    private boolean overridesMetadata;
+    private EventBus eventBus;
+    private LoadController controller;
+    private DefaultArtifactVersion processedVersion;
+    private boolean isNetworkMod;
+
+    private static final BiMap<Class<? extends FMLEvent>, Class<? extends Annotation>> modAnnotationTypes = ImmutableBiMap.<Class<? extends FMLEvent>, Class<? extends Annotation>>builder()
+        .put(FMLPreInitializationEvent.class, Mod.PreInit.class)
+        .put(FMLInitializationEvent.class, Mod.Init.class)
+        .put(FMLPostInitializationEvent.class, Mod.PostInit.class)
+        .put(FMLServerAboutToStartEvent.class, Mod.ServerAboutToStart.class)
+        .put(FMLServerStartingEvent.class, Mod.ServerStarting.class)
+        .put(FMLServerStartedEvent.class, Mod.ServerStarted.class)
+        .put(FMLServerStoppingEvent.class, Mod.ServerStopping.class)
+        .put(FMLServerStoppedEvent.class, Mod.ServerStopped.class)
+        .put(IMCEvent.class,Mod.IMCCallback.class)
+        .put(FMLFingerprintViolationEvent.class, Mod.FingerprintWarning.class)
+        .build();
+    private static final BiMap<Class<? extends Annotation>, Class<? extends FMLEvent>> modTypeAnnotations = modAnnotationTypes.inverse();
+    private String annotationDependencies;
+    private VersionRange minecraftAccepted;
+    private boolean fingerprintNotPresent;
+    private Set<String> sourceFingerprints;
+    private Certificate certificate;
+    private String modLanguage;
+    private ILanguageAdapter languageAdapter;
+    private ListMultimap<Class<? extends FMLEvent>,Method> eventMethods;
+    private Map<String, String> customModProperties;
+
+    public FMLModContainer(String className, File modSource, Map<String,Object> modDescriptor)
+    {
+        this.className = className;
+        this.source = modSource;
+        this.descriptor = modDescriptor;
+        this.modLanguage = (String) modDescriptor.get("modLanguage");
+        this.languageAdapter = "scala".equals(modLanguage) ? new ILanguageAdapter.ScalaAdapter() : new ILanguageAdapter.JavaAdapter();
+        this.eventMethods = ArrayListMultimap.create();
+    }
+
+    private ILanguageAdapter getLanguageAdapter()
+    {
+        return languageAdapter;
+    }
+    @Override
+    public String getModId()
+    {
+        return (String) descriptor.get("modid");
+    }
+
+    @Override
+    public String getName()
+    {
+        return modMetadata.name;
+    }
+
+    @Override
+    public String getVersion()
+    {
+        return internalVersion;
+    }
+
+    @Override
+    public File getSource()
+    {
+        return source;
+    }
+
+    @Override
+    public ModMetadata getMetadata()
+    {
+        return modMetadata;
+    }
+
+    @Override
+    public void bindMetadata(MetadataCollection mc)
+    {
+        modMetadata = mc.getMetadataForId(getModId(), descriptor);
+
+        if (descriptor.containsKey("useMetadata"))
+        {
+            overridesMetadata = !((Boolean)descriptor.get("useMetadata")).booleanValue();
+        }
+
+        if (overridesMetadata || !modMetadata.useDependencyInformation)
+        {
+            Set<ArtifactVersion> requirements = Sets.newHashSet();
+            List<ArtifactVersion> dependencies = Lists.newArrayList();
+            List<ArtifactVersion> dependants = Lists.newArrayList();
+            annotationDependencies = (String) descriptor.get("dependencies");
+            Loader.instance().computeDependencies(annotationDependencies, requirements, dependencies, dependants);
+            modMetadata.requiredMods = requirements;
+            modMetadata.dependencies = dependencies;
+            modMetadata.dependants = dependants;
+            FMLLog.log(getModId(), Level.FINEST, "Parsed dependency info : %s %s %s", requirements, dependencies, dependants);
+        }
+        else
+        {
+            FMLLog.log(getModId(), Level.FINEST, "Using mcmod dependency info : %s %s %s", modMetadata.requiredMods, modMetadata.dependencies, modMetadata.dependants);
+        }
+        if (Strings.isNullOrEmpty(modMetadata.name))
+        {
+            FMLLog.log(getModId(), Level.INFO,"Mod %s is missing the required element 'name'. Substituting %s", getModId(), getModId());
+            modMetadata.name = getModId();
+        }
+        internalVersion = (String) descriptor.get("version");
+        if (Strings.isNullOrEmpty(internalVersion))
+        {
+            Properties versionProps = searchForVersionProperties();
+            if (versionProps != null)
+            {
+                internalVersion = versionProps.getProperty(getModId()+".version");
+                FMLLog.log(getModId(), Level.FINE, "Found version %s for mod %s in version.properties, using", internalVersion, getModId());
+            }
+
+        }
+        if (Strings.isNullOrEmpty(internalVersion) && !Strings.isNullOrEmpty(modMetadata.version))
+        {
+            FMLLog.log(getModId(), Level.WARNING, "Mod %s is missing the required element 'version' and a version.properties file could not be found. Falling back to metadata version %s", getModId(), modMetadata.version);
+            internalVersion = modMetadata.version;
+        }
+        if (Strings.isNullOrEmpty(internalVersion))
+        {
+            FMLLog.log(getModId(), Level.WARNING, "Mod %s is missing the required element 'version' and no fallback can be found. Substituting '1.0'.", getModId());
+            modMetadata.version = internalVersion = "1.0";
+        }
+
+        String mcVersionString = (String) descriptor.get("acceptedMinecraftVersions");
+        if (!Strings.isNullOrEmpty(mcVersionString))
+        {
+            minecraftAccepted = VersionParser.parseRange(mcVersionString);
+        }
+        else
+        {
+            minecraftAccepted = Loader.instance().getMinecraftModContainer().getStaticVersionRange();
+        }
+    }
+
+    public Properties searchForVersionProperties()
+    {
+        try
+        {
+            FMLLog.log(getModId(), Level.FINE,"Attempting to load the file version.properties from %s to locate a version number for %s", getSource().getName(), getModId());
+            Properties version = null;
+            if (getSource().isFile())
+            {
+                ZipFile source = new ZipFile(getSource());
+                ZipEntry versionFile = source.getEntry("version.properties");
+                if (versionFile!=null)
+                {
+                    version = new Properties();
+                    version.load(source.getInputStream(versionFile));
+                }
+                source.close();
+            }
+            else if (getSource().isDirectory())
+            {
+                File propsFile = new File(getSource(),"version.properties");
+                if (propsFile.exists() && propsFile.isFile())
+                {
+                    version = new Properties();
+                    FileInputStream fis = new FileInputStream(propsFile);
+                    version.load(fis);
+                    fis.close();
+                }
+            }
+            return version;
+        }
+        catch (Exception e)
+        {
+            Throwables.propagateIfPossible(e);
+            FMLLog.log(getModId(), Level.FINEST, "Failed to find a usable version.properties file");
+            return null;
+        }
+    }
+
+    @Override
+    public void setEnabledState(boolean enabled)
+    {
+        this.enabled = enabled;
+    }
+
+    @Override
+    public Set<ArtifactVersion> getRequirements()
+    {
+        return modMetadata.requiredMods;
+    }
+
+    @Override
+    public List<ArtifactVersion> getDependencies()
+    {
+        return modMetadata.dependencies;
+    }
+
+    @Override
+    public List<ArtifactVersion> getDependants()
+    {
+        return modMetadata.dependants;
+    }
+
+    @Override
+    public String getSortingRules()
+    {
+        return ((overridesMetadata || !modMetadata.useDependencyInformation) ? Strings.nullToEmpty(annotationDependencies) : modMetadata.printableSortingRules());
+    }
+
+    @Override
+    public boolean matches(Object mod)
+    {
+        return mod == modInstance;
+    }
+
+    @Override
+    public Object getMod()
+    {
+        return modInstance;
+    }
+
+    @Override
+    public boolean registerBus(EventBus bus, LoadController controller)
+    {
+        if (this.enabled)
+        {
+            FMLLog.log(getModId(), Level.FINE, "Enabling mod %s", getModId());
+            this.eventBus = bus;
+            this.controller = controller;
+            eventBus.register(this);
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    private Method gatherAnnotations(Class<?> clazz) throws Exception
+    {
+        Method factoryMethod = null;
+        for (Method m : clazz.getDeclaredMethods())
+        {
+            for (Annotation a : m.getAnnotations())
+            {
+                if (modTypeAnnotations.containsKey(a.annotationType()))
+                {
+                    Class<?>[] paramTypes = new Class[] { modTypeAnnotations.get(a.annotationType()) };
+                    if (Arrays.equals(m.getParameterTypes(), paramTypes))
+                    {
+                        m.setAccessible(true);
+                        eventMethods.put(modTypeAnnotations.get(a.annotationType()), m);
+                    }
+                    else
+                    {
+                        FMLLog.log(getModId(), Level.SEVERE,"The mod %s appears to have an invalid method annotation %s. This annotation can only apply to methods with argument types %s -it will not be called", getModId(), a.annotationType().getSimpleName(), Arrays.toString(paramTypes));
+                    }
+                }
+                else if (a.annotationType().equals(Mod.EventHandler.class))
+                {
+                    if (m.getParameterTypes().length == 1 && modAnnotationTypes.containsKey(m.getParameterTypes()[0]))
+                    {
+                        m.setAccessible(true);
+                        eventMethods.put((Class<? extends FMLEvent>) m.getParameterTypes()[1],m);
+                    }
+                    else
+                    {
+                        FMLLog.log(getModId(), Level.SEVERE,"The mod %s appears to have an invalid event annotation %s. This annotation can only apply to methods with recognized event arguments - it will not be called", getModId(), a.annotationType().getSimpleName());
+                    }
+                }
+                else if (a.annotationType().equals(Mod.InstanceFactory.class))
+                {
+                    if (Modifier.isStatic(m.getModifiers()) && m.getParameterTypes().length == 0 && factoryMethod == null)
+                    {
+                        m.setAccessible(true);
+                        factoryMethod = m;
+                    }
+                    else if (!(Modifier.isStatic(m.getModifiers()) && m.getParameterTypes().length == 0))
+                    {
+                        FMLLog.log(getModId(),  Level.SEVERE, "The InstanceFactory annotation can only apply to a static method, taking zero arguments - it will be ignored on %s(%s)", m.getName(), Arrays.asList(m.getParameterTypes()));
+                    }
+                    else if (factoryMethod != null)
+                    {
+                        FMLLog.log(getModId(), Level.SEVERE, "The InstanceFactory annotation can only be used once, the application to %s(%s) will be ignored", m.getName(), Arrays.asList(m.getParameterTypes()));
+                    }
+                }
+            }
+        }
+        return factoryMethod;
+    }
+
+    private void processFieldAnnotations(ASMDataTable asmDataTable) throws Exception
+    {
+        SetMultimap<String, ASMData> annotations = asmDataTable.getAnnotationsFor(this);
+
+        parseSimpleFieldAnnotation(annotations, Instance.class.getName(), new Function<ModContainer, Object>()
+        {
+            public Object apply(ModContainer mc)
+            {
+                return mc.getMod();
+            }
+        });
+        parseSimpleFieldAnnotation(annotations, Metadata.class.getName(), new Function<ModContainer, Object>()
+        {
+            public Object apply(ModContainer mc)
+            {
+                return mc.getMetadata();
+            }
+        });
+    }
+
+    private void parseSimpleFieldAnnotation(SetMultimap<String, ASMData> annotations, String annotationClassName, Function<ModContainer, Object> retreiver) throws IllegalAccessException
+    {
+        String[] annName = annotationClassName.split("\\.");
+        String annotationName = annName[annName.length - 1];
+        for (ASMData targets : annotations.get(annotationClassName))
+        {
+            String targetMod = (String) targets.getAnnotationInfo().get("value");
+            Field f = null;
+            Object injectedMod = null;
+            ModContainer mc = this;
+            boolean isStatic = false;
+            Class<?> clz = modInstance.getClass();
+            if (!Strings.isNullOrEmpty(targetMod))
+            {
+                if (Loader.isModLoaded(targetMod))
+                {
+                    mc = Loader.instance().getIndexedModList().get(targetMod);
+                }
+                else
+                {
+                    mc = null;
+                }
+            }
+            if (mc != null)
+            {
+                try
+                {
+                    clz = Class.forName(targets.getClassName(), true, Loader.instance().getModClassLoader());
+                    f = clz.getDeclaredField(targets.getObjectName());
+                    f.setAccessible(true);
+                    isStatic = Modifier.isStatic(f.getModifiers());
+                    injectedMod = retreiver.apply(mc);
+                }
+                catch (Exception e)
+                {
+                    Throwables.propagateIfPossible(e);
+                    FMLLog.log(getModId(), Level.WARNING, e, "Attempting to load @%s in class %s for %s and failing", annotationName, targets.getClassName(), mc.getModId());
+                }
+            }
+            if (f != null)
+            {
+                Object target = null;
+                if (!isStatic)
+                {
+                    target = modInstance;
+                    if (!modInstance.getClass().equals(clz))
+                    {
+                        FMLLog.log(getModId(), Level.WARNING, "Unable to inject @%s in non-static field %s.%s for %s as it is NOT the primary mod instance", annotationName, targets.getClassName(), targets.getObjectName(), mc.getModId());
+                        continue;
+                    }
+                }
+                f.set(target, injectedMod);
+            }
+        }
+    }
+
+    @Subscribe
+    public void constructMod(FMLConstructionEvent event)
+    {
+        try
+        {
+            ModClassLoader modClassLoader = event.getModClassLoader();
+            modClassLoader.addFile(source);
+            Class<?> clazz = Class.forName(className, true, modClassLoader);
+
+            Certificate[] certificates = clazz.getProtectionDomain().getCodeSource().getCertificates();
+            int len = 0;
+            if (certificates != null)
+            {
+                len = certificates.length;
+            }
+            Builder<String> certBuilder = ImmutableList.<String>builder();
+            for (int i = 0; i < len; i++)
+            {
+                certBuilder.add(CertificateHelper.getFingerprint(certificates[i]));
+            }
+
+            ImmutableList<String> certList = certBuilder.build();
+            sourceFingerprints = ImmutableSet.copyOf(certList);
+
+            String expectedFingerprint = (String) descriptor.get("certificateFingerprint");
+
+            fingerprintNotPresent = true;
+
+            if (expectedFingerprint != null && !expectedFingerprint.isEmpty())
+            {
+                if (!sourceFingerprints.contains(expectedFingerprint))
+                {
+                    Level warnLevel = Level.SEVERE;
+                    if (source.isDirectory())
+                    {
+                        warnLevel = Level.FINER;
+                    }
+                    FMLLog.log(getModId(), warnLevel, "The mod %s is expecting signature %s for source %s, however there is no signature matching that description", getModId(), expectedFingerprint, source.getName());
+                }
+                else
+                {
+                    certificate = certificates[certList.indexOf(expectedFingerprint)];
+                    fingerprintNotPresent = false;
+                }
+            }
+
+            CustomProperty[] props = (CustomProperty[]) descriptor.get("customProperties");
+            if (props!=null && props.length > 0)
+            {
+                com.google.common.collect.ImmutableMap.Builder<String, String> builder = ImmutableMap.<String,String>builder();
+                for (CustomProperty p : props)
+                {
+                    builder.put(p.k(),p.v());
+                }
+                customModProperties = builder.build();
+            }
+            else
+            {
+                customModProperties = EMPTY_PROPERTIES;
+            }
+
+
+            Method factoryMethod = gatherAnnotations(clazz);
+            isNetworkMod = FMLNetworkHandler.instance().registerNetworkMod(this, clazz, event.getASMHarvestedData());
+            modInstance = getLanguageAdapter().getNewInstance(this,clazz, modClassLoader, factoryMethod);
+            if (fingerprintNotPresent)
+            {
+                eventBus.post(new FMLFingerprintViolationEvent(source.isDirectory(), source, ImmutableSet.copyOf(this.sourceFingerprints), expectedFingerprint));
+            }
+            ProxyInjector.inject(this, event.getASMHarvestedData(), FMLCommonHandler.instance().getSide(), getLanguageAdapter());
+            processFieldAnnotations(event.getASMHarvestedData());
+        }
+        catch (Throwable e)
+        {
+            controller.errorOccurred(this, e);
+            Throwables.propagateIfPossible(e);
+        }
+    }
+
+    @Subscribe
+    public void handleModStateEvent(FMLEvent event)
+    {
+        if (!eventMethods.containsKey(event.getClass()))
+        {
+            return;
+        }
+        try
+        {
+            for (Method m : eventMethods.get(event.getClass()))
+            {
+                m.invoke(modInstance, event);
+            }
+        }
+        catch (Throwable t)
+        {
+            controller.errorOccurred(this, t);
+        }
+    }
+
+    @Override
+    public ArtifactVersion getProcessedVersion()
+    {
+        if (processedVersion == null)
+        {
+            processedVersion = new DefaultArtifactVersion(getModId(), getVersion());
+        }
+        return processedVersion;
+    }
+    @Override
+    public boolean isImmutable()
+    {
+        return false;
+    }
+
+    @Override
+    public boolean isNetworkMod()
+    {
+        return isNetworkMod;
+    }
+
+    @Override
+    public String getDisplayVersion()
+    {
+        return modMetadata.version;
+    }
+
+    @Override
+    public VersionRange acceptableMinecraftVersionRange()
+    {
+        return minecraftAccepted;
+    }
+
+    @Override
+    public Certificate getSigningCertificate()
+    {
+        return certificate;
+    }
+
+    @Override
+    public String toString()
+    {
+        return "FMLMod:"+getModId()+"{"+getVersion()+"}";
+    }
+
+    @Override
+    public Map<String, String> getCustomModProperties()
+    {
+        return customModProperties;
+    }
+}

common/cpw/mods/fml/common/IASMHook.java

@@ -0,0 +1,34 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import org.objectweb.asm.tree.ClassNode;
+
+public interface IASMHook {
+    /**
+     * Inject the {@link Mod} class node into this instance. This allows retrieval from custom
+     * attributes or other artifacts in your mod class
+     *
+     * @param modClassNode The mod class
+     * @return optionally some code generated classes that will be injected into the classloader
+     */
+    ClassNode[] inject(ClassNode modClassNode);
+    /**
+     * Allow mods to manipulate classes loaded from this {@link Mod}'s jar file. The {@link Mod}
+     * class is always guaranteed to be called first.
+     * The node state should be changed in place.
+     *
+     * @param node The class being loaded
+     */
+    void modifyClass(String className, ClassNode node);
+}

common/cpw/mods/fml/common/IConsoleHandler.java

@@ -0,0 +1,22 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+/**
+ * @author cpw
+ *
+ */
+public interface IConsoleHandler
+{
+    public boolean handleCommand(String command, Object... data);
+}

common/cpw/mods/fml/common/ICraftingHandler.java

@@ -0,0 +1,42 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+/**
+ * Return a crafting handler for the mod container to call
+ *
+ * @author cpw
+ *
+ */
+public interface ICraftingHandler
+{
+    /**
+     * The object array contains these three arguments
+     *
+     * @param player
+     * @param item
+     * @param craftMatrix
+     */
+    void onCrafting(EntityPlayer player, ItemStack item, IInventory craftMatrix);
+
+    /**
+     * The object array contains these two arguments
+     * @param player
+     * @param item
+     */
+    void onSmelting(EntityPlayer player, ItemStack item);
+}

common/cpw/mods/fml/common/ICrashCallable.java

@@ -0,0 +1,20 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.concurrent.Callable;
+
+public interface ICrashCallable extends Callable<String>
+{
+    String getLabel();
+}

common/cpw/mods/fml/common/IFMLHandledException.java

@@ -0,0 +1,18 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+public interface IFMLHandledException
+{
+
+}

common/cpw/mods/fml/common/IFMLSidedHandler.java

@@ -0,0 +1,65 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.List;
+
+import com.google.common.collect.MapDifference;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.NetHandler;
+import net.minecraft.network.packet.Packet;
+import net.minecraft.network.packet.Packet131MapData;
+import net.minecraft.server.MinecraftServer;
+import cpw.mods.fml.common.network.EntitySpawnAdjustmentPacket;
+import cpw.mods.fml.common.network.EntitySpawnPacket;
+import cpw.mods.fml.common.network.ModMissingPacket;
+import cpw.mods.fml.common.registry.ItemData;
+import cpw.mods.fml.common.registry.EntityRegistry.EntityRegistration;
+import cpw.mods.fml.relauncher.Side;
+
+public interface IFMLSidedHandler
+{
+    List<String> getAdditionalBrandingInformation();
+
+    Side getSide();
+
+    void haltGame(String message, Throwable exception);
+
+    void showGuiScreen(Object clientGuiElement);
+
+    Entity spawnEntityIntoClientWorld(EntityRegistration registration, EntitySpawnPacket packet);
+
+    void adjustEntityLocationOnClient(EntitySpawnAdjustmentPacket entitySpawnAdjustmentPacket);
+
+    void beginServerLoading(MinecraftServer server);
+
+    void finishServerLoading();
+
+    MinecraftServer getServer();
+
+    void sendPacket(Packet packet);
+
+    void displayMissingMods(ModMissingPacket modMissingPacket);
+
+    void handleTinyPacket(NetHandler handler, Packet131MapData mapData);
+
+    void setClientCompatibilityLevel(byte compatibilityLevel);
+
+    byte getClientCompatibilityLevel();
+
+    boolean shouldServerShouldBeKilledQuietly();
+
+    void disconnectIDMismatch(MapDifference<Integer, ItemData> s, NetHandler toKill, INetworkManager mgr);
+}

common/cpw/mods/fml/common/IFuelHandler.java

@@ -0,0 +1,20 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import net.minecraft.item.ItemStack;
+
+public interface IFuelHandler
+{
+    int getBurnTime(ItemStack fuel);
+}

common/cpw/mods/fml/common/ILanguageAdapter.java

@@ -0,0 +1,197 @@
+package cpw.mods.fml.common;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.logging.Level;
+
+import cpw.mods.fml.common.Mod.Instance;
+import cpw.mods.fml.relauncher.Side;
+
+public interface ILanguageAdapter {
+    public Object getNewInstance(FMLModContainer container, Class<?> objectClass, ClassLoader classLoader, Method factoryMarkedAnnotation) throws Exception;
+    public boolean supportsStatics();
+    public void setProxy(Field target, Class<?> proxyTarget, Object proxy) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException;
+    public void setInternalProxies(ModContainer mod, Side side, ClassLoader loader);
+
+    public static class ScalaAdapter implements ILanguageAdapter {
+        @Override
+        public Object getNewInstance(FMLModContainer container, Class<?> scalaObjectClass, ClassLoader classLoader, Method factoryMarkedAnnotation) throws Exception
+        {
+            Class<?> sObjectClass = Class.forName(scalaObjectClass.getName()+"$",true,classLoader);
+            return sObjectClass.getField("MODULE$").get(null);
+        }
+
+        @Override
+        public boolean supportsStatics()
+        {
+            return false;
+        }
+
+        @Override
+        public void setProxy(Field target, Class<?> proxyTarget, Object proxy) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException
+        {
+            try
+            {
+                // Get the actual singleton class. The two variants are from
+                // whether the @SidedProxy is declared in a the class block
+                // of the object directly, or in the object block, i.e.
+                // whether it's:
+                // class ModName {
+                //   @SidedProxy ...
+                // }
+                // object ModName extends ModName {}
+                // which leads to us getting the outer class, or
+                // object ModName {
+                //   @SidedProxy ...
+                // }
+                // which leads to us getting the inner class.
+                if (!proxyTarget.getName().endsWith("$"))
+                {
+                    // Get internal class generated by Scala.
+                    proxyTarget = Class.forName(proxyTarget.getName() + "$", true, proxyTarget.getClassLoader());
+                }
+            }
+            catch (ClassNotFoundException e)
+            {
+                // Not a singleton, look for @Instance field as a fallback.
+                FMLLog.log(Level.INFO, e, "An error occured trying to load a proxy into %s.%s. Did you declare your mod as 'class' instead of 'object'?", proxyTarget.getSimpleName(), target.getName());
+                return;
+            }
+
+            // Get the instance via the MODULE$ field which is
+            // automatically generated by the Scala compiler for
+            // singletons.
+            Object targetInstance = proxyTarget.getField("MODULE$").get(null);
+
+            try
+            {
+                // Find setter function. We do it this way because we can't
+                // necessarily use proxyTarget.getMethod(proxy.getClass()), as
+                // it might be a subclass and not the exact parameter type.
+                // All fields are private in Scala, wrapped by a getter and
+                // setter named <fieldname> and <fieldname>_$eq. To those
+                // familiar with scala.reflect.BeanProperty: these will always
+                // be there, set<Fieldname> and get<Fieldname> will always
+                // only be generated *additionally*.
+                final String setterName = target.getName() + "_$eq";
+                for (Method setter : proxyTarget.getMethods())
+                {
+                    Class<?>[] setterParameters = setter.getParameterTypes();
+                    if (setterName.equals(setter.getName()) &&
+                            // Some more validation.
+                            setterParameters.length == 1 &&
+                            setterParameters[0].isAssignableFrom(proxy.getClass()))
+                    {
+                        // Here goes nothing...
+                        setter.invoke(targetInstance, proxy);
+                        return;
+                    }
+                }
+            }
+            catch (InvocationTargetException e)
+            {
+                FMLLog.log(Level.SEVERE, e, "An error occured trying to load a proxy into %s.%s", proxyTarget.getSimpleName(), target.getName());
+                throw new LoaderException(e);
+            }
+
+            // If we come here we could not find a setter for this proxy.
+            FMLLog.severe("Failed loading proxy into %s.%s, could not find setter function. Did you declare the field with 'val' instead of 'var'?", proxyTarget.getSimpleName(), target.getName());
+            throw new LoaderException();
+        }
+
+        @Override
+        public void setInternalProxies(ModContainer mod, Side side, ClassLoader loader)
+        {
+            // For Scala mods, we want to enable authors to write them like so:
+            // object ModName {
+            //   @SidedProxy(...)
+            //   var proxy: ModProxy = null
+            // }
+            // For this to work, we have to search inside the inner class Scala
+            // generates for singletons, which is in called ModName$. These are
+            // not automatically handled, because the mod discovery code ignores
+            // internal classes.
+            // Note that it is alternatively possible to write this like so:
+            // class ModName {
+            //   @SidedProxy(...)
+            //   var proxy: ModProxy = null
+            // }
+            // object ModName extends ModName { ... }
+            // which will fall back to the normal injection code which calls
+            // setProxy in turn.
+
+            // Get the actual mod implementation, which will be the inner class
+            // if we have a singleton.
+            Class<?> proxyTarget = mod.getMod().getClass();
+            if (proxyTarget.getName().endsWith("$"))
+            {
+                // So we have a singleton class, check if there are targets.
+                for (Field target : proxyTarget.getDeclaredFields())
+                {
+                    // This will not turn up anything if the alternative
+                    // approach was taken (manually declaring the class).
+                    // So we don't initialize the field twice.
+                    if (target.getAnnotation(SidedProxy.class) != null)
+                    {
+                        String targetType = side.isClient() ? target.getAnnotation(SidedProxy.class).clientSide() : target.getAnnotation(SidedProxy.class).serverSide();
+                        try
+                        {
+                            Object proxy = Class.forName(targetType, true, loader).newInstance();
+
+                            if (!target.getType().isAssignableFrom(proxy.getClass()))
+                            {
+                                FMLLog.severe("Attempted to load a proxy type %s into %s.%s, but the types don't match", targetType, proxyTarget.getSimpleName(), target.getName());
+                                throw new LoaderException();
+                            }
+
+                            setProxy(target, proxyTarget, proxy);
+                        }
+                        catch (Exception e) {
+                            FMLLog.log(Level.SEVERE, e, "An error occured trying to load a proxy into %s.%s", proxyTarget.getSimpleName(), target.getName());
+                            throw new LoaderException(e);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                FMLLog.finer("Mod does not appear to be a singleton.");
+            }
+        }
+    }
+
+    public static class JavaAdapter implements ILanguageAdapter {
+        @Override
+        public Object getNewInstance(FMLModContainer container, Class<?> objectClass, ClassLoader classLoader, Method factoryMarkedMethod) throws Exception
+        {
+            if (factoryMarkedMethod != null)
+            {
+                return factoryMarkedMethod.invoke(null);
+            }
+            else
+            {
+                return objectClass.newInstance();
+            }
+        }
+
+        @Override
+        public boolean supportsStatics()
+        {
+            return true;
+        }
+
+        @Override
+        public void setProxy(Field target, Class<?> proxyTarget, Object proxy) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException,
+                SecurityException
+        {
+            target.set(null, proxy);
+        }
+
+        @Override
+        public void setInternalProxies(ModContainer mod, Side side, ClassLoader loader)
+        {
+            // Nothing to do here.
+        }
+    }
+}

common/cpw/mods/fml/common/INetworkHandler.java

@@ -0,0 +1,26 @@
+/*
+ * 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.common;
+
+
+
+/**
+ * @author cpw
+ *
+ */
+public interface INetworkHandler
+{
+    boolean onChat(Object... data);
+    void onPacket250Packet(Object... data);
+    void onServerLogin(Object handler);
+}

common/cpw/mods/fml/common/IPickupNotifier.java

@@ -0,0 +1,21 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+
+public interface IPickupNotifier
+{
+    void notifyPickup(EntityItem item, EntityPlayer player);
+}

common/cpw/mods/fml/common/IPlayerTracker.java

@@ -0,0 +1,30 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import net.minecraft.entity.player.EntityPlayer;
+
+/**
+ * @author cpw
+ *
+ */
+public interface IPlayerTracker
+{
+    void onPlayerLogin(EntityPlayer player);
+
+    void onPlayerLogout(EntityPlayer player);
+
+    void onPlayerChangedDimension(EntityPlayer player);
+
+    void onPlayerRespawn(EntityPlayer player);
+}

common/cpw/mods/fml/common/IScheduledTickHandler.java

@@ -0,0 +1,24 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+public interface IScheduledTickHandler extends ITickHandler
+{
+    /**
+     * Return the number of actual ticks that will pass
+     * before your next tick will fire. This will be called
+     * just after your last tick fired to compute the next delay.
+     * @return Time until next tick
+     */
+    public int nextTickSpacing();
+}

common/cpw/mods/fml/common/ITickHandler.java

@@ -0,0 +1,59 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.EnumSet;
+
+
+/**
+ * 
+ * Tick handler for mods to implement and register through the TickRegistry
+ * 
+ * The data available to each tick is documented in the TickType
+ * 
+ * @author cpw
+ *
+ */
+public interface ITickHandler
+{
+
+    /**
+     * Called at the "start" phase of a tick
+     * 
+     * Multiple ticks may fire simultaneously- you will only be called once with all the firing ticks
+     * 
+     * @param type
+     * @param tickData
+     */
+    public void tickStart(EnumSet<TickType> type, Object... tickData);
+    
+    /**
+     * Called at the "end" phase of a tick
+     * 
+     * Multiple ticks may fire simultaneously- you will only be called once with all the firing ticks
+     * 
+     * @param type
+     * @param tickData
+     */
+    public void tickEnd(EnumSet<TickType> type, Object... tickData);
+    
+    /**
+     * Returns the list of ticks this tick handler is interested in receiving at the minute
+     */
+    public EnumSet<TickType> ticks();
+    
+    /**
+     * A profiling label for this tick handler
+     */
+    public String getLabel();
+}

common/cpw/mods/fml/common/IWorldGenerator.java

@@ -0,0 +1,41 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.Random;
+
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.IChunkProvider;
+
+
+/**
+ * This is called back during world generation. 
+ *
+ * @author cpw
+ *
+ */
+public interface IWorldGenerator
+{
+    /**
+     * Generate some world
+     *
+     * @param random the chunk specific {@link Random}.
+     * @param chunkX the chunk X coordinate of this chunk.
+     * @param chunkZ the chunk Z coordinate of this chunk.
+     * @param world : additionalData[0] The minecraft {@link World} we're generating for.
+     * @param chunkGenerator : additionalData[1] The {@link IChunkProvider} that is generating.
+     * @param chunkProvider : additionalData[2] {@link IChunkProvider} that is requesting the world generation.
+     *
+     */
+    public void generate(Random random, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider);
+}

common/cpw/mods/fml/common/InjectedModContainer.java

@@ -0,0 +1,164 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.File;
+import java.security.cert.Certificate;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.eventbus.EventBus;
+
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.VersionRange;
+
+public class InjectedModContainer implements ModContainer
+{
+    private File source;
+    public final ModContainer wrappedContainer;
+
+    public InjectedModContainer(ModContainer mc, File source)
+    {
+        this.source = source;
+        this.wrappedContainer = mc;
+    }
+
+    public String getModId()
+    {
+        return wrappedContainer.getModId();
+    }
+
+    public String getName()
+    {
+        return wrappedContainer.getName();
+    }
+
+    public String getVersion()
+    {
+        return wrappedContainer.getVersion();
+    }
+
+    public File getSource()
+    {
+        return source;
+    }
+
+    public ModMetadata getMetadata()
+    {
+        return wrappedContainer.getMetadata();
+    }
+
+    public void bindMetadata(MetadataCollection mc)
+    {
+        wrappedContainer.bindMetadata(mc);
+    }
+
+    public void setEnabledState(boolean enabled)
+    {
+        wrappedContainer.setEnabledState(enabled);
+    }
+
+    public Set<ArtifactVersion> getRequirements()
+    {
+        return wrappedContainer.getRequirements();
+    }
+
+    public List<ArtifactVersion> getDependencies()
+    {
+        return wrappedContainer.getDependencies();
+    }
+
+    public List<ArtifactVersion> getDependants()
+    {
+        return wrappedContainer.getDependants();
+    }
+
+    public String getSortingRules()
+    {
+        return wrappedContainer.getSortingRules();
+    }
+
+    public boolean registerBus(EventBus bus, LoadController controller)
+    {
+        return wrappedContainer.registerBus(bus, controller);
+    }
+
+    public boolean matches(Object mod)
+    {
+        return wrappedContainer.matches(mod);
+    }
+
+    public Object getMod()
+    {
+        return wrappedContainer.getMod();
+    }
+
+    public ArtifactVersion getProcessedVersion()
+    {
+        return wrappedContainer.getProcessedVersion();
+    }
+
+    @Override
+    public boolean isNetworkMod()
+    {
+        return wrappedContainer.isNetworkMod();
+    }
+    @Override
+    public boolean isImmutable()
+    {
+        return true;
+    }
+
+    @Override
+    public String getDisplayVersion()
+    {
+        return wrappedContainer.getDisplayVersion();
+    }
+
+    @Override
+    public VersionRange acceptableMinecraftVersionRange()
+    {
+        return wrappedContainer.acceptableMinecraftVersionRange();
+    }
+
+    public WorldAccessContainer getWrappedWorldAccessContainer()
+    {
+        if (wrappedContainer instanceof WorldAccessContainer)
+        {
+            return (WorldAccessContainer) wrappedContainer;
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+    @Override
+    public Certificate getSigningCertificate()
+    {
+        return wrappedContainer.getSigningCertificate();
+    }
+
+    @Override
+    public String toString()
+    {
+        return "Wrapped{"+wrappedContainer.toString()+"}";
+    }
+
+    @Override
+    public Map<String, String> getCustomModProperties()
+    {
+        return wrappedContainer.getCustomModProperties();
+    }
+}

common/cpw/mods/fml/common/LoadController.java

@@ -0,0 +1,296 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.google.common.base.Functions;
+import com.google.common.base.Joiner;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMap.Builder;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.Subscribe;
+
+import cpw.mods.fml.common.LoaderState.ModState;
+import cpw.mods.fml.common.event.FMLEvent;
+import cpw.mods.fml.common.event.FMLLoadEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.event.FMLStateEvent;
+import cpw.mods.fml.common.functions.ArtifactVersionNameFunction;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+
+public class LoadController
+{
+    private Loader loader;
+    private EventBus masterChannel;
+    private ImmutableMap<String,EventBus> eventChannels;
+    private LoaderState state;
+    private Multimap<String, ModState> modStates = ArrayListMultimap.create();
+    private Multimap<String, Throwable> errors = ArrayListMultimap.create();
+    private Map<String, ModContainer> modList;
+    private List<ModContainer> activeModList = Lists.newArrayList();
+    private ModContainer activeContainer;
+    private BiMap<ModContainer, Object> modObjectList;
+
+    public LoadController(Loader loader)
+    {
+        this.loader = loader;
+        this.masterChannel = new EventBus("FMLMainChannel");
+        this.masterChannel.register(this);
+
+        state = LoaderState.NOINIT;
+
+
+    }
+
+    @Subscribe
+    public void buildModList(FMLLoadEvent event)
+    {
+        this.modList = loader.getIndexedModList();
+        Builder<String, EventBus> eventBus = ImmutableMap.builder();
+
+        for (ModContainer mod : loader.getModList())
+        {
+            EventBus bus = new EventBus(mod.getModId());
+            boolean isActive = mod.registerBus(bus, this);
+            if (isActive)
+            {
+                Level level = Logger.getLogger(mod.getModId()).getLevel();
+                FMLLog.log(mod.getModId(), Level.FINE, "Mod Logging channel %s configured at %s level.", mod.getModId(), level == null ? "default" : level);
+                FMLLog.log(mod.getModId(), Level.INFO, "Activating mod %s", mod.getModId());
+                activeModList.add(mod);
+                modStates.put(mod.getModId(), ModState.UNLOADED);
+                eventBus.put(mod.getModId(), bus);
+            }
+            else
+            {
+                FMLLog.log(mod.getModId(), Level.WARNING, "Mod %s has been disabled through configuration", mod.getModId());
+                modStates.put(mod.getModId(), ModState.UNLOADED);
+                modStates.put(mod.getModId(), ModState.DISABLED);
+            }
+        }
+
+        eventChannels = eventBus.build();
+    }
+
+    public void distributeStateMessage(LoaderState state, Object... eventData)
+    {
+        if (state.hasEvent())
+        {
+            masterChannel.post(state.getEvent(eventData));
+        }
+    }
+
+    public void transition(LoaderState desiredState, boolean forceState)
+    {
+        LoaderState oldState = state;
+        state = state.transition(!errors.isEmpty());
+        if (state != desiredState && !forceState)
+        {
+            Throwable toThrow = null;
+            FMLLog.severe("Fatal errors were detected during the transition from %s to %s. Loading cannot continue", oldState, desiredState);
+            StringBuilder sb = new StringBuilder();
+            printModStates(sb);
+            FMLLog.getLogger().severe(sb.toString());
+            if (errors.size()>0)
+            {
+                FMLLog.severe("The following problems were captured during this phase");
+                for (Entry<String, Throwable> error : errors.entries())
+                {
+                    FMLLog.log(Level.SEVERE, error.getValue(), "Caught exception from %s", error.getKey());
+                    if (error.getValue() instanceof IFMLHandledException)
+                    {
+                        toThrow = error.getValue();
+                    }
+                    else if (toThrow == null)
+                    {
+                        toThrow = error.getValue();
+                    }
+                }
+            }
+            else
+            {
+                FMLLog.severe("The ForgeModLoader state engine has become corrupted. Probably, a state was missed by and invalid modification to a base class" +
+                		"ForgeModLoader depends on. This is a critical error and not recoverable. Investigate any modifications to base classes outside of" +
+                		"ForgeModLoader, especially Optifine, to see if there are fixes available.");
+                throw new RuntimeException("The ForgeModLoader state engine is invalid");
+            }
+            if (toThrow != null && toThrow instanceof RuntimeException)
+            {
+                throw (RuntimeException)toThrow;
+            }
+            else
+            {
+                throw new LoaderException(toThrow);
+            }
+        }
+        else if (state != desiredState && forceState)
+        {
+            FMLLog.info("The state engine was in incorrect state %s and forced into state %s. Errors may have been discarded.", state, desiredState);
+            forceState(desiredState);
+        }
+
+    }
+
+    public ModContainer activeContainer()
+    {
+        return activeContainer;
+    }
+
+    @Subscribe
+    public void propogateStateMessage(FMLEvent stateEvent)
+    {
+        if (stateEvent instanceof FMLPreInitializationEvent)
+        {
+            modObjectList = buildModObjectList();
+        }
+        for (ModContainer mc : activeModList)
+        {
+            sendEventToModContainer(stateEvent, mc);
+        }
+    }
+
+    private void sendEventToModContainer(FMLEvent stateEvent, ModContainer mc)
+    {
+        String modId = mc.getModId();
+        Collection<String> requirements =  Collections2.transform(mc.getRequirements(),new ArtifactVersionNameFunction());
+        for (ArtifactVersion av : mc.getDependencies())
+        {
+            if (av.getLabel()!= null && requirements.contains(av.getLabel()) && modStates.containsEntry(av.getLabel(),ModState.ERRORED))
+            {
+                FMLLog.log(modId, Level.SEVERE, "Skipping event %s and marking errored mod %s since required dependency %s has errored", stateEvent.getEventType(), modId, av.getLabel());
+                modStates.put(modId, ModState.ERRORED);
+                return;
+            }
+        }
+        activeContainer = mc;
+        stateEvent.applyModContainer(activeContainer());
+        FMLLog.log(modId, Level.FINEST, "Sending event %s to mod %s", stateEvent.getEventType(), modId);
+        eventChannels.get(modId).post(stateEvent);
+        FMLLog.log(modId, Level.FINEST, "Sent event %s to mod %s", stateEvent.getEventType(), modId);
+        activeContainer = null;
+        if (stateEvent instanceof FMLStateEvent)
+        {
+            if (!errors.containsKey(modId))
+            {
+                modStates.put(modId, ((FMLStateEvent)stateEvent).getModState());
+            }
+            else
+            {
+                modStates.put(modId, ModState.ERRORED);
+            }
+        }
+    }
+
+    public ImmutableBiMap<ModContainer, Object> buildModObjectList()
+    {
+        ImmutableBiMap.Builder<ModContainer, Object> builder = ImmutableBiMap.<ModContainer, Object>builder();
+        for (ModContainer mc : activeModList)
+        {
+            if (!mc.isImmutable() && mc.getMod()!=null)
+            {
+                builder.put(mc, mc.getMod());
+            }
+            if (mc.getMod()==null && !mc.isImmutable() && state!=LoaderState.CONSTRUCTING)
+            {
+                FMLLog.severe("There is a severe problem with %s - it appears not to have constructed correctly", mc.getModId());
+                if (state != LoaderState.CONSTRUCTING)
+                {
+                    this.errorOccurred(mc, new RuntimeException());
+                }
+            }
+        }
+        return builder.build();
+    }
+
+    public void errorOccurred(ModContainer modContainer, Throwable exception)
+    {
+        if (exception instanceof InvocationTargetException)
+        {
+            errors.put(modContainer.getModId(), ((InvocationTargetException)exception).getCause());
+        }
+        else
+        {
+            errors.put(modContainer.getModId(), exception);
+        }
+    }
+
+    public void printModStates(StringBuilder ret)
+    {
+        for (ModContainer mc : loader.getModList())
+        {
+            ret.append("\n\t").append(mc.getModId()).append("{").append(mc.getVersion()).append("} [").append(mc.getName()).append("] (").append(mc.getSource().getName()).append(") ");
+            Joiner.on("->"). appendTo(ret, modStates.get(mc.getModId()));
+        }
+    }
+
+    public List<ModContainer> getActiveModList()
+    {
+        return activeModList;
+    }
+
+    public ModState getModState(ModContainer selectedMod)
+    {
+        return Iterables.getLast(modStates.get(selectedMod.getModId()), ModState.AVAILABLE);
+    }
+
+    public void distributeStateMessage(Class<?> customEvent)
+    {
+        try
+        {
+            masterChannel.post(customEvent.newInstance());
+        }
+        catch (Exception e)
+        {
+            FMLLog.log(Level.SEVERE, e, "An unexpected exception");
+            throw new LoaderException(e);
+        }
+    }
+
+    public BiMap<ModContainer, Object> getModObjectList()
+    {
+        if (modObjectList == null)
+        {
+            FMLLog.severe("Detected an attempt by a mod %s to perform game activity during mod construction. This is a serious programming error.", activeContainer);
+            return buildModObjectList();
+        }
+        return ImmutableBiMap.copyOf(modObjectList);
+    }
+
+    public boolean isInState(LoaderState state)
+    {
+        return this.state == state;
+    }
+
+	boolean hasReachedState(LoaderState state) {
+		return this.state.ordinal()>=state.ordinal() && this.state!=LoaderState.ERRORED;
+	}
+
+    void forceState(LoaderState newState)
+    {
+        this.state = newState;
+    }
+}

common/cpw/mods/fml/common/Loader.java

@@ -0,0 +1,841 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.logging.Level;
+
+import net.minecraft.crash.CallableMinecraftVersion;
+import net.minecraft.item.ItemStack;
+
+import com.google.common.base.CharMatcher;
+import com.google.common.base.Charsets;
+import com.google.common.base.Function;
+import com.google.common.base.Joiner;
+import com.google.common.base.Joiner.MapJoiner;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableListMultimap.Builder;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.SetMultimap;
+import com.google.common.collect.Sets;
+import com.google.common.collect.Multiset.Entry;
+import com.google.common.collect.Multisets;
+import com.google.common.collect.Ordering;
+import com.google.common.collect.Sets.SetView;
+import com.google.common.collect.Table;
+import com.google.common.collect.TreeMultimap;
+import com.google.common.io.Files;
+
+import cpw.mods.fml.common.LoaderState.ModState;
+import cpw.mods.fml.common.discovery.ModDiscoverer;
+import cpw.mods.fml.common.event.FMLInterModComms;
+import cpw.mods.fml.common.event.FMLLoadEvent;
+import cpw.mods.fml.common.functions.ArtifactVersionNameFunction;
+import cpw.mods.fml.common.functions.ModIdFunction;
+import cpw.mods.fml.common.modloader.BaseModProxy;
+import cpw.mods.fml.common.registry.GameData;
+import cpw.mods.fml.common.toposort.ModSorter;
+import cpw.mods.fml.common.toposort.ModSortingException;
+import cpw.mods.fml.common.toposort.ModSortingException.SortingExceptionData;
+import cpw.mods.fml.common.toposort.TopologicalSort;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.VersionParser;
+import cpw.mods.fml.relauncher.FMLRelaunchLog;
+
+/**
+ * The loader class performs the actual loading of the mod code from disk.
+ *
+ * <p>
+ * There are several {@link LoaderState}s to mod loading, triggered in two
+ * different stages from the FML handler code's hooks into the minecraft code.
+ * </p>
+ *
+ * <ol>
+ * <li>LOADING. Scanning the filesystem for mod containers to load (zips, jars,
+ * directories), adding them to the {@link #modClassLoader} Scanning, the loaded
+ * containers for mod classes to load and registering them appropriately.</li>
+ * <li>PREINIT. The mod classes are configured, they are sorted into a load
+ * order, and instances of the mods are constructed.</li>
+ * <li>INIT. The mod instances are initialized. For BaseMod mods, this involves
+ * calling the load method.</li>
+ * <li>POSTINIT. The mod instances are post initialized. For BaseMod mods this
+ * involves calling the modsLoaded method.</li>
+ * <li>UP. The Loader is complete</li>
+ * <li>ERRORED. The loader encountered an error during the LOADING phase and
+ * dropped to this state instead. It will not complete loading from this state,
+ * but it attempts to continue loading before abandoning and giving a fatal
+ * error.</li>
+ * </ol>
+ *
+ * Phase 1 code triggers the LOADING and PREINIT states. Phase 2 code triggers
+ * the INIT and POSTINIT states.
+ *
+ * @author cpw
+ *
+ */
+public class Loader
+{
+    private static final Splitter DEPENDENCYPARTSPLITTER = Splitter.on(":").omitEmptyStrings().trimResults();
+    private static final Splitter DEPENDENCYSPLITTER = Splitter.on(";").omitEmptyStrings().trimResults();
+    /**
+     * The singleton instance
+     */
+    private static Loader instance;
+    /**
+     * Build information for tracking purposes.
+     */
+    private static String major;
+    private static String minor;
+    private static String rev;
+    private static String build;
+    private static String mccversion;
+    private static String mcpversion;
+
+    /**
+     * The class loader we load the mods into.
+     */
+    private ModClassLoader modClassLoader;
+    /**
+     * The sorted list of mods.
+     */
+    private List<ModContainer> mods;
+    /**
+     * A named list of mods
+     */
+    private Map<String, ModContainer> namedMods;
+    /**
+     * The canonical configuration directory
+     */
+    private File canonicalConfigDir;
+    /**
+     * The canonical minecraft directory
+     */
+    private File canonicalMinecraftDir;
+    /**
+     * The captured error
+     */
+    private Exception capturedError;
+    private File canonicalModsDir;
+    private LoadController modController;
+    private MinecraftDummyContainer minecraft;
+	private MCPDummyContainer mcp;
+
+    private static File minecraftDir;
+    private static List<String> injectedContainers;
+    private File loggingProperties;
+    private ImmutableMap<String, String> fmlBrandingProperties;
+
+    public static Loader instance()
+    {
+        if (instance == null)
+        {
+            instance = new Loader();
+        }
+
+        return instance;
+    }
+
+    public static void injectData(Object... data)
+    {
+        major = (String) data[0];
+        minor = (String) data[1];
+        rev = (String) data[2];
+        build = (String) data[3];
+        mccversion = (String) data[4];
+        mcpversion = (String) data[5];
+        minecraftDir = (File) data[6];
+        injectedContainers = (List<String>)data[7];
+    }
+
+    private Loader()
+    {
+        modClassLoader = new ModClassLoader(getClass().getClassLoader());
+        String actualMCVersion = new CallableMinecraftVersion(null).func_71493_a();
+        if (!mccversion.equals(actualMCVersion))
+        {
+            FMLLog.severe("This version of FML is built for Minecraft %s, we have detected Minecraft %s in your minecraft jar file", mccversion, actualMCVersion);
+            throw new LoaderException();
+        }
+
+        minecraft = new MinecraftDummyContainer(actualMCVersion);
+        mcp = new MCPDummyContainer(MetadataCollection.from(getClass().getResourceAsStream("/mcpmod.info"), "MCP").getMetadataForId("mcp", null));
+    }
+
+    /**
+     * Sort the mods into a sorted list, using dependency information from the
+     * containers. The sorting is performed using a {@link TopologicalSort}
+     * based on the pre- and post- dependency information provided by the mods.
+     */
+    private void sortModList()
+    {
+        FMLLog.finer("Verifying mod requirements are satisfied");
+        try
+        {
+            BiMap<String, ArtifactVersion> modVersions = HashBiMap.create();
+            for (ModContainer mod : getActiveModList())
+            {
+                modVersions.put(mod.getModId(), mod.getProcessedVersion());
+            }
+
+            for (ModContainer mod : getActiveModList())
+            {
+                if (!mod.acceptableMinecraftVersionRange().containsVersion(minecraft.getProcessedVersion()))
+                {
+                    FMLLog.severe("The mod %s does not wish to run in Minecraft version %s. You will have to remove it to play.", mod.getModId(), getMCVersionString());
+                    throw new WrongMinecraftVersionException(mod);
+                }
+                Map<String,ArtifactVersion> names = Maps.uniqueIndex(mod.getRequirements(), new ArtifactVersionNameFunction());
+                Set<ArtifactVersion> versionMissingMods = Sets.newHashSet();
+                Set<String> missingMods = Sets.difference(names.keySet(), modVersions.keySet());
+                if (!missingMods.isEmpty())
+                {
+                    FMLLog.severe("The mod %s (%s) requires mods %s to be available", mod.getModId(), mod.getName(), missingMods);
+                    for (String modid : missingMods)
+                    {
+                        versionMissingMods.add(names.get(modid));
+                    }
+                    throw new MissingModsException(versionMissingMods);
+                }
+                ImmutableList<ArtifactVersion> allDeps = ImmutableList.<ArtifactVersion>builder().addAll(mod.getDependants()).addAll(mod.getDependencies()).build();
+                for (ArtifactVersion v : allDeps)
+                {
+                    if (modVersions.containsKey(v.getLabel()))
+                    {
+                        if (!v.containsVersion(modVersions.get(v.getLabel())))
+                        {
+                            versionMissingMods.add(v);
+                        }
+                    }
+                }
+                if (!versionMissingMods.isEmpty())
+                {
+                    FMLLog.severe("The mod %s (%s) requires mod versions %s to be available", mod.getModId(), mod.getName(), versionMissingMods);
+                    throw new MissingModsException(versionMissingMods);
+                }
+            }
+
+            FMLLog.finer("All mod requirements are satisfied");
+
+            ModSorter sorter = new ModSorter(getActiveModList(), namedMods);
+
+            try
+            {
+                FMLLog.finer("Sorting mods into an ordered list");
+                List<ModContainer> sortedMods = sorter.sort();
+                // Reset active list to the sorted list
+                modController.getActiveModList().clear();
+                modController.getActiveModList().addAll(sortedMods);
+                // And inject the sorted list into the overall list
+                mods.removeAll(sortedMods);
+                sortedMods.addAll(mods);
+                mods = sortedMods;
+                FMLLog.finer("Mod sorting completed successfully");
+            }
+            catch (ModSortingException sortException)
+            {
+                FMLLog.severe("A dependency cycle was detected in the input mod set so an ordering cannot be determined");
+                SortingExceptionData<ModContainer> exceptionData = sortException.getExceptionData();
+                FMLLog.severe("The first mod in the cycle is %s", exceptionData.getFirstBadNode());
+                FMLLog.severe("The mod cycle involves");
+                for (ModContainer mc : exceptionData.getVisitedNodes())
+                {
+                    FMLLog.severe("%s : before: %s, after: %s", mc.toString(), mc.getDependants(), mc.getDependencies());
+                }
+                FMLLog.log(Level.SEVERE, sortException, "The full error");
+                throw sortException;
+            }
+        }
+        finally
+        {
+            FMLLog.fine("Mod sorting data");
+            int unprintedMods = mods.size();
+            for (ModContainer mod : getActiveModList())
+            {
+                if (!mod.isImmutable())
+                {
+                    FMLLog.fine("\t%s(%s:%s): %s (%s)", mod.getModId(), mod.getName(), mod.getVersion(), mod.getSource().getName(), mod.getSortingRules());
+                    unprintedMods--;
+                }
+            }
+            if (unprintedMods == mods.size())
+            {
+                FMLLog.fine("No user mods found to sort");
+            }
+        }
+
+    }
+
+    /**
+     * The primary loading code
+     *
+     * This is visited during first initialization by Minecraft to scan and load
+     * the mods from all sources 1. The minecraft jar itself (for loading of in
+     * jar mods- I would like to remove this if possible but forge depends on it
+     * at present) 2. The mods directory with expanded subdirs, searching for
+     * mods named mod_*.class 3. The mods directory for zip and jar files,
+     * searching for mod classes named mod_*.class again
+     *
+     * The found resources are first loaded into the {@link #modClassLoader}
+     * (always) then scanned for class resources matching the specification
+     * above.
+     *
+     * If they provide the {@link Mod} annotation, they will be loaded as
+     * "FML mods", which currently is effectively a NO-OP. If they are
+     * determined to be {@link BaseModProxy} subclasses they are loaded as such.
+     *
+     * Finally, if they are successfully loaded as classes, they are then added
+     * to the available mod list.
+     */
+    private ModDiscoverer identifyMods()
+    {
+        FMLLog.fine("Building injected Mod Containers %s", injectedContainers);
+        // Add in the MCP mod container
+        mods.add(new InjectedModContainer(mcp,new File("minecraft.jar")));
+        File coremod = new File(minecraftDir,"coremods");
+        for (String cont : injectedContainers)
+        {
+            ModContainer mc;
+            try
+            {
+                mc = (ModContainer) Class.forName(cont,true,modClassLoader).newInstance();
+            }
+            catch (Exception e)
+            {
+                FMLLog.log(Level.SEVERE, e, "A problem occured instantiating the injected mod container %s", cont);
+                throw new LoaderException(e);
+            }
+            mods.add(new InjectedModContainer(mc,coremod));
+        }
+        ModDiscoverer discoverer = new ModDiscoverer();
+        FMLLog.fine("Attempting to load mods contained in the minecraft jar file and associated classes");
+        discoverer.findClasspathMods(modClassLoader);
+        FMLLog.fine("Minecraft jar mods loaded successfully");
+
+        FMLLog.info("Searching %s for mods", canonicalModsDir.getAbsolutePath());
+        discoverer.findModDirMods(canonicalModsDir);
+
+        mods.addAll(discoverer.identifyMods());
+        identifyDuplicates(mods);
+        namedMods = Maps.uniqueIndex(mods, new ModIdFunction());
+        FMLLog.info("Forge Mod Loader has identified %d mod%s to load", mods.size(), mods.size() != 1 ? "s" : "");
+        for (String modId: namedMods.keySet())
+        {
+            FMLLog.makeLog(modId);
+        }
+        return discoverer;
+    }
+
+    private class ModIdComparator implements Comparator<ModContainer>
+    {
+        @Override
+        public int compare(ModContainer o1, ModContainer o2)
+        {
+            return o1.getModId().compareTo(o2.getModId());
+        }
+
+    }
+
+    private void identifyDuplicates(List<ModContainer> mods)
+    {
+        TreeMultimap<ModContainer, File> dupsearch = TreeMultimap.create(new ModIdComparator(), Ordering.arbitrary());
+        for (ModContainer mc : mods)
+        {
+            if (mc.getSource() != null)
+            {
+                dupsearch.put(mc, mc.getSource());
+            }
+        }
+
+        ImmutableMultiset<ModContainer> duplist = Multisets.copyHighestCountFirst(dupsearch.keys());
+        SetMultimap<ModContainer, File> dupes = LinkedHashMultimap.create();
+        for (Entry<ModContainer> e : duplist.entrySet())
+        {
+            if (e.getCount() > 1)
+            {
+                FMLLog.severe("Found a duplicate mod %s at %s", e.getElement().getModId(), dupsearch.get(e.getElement()));
+                dupes.putAll(e.getElement(),dupsearch.get(e.getElement()));
+            }
+        }
+        if (!dupes.isEmpty())
+        {
+        	throw new DuplicateModsFoundException(dupes);
+        }
+    }
+
+    /**
+     *
+     */
+    private void initializeLoader()
+    {
+        File modsDir = new File(minecraftDir, "mods");
+        File configDir = new File(minecraftDir, "config");
+        String canonicalModsPath;
+        String canonicalConfigPath;
+
+        try
+        {
+            canonicalMinecraftDir = minecraftDir.getCanonicalFile();
+            canonicalModsPath = modsDir.getCanonicalPath();
+            canonicalConfigPath = configDir.getCanonicalPath();
+            canonicalConfigDir = configDir.getCanonicalFile();
+            canonicalModsDir = modsDir.getCanonicalFile();
+        }
+        catch (IOException ioe)
+        {
+            FMLLog.log(Level.SEVERE, ioe, "Failed to resolve loader directories: mods : %s ; config %s", canonicalModsDir.getAbsolutePath(),
+                            configDir.getAbsolutePath());
+            throw new LoaderException(ioe);
+        }
+
+        if (!canonicalModsDir.exists())
+        {
+            FMLLog.info("No mod directory found, creating one: %s", canonicalModsPath);
+            boolean dirMade = canonicalModsDir.mkdir();
+            if (!dirMade)
+            {
+                FMLLog.severe("Unable to create the mod directory %s", canonicalModsPath);
+                throw new LoaderException();
+            }
+            FMLLog.info("Mod directory created successfully");
+        }
+
+        if (!canonicalConfigDir.exists())
+        {
+            FMLLog.fine("No config directory found, creating one: %s", canonicalConfigPath);
+            boolean dirMade = canonicalConfigDir.mkdir();
+            if (!dirMade)
+            {
+                FMLLog.severe("Unable to create the config directory %s", canonicalConfigPath);
+                throw new LoaderException();
+            }
+            FMLLog.info("Config directory created successfully");
+        }
+
+        if (!canonicalModsDir.isDirectory())
+        {
+            FMLLog.severe("Attempting to load mods from %s, which is not a directory", canonicalModsPath);
+            throw new LoaderException();
+        }
+
+        if (!configDir.isDirectory())
+        {
+            FMLLog.severe("Attempting to load configuration from %s, which is not a directory", canonicalConfigPath);
+            throw new LoaderException();
+        }
+
+        loggingProperties = new File(canonicalConfigDir, "logging.properties");
+        FMLLog.info("Reading custom logging properties from %s", loggingProperties.getPath());
+        FMLRelaunchLog.loadLogConfiguration(loggingProperties);
+        FMLLog.log(Level.OFF,"Logging level for ForgeModLoader logging is set to %s", FMLRelaunchLog.log.getLogger().getLevel());
+    }
+
+    public List<ModContainer> getModList()
+    {
+        return instance().mods != null ? ImmutableList.copyOf(instance().mods) : ImmutableList.<ModContainer>of();
+    }
+
+    /**
+     * Called from the hook to start mod loading. We trigger the
+     * {@link #identifyMods()} and Constructing, Preinitalization, and Initalization phases here. Finally,
+     * the mod list is frozen completely and is consider immutable from then on.
+     */
+    public void loadMods()
+    {
+        initializeLoader();
+        mods = Lists.newArrayList();
+        namedMods = Maps.newHashMap();
+        modController = new LoadController(this);
+        modController.transition(LoaderState.LOADING, false);
+        ModDiscoverer disc = identifyMods();
+        disableRequestedMods();
+        FMLLog.fine("Reloading logging properties from %s", loggingProperties.getPath());
+        FMLRelaunchLog.loadLogConfiguration(loggingProperties);
+        FMLLog.fine("Reloaded logging properties");
+        modController.distributeStateMessage(FMLLoadEvent.class);
+        sortModList();
+        mods = ImmutableList.copyOf(mods);
+        for (File nonMod : disc.getNonModLibs())
+        {
+            if (nonMod.isFile())
+            {
+                FMLLog.info("FML has found a non-mod file %s in your mods directory. It will now be injected into your classpath. This could severe stability issues, it should be removed if possible.", nonMod.getName());
+                try
+                {
+                    modClassLoader.addFile(nonMod);
+                }
+                catch (MalformedURLException e)
+                {
+                    FMLLog.log(Level.SEVERE, e, "Encountered a weird problem with non-mod file injection : %s", nonMod.getName());
+                }
+            }
+        }
+        modController.transition(LoaderState.CONSTRUCTING, false);
+        modController.distributeStateMessage(LoaderState.CONSTRUCTING, modClassLoader, disc.getASMTable());
+        FMLLog.fine("Mod signature data");
+        for (ModContainer mod : getActiveModList())
+        {
+            FMLLog.fine("\t%s(%s:%s): %s (%s)", mod.getModId(), mod.getName(), mod.getVersion(), mod.getSource().getName(), CertificateHelper.getFingerprint(mod.getSigningCertificate()));
+        }
+        if (getActiveModList().isEmpty())
+        {
+            FMLLog.fine("No user mod signature data found");
+        }
+        modController.transition(LoaderState.PREINITIALIZATION, false);
+        modController.distributeStateMessage(LoaderState.PREINITIALIZATION, disc.getASMTable(), canonicalConfigDir);
+        modController.transition(LoaderState.INITIALIZATION, false);
+    }
+
+    private void disableRequestedMods()
+    {
+        String forcedModList = System.getProperty("fml.modStates", "");
+        FMLLog.finer("Received a system property request \'%s\'",forcedModList);
+        Map<String, String> sysPropertyStateList = Splitter.on(CharMatcher.anyOf(";:"))
+                .omitEmptyStrings().trimResults().withKeyValueSeparator("=")
+                .split(forcedModList);
+        FMLLog.finer("System property request managing the state of %d mods", sysPropertyStateList.size());
+        Map<String, String> modStates = Maps.newHashMap();
+
+        File forcedModFile = new File(canonicalConfigDir, "fmlModState.properties");
+        Properties forcedModListProperties = new Properties();
+        if (forcedModFile.exists() && forcedModFile.isFile())
+        {
+            FMLLog.finer("Found a mod state file %s", forcedModFile.getName());
+            try
+            {
+                forcedModListProperties.load(new FileReader(forcedModFile));
+                FMLLog.finer("Loaded states for %d mods from file", forcedModListProperties.size());
+            }
+            catch (Exception e)
+            {
+                FMLLog.log(Level.INFO, e, "An error occurred reading the fmlModState.properties file");
+            }
+        }
+        modStates.putAll(Maps.fromProperties(forcedModListProperties));
+        modStates.putAll(sysPropertyStateList);
+        FMLLog.fine("After merging, found state information for %d mods", modStates.size());
+
+        Map<String, Boolean> isEnabled = Maps.transformValues(modStates, new Function<String, Boolean>()
+        {
+            public Boolean apply(String input)
+            {
+                return Boolean.parseBoolean(input);
+            }
+        });
+
+        for (Map.Entry<String, Boolean> entry : isEnabled.entrySet())
+        {
+            if (namedMods.containsKey(entry.getKey()))
+            {
+                FMLLog.info("Setting mod %s to enabled state %b", entry.getKey(), entry.getValue());
+                namedMods.get(entry.getKey()).setEnabledState(entry.getValue());
+            }
+        }
+    }
+
+    /**
+     * Query if we know of a mod named modname
+     *
+     * @param modname
+     * @return If the mod is loaded
+     */
+    public static boolean isModLoaded(String modname)
+    {
+        return instance().namedMods.containsKey(modname) && instance().modController.getModState(instance.namedMods.get(modname))!=ModState.DISABLED;
+    }
+
+    public File getConfigDir()
+    {
+        return canonicalConfigDir;
+    }
+
+    public String getCrashInformation()
+    {
+        // Handle being called before we've begun setup
+        if (modController == null)
+        {
+            return "";
+        }
+        StringBuilder ret = new StringBuilder();
+        List<String> branding = FMLCommonHandler.instance().getBrandings();
+
+        Joiner.on(' ').skipNulls().appendTo(ret, branding.subList(1, branding.size()));
+        if (modController!=null)
+        {
+            modController.printModStates(ret);
+        }
+        return ret.toString();
+    }
+
+    public String getFMLVersionString()
+    {
+        return String.format("%s.%s.%s.%s", major, minor, rev, build);
+    }
+
+    public ClassLoader getModClassLoader()
+    {
+        return modClassLoader;
+    }
+
+    public void computeDependencies(String dependencyString, Set<ArtifactVersion> requirements, List<ArtifactVersion> dependencies, List<ArtifactVersion> dependants)
+    {
+        if (dependencyString == null || dependencyString.length() == 0)
+        {
+            return;
+        }
+
+        boolean parseFailure=false;
+
+        for (String dep : DEPENDENCYSPLITTER.split(dependencyString))
+        {
+            List<String> depparts = Lists.newArrayList(DEPENDENCYPARTSPLITTER.split(dep));
+            // Need two parts to the string
+            if (depparts.size() != 2)
+            {
+                parseFailure=true;
+                continue;
+            }
+            String instruction = depparts.get(0);
+            String target = depparts.get(1);
+            boolean targetIsAll = target.startsWith("*");
+
+            // Cannot have an "all" relationship with anything except pure *
+            if (targetIsAll && target.length()>1)
+            {
+                parseFailure = true;
+                continue;
+            }
+
+            // If this is a required element, add it to the required list
+            if ("required-before".equals(instruction) || "required-after".equals(instruction))
+            {
+                // You can't require everything
+                if (!targetIsAll)
+                {
+                    requirements.add(VersionParser.parseVersionReference(target));
+                }
+                else
+                {
+                    parseFailure=true;
+                    continue;
+                }
+            }
+
+            // You cannot have a versioned dependency on everything
+            if (targetIsAll && target.indexOf('@')>-1)
+            {
+                parseFailure = true;
+                continue;
+            }
+            // before elements are things we are loaded before (so they are our dependants)
+            if ("required-before".equals(instruction) || "before".equals(instruction))
+            {
+            	dependants.add(VersionParser.parseVersionReference(target));
+            }
+            // after elements are things that load before we do (so they are out dependencies)
+            else if ("required-after".equals(instruction) || "after".equals(instruction))
+            {
+                dependencies.add(VersionParser.parseVersionReference(target));
+            }
+            else
+            {
+                parseFailure=true;
+            }
+        }
+
+        if (parseFailure)
+        {
+            FMLLog.log(Level.WARNING, "Unable to parse dependency string %s", dependencyString);
+            throw new LoaderException();
+        }
+    }
+
+    public Map<String,ModContainer> getIndexedModList()
+    {
+        return ImmutableMap.copyOf(namedMods);
+    }
+
+    public void initializeMods()
+    {
+        // Mod controller should be in the initialization state here
+        modController.distributeStateMessage(LoaderState.INITIALIZATION);
+        modController.transition(LoaderState.POSTINITIALIZATION, false);
+        // Construct the "mod object table" so mods can refer to it in IMC and postinit
+        GameData.buildModObjectTable();
+        modController.distributeStateMessage(FMLInterModComms.IMCEvent.class);
+        modController.distributeStateMessage(LoaderState.POSTINITIALIZATION);
+        modController.transition(LoaderState.AVAILABLE, false);
+        modController.distributeStateMessage(LoaderState.AVAILABLE);
+        // Dump the custom registry data map, if necessary
+        GameData.dumpRegistry(minecraftDir);
+        FMLLog.info("Forge Mod Loader has successfully loaded %d mod%s", mods.size(), mods.size()==1 ? "" : "s");
+    }
+
+    public ICrashCallable getCallableCrashInformation()
+    {
+        return new ICrashCallable() {
+            @Override
+            public String call() throws Exception
+            {
+                return getCrashInformation();
+            }
+
+            @Override
+            public String getLabel()
+            {
+                return "FML";
+            }
+        };
+    }
+
+    public List<ModContainer> getActiveModList()
+    {
+        return modController != null ? modController.getActiveModList() : ImmutableList.<ModContainer>of();
+    }
+
+    public ModState getModState(ModContainer selectedMod)
+    {
+        return modController.getModState(selectedMod);
+    }
+
+    public String getMCVersionString()
+    {
+        return "Minecraft " + mccversion;
+    }
+
+    public boolean serverStarting(Object server)
+    {
+        try
+        {
+            modController.distributeStateMessage(LoaderState.SERVER_STARTING, server);
+            modController.transition(LoaderState.SERVER_STARTING, false);
+        }
+        catch (Throwable t)
+        {
+            FMLLog.log(Level.SEVERE, t, "A fatal exception occurred during the server starting event");
+            return false;
+        }
+        return true;
+    }
+
+    public void serverStarted()
+    {
+        modController.distributeStateMessage(LoaderState.SERVER_STARTED);
+        modController.transition(LoaderState.SERVER_STARTED, false);
+    }
+
+    public void serverStopping()
+    {
+        modController.distributeStateMessage(LoaderState.SERVER_STOPPING);
+        modController.transition(LoaderState.SERVER_STOPPING, false);
+    }
+
+    public BiMap<ModContainer, Object> getModObjectList()
+    {
+        return modController.getModObjectList();
+    }
+
+    public BiMap<Object, ModContainer> getReversedModObjectList()
+    {
+        return getModObjectList().inverse();
+    }
+
+    public ModContainer activeModContainer()
+    {
+        return modController != null ? modController.activeContainer() : null;
+    }
+
+    public boolean isInState(LoaderState state)
+    {
+        return modController.isInState(state);
+    }
+
+    public MinecraftDummyContainer getMinecraftModContainer()
+    {
+        return minecraft;
+    }
+
+	public boolean hasReachedState(LoaderState state) {
+		return modController != null ? modController.hasReachedState(state) : false;
+	}
+
+	public String getMCPVersionString() {
+		return String.format("MCP v%s", mcpversion);
+	}
+
+    public void serverStopped()
+    {
+        modController.distributeStateMessage(LoaderState.SERVER_STOPPED);
+        modController.transition(LoaderState.SERVER_STOPPED, true);
+        modController.transition(LoaderState.AVAILABLE, true);
+    }
+
+    public boolean serverAboutToStart(Object server)
+    {
+        try
+        {
+            modController.distributeStateMessage(LoaderState.SERVER_ABOUT_TO_START, server);
+            modController.transition(LoaderState.SERVER_ABOUT_TO_START, false);
+        }
+        catch (Throwable t)
+        {
+            FMLLog.log(Level.SEVERE, t, "A fatal exception occurred during the server about to start event");
+            return false;
+        }
+        return true;
+    }
+
+    public Map<String,String> getFMLBrandingProperties()
+    {
+        if (fmlBrandingProperties == null)
+        {
+            Properties loaded = new Properties();
+            try
+            {
+                loaded.load(getClass().getClassLoader().getResourceAsStream("fmlbranding.properties"));
+            }
+            catch (Exception e)
+            {
+                // File not found - ignore
+            }
+            fmlBrandingProperties = Maps.fromProperties(loaded);
+        }
+        return fmlBrandingProperties;
+    }
+
+
+    public Map<String,String> getCustomModProperties(String modId)
+    {
+        return getIndexedModList().get(modId).getCustomModProperties();
+    }
+}

common/cpw/mods/fml/common/LoaderException.java

@@ -0,0 +1,30 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+public class LoaderException extends RuntimeException
+{
+    /**
+     *
+     */
+    private static final long serialVersionUID = -5675297950958861378L;
+
+    public LoaderException(Throwable wrapped)
+    {
+        super(wrapped);
+    }
+
+    public LoaderException()
+    {
+    }
+}

common/cpw/mods/fml/common/LoaderState.java

@@ -0,0 +1,120 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import com.google.common.base.Throwables;
+
+import cpw.mods.fml.common.event.FMLConstructionEvent;
+import cpw.mods.fml.common.event.FMLEvent;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.event.FMLServerAboutToStartEvent;
+import cpw.mods.fml.common.event.FMLServerStartedEvent;
+import cpw.mods.fml.common.event.FMLServerStartingEvent;
+import cpw.mods.fml.common.event.FMLServerStoppedEvent;
+import cpw.mods.fml.common.event.FMLServerStoppingEvent;
+import cpw.mods.fml.common.event.FMLStateEvent;
+
+/**
+ * The state enum used to help track state progression for the loader
+ * @author cpw
+ *
+ */
+public enum LoaderState
+{
+    NOINIT("Uninitialized",null),
+    LOADING("Loading",null),
+    CONSTRUCTING("Constructing mods",FMLConstructionEvent.class),
+    PREINITIALIZATION("Pre-initializing mods", FMLPreInitializationEvent.class),
+    INITIALIZATION("Initializing mods", FMLInitializationEvent.class),
+    POSTINITIALIZATION("Post-initializing mods", FMLPostInitializationEvent.class),
+    AVAILABLE("Mod loading complete", FMLLoadCompleteEvent.class),
+    SERVER_ABOUT_TO_START("Server about to start", FMLServerAboutToStartEvent.class),
+    SERVER_STARTING("Server starting", FMLServerStartingEvent.class),
+    SERVER_STARTED("Server started", FMLServerStartedEvent.class),
+    SERVER_STOPPING("Server stopping", FMLServerStoppingEvent.class),
+    SERVER_STOPPED("Server stopped", FMLServerStoppedEvent.class),
+    ERRORED("Mod Loading errored",null);
+
+
+    private Class<? extends FMLStateEvent> eventClass;
+    private String name;
+
+    private LoaderState(String name, Class<? extends FMLStateEvent> event)
+    {
+        this.name = name;
+        this.eventClass = event;
+    }
+
+    public LoaderState transition(boolean errored)
+    {
+        if (errored)
+        {
+            return ERRORED;
+        }
+        // stopping -> available
+        if (this == SERVER_STOPPED)
+        {
+            return AVAILABLE;
+        }
+        return values()[ordinal() < values().length ? ordinal()+1 : ordinal()];
+    }
+
+    public boolean hasEvent()
+    {
+        return eventClass != null;
+    }
+
+    public FMLStateEvent getEvent(Object... eventData)
+    {
+        try
+        {
+            return eventClass.getConstructor(Object[].class).newInstance((Object)eventData);
+        }
+        catch (Exception e)
+        {
+            throw Throwables.propagate(e);
+        }
+    }
+    public LoaderState requiredState()
+    {
+        if (this == NOINIT) return NOINIT;
+        return LoaderState.values()[this.ordinal()-1];
+    }
+    public enum ModState
+    {
+        UNLOADED("Unloaded"),
+        LOADED("Loaded"),
+        CONSTRUCTED("Constructed"),
+        PREINITIALIZED("Pre-initialized"),
+        INITIALIZED("Initialized"),
+        POSTINITIALIZED("Post-initialized"),
+        AVAILABLE("Available"),
+        DISABLED("Disabled"),
+        ERRORED("Errored");
+
+        private String label;
+
+        private ModState(String label)
+        {
+            this.label = label;
+        }
+
+        public String toString()
+        {
+            return this.label;
+        }
+    }
+}

common/cpw/mods/fml/common/MCPDummyContainer.java

@@ -0,0 +1,26 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import com.google.common.eventbus.EventBus;
+
+public class MCPDummyContainer extends DummyModContainer {
+	public MCPDummyContainer(ModMetadata metadata) {
+		super(metadata);
+	}
+
+	@Override
+	public boolean registerBus(EventBus bus, LoadController controller) {
+		return true;
+	}
+}

common/cpw/mods/fml/common/MetadataCollection.java

@@ -0,0 +1,103 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Map;
+import java.util.logging.Level;
+
+import argo.jdom.JdomParser;
+import argo.jdom.JsonNode;
+import argo.jdom.JsonRootNode;
+import argo.saj.InvalidSyntaxException;
+
+import com.google.common.base.Throwables;
+import com.google.common.collect.Maps;
+
+public class MetadataCollection
+{
+    private static JdomParser parser = new JdomParser();
+    private Map<String, ModMetadata> metadatas = Maps.newHashMap();
+    private int metadataVersion = 1;
+
+    public static MetadataCollection from(InputStream inputStream, String sourceName)
+    {
+        if (inputStream == null)
+        {
+            return new MetadataCollection();
+        }
+
+        InputStreamReader reader = new InputStreamReader(inputStream);
+        try
+        {
+            JsonRootNode root = parser.parse(reader);
+            if (root.hasElements())
+            {
+                return parse10ModInfo(root);
+            }
+            else
+            {
+                return parseModInfo(root);
+            }
+        }
+        catch (InvalidSyntaxException e)
+        {
+            FMLLog.log(Level.SEVERE, e, "The mcmod.info file in %s cannot be parsed as valid JSON. It will be ignored", sourceName);
+            return new MetadataCollection();
+        }
+        catch (Exception e)
+        {
+            throw Throwables.propagate(e);
+        }
+    }
+
+    private static MetadataCollection parseModInfo(JsonRootNode root)
+    {
+        MetadataCollection mc = new MetadataCollection();
+        mc.metadataVersion = Integer.parseInt(root.getNumberValue("modinfoversion"));
+        mc.parseModMetadataList(root.getNode("modlist"));
+        return mc;
+    }
+
+    private static MetadataCollection parse10ModInfo(JsonRootNode root)
+    {
+        MetadataCollection mc = new MetadataCollection();
+        mc.parseModMetadataList(root);
+        return mc;
+    }
+
+    private void parseModMetadataList(JsonNode metadataList)
+    {
+        for (JsonNode node : metadataList.getElements())
+        {
+            ModMetadata mmd = new ModMetadata(node);
+            metadatas.put(mmd.modId, mmd);
+        }
+    }
+
+    public ModMetadata getMetadataForId(String modId, Map<String, Object> extraData)
+    {
+        if (!metadatas.containsKey(modId))
+        {
+            ModMetadata dummy = new ModMetadata();
+            dummy.modId = modId;
+            dummy.name = (String) extraData.get("name");
+            dummy.version = (String) extraData.get("version");
+            dummy.autogenerated = true;
+            metadatas.put(modId, dummy);
+        }
+        return metadatas.get(modId);
+    }
+
+}

common/cpw/mods/fml/common/MinecraftDummyContainer.java

@@ -0,0 +1,38 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
+import cpw.mods.fml.common.versioning.VersionParser;
+import cpw.mods.fml.common.versioning.VersionRange;
+
+public class MinecraftDummyContainer extends DummyModContainer
+{
+
+    private VersionRange staticRange;
+    public MinecraftDummyContainer(String actualMCVersion)
+    {
+        super(new ModMetadata());
+        getMetadata().modId = "Minecraft";
+        getMetadata().name = "Minecraft";
+        getMetadata().version = actualMCVersion;
+        staticRange = VersionParser.parseRange("["+actualMCVersion+"]");
+    }
+
+
+    public VersionRange getStaticVersionRange()
+    {
+        return staticRange;
+    }
+}

common/cpw/mods/fml/common/MissingModsException.java

@@ -0,0 +1,30 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.Set;
+
+import com.google.common.collect.Sets.SetView;
+
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+
+public class MissingModsException extends RuntimeException
+{
+
+    public Set<ArtifactVersion> missingMods;
+
+    public MissingModsException(Set<ArtifactVersion> missingMods)
+    {
+        this.missingMods = missingMods;
+    }
+}

common/cpw/mods/fml/common/Mod.java

@@ -0,0 +1,428 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import net.minecraft.item.ItemBlock;
+import net.minecraft.network.packet.Packet250CustomPayload;
+
+import cpw.mods.fml.common.event.FMLFingerprintViolationEvent;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLInterModComms;
+import cpw.mods.fml.common.event.FMLInterModComms.IMCEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLInterModComms.IMCMessage;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.event.FMLServerAboutToStartEvent;
+import cpw.mods.fml.common.event.FMLServerStartedEvent;
+import cpw.mods.fml.common.event.FMLServerStartingEvent;
+import cpw.mods.fml.common.event.FMLServerStoppedEvent;
+import cpw.mods.fml.common.event.FMLServerStoppingEvent;
+import cpw.mods.fml.common.event.FMLStateEvent;
+import cpw.mods.fml.common.network.IPacketHandler;
+import cpw.mods.fml.common.network.NetworkMod;
+import cpw.mods.fml.common.registry.GameRegistry;
+
+/**
+ * This defines a Mod to FML.
+ * Any class found with this annotation applied will be loaded as a Mod. The instance that is loaded will
+ * represent the mod to other Mods in the system. It will be sent various subclasses of {@link FMLEvent}
+ * at pre-defined times during the loading of the game, based on where you have applied the {@link EventHandler}
+ * annotation.
+ *
+ * This annotation is usually paired with a second annotation {@link NetworkMod}, which declares the
+ * network related properties of this mod.
+ *
+ * <p>This is a simple example of a Mod. It has the modId of "MyModId", the name of "My example mod", it is
+ * version 1.0, and depends on FML being loaded. It has the {@link NetworkMod} annotation as well, declaring it uses channel
+ * "MyModChannel" and {@link IPacketHandler} class PacketHandler.
+ * <pre>{@code
+ * package mymod;
+ * // Declare that this is a mod with modId "MyModId", name "My example mod", version "1.0" and dependency on FML.
+ * {@literal @}Mod(modId="MyModId",name="My example mod",version="1.0",dependencies="required-after:FML")
+ * // Declare that this is a network mod using the {@link Packet250CustomPayload} channel "MyModChannel", required on the client if it's present
+ * // on the server, with {@link IPacketHandler} class PacketHandler.
+ * {@literal @}NetworkMod(channels = { "MyModChannel" }, clientSideRequired = true, serverSideRequired = false, packetHandler = PacketHandler.class)
+ * public class MyMod {
+ *      // Populate this field with the instance of the mod created by FML
+ *      {@literal @}Instance("MyModId")
+ *      public MyMod instance;
+ *
+ *      // Mark this method for receiving an {@link FMLEvent} (in this case, it's the {@link FMLPreInitializationEvent})
+ *      {@literal @}EventHandler public void preInit(FMLPreInitializationEvent event)
+ *      {
+ *          // Do stuff in pre-init phase (read config, create blocks and items, register them)
+ *      }
+ * }
+ * </pre>
+ *
+ * @author cpw
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Mod
+{
+    /**
+     * The unique mod identifier for this mod
+     */
+    String modid();
+    /**
+     * A user friendly name for the mod
+     */
+    String name() default "";
+    /**
+     * A version string for this mod
+     */
+    String version() default "";
+    /**
+     * A simple dependency string for this mod (see modloader's "priorities" string specification)
+     */
+    String dependencies() default "";
+    /**
+     * Whether to use the mcmod.info metadata by default for this mod.
+     * If true, settings in the mcmod.info file will override settings in these annotations.
+     */
+    boolean useMetadata() default false;
+
+    /**
+     * The acceptable range of minecraft versions that this mod will load and run in
+     * The default ("empty string") indicates that only the current minecraft version is acceptable.
+     * FML will refuse to run with an error if the minecraft version is not in this range across all mods.
+     * @return A version range as specified by the maven version range specification or the empty string
+     */
+    String acceptedMinecraftVersions() default "";
+    /**
+     * An optional bukkit plugin that will be injected into the bukkit plugin framework if
+     * this mod is loaded into the FML framework and the bukkit coremod is present.
+     * Instances of the bukkit plugin can be obtained via the {@link BukkitPluginRef} annotation on fields.
+     *
+     * This may be implemented by a bukkit integration. It is not provided with vanilla FML or MinecraftForge.
+     *
+     * @return The name of the plugin to load for this mod
+     */
+    String bukkitPlugin() default "";
+    /**
+     * NOT YET IMPLEMENTED.</br>
+     * Mods that this mod will <strong>not</strong> load with.
+     * An optional comma separated string of (+|-)(*|modid[@value]) which specify mods that
+     * this mod will refuse to load with, resulting in the game failing to start.
+     * Entries can be prefixed with a + for a positive exclusion assertion, or - for a negative exclusion
+     * assertion. Asterisk is the wildcard and represents <strong>all</strong> mods.
+     *
+     * The <strong>only</strong> mods that cannot be excluded are FML and MCP, trivially.
+     * Other special values:
+     * <ul>
+     * <li>+f indicates that the mod will accept a minecraft forge environment.</li>
+     * <li>-* indicates that the mod will not accept any other mods.</li>
+     * </ul>
+     *
+     * Some examples:
+     * <ul>
+     * <li><em>-*,+f,+IronChest</em>: Will run only in a minecraft forge environment with the mod IronChests.
+     * The -* forces all mods to be excluded, then the +f and +IronChest add into the "allowed list".</li>
+     * <li><em>+f,-IC2</em>: Will run in a minecraft forge environment but will <strong>not</strong> run if
+     * IndustrialCraft 2 (IC2) is loaded alongside.</li>
+     * <li><em>-*</em>: Will not run if <strong>any</strong> othe mod is loaded except MCP/FML itself.</li>
+     * </ul>
+     *
+     * If a mod is present on the excluded list, the game will stop and show an error screen. If the
+     * class containing the {@link Mod} annotation has a "getCustomErrorException" method, it will be
+     * called to retrieve a custom error message for display in this case. If two mods have a declared
+     * exclusion which is matched, the screen that is shown is indeterminate.
+     *
+     * @return A string listing modids to exclude from loading with this mod.
+     */
+    @Deprecated
+    String modExclusionList() default "";
+    /**
+     * Specifying this field allows for a mod to expect a signed jar with a fingerprint matching this value.
+     * The fingerprint should be SHA-1 encoded, lowercase with ':' removed. An empty value indicates that
+     * the mod is not expecting to be signed.
+     *
+     * Any incorrectness of the fingerprint, be it missing or wrong, will result in the {@link FMLFingerprintViolationEvent}
+     * event firing <i>prior to any other event on the mod</i>.
+     *
+     * @return A certificate fingerprint that is expected for this mod.
+     */
+    String certificateFingerprint() default "";
+
+    /**
+     * The language the mod is authored in. This will be used to control certain compatibility behaviours for this mod.
+     * Valid values are currently "java", "scala"
+     *
+     * @return The language the mod is authored in
+     */
+    String modLanguage() default "java";
+    /**
+     * NOT YET IMPLEMENTED. </br>
+     * An optional ASM hook class, that can be used to apply ASM to classes loaded from this mod. It is also given
+     * the ASM tree of the class declaring {@link Mod} to do with what it will.
+     *
+     * @return The name of a class to be loaded and executed. Must implement {@link IASMHook}.
+     */
+    @Deprecated
+    String asmHookClass() default "";
+
+    /**
+     * A list of custom properties for this mod. Completely up to the mod author if/when they
+     * want to put anything in here.
+     * @return an optional list of custom properties
+     */
+    CustomProperty[] customProperties() default {};
+
+    /**
+     * A custom key => value property pair for use with {@link Mod#customProperties()}
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({})
+    public @interface CustomProperty
+    {
+        /**
+         * A key. Should be unique.
+         * @return A key
+         */
+        String k();
+        /**
+         * A value. Can be anything.
+         * @return A value
+         */
+        String v();
+    }
+    /**
+     * Marks the associated method as handling an FML lifecycle event.
+     * The method must have a single parameter, one of the following types. This annotation
+     * replaces the multiple different annotations that previously were used.
+     *
+     * Current event classes. This first section is standard lifecycle events. They are dispatched
+     * at various phases as the game starts. Each event should have information useful to that
+     * phase of the lifecycle. They are fired in this order.
+     *
+     * These suggestions are mostly just suggestions on what to do in each event.
+     * <ul>
+     * <li> {@link FMLPreInitializationEvent} : Run before anything else. Read your config, create blocks,
+     * items, etc, and register them with the {@link GameRegistry}.</li>
+     * <li> {@link FMLInitializationEvent} : Do your mod setup. Build whatever data structures you care about. Register recipes,
+     * send {@link FMLInterModComms} messages to other mods.</li>
+     * <li> {@link FMLPostInitializationEvent} : Handle interaction with other mods, complete your setup based on this.</li>
+     * </ul>
+     * <p>These are the server lifecycle events. They are fired whenever a server is running, or about to run. Each time a server
+     * starts they will be fired in this sequence.
+     * <ul>
+     * <li> {@link FMLServerAboutToStartEvent} : Use if you need to handle something before the server has even been created.</li>
+     * <li> {@link FMLServerStartingEvent} : Do stuff you need to do to set up the server. register commands, tweak the server.</li>
+     * <li> {@link FMLServerStartedEvent} : Do what you need to with the running server.</li>
+     * <li> {@link FMLServerStoppingEvent} : Do what you need to before the server has started it's shutdown sequence.</li>
+     * <li> {@link FMLServerStoppedEvent} : Do whatever cleanup you need once the server has shutdown. Generally only useful
+     * on the integrated server.</li>
+     * </ul>
+     * The second set of events are more specialized, for receiving notification of specific
+     * information.
+     * <ul>
+     * <li> {@link FMLFingerprintViolationEvent} : Sent just before {@link FMLPreInitializationEvent}
+     * if something is wrong with your mod signature</li>
+     * <li> {@link IMCEvent} : Sent just after {@link FMLInitializationEvent} if you have IMC messages waiting
+     * from other mods</li>
+     * </ul>
+     *
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    public @interface EventHandler{}
+
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as to be called at if there is something wrong with the certificate fingerprint of
+     * the mod's jar, or it is missing, or otherwise a problem.
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface FingerprintWarning {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "pre-initialization" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface PreInit {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "initialization" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface Init {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "post-initialization" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface PostInit {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "server-about-to-start" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface ServerAboutToStart {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "server-starting" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface ServerStarting {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "server-started" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface ServerStarted {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "server-stopping" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface ServerStopping {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as being called at the "server-stopped" phase
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface ServerStopped {}
+    /**
+     * Deprecated for {@link EventHandler}<br/>
+     * Mark the designated method as the receiver for {@link FMLInterModComms} messages
+     * Called between {@link Init} and {@link PostInit}
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.METHOD)
+    @Deprecated
+    public @interface IMCCallback {}
+    /**
+     * Populate the annotated field with the mod instance based on the specified ModId. This can be used
+     * to retrieve instances of other mods.
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    public @interface Instance {
+        /**
+         * The mod object to inject into this field
+         */
+        String value() default "";
+    }
+    /**
+     * Populate the annotated field with the mod's metadata.
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    public @interface Metadata {
+        /**
+         * The mod id specifying the metadata to load here
+         */
+        String value() default "";
+    }
+    /**
+     * NOT IMPLEMENTED AND SCHEDULED FOR REMOVAL.<br/>
+     * Populate the annotated field with an instance of the Block as specified. This never worked. It will be removed.
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    @Deprecated
+    public @interface Block {
+        /**
+         * The block's name
+         */
+        String name();
+        /**
+         * The associated ItemBlock subtype for the item (can be null for an ItemBlock)
+         */
+        Class<?> itemTypeClass() default ItemBlock.class;
+    }
+    /**
+     * NOT IMPLEMENTED AND SCHEDULED FOR REMOVAL.<br/>
+     * Populate the annotated field with an Item. This never worked. It will be removed.
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    @Deprecated
+    public @interface Item {
+        /**
+         * The name of the item
+         */
+        String name();
+        /**
+         * The type of the item
+         */
+        String typeClass();
+    }
+
+    /**
+     * Mod instance factory method. Should return an instance of the mod. Applies only to static methods on the same class as {@link Mod}.
+     * @author cpw
+     *
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    public @interface InstanceFactory {
+    }
+}

common/cpw/mods/fml/common/ModClassLoader.java

@@ -0,0 +1,89 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.List;
+import java.util.logging.Level;
+
+import net.minecraft.launchwrapper.LaunchClassLoader;
+
+import com.google.common.collect.ImmutableList;
+
+import cpw.mods.fml.common.asm.ASMTransformer;
+import cpw.mods.fml.common.asm.transformers.AccessTransformer;
+import cpw.mods.fml.common.modloader.BaseModProxy;
+
+/**
+ * A simple delegating class loader used to load mods into the system
+ *
+ *
+ * @author cpw
+ *
+ */
+public class ModClassLoader extends URLClassLoader
+{
+    private static final List<String> STANDARD_LIBRARIES = ImmutableList.of("jinput.jar", "lwjgl.jar", "lwjgl_util.jar");
+    private LaunchClassLoader mainClassLoader;
+
+    public ModClassLoader(ClassLoader parent) {
+        super(new URL[0], null);
+        this.mainClassLoader = (LaunchClassLoader)parent;
+    }
+
+    public void addFile(File modFile) throws MalformedURLException
+    {
+        URL url = modFile.toURI().toURL();
+        mainClassLoader.addURL(url);
+    }
+
+    @Override
+    public Class<?> loadClass(String name) throws ClassNotFoundException
+    {
+        return mainClassLoader.loadClass(name);
+    }
+
+    public File[] getParentSources() {
+        List<URL> urls=mainClassLoader.getSources();
+        File[] sources=new File[urls.size()];
+        try
+        {
+            for (int i = 0; i<urls.size(); i++)
+            {
+                sources[i]=new File(urls.get(i).toURI());
+            }
+            return sources;
+        }
+        catch (URISyntaxException e)
+        {
+            FMLLog.log(Level.SEVERE, e, "Unable to process our input to locate the minecraft code");
+            throw new LoaderException(e);
+        }
+    }
+
+    public List<String> getDefaultLibraries()
+    {
+        return STANDARD_LIBRARIES;
+    }
+
+    public Class<? extends BaseModProxy> loadBaseModClass(String modClazzName) throws Exception
+    {
+        AccessTransformer transformer = (AccessTransformer)mainClassLoader.getTransformers().get(0);
+        transformer.ensurePublicAccessFor(modClazzName);
+        return (Class<? extends BaseModProxy>) Class.forName(modClazzName, true, this);
+    }
+}

common/cpw/mods/fml/common/ModContainer.java

@@ -0,0 +1,139 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.File;
+import java.security.cert.Certificate;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.eventbus.EventBus;
+
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.VersionRange;
+
+/**
+ * The container that wraps around mods in the system.
+ * <p>
+ * The philosophy is that individual mod implementation technologies should not
+ * impact the actual loading and management of mod code. This interface provides
+ * a mechanism by which we can wrap actual mod code so that the loader and other
+ * facilities can treat mods at arms length.
+ * </p>
+ *
+ * @author cpw
+ *
+ */
+
+public interface ModContainer
+{
+    /**
+     * The globally unique modid for this mod
+     */
+    String getModId();
+
+    /**
+     * A human readable name
+     */
+
+    String getName();
+
+    /**
+     * A human readable version identifier
+     */
+    String getVersion();
+
+    /**
+     * The location on the file system which this mod came from
+     */
+    File getSource();
+
+    /**
+     * The metadata for this mod
+     */
+    ModMetadata getMetadata();
+
+    /**
+     * Attach this mod to it's metadata from the supplied metadata collection
+     */
+    void bindMetadata(MetadataCollection mc);
+
+    /**
+     * Set the enabled/disabled state of this mod
+     */
+    void setEnabledState(boolean enabled);
+
+    /**
+     * A list of the modids that this mod requires loaded prior to loading
+     */
+    Set<ArtifactVersion> getRequirements();
+
+    /**
+     * A list of modids that should be loaded prior to this one. The special
+     * value <strong>*</strong> indicates to load <em>after</em> any other mod.
+     */
+    List<ArtifactVersion> getDependencies();
+
+    /**
+     * A list of modids that should be loaded <em>after</em> this one. The
+     * special value <strong>*</strong> indicates to load <em>before</em> any
+     * other mod.
+     */
+    List<ArtifactVersion> getDependants();
+
+    /**
+     * A representative string encapsulating the sorting preferences for this
+     * mod
+     */
+    String getSortingRules();
+
+    /**
+     * Register the event bus for the mod and the controller for error handling
+     * Returns if this bus was successfully registered - disabled mods and other
+     * mods that don't need real events should return false and avoid further
+     * processing
+     *
+     * @param bus
+     * @param controller
+     */
+    boolean registerBus(EventBus bus, LoadController controller);
+
+    /**
+     * Does this mod match the supplied mod
+     *
+     * @param mod
+     */
+    boolean matches(Object mod);
+
+    /**
+     * Get the actual mod object
+     */
+    Object getMod();
+
+    ArtifactVersion getProcessedVersion();
+
+    boolean isImmutable();
+
+    boolean isNetworkMod();
+
+    String getDisplayVersion();
+
+    VersionRange acceptableMinecraftVersionRange();
+
+    Certificate getSigningCertificate();
+
+    public static final Map<String,String> EMPTY_PROPERTIES = ImmutableMap.of();
+    Map<String,String> getCustomModProperties();
+}

common/cpw/mods/fml/common/ModContainerFactory.java

@@ -0,0 +1,70 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+import org.objectweb.asm.Type;
+
+import cpw.mods.fml.common.discovery.ModCandidate;
+import cpw.mods.fml.common.discovery.asm.ASMModParser;
+import cpw.mods.fml.common.discovery.asm.ModAnnotation;
+import cpw.mods.fml.common.modloader.ModLoaderModContainer;
+
+public class ModContainerFactory
+{
+    private static Pattern modClass = Pattern.compile(".*(\\.|)(mod\\_[^\\s$]+)$");
+    private static ModContainerFactory INSTANCE = new ModContainerFactory();
+    public static ModContainerFactory instance() {
+        return INSTANCE;
+    }
+    public ModContainer build(ASMModParser modParser, File modSource, ModCandidate container)
+    {
+        String className = modParser.getASMType().getClassName();
+        if (modParser.isBaseMod(container.getRememberedBaseMods()) && modClass.matcher(className).find())
+        {
+            FMLLog.fine("Identified a BaseMod type mod %s", className);
+            return new ModLoaderModContainer(className, modSource, modParser.getBaseModProperties());
+        }
+        else if (modClass.matcher(className).find())
+        {
+            FMLLog.fine("Identified a class %s following modloader naming convention but not directly a BaseMod or currently seen subclass", className);
+            container.rememberModCandidateType(modParser);
+        }
+        else if (modParser.isBaseMod(container.getRememberedBaseMods()))
+        {
+            FMLLog.fine("Found a basemod %s of non-standard naming format", className);
+            container.rememberBaseModType(className);
+        }
+
+        // We warn if it's not a basemod instance -- compatibility requires it to be in net.minecraft.src *sigh*
+        if (className.startsWith("net.minecraft.src.") && container.isClasspath() && !container.isMinecraftJar())
+        {
+            FMLLog.severe("FML has detected a mod that is using a package name based on 'net.minecraft.src' : %s. This is generally a severe programming error. "
+                    + " There should be no mod code in the minecraft namespace. MOVE YOUR MOD! If you're in eclipse, select your source code and 'refactor' it into "
+                    + "a new package. Go on. DO IT NOW!",className);
+        }
+
+        for (ModAnnotation ann : modParser.getAnnotations())
+        {
+            if (ann.getASMType().equals(Type.getType(Mod.class)))
+            {
+                FMLLog.fine("Identified an FMLMod type mod %s", className);
+                return new FMLModContainer(className, modSource, ann.getValues());
+            }
+        }
+
+        return null;
+    }
+}

common/cpw/mods/fml/common/ModMetadata.java

@@ -0,0 +1,162 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import static argo.jdom.JsonNodeBuilders.aStringBuilder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+
+import argo.jdom.JsonNode;
+import argo.jdom.JsonStringNode;
+
+import com.google.common.base.Function;
+import com.google.common.base.Joiner;
+import com.google.common.base.Objects;
+import com.google.common.base.Optional;
+import com.google.common.base.Strings;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+import cpw.mods.fml.common.functions.ModNameFunction;
+import cpw.mods.fml.common.versioning.ArtifactVersion;
+import cpw.mods.fml.common.versioning.VersionParser;
+
+/**
+ * @author cpw
+ *
+ */
+public class ModMetadata
+{
+    private static final class JsonStringConverter implements Function<JsonNode, Object>
+    {
+        public Object apply(JsonNode arg0)
+        {
+            if (arg0.hasElements())
+            {
+                return Lists.transform(arg0.getElements(), new JsonArrayConverter());
+            }
+            else
+            {
+                return arg0.getText();
+            }
+        }
+    }
+
+    private static final class JsonArrayConverter implements Function<JsonNode, String>
+    {
+        public String apply(JsonNode arg0)
+        {
+            return arg0.getText();
+        }
+    }
+
+    public String modId;
+    public String name;
+    public String description;
+
+    public String url = "";
+    public String updateUrl = "";
+
+    public String logoFile = "";
+    public String version = "";
+    public List<String> authorList = Lists.newArrayList();
+    public String credits = "";
+    public String parent = "";
+    public String[] screenshots;
+
+    public ModContainer parentMod;
+    public List<ModContainer> childMods = Lists.newArrayList();
+
+    public boolean useDependencyInformation;
+    public Set<ArtifactVersion> requiredMods;
+    public List<ArtifactVersion> dependencies;
+    public List<ArtifactVersion> dependants;
+    public boolean autogenerated;
+
+    public ModMetadata(JsonNode node)
+    {
+        Map<JsonStringNode, Object> processedFields = Maps.transformValues(node.getFields(), new JsonStringConverter());
+        modId = (String)processedFields.get(aStringBuilder("modid"));
+        if (Strings.isNullOrEmpty(modId))
+        {
+            FMLLog.log(Level.SEVERE, "Found an invalid mod metadata file - missing modid");
+            throw new LoaderException();
+        }
+        name = Strings.nullToEmpty((String)processedFields.get(aStringBuilder("name")));
+        description = Strings.nullToEmpty((String)processedFields.get(aStringBuilder("description")));
+        url = Strings.nullToEmpty((String)processedFields.get(aStringBuilder("url")));
+        updateUrl = Strings.nullToEmpty((String)processedFields.get(aStringBuilder("updateUrl")));
+        logoFile = Strings.nullToEmpty((String)processedFields.get(aStringBuilder("logoFile")));
+        version = Strings.nullToEmpty((String)processedFields.get(aStringBuilder("version")));
+        credits = Strings.nullToEmpty((String)processedFields.get(aStringBuilder("credits")));
+        parent =  Strings.nullToEmpty((String)processedFields.get(aStringBuilder("parent")));
+        authorList = Objects.firstNonNull(((List<String>)processedFields.get(aStringBuilder("authors"))),Objects.firstNonNull(((List<String>)processedFields.get(aStringBuilder("authorList"))), authorList));
+        requiredMods = processReferences(processedFields.get(aStringBuilder("requiredMods")), HashSet.class);
+        dependencies = processReferences(processedFields.get(aStringBuilder("dependencies")), ArrayList.class);
+        dependants = processReferences(processedFields.get(aStringBuilder("dependants")), ArrayList.class);
+        useDependencyInformation = Boolean.parseBoolean(Strings.nullToEmpty((String)processedFields.get(aStringBuilder("useDependencyInformation"))));
+    }
+
+    public ModMetadata()
+    {
+    }
+
+    private <T extends Collection<ArtifactVersion>> T processReferences(Object refs, Class<? extends T> retType)
+    {
+        T res = null;
+        try
+        {
+            res = retType.newInstance();
+        }
+        catch (Exception e)
+        {
+            // unpossible
+        }
+
+        if (refs == null)
+        {
+            return res;
+        }
+        for (String ref : ((List<String>)refs))
+        {
+            res.add(VersionParser.parseVersionReference(ref));
+        }
+        return res;
+    }
+
+    public String getChildModCountString()
+    {
+        return String.format("%d child mod%s", childMods.size(), childMods.size() != 1 ? "s" : "");
+    }
+
+    public String getAuthorList()
+    {
+        return Joiner.on(", ").join(authorList);
+    }
+
+    public String getChildModList()
+    {
+        return Joiner.on(", ").join(Lists.transform(childMods, new ModNameFunction()));
+    }
+
+    public String printableSortingRules()
+    {
+        return "";
+    }
+}

common/cpw/mods/fml/common/ObfuscationReflectionHelper.java

@@ -0,0 +1,117 @@
+/*
+ * 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.common;
+
+import java.util.Arrays;
+import java.util.logging.Level;
+
+import cpw.mods.fml.common.asm.transformers.deobf.FMLDeobfuscatingRemapper;
+import cpw.mods.fml.relauncher.ReflectionHelper;
+import cpw.mods.fml.relauncher.ReflectionHelper.UnableToAccessFieldException;
+import cpw.mods.fml.relauncher.ReflectionHelper.UnableToFindFieldException;
+
+/**
+ * Some reflection helper code.
+ *
+ * @author cpw
+ *
+ */
+public class ObfuscationReflectionHelper
+{
+    @SuppressWarnings("unchecked")
+    public static <T, E> T getPrivateValue(Class<? super E> classToAccess, E instance, int fieldIndex)
+    {
+        try
+        {
+            return ReflectionHelper.getPrivateValue(classToAccess, instance, fieldIndex);
+        }
+        catch (UnableToAccessFieldException e)
+        {
+            FMLLog.log(Level.SEVERE, e, "There was a problem getting field index %d from %s", fieldIndex, classToAccess.getName());
+            throw e;
+        }
+    }
+
+    public static String[] remapFieldNames(String className, String... fieldNames)
+    {
+        String internalClassName = FMLDeobfuscatingRemapper.INSTANCE.unmap(className.replace('.', '/'));
+        String[] mappedNames = new String[fieldNames.length];
+        int i = 0;
+        for (String fName : fieldNames)
+        {
+            mappedNames[i++] = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(internalClassName, fName, null);
+        }
+        return mappedNames;
+    }
+    @SuppressWarnings("unchecked")
+    public static <T, E> T getPrivateValue(Class<? super E> classToAccess, E instance, String... fieldNames)
+    {
+        try
+        {
+            return ReflectionHelper.getPrivateValue(classToAccess, instance, remapFieldNames(classToAccess.getName(),fieldNames));
+        }
+        catch (UnableToFindFieldException e)
+        {
+            FMLLog.log(Level.SEVERE,e,"Unable to locate any field %s on type %s", Arrays.toString(fieldNames), classToAccess.getName());
+            throw e;
+        }
+        catch (UnableToAccessFieldException e)
+        {
+            FMLLog.log(Level.SEVERE, e, "Unable to access any field %s on type %s", Arrays.toString(fieldNames), classToAccess.getName());
+            throw e;
+        }
+    }
+
+    @Deprecated
+    public static <T, E> void setPrivateValue(Class<? super T> classToAccess, T instance, int fieldIndex, E value)
+    {
+        setPrivateValue(classToAccess, instance, value, fieldIndex);
+    }
+
+    public static <T, E> void setPrivateValue(Class<? super T> classToAccess, T instance, E value, int fieldIndex)
+    {
+        try
+        {
+            ReflectionHelper.setPrivateValue(classToAccess, instance, value, fieldIndex);
+        }
+        catch (UnableToAccessFieldException e)
+        {
+            FMLLog.log(Level.SEVERE, e, "There was a problem setting field index %d on type %s", fieldIndex, classToAccess.getName());
+            throw e;
+        }
+    }
+
+    @Deprecated
+    public static <T, E> void setPrivateValue(Class<? super T> classToAccess, T instance, String fieldName, E value)
+    {
+        setPrivateValue(classToAccess, instance, value, fieldName);
+    }
+
+    public static <T, E> void setPrivateValue(Class<? super T> classToAccess, T instance, E value, String... fieldNames)
+    {
+        try
+        {
+            ReflectionHelper.setPrivateValue(classToAccess, instance, value, remapFieldNames(classToAccess.getName(), fieldNames));
+        }
+        catch (UnableToFindFieldException e)
+        {
+            FMLLog.log(Level.SEVERE, e, "Unable to locate any field %s on type %s", Arrays.toString(fieldNames), classToAccess.getName());
+            throw e;
+        }
+        catch (UnableToAccessFieldException e)
+        {
+            FMLLog.log(Level.SEVERE, e, "Unable to set any field %s on type %s", Arrays.toString(fieldNames), classToAccess.getName());
+            throw e;
+        }
+    }
+}

common/cpw/mods/fml/common/ProxyInjector.java

@@ -0,0 +1,82 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Set;
+import java.util.logging.Level;
+
+import com.google.common.base.Strings;
+
+import cpw.mods.fml.common.discovery.ASMDataTable;
+import cpw.mods.fml.common.discovery.ASMDataTable.ASMData;
+import cpw.mods.fml.relauncher.Side;
+
+/**
+ * @author cpw
+ *
+ */
+public class ProxyInjector
+{
+    public static void inject(ModContainer mod, ASMDataTable data, Side side, ILanguageAdapter languageAdapter)
+    {
+        FMLLog.fine("Attempting to inject @SidedProxy classes into %s", mod.getModId());
+        Set<ASMData> targets = data.getAnnotationsFor(mod).get(SidedProxy.class.getName());
+        ClassLoader mcl = Loader.instance().getModClassLoader();
+
+        for (ASMData targ : targets)
+        {
+            try
+            {
+                Class<?> proxyTarget = Class.forName(targ.getClassName(), true, mcl);
+                Field target = proxyTarget.getDeclaredField(targ.getObjectName());
+                if (target == null)
+                {
+                    // Impossible?
+                    FMLLog.severe("Attempted to load a proxy type into %s.%s but the field was not found", targ.getClassName(), targ.getObjectName());
+                    throw new LoaderException();
+                }
+
+                SidedProxy annotation = target.getAnnotation(SidedProxy.class);
+                if (!Strings.isNullOrEmpty(annotation.modId()) && !annotation.modId().equals(mod.getModId()))
+                {
+                    FMLLog.fine("Skipping proxy injection for %s.%s since it is not for mod %s", targ.getClassName(), targ.getObjectName(), mod.getModId());
+                    continue;
+                }
+                String targetType = side.isClient() ? annotation.clientSide() : annotation.serverSide();
+                Object proxy=Class.forName(targetType, true, mcl).newInstance();
+
+                if (languageAdapter.supportsStatics() && (target.getModifiers() & Modifier.STATIC) == 0 )
+                {
+                    FMLLog.severe("Attempted to load a proxy type %s into %s.%s, but the field is not static", targetType, targ.getClassName(), targ.getObjectName());
+                    throw new LoaderException();
+                }
+                if (!target.getType().isAssignableFrom(proxy.getClass()))
+                {
+                    FMLLog.severe("Attempted to load a proxy type %s into %s.%s, but the types don't match", targetType, targ.getClassName(), targ.getObjectName());
+                    throw new LoaderException();
+                }
+                languageAdapter.setProxy(target, proxyTarget, proxy);
+            }
+            catch (Exception e)
+            {
+                FMLLog.log(Level.SEVERE, e, "An error occured trying to load a proxy into %s.%s", targ.getAnnotationInfo(), targ.getClassName(), targ.getObjectName());
+                throw new LoaderException(e);
+            }
+        }
+
+        // Allow language specific proxy injection.
+        languageAdapter.setInternalProxies(mod, side, mcl);
+    }
+}

common/cpw/mods/fml/common/SidedProxy.java

@@ -0,0 +1,74 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Sided proxies are loaded based on the specific environment they find themselves loaded into.
+ * They are used to ensure that client-specific code (such as GUIs) is only loaded into the game
+ * on the client side.
+ * It is applied to static fields of a class, anywhere in your mod code. FML will scan
+ * and load any classes with this annotation at mod construction time.
+ *
+ * <p>
+ * This example will load a CommonProxy on the server side, and a ClientProxy on the client side.
+ *
+ * <pre>{@code
+ *  public class MySidedProxyHolder {
+ *      {@literal @}SidedProxy(modId="MyModId",clientSide="mymod.ClientProxy", serverSide="mymod.CommonProxy")
+ *      public static CommonProxy proxy;
+ *  }
+ *
+ *  public class CommonProxy {
+ *      // Common or server stuff here that needs to be overridden on the client
+ *  }
+ *
+ *  public class ClientProxy extends CommonProxy {
+ *      // Override common stuff with client specific stuff here
+ *  }
+ * </pre>
+ * @author cpw
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface SidedProxy
+{
+    /**
+     * The name of the client side class to load and populate
+     */
+    String clientSide() default "";
+
+    /**
+     * The name of the server side class to load and populate
+     */
+    String serverSide() default "";
+
+    @Deprecated
+    /**
+     * Not implemented
+     * The name of a special bukkit plugin class to load and populate
+     */
+    String bukkitSide() default "";
+
+    /**
+     * The (optional) name of a mod to load this proxy for. This will help ensure correct behaviour when loading a combined
+     * scala/java mod package. It is almost never going to be required, unless you ship both Scala and Java {@link Mod} content
+     * in a single jar.
+     */
+    String modId() default "";
+}

common/cpw/mods/fml/common/SingleIntervalHandler.java

@@ -0,0 +1,55 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * 
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.EnumSet;
+
+public class SingleIntervalHandler implements IScheduledTickHandler
+{
+    private ITickHandler wrapped;
+    public SingleIntervalHandler(ITickHandler handler)
+    {
+        this.wrapped=handler;
+    }
+
+    @Override
+    public void tickStart(EnumSet<TickType> type, Object... tickData)
+    {
+        wrapped.tickStart(type, tickData);
+    }
+
+    @Override
+    public void tickEnd(EnumSet<TickType> type, Object... tickData)
+    {
+        wrapped.tickEnd(type, tickData);
+    }
+
+    @Override
+    public EnumSet<TickType> ticks()
+    {
+        return wrapped.ticks();
+    }
+
+    @Override
+    public String getLabel()
+    {
+        return wrapped.getLabel();
+    }
+
+    @Override
+    public int nextTickSpacing()
+    {
+        return 1;
+    }
+
+}

common/cpw/mods/fml/common/TickType.java

@@ -0,0 +1,64 @@
+/*
+ * Forge Mod Loader
+ * Copyright (c) 2012-2013 cpw.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser Public License v2.1
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ * Contributors:
+ *     cpw - implementation
+ */
+
+package cpw.mods.fml.common;
+
+import java.util.EnumSet;
+
+public enum TickType {
+    /**
+     * Fired during the world evaluation loop
+     * server and client side
+     *
+     * arg 0 : The world that is ticking
+     */
+    WORLD,
+    /**
+     * client side
+     * Fired during the render processing phase
+     * arg 0 : float "partial render time"
+     */
+    RENDER,
+    /**
+     * server side
+     * Fired once as the world loads from disk
+     */
+    WORLDLOAD,
+    /**
+     * client side only
+     * Fired once per client tick loop.
+     */
+    CLIENT,
+    /**
+     * client and server side.
+     * Fired whenever the players update loop runs.
+     * arg 0 : the player
+     * arg 1 : the world the player is in
+     */
+    PLAYER,
+    /**
+     * server side only.
+     * This is the server game tick.
+     * Fired once per tick loop on the server.
+     */
+    SERVER;
+
+    /**
+     * Partner ticks that are also cancelled by returning false from onTickInGame
+     */
+    public EnumSet<TickType> partnerTicks()
+    {
+        if (this==CLIENT) return EnumSet.of(RENDER);
+        if (this==RENDER) return EnumSet.of(CLIENT);
+        return EnumSet.noneOf(TickType.class);
+    }
+}