Fix CME when removing ticket managers (#5861)

This reverts commit 75788f63ee.

This solution is invalid as TEs are free to modify the world tileEntities
list, usually indirectly via chunkloading, from inside invalidate().

This happens in vanilla, in TileEntityChest#invalidate, where it calls
checkForAdjacentChests(), which has the potential to load neighboring
chunks and cause a CME.

A more sophisticated solution is needed.

.gitattributes

@@ -13,4 +13,3 @@
 *.pyd binary
 *.cfg text eol=lf
 *.py text eol=lf
-*.jks binary

.gitignore

@@ -1,8 +1,7 @@
 #eclipse
-**/bin
-**/.settings
-**/.classpath
-*.project
+/bin
+/.settings
+/.classpath
 
 #In case people make their workspace in the repo
 /eclipse/
@@ -15,8 +14,6 @@
 #gradle
 /build
 /.gradle
-/mdk/.gradle
-/mdk/build
 
 #occupational hazards
 /projects/
@@ -29,9 +26,7 @@
 
 # FML changelog
 changelog.txt
+/patches_old/
+/patches_old_bak/
 *.py
 *.7z
-/logs/
-
-gradle.properties
-!/mdk/gradle.properties

.travis.yml

@@ -28,8 +28,3 @@ script:
 
 notifications:
   email: false
-
-# skip building travis on 1.13 - it doesn't work there
-branches:
-  except:
-    - 1.13-pre

CREDITS.txt

@@ -10,7 +10,7 @@ alpha. Eloraam of RedPower, and SpaceToad of Buildcraft, without their acceptian
 of me taking over the project, who knows what Minecraft modding would be today.
 
 Secondly, someone who has worked with me, and developed some of the core features
-that allow modding to be as functional, and as simple as it is, cpw. For developing
+that allow modding to he as functional, and as simple as it is, cpw. For developing
 FML, which stabelized the client and server modding ecosystem. As well as the base
 loading system that allows us to modify Minecraft's code as elegently as possible.
 

Jenkinsfile

@@ -12,6 +12,9 @@ pipeline {
     }
     environment {
         GRADLE_ARGS = '--no-daemon --console=plain' // No daemon for now as FG3 kinda derps. //'-Dorg.gradle.daemon.idletimeout=5000'
+        DISCORD_WEBHOOK = credentials('forge-discord-jenkins-webhook')
+        DISCORD_PREFIX = "Job: Forge Branch: ${BRANCH_NAME} Build: #${BUILD_NUMBER}"
+        JENKINS_HEAD = 'https://wiki.jenkins-ci.org/download/attachments/2916393/headshot.png'
     }
 
     stages {
@@ -20,19 +23,42 @@ pipeline {
                 checkout scm
             }
         }
-        stage('setup') {
-            steps {
-                sh './gradlew ${GRADLE_ARGS} --refresh-dependencies --continue setup'
-                script {
-                    env.MYVERSION = sh(returnStdout: true, script: './gradlew :forge:properties -q | grep "version:" | awk \'{print $2}\'').trim()
+        stage('notify_start') {
+            when {
+                not {
+                    changeRequest()
                 }
             }
-            post {
-                success {
-                    writeChangelog(currentBuild, 'build/changelog.txt')
+            steps {
+                discordSend(
+                    title: "${DISCORD_PREFIX} Started",
+                    successful: true,
+                    result: 'ABORTED', //White border
+                    thumbnail: JENKINS_HEAD,
+                    webhookURL: DISCORD_WEBHOOK
+                )
+            }
+        }
+        stage('ciWriteBuildNumber') {
+            steps {
+                sh './gradlew ${GRADLE_ARGS} --refresh-dependencies --continue ciWriteBuildNumber'
+                script {
+                    env.MYGROUP = sh(returnStdout: true, script: './gradlew properties -q | grep "group:" | awk \'{print $2}\'').trim()
+                    env.MYARTIFACT = sh(returnStdout: true, script: './gradlew properties -q | grep "name:" | awk \'{print $2}\'').trim()
+                    env.MYVERSION = sh(returnStdout: true, script: './gradlew properties -q | grep "version:" | awk \'{print $2}\'').trim()
                 }
             }
         }
+        stage('changelog') {
+            when {
+                not {
+                    changeRequest()
+                }
+            }
+            steps {
+                writeChangelog(currentBuild, 'build/changelog_new.txt')
+            }
+        }
         stage('publish') {
             when {
                 not {
@@ -47,13 +73,8 @@ pipeline {
                 KEYSTORE_STOREPASS = credentials('forge-jenkins-keystore-old-keypass')
             }
             steps {
-                cache(maxCacheSize: 250/*MB*/, caches: [
-                    [$class: 'ArbitraryFileCache', excludes: '', includes: 'output.txt', path: '${WORKSPACE}/projects/forge/build/extractRangeMap/'] //Cache the rangemap to help speed up builds
-                ]){
-                    sh './gradlew ${GRADLE_ARGS} :forge:publish -PforgeMavenUser=${FORGE_MAVEN_USR} -PforgeMavenPassword=${FORGE_MAVEN_PSW} -PkeystoreKeyPass=${KEYSTORE_KEYPASS} -PkeystoreStorePass=${KEYSTORE_STOREPASS} -Pkeystore=${KEYSTORE} -PcrowdinKey=${CROWDIN}'
-                }
-                //We're testing so use the test group
-                sh 'curl --user ${FORGE_MAVEN} http://files.minecraftforge.net/maven/manage/promote/latest/net.minecraftforge.test.forge/${MYVERSION}'
+                sh './gradlew ${GRADLE_ARGS} uploadArchives -PforgeMavenUser=${FORGE_MAVEN_USR} -PforgeMavenPassword=${FORGE_MAVEN_PSW} -PkeystoreKeyPass=${KEYSTORE_KEYPASS} -PkeystoreStorePass=${KEYSTORE_STOREPASS} -Pkeystore=${KEYSTORE} -PcrowdinKey=${CROWDIN}'
+                sh 'curl --user ${FORGE_MAVEN} http://files.minecraftforge.net/maven/manage/promote/latest/${MYGROUP}.${MYARTIFACT}/${MYVERSION}'
             }
         }
         stage('test_publish_pr') { //Publish to local repo to test full process, but don't include credentials so it can't sign/publish to maven
@@ -64,19 +85,28 @@ pipeline {
                 CROWDIN = credentials('forge-crowdin')
             }
             steps {
-                cache(maxCacheSize: 250/*MB*/, caches: [
-                    [$class: 'ArbitraryFileCache', excludes: '', includes: 'output.txt', path: '${WORKSPACE}/projects/forge/build/extractRangeMap/'] //Cache the rangemap to help speed up builds
-                ]){
-                    sh './gradlew ${GRADLE_ARGS} :forge:publish -PcrowdinKey=${CROWDIN}'
-                }
+                sh './gradlew ${GRADLE_ARGS} uploadArchives -PcrowdinKey=${CROWDIN}'
             }
         }
     }
     post {
         always {
-            archiveArtifacts artifacts: 'projects/forge/build/libs/**/*.*', fingerprint: true
-            //junit 'build/test-results/*/*.xml'
-            //jacoco sourcePattern: '**/src/*/java'
+            script {
+                //archiveArtifacts artifacts: 'projects/forge/build/libs/**/*.*', fingerprint: true, onlyIfSuccessful: true, allowEmptyArchive: true
+                //junit 'build/test-results/*/*.xml'
+                //jacoco sourcePattern: '**/src/*/java'
+                
+                if (env.CHANGE_ID == null) { // This is unset for non-PRs
+                    discordSend(
+                        title: "${DISCORD_PREFIX} Finished ${currentBuild.currentResult}",
+                        description: '```\n' + getChanges(currentBuild) + '\n```',
+                        successful: currentBuild.resultIsBetterOrEqualTo("SUCCESS"),
+                        result: currentBuild.currentResult,
+                        thumbnail: JENKINS_HEAD,
+                        webhookURL: DISCORD_WEBHOOK
+                    )
+                }
+            }
         }
     }
 }

LICENSE-Paulscode IBXM Library.txt

@@ -0,0 +1,10 @@
+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.
+

LICENSE-Paulscode SoundSystem CodecIBXM.txt

@@ -0,0 +1,40 @@
+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.

LICENSE-header.txt

@@ -1,5 +1,5 @@
 Minecraft Forge
-Copyright (c) 2016-2019.
+Copyright (c) 2016-2018.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public

LICENSE.txt

@@ -3,8 +3,8 @@ parts herein are licensed under the terms of the LGPL 2.1 found
 here http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt and 
 copied below.
 
-Homepage: http://minecraftforge.net/
-          https://github.com/MinecraftForge/MinecraftForge
+Homepage: http://MinecraftForge.net/
+          http://github.com/MinecraftForge/MinecraftForge
           
 
 A note on authorship:
@@ -57,6 +57,12 @@ This software contains a partial repackaging of javaxdelta, a BSD licensed progr
 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.
+
+This software contains potions of Paulscodee IBXM library, a BSD liceensed library for
+loading and playing IBXM formated auto. No modifications havee beeen made. The associated 
+licenses can be found along side this one, or at
+https://github.com/MinecraftForge/MinecraftForge/blob/1.12.x/LICENSE-Paulscode%20IBXM%20Library.txt
+https://github.com/MinecraftForge/MinecraftForge/blob/1.12.x/LICENSE-Paulscode%20SoundSystem%20CodecIBXM.txt
 =========================================================================
 
 

NewFML.md

@@ -1,127 +0,0 @@
-# FML
-
-Entrypoint : ```FMLServiceProvider.onLoad```
-
-- Verify environment
--- Check all libraries are present: ```accesstransformer```, ```coremod```, ```deobfuscator```
--- Check versions are suitable: ```modlauncher```, ```accesstransformer```, ```coremod```, ```deobfuscator```
-- Find deobfuscated and patched MC
--- If not found, trigger job to generate that (loaded later at FMLLaunchProvider.launch)
-
-Injected arguments:
-
-- ```mods``` : CSV list of mod files to load
-- ```modlist``` : JSON formatted list of mod files in a maven-like repository format
-
-Entrypoint : ```FMLServiceProvider.initializer```
-- Setup paths
--- ```mods``` folder
--- ```config``` folder
-- FML config file read (JSON?)
-- Trigger initial loading
-
-Entrypoint : ```FMLLaunchProvider.launch```
-- Launches the patched and deobfuscated game
-- - If that wasn't found it'll be generated from the vanilla jar and patch/deobf files (see above)
-- Possible we'll use an alternative launch for the development environment
-
-(A goal is that we pre-generate this JAR during forge installation or modpack installation)
-
-## Loading
-
-- First we discover all mods
-- - IModLocator instances present in system are found and queried to compile a master list of all mod artifacts of the three types
-- LANGPROVIDERs are added to the supported language system : IModLanguageProvider
-- The MODS from the list have their META-INF/mods.json file queried for mod instances to load
-- - MODS are cross-referenced for their language being available
-- - MODS are cross-referenced for their libraries being available
-- - MODS are cross-referenced for their MOD dependencies being available
-- - MODS with META-INF/coremods.json specification are loaded into the COREMOD system
-- - MODS with META-INF/accesstransformer.json are loaded into the ACCESSTRANSFORMER system
-- - MODS are enqueued to the background loading system
-- FMLLaunchProvider will be triggered from the ModLauncher to start the game
-
-## Game loading
-
-- Events triggered from loadGame will launch various phases of modloading as before
--- Deprecation of old "FML" events in favour of Forge events
--- If a mod hasn't completed scanning there might be a pause waiting for it to complete before loading (testing indicates this should be a very rare occurrence and isn't worse than existing status quo where all scanning and loading is on-thread)
-
-### ```IModLocator```
-
-Finds mods from various sources of various types
-manifest is queried for type: FMLModType
-
-- MOD : this file will be scanned as a mod. This is default if nothing is present
-- LIBRARY : this file will be added to the classpath and no further processing is done
-- LANGPROVIDER : this file will be loaded as a language provider
-
-#### ```ModsFolderLocator```
-
-- scans for jar files from mods folder
--- able to load all types
--- loads in all environments
--- maybe able to do runtime name transformation for dev time?
-
-Standard mechanism to find and load mods
-
-#### ```ExplodedDirectoryLocator```
-
-- loads a directory as a mod
--- only able to load mods
--- should only load in dev env
-
-Intended as a mechanism to allow development of mods easily by pointing at a compiled output directory
-
-#### ```ArgumentModsLocator``` : NYI
-
-- loads mods from the arguments on the command line
--- able to load all types
--- loads in all environments
-
-### ```IModLanguageProvider```
-
-Provides mod and language provider services
-
-- Provides a means to transform a Mod File (from the IModLocator) into a list of modcontainer objects based on mods.json
-- Scanning work will be done in background threads
-- Language providers can be provided as JARs via the modlocator for ease of distribution
-
-#### ```FMLModLanguageProvider```
-
-This is the standard Java @Mod implementation provider
-
-- provided by default (always supported)
-- All scanning for @Mod will be done in the background thread
-
-#### ```ScalaModLanguageProvider```
-
-This is the scala language provider. It'll be provided separately as a JAR mod download.
-
-- API contract will need definition
-
-Other languages? Kotlin? Alternative Scala versions? Javascript?
-
-## Coremods
-
-Coremods are now forcefully separated into _injection_ and _runtime_ phases.
-
-### Injection
-
-Injection is the act of intercepting the loading of a class and modifying the inbound class with alterations such as additions, replacements and deletions
-
-Injections will be written using Javascript. Two functions are required: a function providing the list of injection sites, and the function to transform the injection site.
-
-All injection sites will need to be pre-specified by the coremod in their metadata. Lookup services should be provided in the Javascript API.
-
-Javascript API for common coremod injection tasks needs to be developed, to allow common best-practice tooling for these complex tasks.
-
-Runtime coremod code (code that has been injected) is Java as usual.
-
-## Background loading thread
-
-Early in loading, a background thread is triggered which will perform scanning tasks for common resources, such as @Mod instances and other annotations. This thread will also be responsible for loading any cached resources, either those defined at build time or pre-computed from previous runs. It may also be tasked with writing those precomputed resources.
-
-There will be a IPreLoaderJobProvider that will allow extension of the scope of these tasks
-
-

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Mon Sep 14 12:28:28 PDT 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.14-bin.zip

gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
 
 ##############################################################################
 ##
@@ -6,6 +6,47 @@
 ##
 ##############################################################################
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -20,49 +61,9 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
+cd "`dirname \"$PRG\"`/" >&-
 APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
+cd "$SAVED" >&-
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -89,7 +90,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -113,7 +114,6 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -154,19 +154,11 @@ if $cygwin ; then
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
 }
-APP_ARGS=$(save "$@")
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,9 +46,10 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windows variants
+@rem Get command-line arguments, handling Windowz variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -59,6 +60,11 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

legacy_changelog.txt

@@ -0,0 +1,430 @@
+
+Build 2838:
+	bs2609: Fix vanilla handling of options file (MC-117449, MC-151173) (#5725)
+
+Build 2837:
+	clienthax: Update EnumHelper to be compatible with Eclipse's OpenJ9 JVM. (#5712)
+
+Build 2836:
+	tterrag:
+		Revert "Invalidate tile entities that are queued for removal (#5512)"
+		This reverts commit 75788f63eea6c33ccef7e5cbcab27ad9ad2c2a04.
+		This solution is invalid as TEs are free to modify the world
+		tileEntities list, usually indirectly via chunkloading, from inside
+		invalidate().
+		This happens in vanilla, in TileEntityChest#invalidate, where it calls 
+		checkForAdjacentChests(), which has the potential to load neighboring 
+		chunks and cause a CME.
+		A more sophisticated solution is needed.
+
+Build 2835:
+	bs2609: Fix some vertex format changes not being handled correctly (#5368)
+
+Build 2834:
+	bs2609:
+		Transform vertex normals as well as positions when generating quads
+		(#5242)
+
+Build 2833:
+	rseifert.phone: Fix for SidedInvWrapper isItemValid using wrong slot (#5642)
+
+Build 2832:
+	bs2609: Invalidate tile entities that are queued for removal (#5512)
+
+Build 2831:
+	lclc98: Added Wool to OreDictionary (#5414)
+
+Build 2830:
+	CreativeMD: Fixed boat not taking care of block-liquid hooks (#5086)
+
+Build 2829:
+	bs2609: Add Forge dimension-changing hooks to spectator handling code (#5212)
+
+Build 2828:
+	ichttt:
+		Minor performace improvement when building chunks and rendering blocks
+		(#5286)
+
+Build 2827:
+	bs2609: Catch json parsing errors from constants/factories files (#5258)
+
+Build 2826:
+	bs2609: Allow custom DataSerializers to be registered safely (#5245)
+
+Build 2825:
+	cpw:
+		Try and make 1.13 mods more obviously wrong in 1.12..
+		Signed-off-by: cpw <[email protected]>
+
+Build 2824:
+	tterrag: Fix #5651 Re-add canPlaceBlockOnSide check in World#mayPlace
+
+Build 2823:
+	Pokechu022:
+		Fail fast when null is used with setTag instead of crashing in
+		writeEntry (#5257)
+
+Build 2822:
+	tterrag: Fix block placement not checking for player collision
+
+Build 2821:
+	wynprice999: Added more Constants (#5323)
+
+Build 2820:
+	python0429: [1.12.2] Add a few events pertaining to villages (#5302)
+
+Build 2819:
+	Tyler Hancock: [1.12] Fix special spawn event not firing in many cases. (#5389)
+
+Build 2818:
+	bs2609: Only prompt for missing registries on local worlds (#5348)
+
+Build 2817:
+	ckrier.3000: Add EntityPlaceEvent (#5057)
+
+Build 2816:
+	bs2609: Generalise EnumRarity to an interface (#5182)
+
+Build 2815:
+	bs2609: Apply access-level changes to inner class attributes (#5468)
+
+Build 2814:
+	bs2609: Fix small logic error in ItemTextureQuadConverter (#5463)
+
+Build 2813:
+	bs2609: Better support for custom bows (#5209)
+
+Build 2812:
+	CovertJaguar: Remove FluidStack amount from hashcode calculation (#5272)
+	molecularphylo:
+		Fixed incorrect string representation of string list config property
+		default values in their comments.
+	bs2609:
+		Improve tracking of used dimension IDs (#5249)
+		Closes #5378 Large dimension IDs bloat level.data
+
+Build 2811:
+	bs2609:
+		Fix up torch placement logic to handle more vanilla special-casing
+		(#5426)
+
+Build 2810:
+	LexManos: Written size does not include int bytes.
+
+Build 2809:
+	LexManos:
+		Extend Region files to support >1MB per chunk. If the 'sector count' is
+		255, ask the compressed data header for the proper length.
+
+Build 2808:
+	tterrag1098: Add default impl to IConfigElement#getValidValuesDisplay
+
+Build 2807:
+	tterrag: Simplify custom item rendering by removing GL emissivity hacks
+
+Build 2806:
+	tterrag: Support diffuse lighting flag in item rendering
+
+Build 2805:
+	bs2609:
+		Add a hook to allow continuously using items through stack changes
+		(#4834)
+		* Add a hook to allow continuously using items through stack changes
+		
+		* Update licences
+
+Build 2804:
+	oOMitchOo:
+		Added an additional constructor to every implementation of IFluidBlock.
+		It is now possible to create a fluid block with a Fluid, Material and
+		MapColor, so that the Material's MapColor isn't used for the blocks
+		MapColor. (#5293)
+
+Build 2803:
+	bs2609: Add redirects to PotionEffect to respect registry replacement (#5213)
+
+Build 2802:
+	alexiy.ov:
+		Add an annotation for @Config elements which will automatically create a
+		slider control (#5026)
+
+Build 2801:
+	bs2609: Fix small logic error in emissive item rendering code (#5320)
+
+Build 2800:
+	molecularphylo:
+		Allow config GUI cycling button elements generated from enums to display
+		toString return values, rather than actual values. (#5125)
+
+Build 2799:
+	bs2609: Fix incorrect indexing in mipmap generation code (#5201)
+
+Build 2798:
+	bs2609:
+		Ensure slave maps are cleaned up when handling registry overrides
+		(#5250)
+
+Build 2797:
+	d_scalzi: Fix issue with --modListFile. (#5316)
+
+Build 2796:
+	LexManos:
+		Fix potential issues with the Minecraft FakePlayer lingering around
+		after world unloads.
+
+Build 2795:
+	tterrag: Fix potion remove event not always firing, add expiry event
+
+Build 2794:
+	tterrag: Clean up CraftingHelper constants loading API
+
+Build 2793:
+	tterrag: Fix crash from CraftingHelper due to FileSystem being closed early
+
+Build 2792:
+	tterrag:
+		added PotionHooks, closes #3867, #4375 (#4614)
+		* solved merge confilct
+		
+		* improved var names & removed tabs
+		
+		* Added spaces around !=
+		
+		* fixed typo
+
+Build 2791:
+	tterrag:
+		Add a hook for farmland watering (#4891)
+		* Add a FarmlandWaterCheckEvent to allow mods to override when Farmland
+		is watered or not
+		
+		* revert 1.12.2 json
+		
+		* Move the farmland patch to a ticket based instead of a event based
+		system
+		
+		* Minor changes
+		
+		* Faster isValid checks, faster validation/invalidation if the state did
+		not change, expand test mod to include a test for the validation system
+		
+		* remove isValid boolean flag, we can express it with the tick counter
+		
+		* Fix test mod resource warnings
+		
+		* Remove tick timeout, add a javadoc note to invalidate on chunk unload,
+		cleaned up test mod
+		
+		* Allow mods to provide custom handling to determine if a pos is valid
+		or not
+		
+		* Make SimpleTicket more simple, make register public so custom tickets
+		can be registered
+		
+		* Fixes for review
+		
+		* Add missing license headers
+		
+		* Use a weak hash set
+		
+		* Split up the map into smaller chunk based maps
+		
+		* Add missing license headers
+		
+		* Make MultiTicketManager more universal for custom implementations,
+		cleanup imports
+
+Build 2790:
+	tterrag:
+		Add methods to allow loading json constants outside of _constants
+		(#4975)
+		* add interface methods for loading json constants from an arbitary file
+		
+		
+		* use try-with-resources
+		
+		* don't make modders create jsoncontext, clean up resource use
+		
+		* very minor cleanup
+
+Build 2789:
+	tterrag:
+		Compute ASMDataTable submaps parallel, speeds up contructing mods
+		(#5246)
+		* Compute submaps parallel, speeds up contructing mods by a lot
+		
+		* Use stream API better
+
+Build 2788:
+	mezz: Add logging for data manager key registration errors (#5129)
+
+Build 2787:
+	mezz: Improve support for custom block path types (#5203)
+
+Build 2786:
+	mezz: Fix missing comments in configs created with annotations (#5189)
+
+Build 2785:
+	mezz: Allow items to control the rate of repair from mending (#5102)
+
+Build 2784:
+	mezz: Improve exception handling from server starting events (#5226)
+
+Build 2783:
+	mezz: Improve context provided by potion icon rendering hooks (#5111)
+
+Build 2782:
+	mezz: Fix an ObjectHolderRef internal error message (#5214)
+
+Build 2781:
+	mezz: Implement rendering for item models with emissive quads (#5047)
+
+Build 2780:
+	mezz: Clean up logged mod states (#5227)
+	mezz: Fix minor issue in getFilledPercentage for Fluid rendering (#5206)
+
+Build 2779:
+	mezz: Improve reflection helper methods (#4853)
+	mezz: Fix inaccurate main thread name shown in client log (#5078)
+
+Build 2778:
+	mezz: Fix Baked Item models with transformations (#5241)
+
+Build 2777:
+	mezz:
+		Re-add some missing villager profession patches (#5200)
+		* Fix zombie villagers only spawning with vanilla professions
+		* Fix spawning modded villagers that do not have their own building
+	mezz: Fix missing string parameters in some log messages (#5210)
+	mezz: Stop firing LivingSetAttackTargetEvent for setRevengeTarget (#5217)
+	mezz: Prevent RecipeBook from crashing on empty modded ingredients (#5234)
+
+Build 2776:
+	mezz: Fix the bed position given to the SleepingTimeCheck event (#5107)
+
+Build 2775:
+	LexManos: Fix some null returns from defaulted registries (#5235)
+
+Build 2774:
+	LexManos:
+		Only remove synthetic lambda methods referenced in body of SideOnly
+		methods (#5127)
+
+Build 2773:
+	LexManos:
+		A different approach to my changes in
+		https://github.com/MinecraftForge/MinecraftForge/commit/8ace535995522bec0557d4217e0d98b3dc76cf1e
+		to fix #5207
+	LexManos: Fix patches from #5160 setting rotation as well as position (#5233)
+	LexManos: Use HTTPS for files website.
+
+Build 2772:
+	tterrag: Make Forge-provided default transforms accessible to custom models
+	tterrag:
+		Make Forge blockstate variants correctly inherit AO setting from vanilla
+		models (#5190)
+		* Make Forge blockstate variants correctly inherit AO setting
+		
+		* Move variant format checks into variant, check for added properties
+		
+		* Small code cleanup
+	tterrag: fixed visual bug with guislider
+	tterrag:
+		Allow IModel to express itself as a vanilla parent (#5195)
+		* Fix errors caused by fancy missing model being non-vanilla parent
+		
+		* Switch instanceof checks to a default IModel method
+		
+		* Small code tweaks
+
+Build 2771:
+	tterrag: Add CreativeTabs#getLabelColor
+
+Build 2770:
+	tterrag:
+		Allow providing a BufferedImage for banner render generation (#5041)
+		* Adds an Event to allow providing a BufferedImage for the banner render
+		generation (cached)
+		textures, since banners don't use an atlas.
+		implementation.
+		
+		* Missed some copyright; might as well absolut text match, I guess
+		
+		* Remove unneeded patch change
+		
+		* Fix event variable access convention
+		
+		* Formatting fix
+		
+		* Improve event handling registration
+		
+		* Import cleanup
+		
+		* Replace event approach with Supplier approach
+		
+		* Better name for test mod (now that it's no longer an event); adds
+		ENABLE flag
+		
+		* Moves MC code into
+		net.minecraftforge.client.MinecraftForgeClient.getImageLayer to simplify
+		patch
+		
+		* Generalize naming
+
+Build 2769:
+	mezz: Fix Mesa biome entry tags in the BiomeDictionary (#5177)
+
+Build 2768:
+	LexManos: Bump version number for RB.
+
+Build 2767:
+	LexManos:
+		Change biome spawn list entries to use factory method where possible
+		(#5075)
+	LexManos: Prevent some texture loading errors from crashing the game (#5121)
+	LexManos: Patch PotionHelper to use registry delegates (#5142)
+	LexManos: Add a notification event for handling game rule changes (#5152)
+
+Build 2766:
+	LexManos:
+		Change universal bucket support to use fluid names instead of instances
+		(#5031)
+
+Build 2765:
+	LexManos: Fix NPE on clientside entities constructed with null world (#5170)
+
+Build 2764:
+	tterrag: Fix patches from #5160 running on the client and causing stutter
+
+Build 2763:
+	LexManos:
+		Class transformer optimizations (#5159)
+		* Filter packages for deobf transformation
+		* Only serialize transformed class with TerminalTransformer if bytecode
+		changed
+
+Build 2762:
+	github: Update github stale so issues can be Assigned
+
+Build 2761:
+	LexManos:
+		Fix MC-136995 - Chunk loading and unloading issue with entities placed
+		in exact positions. (#5160)
+		Scatter gun patches to improve entity tracking and position tracking. 
+		Provided by Aikar through the Paper project, this commit of patches
+		combines the following patches:
+		 
+		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0306-Mark-chunk-dirty-anytime-entities-change-to-guarante.patch
+		 
+		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0315-Always-process-chunk-registration-after-moving.patch
+		 
+		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0335-Ensure-chunks-are-always-loaded-on-hard-position-set.patch
+		 
+		https://github.com/PaperMC/Paper/blob/fd1bd5223a461b6d98280bb8f2d67280a30dd24a/Spigot-Server-Patches/0378-Sync-Player-Position-to-Vehicles.patch
+
+Build 2760:
+	LexManos: Fix --mods and --modListFile arguments not making it past LaunchWrapper.
+
+Build 2759:
+	LexManos: Remove BlamingTransformer (#5115)
+

mdk/build.gradle

@@ -1,67 +1,44 @@
 buildscript {
     repositories {
-        maven { url = 'https://files.minecraftforge.net/maven' }
         jcenter()
-        mavenCentral()
+        maven { url = "https://files.minecraftforge.net/maven" }
     }
     dependencies {
-        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
     }
 }
-apply plugin: 'net.minecraftforge.gradle'
+apply plugin: 'net.minecraftforge.gradle.forge'
 //Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
-apply plugin: 'eclipse'
 
-version = '1.0'
-group = 'com.yourname.modid' // http://maven.apache.org/guides/mini/guide-naming-conventions.html
-archivesBaseName = 'modid'
 
-sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
+version = "1.0"
+group = "com.yourname.modid" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
+archivesBaseName = "modid"
+
+sourceCompatibility = targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
+compileJava {
+    sourceCompatibility = targetCompatibility = '1.8'
+}
 
 minecraft {
+    version = "@VERSION@"
+    runDir = "run"
+    
     // the mappings can be changed at any time, and must be in the following format.
     // snapshot_YYYYMMDD   snapshot are built nightly.
     // stable_#            stables are built at the discretion of the MCP team.
     // Use non-default mappings at your own risk. they may not always work.
     // simply re-run your setup task after changing the mappings to update your workspace.
-    mappings channel: '@MAPPING_CHANNEL@', version: '@MAPPING_VERSION@'
+    mappings = "@MAPPINGS@"
     // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
-    
-    //accessTransformer = file('my_at.cfg')
-
-    // default run configurations.
-    // these can be tweaked, removed, or duplicated as needed.
-    runs {
-        client = {
-            // recommended logging data for a userdev environment
-            properties 'forge.logging.markers': 'SCAN,REGISTRIES,REGISTRYDUMP'
-            // recommended logging level for the console
-            properties 'forge.logging.console.level': 'debug'
-            workingDirectory project.file('run').canonicalPath
-            source sourceSets.main
-        }
-        server = {
-            // recommended logging data for a userdev environment
-            properties 'forge.logging.markers': 'SCAN,REGISTRIES,REGISTRYDUMP'
-            // recommended logging level for the console
-            properties 'forge.logging.console.level': 'debug'
-            workingDirectory project.file('run').canonicalPath
-            source sourceSets.main
-        }
-    }
 }
 
 dependencies {
-    // Specify the version of Minecraft to use, If this is any group other then 'net.minecraft' it is assumed
-    // that the dep is a ForgeGradle 'patcher' dependency. And it's patches will be applied.
-    // The userdev artifact is a special name and will get all sorts of transformations applied to it.
-    minecraft '@FORGE_GROUP@:@FORGE_NAME@:@FORGE_VERSION@'
-
     // you may put jars on which you depend on in ./libs
     // or you may define them like so..
     //compile "some.group:artifact:version:classifier"
     //compile "some.group:artifact:version"
-
+      
     // real examples
     //compile 'com.mod-buildcraft:buildcraft:6.0.8:dev'  // adds buildcraft to the dev env
     //compile 'com.googlecode.efficient-java-matrix-library:ejml:0.24' // adds ejml to the dev env
@@ -69,8 +46,10 @@ dependencies {
     // the 'provided' configuration is for optional dependencies that exist at compile-time but might not at runtime.
     //provided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
 
-    // These dependencies get remapped to your current MCP mappings
-    //deobf 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+    // the deobf configurations:  'deobfCompile' and 'deobfProvided' are the same as the normal compile and provided,
+    // except that these dependencies get remapped to your current MCP mappings
+    //deobfCompile 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+    //deobfProvided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
 
     // for more info...
     // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
@@ -78,15 +57,21 @@ dependencies {
 
 }
 
-// Example for how to get properties into the manifest for reading by the runtime..
-jar {
-    manifest {
-        attributes(["Specification-Title": "examplemod",
-                    "Specification-Vendor": "examplemodsareus",
-                    "Specification-Version": "24.0", // We are version 1 of the modlauncher specification
-                    "Implementation-Title": project.name,
-                    "Implementation-Version": "${version}",
-                    "Implementation-Vendor" :"examplemodsareus",
-                    "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")],)
+processResources {
+    // this will ensure that this task is redone when the versions change.
+    inputs.property "version", project.version
+    inputs.property "mcversion", project.minecraft.version
+
+    // replace stuff in mcmod.info, nothing else
+    from(sourceSets.main.resources.srcDirs) {
+        include 'mcmod.info'
+                
+        // replace version and mcversion
+        expand 'version':project.version, 'mcversion':project.minecraft.version
     }
-}
+        
+    // copy everything else except the mcmod.info
+    from(sourceSets.main.resources.srcDirs) {
+        exclude 'mcmod.info'
+    }
+}

mdk/gitignore.txt

@@ -20,6 +20,3 @@ build
 # other
 eclipse
 run
-
-# Files from Forge MDK
-forge*changelog.txt

mdk/gradle.properties

@@ -1,4 +1,3 @@
 # Sets default memory used for gradle commands. Can be overridden by user or command line properties.
 # This is required to provide enough memory for the Minecraft decompilation process.
 org.gradle.jvmargs=-Xmx3G
-org.gradle.daemon=false

mdk/src/main/java/com/example/examplemod/ExampleMod.java

@@ -1,83 +1,31 @@
 package com.example.examplemod;
 
-import net.minecraft.block.Block;
 import net.minecraft.init.Blocks;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.event.RegistryEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.InterModComms;
 import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
-import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
-import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent;
-import net.minecraftforge.fml.event.lifecycle.InterModProcessEvent;
-import net.minecraftforge.fml.event.server.FMLServerStartingEvent;
-import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
-import org.apache.logging.log4j.LogManager;
+import net.minecraftforge.fml.common.Mod.EventHandler;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import org.apache.logging.log4j.Logger;
 
-import java.util.stream.Collectors;
-
-// The value here should match an entry in the META-INF/mods.toml file
-@Mod("examplemod")
+@Mod(modid = ExampleMod.MODID, name = ExampleMod.NAME, version = ExampleMod.VERSION)
 public class ExampleMod
 {
-    // Directly reference a log4j logger.
-    private static final Logger LOGGER = LogManager.getLogger();
+    public static final String MODID = "examplemod";
+    public static final String NAME = "Example Mod";
+    public static final String VERSION = "1.0";
 
-    public ExampleMod() {
-        // Register the setup method for modloading
-        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
-        // Register the enqueueIMC method for modloading
-        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::enqueueIMC);
-        // Register the processIMC method for modloading
-        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::processIMC);
-        // Register the doClientStuff method for modloading
-        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::doClientStuff);
+    private static Logger logger;
 
-        // Register ourselves for server, registry and other game events we are interested in
-        MinecraftForge.EVENT_BUS.register(this);
-    }
-
-    private void setup(final FMLCommonSetupEvent event)
+    @EventHandler
+    public void preInit(FMLPreInitializationEvent event)
     {
-        // some preinit code
-        LOGGER.info("HELLO FROM PREINIT");
-        LOGGER.info("DIRT BLOCK >> {}", Blocks.DIRT.getRegistryName());
+        logger = event.getModLog();
     }
 
-    private void doClientStuff(final FMLClientSetupEvent event) {
-        // do something that can only be done on the client
-        LOGGER.info("Got game settings {}", event.getMinecraftSupplier().get().gameSettings);
-    }
-
-    private void enqueueIMC(final InterModEnqueueEvent event)
+    @EventHandler
+    public void init(FMLInitializationEvent event)
     {
-        // some example code to dispatch IMC to another mod
-        InterModComms.sendTo("forge", "helloworld", () -> { LOGGER.info("Hello world"); return "Hello world";});
-    }
-
-    private void processIMC(final InterModProcessEvent event)
-    {
-        // some example code to receive and process InterModComms from other mods
-        LOGGER.info("Got IMC", event.getIMCStream().
-                map(m->m.getMessageSupplier().get()).
-                collect(Collectors.toList()));
-    }
-    // You can use SubscribeEvent and let the Event Bus discover methods to call
-    @SubscribeEvent
-    public static void onServerStarting(FMLServerStartingEvent event) {
-        // do something when the server starts
-        LOGGER.info("HELLO from server starting");
-    }
-
-    // You can use EventBusSubscriber to automatically subscribe events on the contained class (this is subscribing to the MOD event bus
-    @Mod.EventBusSubscriber(bus=Mod.EventBusSubscriber.Bus.MOD)
-    public static class RegistryEvents {
-        @SubscribeEvent
-        public void onBlocksRegistry(final RegistryEvent.Register<Block> blockRegistryEvent) {
-            // register a new block here
-            LOGGER.info("HELLO from Register Block");
-        }
+        // some example code
+        logger.info("DIRT BLOCK >> {}", Blocks.DIRT.getRegistryName());
     }
 }

mdk/src/main/resources/META-INF/mods.toml

@@ -1,56 +0,0 @@
-# This is an example mods.toml file. It contains the data relating to the loading mods.
-# There are several mandatory fields (#mandatory), and many more that are optional (#optional).
-# The overall format is standard TOML format, v0.5.0.
-# Note that there are a couple of TOML lists in this file.
-# Find more information on toml format here:  https://github.com/toml-lang/toml
-# The name of the mod loader type to load - for regular FML @Mod mods it should be javafml
-modLoader="javafml" #mandatory
-# A version range to match for said mod loader - for regular FML @Mod it will be the forge version
-loaderVersion="[24,)" #mandatory (24 is current forge version)
-# A URL to refer people to when problems occur with this mod
-issueTrackerURL="http://my.issue.tracker/" #optional
-# A URL for the "homepage" for this mod, displayed in the mod UI
-displayURL="http://example.com/" #optional
-# A file name (in the root of the mod JAR) containing a logo for display
-logoFile="examplemod.png" #optional
-# A text field displayed in the mod UI
-credits="Thanks for this example mod goes to Java" #optional
-# A text field displayed in the mod UI
-authors="Love, Cheese and small house plants" #optional
-# A list of mods - how many allowed here is determined by the individual mod loader
-[[mods]] #mandatory
-# The modid of the mod
-modId="examplemod" #mandatory
-# The version number of the mod - there's a few well known ${} variables useable here or just hardcode it
-version="${file.jarVersion}" #mandatory
- # A display name for the mod
-displayName="Example Mod" #mandatory
-# A URL to query for updates for this mod. See the JSON update specification <here>
-updateJSONURL="http://myurl.me/" #optional
-# The description text for the mod (multi line!) (#mandatory)
-description='''
-This is a long form description of the mod. You can write whatever you want here
-
-Have some lorem ipsum.
-
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed mollis lacinia magna. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Sed sagittis luctus odio eu tempus. Interdum et malesuada fames ac ante ipsum primis in faucibus. Pellentesque volutpat ligula eget lacus auctor sagittis. In hac habitasse platea dictumst. Nunc gravida elit vitae sem vehicula efficitur. Donec mattis ipsum et arcu lobortis, eleifend sagittis sem rutrum. Cras pharetra quam eget posuere fermentum. Sed id tincidunt justo. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
-'''
-# A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
-[[dependencies.examplemod]] #optional
-    # the modid of the dependency
-    modId="forge" #mandatory
-    # Does this dependency have to exist - if not, ordering below must be specified
-    mandatory=true #mandatory
-    # The version range of the dependency
-    versionRange="[24,)" #mandatory
-    # An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory
-    ordering="NONE"
-    # Side this dependency is applied on - BOTH, CLIENT or SERVER
-    side="BOTH"
-# Here's another dependency
-[[dependencies.examplemod]]
-    modId="minecraft"
-    mandatory=true
-    versionRange="[1.13]"
-    ordering="NONE"
-    side="BOTH"

mdk/src/main/resources/mcmod.info

@@ -0,0 +1,16 @@
+[
+{
+  "modid": "examplemod",
+  "name": "Example Mod",
+  "description": "Example placeholder mod.",
+  "version": "${version}",
+  "mcversion": "${mcversion}",
+  "url": "",
+  "updateUrl": "",
+  "authorList": ["ExampleDude"],
+  "credits": "The Forge and FML guys, for making this example",
+  "logoFile": "",
+  "screenshots": [],
+  "dependencies": []
+}
+]

mdk/src/main/resources/pack.mcmeta

@@ -1,7 +1,7 @@
 {
     "pack": {
         "description": "examplemod resources",
-        "pack_format": 4,
-        "_comment": "A pack_format of 4 requires json lang files. Note: we require v4 pack meta for all mods."
+        "pack_format": 3,
+        "_comment": "A pack_format of 3 should be used starting with Minecraft 1.11. All resources, including language files, should be lowercase (eg: en_us.lang). A pack_format of 2 will load your mod resources with LegacyV2Adapter, which requires language files to have uppercase letters (eg: en_US.lang)."
     }
 }

mods.toml

@@ -1,66 +0,0 @@
-# The name of the mod loader type to load
-modLoader="javafml"
-# A version range to match for said mod loader
-loaderVersion="[2.0,)"
-# A URL to query for updates
-updateJSONURL="http://myurl.me/"
-# A URL to refer people to when problems occur with this mod
-issueTrackerURL="http://my.issue.tracker/"
-# Extra mod loader property
-randomScalaProperty="fishy"
-# Arbitrary key-value property pairs available to mods
-[properties]
-key="value"
-
-# A list of mods - how many allowed here is determined by the individual mod loader
-[[mods]]
-    # The modid of the mod
-    modId="inventorysorter"
-    # The version number of the mod
-    version="1.1"
-     # A display name for the mod
-    displayName="Inventory Sorter"
-    # The description text for the mod (multi line!)
-    description='''
-    This is my mod, there may be
-    others, but this one is mine
-    '''
-    # Override the default resourcelocation namespace with this instead
-    # Currently not implemented
-    namespace="invsorter"
-    # A random extra property for a mod loader
-    randomExtraProperty="somevalue"
-     # Arbitrary key-value pairs
-    [modproperties.inventorysorter]
-        key="value"
-    # A list of dependencies
-    [[dependencies.inventorysorter]]
-        # the modid of the dependency
-        modid="forge"
-        # Does this dependency have to exist - if not, ordering below must be specified
-        mandatory=true
-        # The version range of the dependency
-        versionRange="[14.23.2.0,)"
-        # An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory
-        ordering="NONE"
-        # Side this dependency is applied on - BOTH, CLIENT or SERVER
-        side="BOTH"
-    # Here's another dependency
-    [[dependencies.inventorysorter]]
-        modid="minecraft"
-        mandatory=true
-        versionRange="[1.12.2]"
-        ordering="NONE"
-        side="BOTH"
-
-# Here's another mod in this jar
-[[mods]]
-    # Note that other mod types may want to add additional key-value pairs in here
-    modId="inventorysortertoo"
-    # ${file.jarVersion} will read the Implementation-Version of the jar file
-    version="${file.jarVersion}"
-    displayName="Inventory Sorter as well"
-    description='''
-    This is also my mod, there may be
-    others, but this one is mine
-    '''

patches/minecraft/net/minecraft/advancements/AdvancementManager.java.patch

@@ -0,0 +1,10 @@
+--- ../src-base/minecraft/net/minecraft/advancements/AdvancementManager.java
++++ ../src-work/minecraft/net/minecraft/advancements/AdvancementManager.java
+@@ -66,6 +66,7 @@
+         field_192784_c.func_192087_a();
+         Map<ResourceLocation, Advancement.Builder> map = this.func_192781_c();
+         this.func_192777_a(map);
++        this.field_193768_e |= net.minecraftforge.common.ForgeHooks.loadAdvancements(map);
+         field_192784_c.func_192083_a(map);
+ 
+         for (Advancement advancement : field_192784_c.func_192088_b())

patches/minecraft/net/minecraft/advancements/AdvancementRewards.java.patch

@@ -1,11 +1,11 @@
---- a/net/minecraft/advancements/AdvancementRewards.java
-+++ b/net/minecraft/advancements/AdvancementRewards.java
-@@ -41,7 +41,7 @@
+--- ../src-base/minecraft/net/minecraft/advancements/AdvancementRewards.java
++++ ../src-work/minecraft/net/minecraft/advancements/AdvancementRewards.java
+@@ -49,7 +49,7 @@
+     public void func_192113_a(final EntityPlayerMP p_192113_1_)
+     {
+         p_192113_1_.func_71023_q(this.field_192115_b);
+-        LootContext lootcontext = (new LootContext.Builder(p_192113_1_.func_71121_q())).func_186472_a(p_192113_1_).func_186471_a();
++        LootContext lootcontext = (new LootContext.Builder(p_192113_1_.func_71121_q())).func_186472_a(p_192113_1_).func_186470_a(p_192113_1_).func_186469_a(p_192113_1_.func_184817_da()).func_186471_a(); // Forge: add player & luck to LootContext
+         boolean flag = false;
  
-    public void func_192113_a(EntityPlayerMP p_192113_1_) {
-       p_192113_1_.func_195068_e(this.field_192115_b);
--      LootContext lootcontext = (new LootContext.Builder(p_192113_1_.func_71121_q())).func_186472_a(p_192113_1_).func_204313_a(new BlockPos(p_192113_1_)).func_186471_a();
-+      LootContext lootcontext = (new LootContext.Builder(p_192113_1_.func_71121_q())).func_186472_a(p_192113_1_).func_204313_a(new BlockPos(p_192113_1_)).func_186470_a(p_192113_1_).func_186469_a(p_192113_1_.func_184817_da()).func_186471_a(); // FORGE: add player & luck to LootContext
-       boolean flag = false;
- 
-       for(ResourceLocation resourcelocation : this.field_192116_c) {
+         for (ResourceLocation resourcelocation : this.field_192116_c)

patches/minecraft/net/minecraft/advancements/DisplayInfo.java.patch

@@ -0,0 +1,13 @@
+--- ../src-base/minecraft/net/minecraft/advancements/DisplayInfo.java
++++ ../src-work/minecraft/net/minecraft/advancements/DisplayInfo.java
+@@ -132,7 +132,9 @@
+         {
+             Item item = JsonUtils.func_188180_i(p_193221_0_, "item");
+             int i = JsonUtils.func_151208_a(p_193221_0_, "data", 0);
+-            return new ItemStack(item, 1, i);
++            ItemStack ret = new ItemStack(item, 1, i);
++            ret.func_77982_d(net.minecraftforge.common.util.JsonUtils.readNBT(p_193221_0_, "nbt"));
++            return ret;
+         }
+     }
+ 

patches/minecraft/net/minecraft/advancements/PlayerAdvancements.java.patch

@@ -1,19 +1,21 @@
---- a/net/minecraft/advancements/PlayerAdvancements.java
-+++ b/net/minecraft/advancements/PlayerAdvancements.java
-@@ -174,6 +174,8 @@
-    }
+--- ../src-base/minecraft/net/minecraft/advancements/PlayerAdvancements.java
++++ ../src-work/minecraft/net/minecraft/advancements/PlayerAdvancements.java
+@@ -196,6 +196,9 @@
  
-    public boolean func_192750_a(Advancement p_192750_1_, String p_192750_2_) {
-+      // Forge: don't grant advancements for fake players
-+      if (this.field_192762_j instanceof net.minecraftforge.common.util.FakePlayer) return false;
-       boolean flag = false;
-       AdvancementProgress advancementprogress = this.func_192747_a(p_192750_1_);
-       boolean flag1 = advancementprogress.func_192105_a();
-@@ -186,6 +188,7 @@
-             if (p_192750_1_.func_192068_c() != null && p_192750_1_.func_192068_c().func_193220_i() && this.field_192762_j.field_70170_p.func_82736_K().func_82766_b("announceAdvancements")) {
-                this.field_192756_d.func_184103_al().func_148539_a(new TextComponentTranslation("chat.type.advancement." + p_192750_1_.func_192068_c().func_192291_d().func_192307_a(), this.field_192762_j.func_145748_c_(), p_192750_1_.func_193123_j()));
+     public boolean func_192750_a(Advancement p_192750_1_, String p_192750_2_)
+     {
++        // Forge: don't grant advancements for fake players
++        if (this.field_192762_j instanceof net.minecraftforge.common.util.FakePlayer) return false;
++
+         boolean flag = false;
+         AdvancementProgress advancementprogress = this.func_192747_a(p_192750_1_);
+         boolean flag1 = advancementprogress.func_192105_a();
+@@ -214,6 +217,8 @@
+                 {
+                     this.field_192756_d.func_184103_al().func_148539_a(new TextComponentTranslation("chat.type.advancement." + p_192750_1_.func_192068_c().func_192291_d().func_192307_a(), new Object[] {this.field_192762_j.func_145748_c_(), p_192750_1_.func_193123_j()}));
+                 }
++
++                net.minecraftforge.common.ForgeHooks.onAdvancement(this.field_192762_j, p_192750_1_);
              }
-+            net.minecraftforge.common.ForgeHooks.onAdvancement(this.field_192762_j, p_192750_1_);
-          }
-       }
+         }
  

patches/minecraft/net/minecraft/advancements/critereon/ItemPredicate.java.patch

@@ -0,0 +1,16 @@
+--- ../src-base/minecraft/net/minecraft/advancements/critereon/ItemPredicate.java
++++ ../src-work/minecraft/net/minecraft/advancements/critereon/ItemPredicate.java
+@@ -104,6 +104,13 @@
+         if (p_192492_0_ != null && !p_192492_0_.isJsonNull())
+         {
+             JsonObject jsonobject = JsonUtils.func_151210_l(p_192492_0_, "item");
++            if (jsonobject.has("type"))
++            {
++                 final ResourceLocation rl = new ResourceLocation(JsonUtils.func_151200_h(jsonobject, "type"));
++                 final Map<ResourceLocation, java.util.function.Function<JsonObject, ItemPredicate>> map = net.minecraftforge.advancements.critereon.ItemPredicates.getPredicates();
++                 if (map.containsKey(rl)) return map.get(rl).apply(jsonobject);
++                 else throw new JsonSyntaxException("There is no ItemPredicate of type "+rl);
++            }
+             MinMaxBounds minmaxbounds = MinMaxBounds.func_192515_a(jsonobject.get("count"));
+             MinMaxBounds minmaxbounds1 = MinMaxBounds.func_192515_a(jsonobject.get("durability"));
+             Integer integer = jsonobject.has("data") ? JsonUtils.func_151203_m(jsonobject, "data") : null;

patches/minecraft/net/minecraft/advancements/criterion/ItemPredicate.java.patch

@@ -1,38 +0,0 @@
---- a/net/minecraft/advancements/criterion/ItemPredicate.java
-+++ b/net/minecraft/advancements/criterion/ItemPredicate.java
-@@ -24,6 +24,8 @@
- import net.minecraft.util.registry.IRegistry;
- 
- public class ItemPredicate {
-+   private static final Map<ResourceLocation, java.util.function.Function<JsonObject, ItemPredicate>> custom_predicates = new java.util.HashMap<>();
-+   private static final Map<ResourceLocation, java.util.function.Function<JsonObject, ItemPredicate>> unmod_predicates = java.util.Collections.unmodifiableMap(custom_predicates);
-    public static final ItemPredicate field_192495_a = new ItemPredicate();
-    @Nullable
-    private final Tag<Item> field_200018_b;
-@@ -90,6 +92,11 @@
-    public static ItemPredicate func_192492_a(@Nullable JsonElement p_192492_0_) {
-       if (p_192492_0_ != null && !p_192492_0_.isJsonNull()) {
-          JsonObject jsonobject = JsonUtils.func_151210_l(p_192492_0_, "item");
-+         if (jsonobject.has("type")) {
-+              final ResourceLocation rl = new ResourceLocation(JsonUtils.func_151200_h(jsonobject, "type"));
-+              if (custom_predicates.containsKey(rl)) return custom_predicates.get(rl).apply(jsonobject);
-+              else throw new JsonSyntaxException("There is no ItemPredicate of type "+rl);
-+         }
-          MinMaxBounds.IntBound minmaxbounds$intbound = MinMaxBounds.IntBound.func_211344_a(jsonobject.get("count"));
-          MinMaxBounds.IntBound minmaxbounds$intbound1 = MinMaxBounds.IntBound.func_211344_a(jsonobject.get("durability"));
-          if (jsonobject.has("data")) {
-@@ -181,6 +188,14 @@
-       }
-    }
- 
-+   public static void register(ResourceLocation name, java.util.function.Function<JsonObject, ItemPredicate> deserializer) {
-+      custom_predicates.put(name, deserializer);
-+   }
-+
-+   public static Map<ResourceLocation, java.util.function.Function<JsonObject, ItemPredicate>> getPredicates() {
-+       return unmod_predicates;
-+   }
-+
-    public static class Builder {
-       private final List<EnchantmentPredicate> field_200312_a = Lists.newArrayList();
-       @Nullable

patches/minecraft/net/minecraft/block/BlockAbstractBanner.java.patch

@@ -1,22 +0,0 @@
---- a/net/minecraft/block/BlockAbstractBanner.java
-+++ b/net/minecraft/block/BlockAbstractBanner.java
-@@ -51,7 +51,7 @@
-    }
- 
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
--      func_180635_a(p_196255_2_, p_196255_3_, this.func_185473_a(p_196255_2_, p_196255_3_, p_196255_1_));
-+      super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
-    }
- 
-    public void func_180657_a(World p_180657_1_, EntityPlayer p_180657_2_, BlockPos p_180657_3_, IBlockState p_180657_4_, @Nullable TileEntity p_180657_5_, ItemStack p_180657_6_) {
-@@ -75,4 +75,10 @@
-    public EnumDyeColor func_196285_M_() {
-       return this.field_196286_a;
-    }
-+
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World world, BlockPos pos, int fortune) {
-+      TileEntity te = world.func_175625_s(pos);
-+      drops.add((te instanceof TileEntityBanner) ? ((TileEntityBanner)te).func_190615_l(state) : func_185473_a(world, pos, state));
-+   }
- }

patches/minecraft/net/minecraft/block/BlockAbstractSkull.java.patch

@@ -1,52 +0,0 @@
---- a/net/minecraft/block/BlockAbstractSkull.java
-+++ b/net/minecraft/block/BlockAbstractSkull.java
-@@ -38,6 +38,7 @@
-    }
- 
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
-+       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
-    }
- 
-    public void func_176208_a(World p_176208_1_, BlockPos p_176208_2_, IBlockState p_176208_3_, EntityPlayer p_176208_4_) {
-@@ -45,6 +46,7 @@
-          TileEntitySkull.func_195486_a(p_176208_1_, p_176208_2_);
-       }
- 
-+      this.func_196255_a(p_176208_3_, p_176208_1_, p_176208_2_, 1.0f, 0);
-       super.func_176208_a(p_176208_1_, p_176208_2_, p_176208_3_, p_176208_4_);
-    }
- 
-@@ -55,7 +57,7 @@
-    public void func_196243_a(IBlockState p_196243_1_, World p_196243_2_, BlockPos p_196243_3_, IBlockState p_196243_4_, boolean p_196243_5_) {
-       if (p_196243_1_.func_177230_c() != p_196243_4_.func_177230_c() && !p_196243_2_.field_72995_K) {
-          TileEntity tileentity = p_196243_2_.func_175625_s(p_196243_3_);
--         if (tileentity instanceof TileEntitySkull) {
-+         if (false && tileentity instanceof TileEntitySkull) { //Forge: Moved to getDrops
-             TileEntitySkull tileentityskull = (TileEntitySkull)tileentity;
-             if (tileentityskull.func_195487_d()) {
-                ItemStack itemstack = this.func_185473_a(p_196243_2_, p_196243_3_, p_196243_1_);
-@@ -74,6 +76,24 @@
-       }
-    }
- 
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World world, BlockPos pos, int fortune) {
-+      TileEntity te = world.func_175625_s(pos);
-+      if (te instanceof TileEntitySkull) {
-+         TileEntitySkull skull = (TileEntitySkull)te;
-+         if (skull.func_195487_d()) {
-+            ItemStack ret = func_185473_a(world, pos, state);
-+            Block block = skull.func_195044_w().func_177230_c();
-+            if ((block == Blocks.field_196710_eS || block == Blocks.field_196709_eR) && skull.func_152108_a() != null) {
-+               NBTTagCompound nbt = new NBTTagCompound();
-+               NBTUtil.func_180708_a(nbt, skull.func_152108_a());
-+               ret.func_196082_o().func_74782_a("SkullOwner", nbt);
-+            }
-+            drops.add(ret);
-+         }
-+      }
-+   }
-+
-    @OnlyIn(Dist.CLIENT)
-    public BlockSkull.ISkullType func_196292_N_() {
-       return this.field_196293_a;

patches/minecraft/net/minecraft/block/BlockBanner.java.patch

@@ -0,0 +1,43 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockBanner.java
++++ ../src-work/minecraft/net/minecraft/block/BlockBanner.java
+@@ -90,16 +90,9 @@
+ 
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+-        ItemStack itemstack = this.func_185549_e(p_180653_1_, p_180653_2_);
+-
+-        if (itemstack.func_190926_b())
+         {
+             super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
+         }
+-        else
+-        {
+-            func_180635_a(p_180653_1_, p_180653_2_, itemstack);
+-        }
+     }
+ 
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+@@ -126,6 +119,23 @@
+         return BlockFaceShape.UNDEFINED;
+     }
+ 
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        TileEntity te = world.func_175625_s(pos);
++
++        if (te instanceof TileEntityBanner)
++        {
++            TileEntityBanner tileentitybanner = (TileEntityBanner)te;
++            ItemStack itemstack = tileentitybanner.func_190615_l();
++            drops.add(itemstack);
++        }
++        else
++        {
++            drops.add(new ItemStack(Items.field_179564_cE, 1, 0));
++        }
++    }
++
+     public static class BlockBannerHanging extends BlockBanner
+         {
+             protected static final AxisAlignedBB field_185551_d = new AxisAlignedBB(0.0D, 0.0D, 0.875D, 1.0D, 0.78125D, 1.0D);

patches/minecraft/net/minecraft/block/BlockBed.java.patch

@@ -1,13 +1,14 @@
---- a/net/minecraft/block/BlockBed.java
-+++ b/net/minecraft/block/BlockBed.java
-@@ -67,7 +67,9 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockBed.java
++++ ../src-work/minecraft/net/minecraft/block/BlockBed.java
+@@ -84,8 +84,10 @@
+                 }
              }
-          }
  
--         if (p_196250_2_.field_73011_w.func_76567_e() && p_196250_2_.func_180494_b(p_196250_3_) != Biomes.field_76778_j) {
-+         net.minecraftforge.common.extensions.IForgeDimension.SleepResult sleepResult = p_196250_2_.field_73011_w.canSleepAt(p_196250_4_, p_196250_3_);
-+         if (sleepResult != net.minecraftforge.common.extensions.IForgeDimension.SleepResult.BED_EXPLODES) {
-+            if (sleepResult == net.minecraftforge.common.extensions.IForgeDimension.SleepResult.DENY) return true;
-             if (p_196250_1_.func_177229_b(field_176471_b)) {
-                EntityPlayer entityplayer = this.func_176470_e(p_196250_2_, p_196250_3_);
-                if (entityplayer != null) {
+-            if (p_180639_1_.field_73011_w.func_76567_e() && p_180639_1_.func_180494_b(p_180639_2_) != Biomes.field_76778_j)
++            net.minecraft.world.WorldProvider.WorldSleepResult sleepResult = p_180639_1_.field_73011_w.canSleepAt(p_180639_4_, p_180639_2_);
++            if (sleepResult != net.minecraft.world.WorldProvider.WorldSleepResult.BED_EXPLODES)
+             {
++                if (sleepResult == net.minecraft.world.WorldProvider.WorldSleepResult.DENY) return true;
+                 if (((Boolean)p_180639_3_.func_177229_b(field_176471_b)).booleanValue())
+                 {
+                     EntityPlayer entityplayer = this.func_176470_e(p_180639_1_, p_180639_2_);

patches/minecraft/net/minecraft/block/BlockBush.java.patch

@@ -1,32 +1,70 @@
---- a/net/minecraft/block/BlockBush.java
-+++ b/net/minecraft/block/BlockBush.java
-@@ -10,7 +10,7 @@
- import net.minecraft.world.IWorld;
- import net.minecraft.world.IWorldReaderBase;
+--- ../src-base/minecraft/net/minecraft/block/BlockBush.java
++++ ../src-work/minecraft/net/minecraft/block/BlockBush.java
+@@ -17,7 +17,7 @@
+ import net.minecraftforge.fml.relauncher.Side;
+ import net.minecraftforge.fml.relauncher.SideOnly;
  
--public class BlockBush extends Block {
-+public class BlockBush extends Block implements net.minecraftforge.common.IPlantable {
-    protected BlockBush(Block.Properties p_i48437_1_) {
-       super(p_i48437_1_);
-    }
-@@ -26,6 +26,8 @@
+-public class BlockBush extends Block
++public class BlockBush extends Block implements net.minecraftforge.common.IPlantable
+ {
+     protected static final AxisAlignedBB field_185515_b = new AxisAlignedBB(0.30000001192092896D, 0.0D, 0.30000001192092896D, 0.699999988079071D, 0.6000000238418579D, 0.699999988079071D);
  
-    public boolean func_196260_a(IBlockState p_196260_1_, IWorldReaderBase p_196260_2_, BlockPos p_196260_3_) {
-       BlockPos blockpos = p_196260_3_.func_177977_b();
-+      if (p_196260_1_.func_177230_c() == this) //Forge: This function is called during world gen and placement, before this block is set, so if we are not 'here' then assume it's the pre-check.
-+         return p_196260_2_.func_180495_p(blockpos).canSustainPlant(p_196260_2_, blockpos, EnumFacing.UP, this);
-       return this.func_200014_a_(p_196260_2_.func_180495_p(blockpos), p_196260_2_, blockpos);
-    }
+@@ -40,7 +40,8 @@
  
-@@ -44,4 +46,11 @@
-    public int func_200011_d(IBlockState p_200011_1_, IBlockReader p_200011_2_, BlockPos p_200011_3_) {
-       return 0;
-    }
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        return super.func_176196_c(p_176196_1_, p_176196_2_) && this.func_185514_i(p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()));
++        IBlockState soil = p_176196_1_.func_180495_p(p_176196_2_.func_177977_b());
++        return super.func_176196_c(p_176196_1_, p_176196_2_) && soil.func_177230_c().canSustainPlant(soil, p_176196_1_, p_176196_2_.func_177977_b(), net.minecraft.util.EnumFacing.UP, this);
+     }
+ 
+     protected boolean func_185514_i(IBlockState p_185514_1_)
+@@ -70,6 +71,11 @@
+ 
+     public boolean func_180671_f(World p_180671_1_, BlockPos p_180671_2_, IBlockState p_180671_3_)
+     {
++        if (p_180671_3_.func_177230_c() == this) //Forge: This function is called during world gen and placement, before this block is set, so if we are not 'here' then assume it's the pre-check.
++        {
++            IBlockState soil = p_180671_1_.func_180495_p(p_180671_2_.func_177977_b());
++            return soil.func_177230_c().canSustainPlant(soil, p_180671_1_, p_180671_2_.func_177977_b(), net.minecraft.util.EnumFacing.UP, this);
++        }
+         return this.func_185514_i(p_180671_1_.func_180495_p(p_180671_2_.func_177977_b()));
+     }
+ 
+@@ -94,6 +100,36 @@
+         return false;
+     }
+ 
++    @Override
++    public net.minecraftforge.common.EnumPlantType getPlantType(net.minecraft.world.IBlockAccess world, BlockPos pos)
++    {
++        if (this == Blocks.field_150464_aj)          return net.minecraftforge.common.EnumPlantType.Crop;
++        if (this == Blocks.field_150459_bM)        return net.minecraftforge.common.EnumPlantType.Crop;
++        if (this == Blocks.field_150469_bN)       return net.minecraftforge.common.EnumPlantType.Crop;
++        if (this == Blocks.field_185773_cZ)      return net.minecraftforge.common.EnumPlantType.Crop;
++        if (this == Blocks.field_150394_bc)     return net.minecraftforge.common.EnumPlantType.Crop;
++        if (this == Blocks.field_150393_bb)   return net.minecraftforge.common.EnumPlantType.Crop;
++        if (this == Blocks.field_150330_I)       return net.minecraftforge.common.EnumPlantType.Desert;
++        if (this == Blocks.field_150392_bi)      return net.minecraftforge.common.EnumPlantType.Water;
++        if (this == Blocks.field_150337_Q)   return net.minecraftforge.common.EnumPlantType.Cave;
++        if (this == Blocks.field_150338_P) return net.minecraftforge.common.EnumPlantType.Cave;
++        if (this == Blocks.field_150388_bm)    return net.minecraftforge.common.EnumPlantType.Nether;
++        if (this == Blocks.field_150345_g)        return net.minecraftforge.common.EnumPlantType.Plains;
++        if (this == Blocks.field_150329_H)      return net.minecraftforge.common.EnumPlantType.Plains;
++        if (this == Blocks.field_150398_cm)   return net.minecraftforge.common.EnumPlantType.Plains;
++        if (this == Blocks.field_150328_O)     return net.minecraftforge.common.EnumPlantType.Plains;
++        if (this == Blocks.field_150327_N)  return net.minecraftforge.common.EnumPlantType.Plains;
++        return net.minecraftforge.common.EnumPlantType.Plains;
++    }
 +
-+   @Override
-+   public IBlockState getPlant(IBlockReader world, BlockPos pos) {
-+       IBlockState state = world.func_180495_p(pos);
-+       if (state.func_177230_c() != this) return func_176223_P();
-+       return state;
-+   }
- }
++    @Override
++    public IBlockState getPlant(net.minecraft.world.IBlockAccess world, BlockPos pos)
++    {
++        IBlockState state = world.func_180495_p(pos);
++        if (state.func_177230_c() != this) return func_176223_P();
++        return state;
++    }
++
+     @SideOnly(Side.CLIENT)
+     public BlockRenderLayer func_180664_k()
+     {

patches/minecraft/net/minecraft/block/BlockButton.java.patch

@@ -0,0 +1,11 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockButton.java
++++ ../src-work/minecraft/net/minecraft/block/BlockButton.java
+@@ -98,7 +98,7 @@
+ 
+         if (p_181088_2_ == EnumFacing.UP)
+         {
+-            return block == Blocks.field_150438_bZ || !func_193384_b(block) && flag;
++            return iblockstate.func_185896_q() || !func_193384_b(block) && flag;
+         }
+         else
+         {

patches/minecraft/net/minecraft/block/BlockCactus.java.patch

@@ -1,63 +1,67 @@
---- a/net/minecraft/block/BlockCactus.java
-+++ b/net/minecraft/block/BlockCactus.java
-@@ -21,7 +21,7 @@
- import net.minecraft.world.IWorldReaderBase;
- import net.minecraft.world.World;
+--- ../src-base/minecraft/net/minecraft/block/BlockCactus.java
++++ ../src-work/minecraft/net/minecraft/block/BlockCactus.java
+@@ -20,7 +20,7 @@
+ import net.minecraftforge.fml.relauncher.Side;
+ import net.minecraftforge.fml.relauncher.SideOnly;
  
--public class BlockCactus extends Block {
-+public class BlockCactus extends Block implements net.minecraftforge.common.IPlantable {
-    public static final IntegerProperty field_176587_a = BlockStateProperties.field_208171_X;
-    protected static final VoxelShape field_196400_b = Block.func_208617_a(1.0D, 0.0D, 1.0D, 15.0D, 15.0D, 15.0D);
-    protected static final VoxelShape field_196401_c = Block.func_208617_a(1.0D, 0.0D, 1.0D, 15.0D, 16.0D, 15.0D);
-@@ -32,6 +32,7 @@
-    }
+-public class BlockCactus extends Block
++public class BlockCactus extends Block implements net.minecraftforge.common.IPlantable
+ {
+     public static final PropertyInteger field_176587_a = PropertyInteger.func_177719_a("age", 0, 15);
+     protected static final AxisAlignedBB field_185593_b = new AxisAlignedBB(0.0625D, 0.0D, 0.0625D, 0.9375D, 0.9375D, 0.9375D);
+@@ -36,6 +36,7 @@
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-+      if (!p_196267_2_.func_205050_e(p_196267_3_, 1)) return; // Forge: prevent growing cactus from loading unloaded chunks with block update
-       if (!p_196267_1_.func_196955_c(p_196267_2_, p_196267_3_)) {
-          p_196267_2_.func_175655_b(p_196267_3_, true);
-       } else {
-@@ -44,6 +45,7 @@
+     public void func_180650_b(World p_180650_1_, BlockPos p_180650_2_, IBlockState p_180650_3_, Random p_180650_4_)
+     {
++        if (!p_180650_1_.func_175697_a(p_180650_2_, 1)) return; // Forge: prevent growing cactus from loading unloaded chunks with block update
+         BlockPos blockpos = p_180650_2_.func_177984_a();
  
-             if (i < 3) {
-                int j = p_196267_1_.func_177229_b(field_176587_a);
-+               if(net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_196267_2_, blockpos, p_196267_1_, true)) {
-                if (j == 15) {
-                   p_196267_2_.func_175656_a(blockpos, this.func_176223_P());
-                   IBlockState iblockstate = p_196267_1_.func_206870_a(field_176587_a, Integer.valueOf(0));
-@@ -52,7 +54,8 @@
-                } else {
-                   p_196267_2_.func_180501_a(p_196267_3_, p_196267_1_.func_206870_a(field_176587_a, Integer.valueOf(j + 1)), 4);
-                }
--
-+               net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_196267_2_, p_196267_3_, p_196267_1_);
-+               }
+         if (p_180650_1_.func_175623_d(blockpos))
+@@ -51,6 +52,8 @@
+             {
+                 int j = ((Integer)p_180650_3_.func_177229_b(field_176587_a)).intValue();
+ 
++                if(net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_180650_1_, blockpos, p_180650_3_, true))
++                {
+                 if (j == 15)
+                 {
+                     p_180650_1_.func_175656_a(blockpos, this.func_176223_P());
+@@ -62,6 +65,8 @@
+                 {
+                     p_180650_1_.func_180501_a(p_180650_2_, p_180650_3_.func_177226_a(field_176587_a, Integer.valueOf(j + 1)), 4);
+                 }
++                net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_1_.func_180495_p(p_180650_2_));
++                }
              }
-          }
-       }
-@@ -91,8 +94,8 @@
-          }
-       }
+         }
+     }
+@@ -112,8 +117,8 @@
+             }
+         }
  
--      Block block = p_196260_2_.func_180495_p(p_196260_3_.func_177977_b()).func_177230_c();
--      return (block == Blocks.field_150434_aF || block == Blocks.field_150354_m || block == Blocks.field_196611_F) && !p_196260_2_.func_180495_p(p_196260_3_.func_177984_a()).func_185904_a().func_76224_d();
-+      IBlockState soil = p_196260_2_.func_180495_p(p_196260_3_.func_177977_b());
-+      return soil.canSustainPlant(p_196260_2_, p_196260_3_.func_177977_b(), EnumFacing.UP, this) && !p_196260_2_.func_180495_p(p_196260_3_.func_177984_a()).func_185904_a().func_76224_d();
-    }
+-        Block block = p_176586_1_.func_180495_p(p_176586_2_.func_177977_b()).func_177230_c();
+-        return block == Blocks.field_150434_aF || block == Blocks.field_150354_m && !p_176586_1_.func_180495_p(p_176586_2_.func_177984_a()).func_185904_a().func_76224_d();
++        IBlockState state = p_176586_1_.func_180495_p(p_176586_2_.func_177977_b());
++        return state.func_177230_c().canSustainPlant(state, p_176586_1_, p_176586_2_.func_177977_b(), EnumFacing.UP, this) && !p_176586_1_.func_180495_p(p_176586_2_.func_177984_a()).func_185904_a().func_76224_d();
+     }
  
-    public void func_196262_a(IBlockState p_196262_1_, World p_196262_2_, BlockPos p_196262_3_, Entity p_196262_4_) {
-@@ -114,4 +117,14 @@
-    public boolean func_196266_a(IBlockState p_196266_1_, IBlockReader p_196266_2_, BlockPos p_196266_3_, PathType p_196266_4_) {
-       return false;
-    }
+     public void func_180634_a(World p_180634_1_, BlockPos p_180634_2_, IBlockState p_180634_3_, Entity p_180634_4_)
+@@ -137,6 +142,18 @@
+         return ((Integer)p_176201_1_.func_177229_b(field_176587_a)).intValue();
+     }
+ 
++    @Override
++    public net.minecraftforge.common.EnumPlantType getPlantType(net.minecraft.world.IBlockAccess world, BlockPos pos)
++    {
++        return net.minecraftforge.common.EnumPlantType.Desert;
++    }
 +
-+   @Override
-+   public net.minecraftforge.common.EnumPlantType getPlantType(IBlockReader world, BlockPos pos) {
-+       return net.minecraftforge.common.EnumPlantType.Desert;
-+   }
++    @Override
++    public IBlockState getPlant(net.minecraft.world.IBlockAccess world, BlockPos pos)
++    {
++        return func_176223_P();
++    }
 +
-+   @Override
-+   public IBlockState getPlant(IBlockReader world, BlockPos pos) {
-+       return func_176223_P();
-+   }
- }
+     protected BlockStateContainer func_180661_e()
+     {
+         return new BlockStateContainer(this, new IProperty[] {field_176587_a});

patches/minecraft/net/minecraft/block/BlockChest.java.patch

@@ -1,11 +1,31 @@
---- a/net/minecraft/block/BlockChest.java
-+++ b/net/minecraft/block/BlockChest.java
-@@ -258,7 +258,7 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockChest.java
++++ ../src-work/minecraft/net/minecraft/block/BlockChest.java
+@@ -470,7 +470,7 @@
  
-    private boolean func_176456_n(IBlockReader p_176456_1_, BlockPos p_176456_2_) {
--      return p_176456_1_.func_180495_p(p_176456_2_.func_177984_a()).func_185915_l();
-+       return p_176456_1_.func_180495_p(p_176456_2_.func_177984_a()).doesSideBlockChestOpening(p_176456_1_, p_176456_2_.func_177984_a(), EnumFacing.DOWN);
-    }
+                     if (block == this)
+                     {
+-                        if (this.func_176457_m(p_189418_1_, blockpos))
++                        if (!p_189418_3_ && this.func_176457_m(p_189418_1_, blockpos)) // Forge: fix MC-99321
+                         {
+                             return null;
+                         }
+@@ -538,7 +538,7 @@
  
-    private boolean func_176453_o(World p_176453_1_, BlockPos p_176453_2_) {
+     private boolean func_176456_n(World p_176456_1_, BlockPos p_176456_2_)
+     {
+-        return p_176456_1_.func_180495_p(p_176456_2_.func_177984_a()).func_185915_l();
++        return p_176456_1_.func_180495_p(p_176456_2_.func_177984_a()).doesSideBlockChestOpening(p_176456_1_, p_176456_2_.func_177984_a(), EnumFacing.DOWN);
+     }
+ 
+     private boolean func_176453_o(World p_176453_1_, BlockPos p_176453_2_)
+@@ -608,4 +608,10 @@
+         BASIC,
+         TRAP;
+     }
++
++    /* ======================================== FORGE START =====================================*/
++    public boolean rotateBlock(World world, BlockPos pos, EnumFacing axis)
++    {
++        return !func_176454_e(world, pos) && super.rotateBlock(world, pos, axis);
++    }
+ }

patches/minecraft/net/minecraft/block/BlockChorusFlower.java.patch

@@ -1,20 +1,19 @@
---- a/net/minecraft/block/BlockChorusFlower.java
-+++ b/net/minecraft/block/BlockChorusFlower.java
-@@ -42,7 +42,7 @@
-          BlockPos blockpos = p_196267_3_.func_177984_a();
-          if (p_196267_2_.func_175623_d(blockpos) && blockpos.func_177956_o() < 256) {
-             int i = p_196267_1_.func_177229_b(field_185607_a);
--            if (i < 5) {
-+            if (i < 5 && net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_196267_2_, blockpos, p_196267_1_, true)) {
-                boolean flag = false;
-                boolean flag1 = false;
-                IBlockState iblockstate = p_196267_2_.func_180495_p(p_196267_3_.func_177977_b());
-@@ -99,7 +99,7 @@
-                } else {
-                   this.func_185605_c(p_196267_2_, p_196267_3_);
-                }
--
-+               net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_196267_2_, p_196267_3_, p_196267_1_);
+--- ../src-base/minecraft/net/minecraft/block/BlockChorusFlower.java
++++ ../src-work/minecraft/net/minecraft/block/BlockChorusFlower.java
+@@ -55,7 +55,7 @@
+             {
+                 int i = ((Integer)p_180650_3_.func_177229_b(field_185607_a)).intValue();
+ 
+-                if (i < 5 && p_180650_4_.nextInt(1) == 0)
++                if (i < 5 &&  net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_180650_1_, blockpos, p_180650_3_, p_180650_4_.nextInt(1) == 0))
+                 {
+                     boolean flag = false;
+                     boolean flag1 = false;
+@@ -144,6 +144,7 @@
+                     {
+                         this.func_185605_c(p_180650_1_, p_180650_2_);
+                     }
++                    net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_1_.func_180495_p(p_180650_2_));
+                 }
              }
-          }
-       }
+         }

patches/minecraft/net/minecraft/block/BlockCocoa.java.patch

@@ -1,39 +1,44 @@
---- a/net/minecraft/block/BlockCocoa.java
-+++ b/net/minecraft/block/BlockCocoa.java
-@@ -34,10 +34,11 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockCocoa.java
++++ ../src-work/minecraft/net/minecraft/block/BlockCocoa.java
+@@ -44,13 +44,14 @@
+         {
+             this.func_176500_f(p_180650_1_, p_180650_2_, p_180650_3_);
+         }
+-        else if (p_180650_1_.field_73012_v.nextInt(5) == 0)
++        else
+         {
+             int i = ((Integer)p_180650_3_.func_177229_b(field_176501_a)).intValue();
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
--      if (p_196267_2_.field_73012_v.nextInt(5) == 0) {
-+      if (true) {
-          int i = p_196267_1_.func_177229_b(field_176501_a);
--         if (i < 2) {
-+         if (i < 2 && net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_196267_2_, p_196267_3_, p_196267_1_, p_196267_2_.field_73012_v.nextInt(5) == 0)) {
-             p_196267_2_.func_180501_a(p_196267_3_, p_196267_1_.func_206870_a(field_176501_a, Integer.valueOf(i + 1)), 2);
-+            net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_196267_2_, p_196267_3_, p_196267_1_);
-          }
-       }
+-            if (i < 2)
++            if (i < 2 && net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_.nextInt(5) == 0))
+             {
+                 p_180650_1_.func_180501_a(p_180650_2_, p_180650_3_.func_177226_a(field_176501_a, Integer.valueOf(i + 1)), 2);
++                net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_1_.func_180495_p(p_180650_2_));
+             }
+         }
+     }
+@@ -132,7 +133,14 @@
  
-@@ -90,14 +91,20 @@
-    }
- 
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
--      int i = p_196255_1_.func_177229_b(field_176501_a);
-+      super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
-+   }
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+-        int i = ((Integer)p_180653_3_.func_177229_b(field_176501_a)).intValue();
++        super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
++    }
 +
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World world, BlockPos pos, int fortune) {
-+      super.getDrops(state, drops, world, pos, fortune);
-+      int i = state.func_177229_b(field_176501_a);
-       int j = 1;
-       if (i >= 2) {
-          j = 3;
-       }
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        super.getDrops(drops, world, pos, state, fortune);
++        int i = ((Integer)state.func_177229_b(field_176501_a)).intValue();
+         int j = 1;
  
-       for(int k = 0; k < j; ++k) {
--         func_180635_a(p_196255_2_, p_196255_3_, new ItemStack(Items.field_196130_bo));
-+         drops.add(new ItemStack(Items.field_196130_bo));
-       }
+         if (i >= 2)
+@@ -142,7 +150,7 @@
+ 
+         for (int k = 0; k < j; ++k)
+         {
+-            func_180635_a(p_180653_1_, p_180653_2_, new ItemStack(Items.field_151100_aR, 1, EnumDyeColor.BROWN.func_176767_b()));
++            drops.add(new ItemStack(Items.field_151100_aR, 1, EnumDyeColor.BROWN.func_176767_b()));
+         }
+     }
  
-    }

patches/minecraft/net/minecraft/block/BlockCrops.java.patch

@@ -1,56 +1,81 @@
---- a/net/minecraft/block/BlockCrops.java
-+++ b/net/minecraft/block/BlockCrops.java
-@@ -55,12 +55,14 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockCrops.java
++++ ../src-work/minecraft/net/minecraft/block/BlockCrops.java
+@@ -70,6 +70,7 @@
+     {
+         super.func_180650_b(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_);
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-       super.func_196267_b(p_196267_1_, p_196267_2_, p_196267_3_, p_196267_4_);
-+      if (!p_196267_2_.func_205050_e(p_196267_3_, 1)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light
-       if (p_196267_2_.func_201669_a(p_196267_3_.func_177984_a(), 0) >= 9) {
-          int i = this.func_185527_x(p_196267_1_);
-          if (i < this.func_185526_g()) {
-             float f = func_180672_a(this, p_196267_2_, p_196267_3_);
--            if (p_196267_4_.nextInt((int)(25.0F / f) + 1) == 0) {
-+            if (net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_196267_2_, p_196267_3_, p_196267_1_, p_196267_4_.nextInt((int)(25.0F / f) + 1) == 0)) {
-                p_196267_2_.func_180501_a(p_196267_3_, this.func_185528_e(i + 1), 2);
-+               net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_196267_2_, p_196267_3_, p_196267_1_);
-             }
-          }
-       }
-@@ -89,9 +91,9 @@
-          for(int j = -1; j <= 1; ++j) {
-             float f1 = 0.0F;
-             IBlockState iblockstate = p_180672_1_.func_180495_p(blockpos.func_177982_a(i, 0, j));
--            if (iblockstate.func_177230_c() == Blocks.field_150458_ak) {
-+            if (iblockstate.canSustainPlant(p_180672_1_, blockpos.func_177982_a(i, 0, j), net.minecraft.util.EnumFacing.UP, (net.minecraftforge.common.IPlantable)p_180672_0_)) {
-                f1 = 1.0F;
--               if (iblockstate.func_177229_b(BlockFarmland.field_176531_a) > 0) {
-+               if (iblockstate.isFertile(p_180672_1_, blockpos.func_177982_a(i, 0, j))) {
-                   f1 = 3.0F;
-                }
-             }
-@@ -135,15 +137,19 @@
-    }
++        if (!p_180650_1_.func_175697_a(p_180650_2_, 1)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light
+         if (p_180650_1_.func_175671_l(p_180650_2_.func_177984_a()) >= 9)
+         {
+             int i = this.func_185527_x(p_180650_3_);
+@@ -78,9 +79,10 @@
+             {
+                 float f = func_180672_a(this, p_180650_1_, p_180650_2_);
  
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
--      super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, 0);
--      if (!p_196255_2_.field_72995_K) {
--         int i = this.func_185527_x(p_196255_1_);
-+      super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
-+   }
+-                if (p_180650_4_.nextInt((int)(25.0F / f) + 1) == 0)
++                if(net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_.nextInt((int)(25.0F / f) + 1) == 0))
+                 {
+                     p_180650_1_.func_180501_a(p_180650_2_, this.func_185528_e(i + 1), 2);
++                    net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_1_.func_180495_p(p_180650_2_));
+                 }
+             }
+         }
+@@ -116,11 +118,11 @@
+                 float f1 = 0.0F;
+                 IBlockState iblockstate = p_180672_1_.func_180495_p(blockpos.func_177982_a(i, 0, j));
+ 
+-                if (iblockstate.func_177230_c() == Blocks.field_150458_ak)
++                if (iblockstate.func_177230_c().canSustainPlant(iblockstate, p_180672_1_, blockpos.func_177982_a(i, 0, j), net.minecraft.util.EnumFacing.UP, (net.minecraftforge.common.IPlantable)p_180672_0_))
+                 {
+                     f1 = 1.0F;
+ 
+-                    if (((Integer)iblockstate.func_177229_b(BlockFarmland.field_176531_a)).intValue() > 0)
++                    if (iblockstate.func_177230_c().isFertile(p_180672_1_, blockpos.func_177982_a(i, 0, j)))
+                     {
+                         f1 = 3.0F;
+                     }
+@@ -161,7 +163,8 @@
+ 
+     public boolean func_180671_f(World p_180671_1_, BlockPos p_180671_2_, IBlockState p_180671_3_)
+     {
+-        return (p_180671_1_.func_175699_k(p_180671_2_) >= 8 || p_180671_1_.func_175678_i(p_180671_2_)) && this.func_185514_i(p_180671_1_.func_180495_p(p_180671_2_.func_177977_b()));
++        IBlockState soil = p_180671_1_.func_180495_p(p_180671_2_.func_177977_b());
++        return (p_180671_1_.func_175699_k(p_180671_2_) >= 8 || p_180671_1_.func_175678_i(p_180671_2_)) && soil.func_177230_c().canSustainPlant(soil, p_180671_1_, p_180671_2_.func_177977_b(), net.minecraft.util.EnumFacing.UP, this);
+     }
+ 
+     protected Item func_149866_i()
+@@ -174,11 +177,32 @@
+         return Items.field_151015_O;
+     }
+ 
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, net.minecraft.world.IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        super.getDrops(drops, world, pos, state, 0);
++        int age = func_185527_x(state);
++        Random rand = world instanceof World ? ((World)world).field_73012_v : new Random();
 +
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World world, BlockPos pos, int fortune) {
-+      {
-+         int i = this.func_185527_x(state);
-          if (i >= this.func_185526_g()) {
--            int j = 3 + p_196255_5_;
-+            int j = 3 + fortune;
++        if (age >= func_185526_g())
++        {
++            int k = 3 + fortune;
++
++            for (int i = 0; i < 3 + fortune; ++i)
++            {
++                if (rand.nextInt(2 * func_185526_g()) <= age)
++                {
++                    drops.add(new ItemStack(this.func_149866_i(), 1, 0));
++                }
++            }
++        }
++    }
++
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+-        super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, 0);
++        super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
+ 
+-        if (!p_180653_1_.field_72995_K)
++        if (false && !p_180653_1_.field_72995_K) // Forge: NOP all this.
+         {
+             int i = this.func_185527_x(p_180653_3_);
  
-             for(int k = 0; k < j; ++k) {
--               if (p_196255_2_.field_73012_v.nextInt(2 * this.func_185526_g()) <= i) {
--                  func_180635_a(p_196255_2_, p_196255_3_, new ItemStack(this.func_199772_f()));
-+               if (world.field_73012_v.nextInt(2 * this.func_185526_g()) <= i) {
-+                  drops.add(new ItemStack(this.func_199772_f()));
-                }
-             }
-          }

patches/minecraft/net/minecraft/block/BlockDeadBush.java.patch

@@ -1,22 +1,23 @@
---- a/net/minecraft/block/BlockDeadBush.java
-+++ b/net/minecraft/block/BlockDeadBush.java
-@@ -14,7 +14,7 @@
- import net.minecraft.world.IBlockReader;
+--- ../src-base/minecraft/net/minecraft/block/BlockDeadBush.java
++++ ../src-work/minecraft/net/minecraft/block/BlockDeadBush.java
+@@ -17,7 +17,7 @@
+ import net.minecraft.world.IBlockAccess;
  import net.minecraft.world.World;
  
--public class BlockDeadBush extends BlockBush {
-+public class BlockDeadBush extends BlockBush implements net.minecraftforge.common.IShearable {
-    protected static final VoxelShape field_196397_a = Block.func_208617_a(2.0D, 0.0D, 2.0D, 14.0D, 13.0D, 14.0D);
+-public class BlockDeadBush extends BlockBush
++public class BlockDeadBush extends BlockBush implements net.minecraftforge.common.IShearable
+ {
+     protected static final AxisAlignedBB field_185516_a = new AxisAlignedBB(0.09999999403953552D, 0.0D, 0.09999999403953552D, 0.8999999761581421D, 0.800000011920929D, 0.8999999761581421D);
  
-    protected BlockDeadBush(Block.Properties p_i48418_1_) {
-@@ -46,4 +46,10 @@
- 
-       super.func_180657_a(p_180657_1_, p_180657_2_, p_180657_3_, flag ? Blocks.field_150350_a.func_176223_P() : p_180657_4_, p_180657_5_, p_180657_6_);
-    }
+@@ -68,4 +68,11 @@
+             super.func_180657_a(p_180657_1_, p_180657_2_, p_180657_3_, p_180657_4_, p_180657_5_, p_180657_6_);
+         }
+     }
 +
-+   @Override
-+   public java.util.List<ItemStack> onSheared(ItemStack item, net.minecraft.world.IWorld world, BlockPos pos, int fortune) {
-+      world.func_180501_a(pos, Blocks.field_150350_a.func_176223_P(), 11);
-+      return java.util.Arrays.asList(new ItemStack(Blocks.field_196555_aI));
-+   }
++    @Override public boolean isShearable(ItemStack item, net.minecraft.world.IBlockAccess world, BlockPos pos){ return true; }
++    @Override
++    public java.util.List<ItemStack> onSheared(ItemStack item, net.minecraft.world.IBlockAccess world, BlockPos pos, int fortune)
++    {
++        return java.util.Arrays.asList(new ItemStack(Blocks.field_150330_I));
++    }
  }

patches/minecraft/net/minecraft/block/BlockDirtSnowySpreadable.java.patch

@@ -1,10 +0,0 @@
---- a/net/minecraft/block/BlockDirtSnowySpreadable.java
-+++ b/net/minecraft/block/BlockDirtSnowySpreadable.java
-@@ -25,6 +25,7 @@
- 
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-       if (!p_196267_2_.field_72995_K) {
-+         if (!p_196267_2_.func_205050_e(p_196267_3_, 3)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light and spreading
-          if (!func_196383_a(p_196267_2_, p_196267_3_)) {
-             p_196267_2_.func_175656_a(p_196267_3_, Blocks.field_150346_d.func_176223_P());
-          } else {

patches/minecraft/net/minecraft/block/BlockDoor.java.patch

@@ -0,0 +1,28 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockDoor.java
++++ ../src-work/minecraft/net/minecraft/block/BlockDoor.java
+@@ -203,7 +203,7 @@
+                 flag1 = true;
+             }
+ 
+-            if (!p_189540_2_.func_180495_p(p_189540_3_.func_177977_b()).func_185896_q())
++            if (!p_189540_2_.func_180495_p(p_189540_3_.func_177977_b()).isSideSolid(p_189540_2_,  p_189540_3_.func_177977_b(), EnumFacing.UP))
+             {
+                 p_189540_2_.func_175698_g(p_189540_3_);
+                 flag1 = true;
+@@ -247,13 +247,14 @@
+ 
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        if (p_176196_2_.func_177956_o() >= 255)
++        if (p_176196_2_.func_177956_o() >= p_176196_1_.func_72800_K() - 1)
+         {
+             return false;
+         }
+         else
+         {
+-            return p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_185896_q() && super.func_176196_c(p_176196_1_, p_176196_2_) && super.func_176196_c(p_176196_1_, p_176196_2_.func_177984_a());
++            IBlockState state = p_176196_1_.func_180495_p(p_176196_2_.func_177977_b());
++            return (state.func_185896_q() || state.func_193401_d(p_176196_1_, p_176196_2_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID) && super.func_176196_c(p_176196_1_, p_176196_2_) && super.func_176196_c(p_176196_1_, p_176196_2_.func_177984_a());
+         }
+     }
+ 

patches/minecraft/net/minecraft/block/BlockDoublePlant.java.patch

@@ -1,19 +1,81 @@
---- a/net/minecraft/block/BlockDoublePlant.java
-+++ b/net/minecraft/block/BlockDoublePlant.java
-@@ -43,7 +43,7 @@
-    @Nullable
-    public IBlockState func_196258_a(BlockItemUseContext p_196258_1_) {
-       BlockPos blockpos = p_196258_1_.func_195995_a();
--      return blockpos.func_177956_o() < 255 && p_196258_1_.func_195991_k().func_180495_p(blockpos.func_177984_a()).func_196953_a(p_196258_1_) ? super.func_196258_a(p_196258_1_) : null;
-+      return blockpos.func_177956_o() < p_196258_1_.func_195991_k().func_72800_K() - 1 && p_196258_1_.func_195991_k().func_180495_p(blockpos.func_177984_a()).func_196953_a(p_196258_1_) ? super.func_196258_a(p_196258_1_) : null;
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockDoublePlant.java
++++ ../src-work/minecraft/net/minecraft/block/BlockDoublePlant.java
+@@ -24,7 +24,7 @@
+ import net.minecraft.world.IBlockAccess;
+ import net.minecraft.world.World;
  
-    public void func_180633_a(World p_180633_1_, BlockPos p_180633_2_, IBlockState p_180633_3_, EntityLivingBase p_180633_4_, ItemStack p_180633_5_) {
-@@ -51,6 +51,7 @@
-    }
+-public class BlockDoublePlant extends BlockBush implements IGrowable
++public class BlockDoublePlant extends BlockBush implements IGrowable, net.minecraftforge.common.IShearable
+ {
+     public static final PropertyEnum<BlockDoublePlant.EnumPlantType> field_176493_a = PropertyEnum.<BlockDoublePlant.EnumPlantType>func_177709_a("variant", BlockDoublePlant.EnumPlantType.class);
+     public static final PropertyEnum<BlockDoublePlant.EnumBlockHalf> field_176492_b = PropertyEnum.<BlockDoublePlant.EnumBlockHalf>func_177709_a("half", BlockDoublePlant.EnumBlockHalf.class);
+@@ -87,6 +87,8 @@
+             Block block = (Block)(flag ? this : p_176475_1_.func_180495_p(blockpos).func_177230_c());
+             Block block1 = (Block)(flag ? p_176475_1_.func_180495_p(blockpos1).func_177230_c() : this);
  
-    public boolean func_196260_a(IBlockState p_196260_1_, IWorldReaderBase p_196260_2_, BlockPos p_196260_3_) {
-+      if (p_196260_1_.func_177230_c() != this) return super.func_196260_a(p_196260_1_, p_196260_2_, p_196260_3_); //Forge: This function is called during world gen and placement, before this block is set, so if we are not 'here' then assume it's the pre-check.
-       if (p_196260_1_.func_177229_b(field_176492_b) != DoubleBlockHalf.UPPER) {
-          return super.func_196260_a(p_196260_1_, p_196260_2_, p_196260_3_);
-       } else {
++            if (!flag) this.func_176226_b(p_176475_1_, p_176475_2_, p_176475_3_, 0); //Forge move above the setting to air.
++
+             if (block == this)
+             {
+                 p_176475_1_.func_180501_a(blockpos, Blocks.field_150350_a.func_176223_P(), 2);
+@@ -95,17 +97,13 @@
+             if (block1 == this)
+             {
+                 p_176475_1_.func_180501_a(blockpos1, Blocks.field_150350_a.func_176223_P(), 3);
+-
+-                if (!flag)
+-                {
+-                    this.func_176226_b(p_176475_1_, blockpos1, p_176475_3_, 0);
+-                }
+             }
+         }
+     }
+ 
+     public boolean func_180671_f(World p_180671_1_, BlockPos p_180671_2_, IBlockState p_180671_3_)
+     {
++        if (p_180671_3_.func_177230_c() != this) return super.func_180671_f(p_180671_1_, p_180671_2_, p_180671_3_); //Forge: This function is called during world gen and placement, before this block is set, so if we are not 'here' then assume it's the pre-check.
+         if (p_180671_3_.func_177229_b(field_176492_b) == BlockDoublePlant.EnumBlockHalf.UPPER)
+         {
+             return p_180671_1_.func_180495_p(p_180671_2_.func_177977_b()).func_177230_c() == this;
+@@ -160,7 +158,6 @@
+ 
+     public void func_180657_a(World p_180657_1_, EntityPlayer p_180657_2_, BlockPos p_180657_3_, IBlockState p_180657_4_, @Nullable TileEntity p_180657_5_, ItemStack p_180657_6_)
+     {
+-        if (p_180657_1_.field_72995_K || p_180657_6_.func_77973_b() != Items.field_151097_aZ || p_180657_4_.func_177229_b(field_176492_b) != BlockDoublePlant.EnumBlockHalf.LOWER || !this.func_176489_b(p_180657_1_, p_180657_3_, p_180657_4_, p_180657_2_))
+         {
+             super.func_180657_a(p_180657_1_, p_180657_2_, p_180657_3_, p_180657_4_, p_180657_5_, p_180657_6_);
+         }
+@@ -220,8 +217,6 @@
+         else
+         {
+             p_176489_4_.func_71029_a(StatList.func_188055_a(this));
+-            int i = (blockdoubleplant$enumplanttype == BlockDoublePlant.EnumPlantType.GRASS ? BlockTallGrass.EnumType.GRASS : BlockTallGrass.EnumType.FERN).func_177044_a();
+-            func_180635_a(p_176489_1_, p_176489_2_, new ItemStack(Blocks.field_150329_H, 2, i));
+             return true;
+         }
+     }
+@@ -290,6 +285,24 @@
+         return Block.EnumOffsetType.XZ;
+     }
+ 
++    @Override
++    public boolean isShearable(ItemStack item, IBlockAccess world, BlockPos pos)
++    {
++        IBlockState state = world.func_180495_p(pos);
++        EnumPlantType type = (EnumPlantType)state.func_177229_b(field_176493_a);
++        return state.func_177229_b(field_176492_b) == EnumBlockHalf.LOWER && (type == EnumPlantType.FERN || type == EnumPlantType.GRASS);
++    }
++
++    @Override
++    public java.util.List<ItemStack> onSheared(ItemStack item, net.minecraft.world.IBlockAccess world, BlockPos pos, int fortune)
++    {
++        java.util.List<ItemStack> ret = new java.util.ArrayList<ItemStack>();
++        EnumPlantType type = (EnumPlantType)world.func_180495_p(pos).func_177229_b(field_176493_a);
++        if (type == EnumPlantType.FERN) ret.add(new ItemStack(Blocks.field_150329_H, 2, BlockTallGrass.EnumType.FERN.func_177044_a()));
++        if (type == EnumPlantType.GRASS) ret.add(new ItemStack(Blocks.field_150329_H, 2, BlockTallGrass.EnumType.GRASS.func_177044_a()));
++        return ret;
++    }
++
+     public static enum EnumBlockHalf implements IStringSerializable
+     {
+         UPPER,

patches/minecraft/net/minecraft/block/BlockDragonEgg.java.patch

@@ -0,0 +1,29 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockDragonEgg.java
++++ ../src-work/minecraft/net/minecraft/block/BlockDragonEgg.java
+@@ -48,7 +48,7 @@
+ 
+     private void func_180683_d(World p_180683_1_, BlockPos p_180683_2_)
+     {
+-        if (BlockFalling.func_185759_i(p_180683_1_.func_180495_p(p_180683_2_.func_177977_b())) && p_180683_2_.func_177956_o() >= 0)
++        if (p_180683_1_.func_175623_d(p_180683_2_.func_177977_b()) && BlockFalling.func_185759_i(p_180683_1_.func_180495_p(p_180683_2_.func_177977_b())) && p_180683_2_.func_177956_o() >= 0)
+         {
+             int i = 32;
+ 
+@@ -61,7 +61,7 @@
+                 p_180683_1_.func_175698_g(p_180683_2_);
+                 BlockPos blockpos;
+ 
+-                for (blockpos = p_180683_2_; BlockFalling.func_185759_i(p_180683_1_.func_180495_p(blockpos)) && blockpos.func_177956_o() > 0; blockpos = blockpos.func_177977_b())
++                for (blockpos = p_180683_2_; p_180683_1_.func_175623_d(blockpos) && BlockFalling.func_185759_i(p_180683_1_.func_180495_p(blockpos)) && blockpos.func_177956_o() > 0; blockpos = blockpos.func_177977_b())
+                 {
+                     ;
+                 }
+@@ -95,7 +95,7 @@
+             {
+                 BlockPos blockpos = p_180684_2_.func_177982_a(p_180684_1_.field_73012_v.nextInt(16) - p_180684_1_.field_73012_v.nextInt(16), p_180684_1_.field_73012_v.nextInt(8) - p_180684_1_.field_73012_v.nextInt(8), p_180684_1_.field_73012_v.nextInt(16) - p_180684_1_.field_73012_v.nextInt(16));
+ 
+-                if (p_180684_1_.func_180495_p(blockpos).func_177230_c().field_149764_J == Material.field_151579_a)
++                if (p_180684_1_.func_175623_d(blockpos))
+                 {
+                     if (p_180684_1_.field_72995_K)
+                     {

patches/minecraft/net/minecraft/block/BlockDropper.java.patch

@@ -1,11 +1,11 @@
---- a/net/minecraft/block/BlockDropper.java
-+++ b/net/minecraft/block/BlockDropper.java
-@@ -37,7 +37,7 @@
-          p_176439_1_.func_175718_b(1001, p_176439_2_, 0);
-       } else {
-          ItemStack itemstack = tileentitydispenser.func_70301_a(i);
--         if (!itemstack.func_190926_b()) {
-+         if (!itemstack.func_190926_b() && net.minecraftforge.items.VanillaInventoryCodeHooks.dropperInsertHook(p_176439_1_, p_176439_2_, tileentitydispenser, i, itemstack)) {
-             EnumFacing enumfacing = p_176439_1_.func_180495_p(p_176439_2_).func_177229_b(field_176441_a);
-             IInventory iinventory = TileEntityHopper.func_195484_a(p_176439_1_, p_176439_2_.func_177972_a(enumfacing));
-             ItemStack itemstack1;
+--- ../src-base/minecraft/net/minecraft/block/BlockDropper.java
++++ ../src-work/minecraft/net/minecraft/block/BlockDropper.java
+@@ -43,7 +43,7 @@
+             {
+                 ItemStack itemstack = tileentitydispenser.func_70301_a(i);
+ 
+-                if (!itemstack.func_190926_b())
++                if (!itemstack.func_190926_b() && net.minecraftforge.items.VanillaInventoryCodeHooks.dropperInsertHook(p_176439_1_, p_176439_2_, tileentitydispenser, i, itemstack))
+                 {
+                     EnumFacing enumfacing = (EnumFacing)p_176439_1_.func_180495_p(p_176439_2_).func_177229_b(field_176441_a);
+                     BlockPos blockpos = p_176439_2_.func_177972_a(enumfacing);

patches/minecraft/net/minecraft/block/BlockEnchantmentTable.java.patch

@@ -1,11 +1,11 @@
---- a/net/minecraft/block/BlockEnchantmentTable.java
-+++ b/net/minecraft/block/BlockEnchantmentTable.java
-@@ -49,7 +49,7 @@
-             if (p_180655_4_.nextInt(16) == 0) {
-                for(int k = 0; k <= 1; ++k) {
-                   BlockPos blockpos = p_180655_3_.func_177982_a(i, k, j);
--                  if (p_180655_2_.func_180495_p(blockpos).func_177230_c() == Blocks.field_150342_X) {
-+                  if (p_180655_2_.func_180495_p(blockpos).getEnchantPowerBonus(p_180655_2_, p_180655_3_) > 0) {
-                      if (!p_180655_2_.func_175623_d(p_180655_3_.func_177982_a(i / 2, 0, j / 2))) {
-                         break;
-                      }
+--- ../src-base/minecraft/net/minecraft/block/BlockEnchantmentTable.java
++++ ../src-work/minecraft/net/minecraft/block/BlockEnchantmentTable.java
+@@ -64,7 +64,7 @@
+                     {
+                         BlockPos blockpos = p_180655_3_.func_177982_a(i, k, j);
+ 
+-                        if (p_180655_2_.func_180495_p(blockpos).func_177230_c() == Blocks.field_150342_X)
++                        if (net.minecraftforge.common.ForgeHooks.getEnchantPower(p_180655_2_, blockpos) > 0)
+                         {
+                             if (!p_180655_2_.func_175623_d(p_180655_3_.func_177982_a(i / 2, 0, j / 2)))
+                             {

patches/minecraft/net/minecraft/block/BlockEnderChest.java.patch

@@ -1,11 +1,11 @@
---- a/net/minecraft/block/BlockEnderChest.java
-+++ b/net/minecraft/block/BlockEnderChest.java
-@@ -81,7 +81,7 @@
-       InventoryEnderChest inventoryenderchest = p_196250_4_.func_71005_bN();
-       TileEntity tileentity = p_196250_2_.func_175625_s(p_196250_3_);
-       if (inventoryenderchest != null && tileentity instanceof TileEntityEnderChest) {
--         if (p_196250_2_.func_180495_p(p_196250_3_.func_177984_a()).func_185915_l()) {
-+         if (p_196250_2_.func_180495_p(p_196250_3_.func_177984_a()).doesSideBlockChestOpening(p_196250_2_, p_196250_3_.func_177984_a(), EnumFacing.DOWN)) {
-             return true;
-          } else if (p_196250_2_.field_72995_K) {
-             return true;
+--- ../src-base/minecraft/net/minecraft/block/BlockEnderChest.java
++++ ../src-work/minecraft/net/minecraft/block/BlockEnderChest.java
+@@ -100,7 +100,7 @@
+ 
+         if (inventoryenderchest != null && tileentity instanceof TileEntityEnderChest)
+         {
+-            if (p_180639_1_.func_180495_p(p_180639_2_.func_177984_a()).func_185915_l())
++            if (p_180639_1_.func_180495_p(p_180639_2_.func_177984_a()).doesSideBlockChestOpening(p_180639_1_, p_180639_2_.func_177984_a(), EnumFacing.DOWN))
+             {
+                 return true;
+             }

patches/minecraft/net/minecraft/block/BlockFalling.java.patch

@@ -1,21 +1,32 @@
---- a/net/minecraft/block/BlockFalling.java
-+++ b/net/minecraft/block/BlockFalling.java
-@@ -48,7 +48,9 @@
-                p_176503_1_.func_72838_d(entityfallingblock);
-             }
-          } else {
-+            IBlockState state = func_176223_P();
-             if (p_176503_1_.func_180495_p(p_176503_2_).func_177230_c() == this) {
-+               state = p_176503_1_.func_180495_p(p_176503_2_);
-                p_176503_1_.func_175698_g(p_176503_2_);
-             }
+--- ../src-base/minecraft/net/minecraft/block/BlockFalling.java
++++ ../src-work/minecraft/net/minecraft/block/BlockFalling.java
+@@ -47,7 +47,7 @@
  
-@@ -58,7 +60,7 @@
-             }
+     private void func_176503_e(World p_176503_1_, BlockPos p_176503_2_)
+     {
+-        if (func_185759_i(p_176503_1_.func_180495_p(p_176503_2_.func_177977_b())) && p_176503_2_.func_177956_o() >= 0)
++        if ((p_176503_1_.func_175623_d(p_176503_2_.func_177977_b()) || func_185759_i(p_176503_1_.func_180495_p(p_176503_2_.func_177977_b()))) && p_176503_2_.func_177956_o() >= 0)
+         {
+             int i = 32;
  
-             if (blockpos.func_177956_o() > 0) {
--               p_176503_1_.func_175656_a(blockpos.func_177984_a(), this.func_176223_P());
-+               p_176503_1_.func_175656_a(blockpos.func_177984_a(), state); //Forge: Fix loss of state information during world gen.
+@@ -62,17 +62,18 @@
              }
-          }
+             else
+             {
++                IBlockState state = p_176503_1_.func_180495_p(p_176503_2_);
+                 p_176503_1_.func_175698_g(p_176503_2_);
+                 BlockPos blockpos;
  
+-                for (blockpos = p_176503_2_.func_177977_b(); func_185759_i(p_176503_1_.func_180495_p(blockpos)) && blockpos.func_177956_o() > 0; blockpos = blockpos.func_177977_b())
++                for (blockpos = p_176503_2_.func_177977_b(); (p_176503_1_.func_175623_d(blockpos) || func_185759_i(p_176503_1_.func_180495_p(blockpos))) && blockpos.func_177956_o() > 0; blockpos = blockpos.func_177977_b())
+                 {
+                     ;
+                 }
+ 
+                 if (blockpos.func_177956_o() > 0)
+                 {
+-                    p_176503_1_.func_175656_a(blockpos.func_177984_a(), this.func_176223_P());
++                    p_176503_1_.func_175656_a(blockpos.func_177984_a(), state); //Forge: Fix loss of state information during world gen.
+                 }
+             }
+         }

patches/minecraft/net/minecraft/block/BlockFarmland.java.patch

@@ -1,24 +1,29 @@
---- a/net/minecraft/block/BlockFarmland.java
-+++ b/net/minecraft/block/BlockFarmland.java
-@@ -79,7 +79,7 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockFarmland.java
++++ ../src-work/minecraft/net/minecraft/block/BlockFarmland.java
+@@ -72,7 +72,7 @@
  
-    public void func_180658_a(World p_180658_1_, BlockPos p_180658_2_, Entity p_180658_3_, float p_180658_4_) {
--      if (!p_180658_1_.field_72995_K && p_180658_1_.field_73012_v.nextFloat() < p_180658_4_ - 0.5F && p_180658_3_ instanceof EntityLivingBase && (p_180658_3_ instanceof EntityPlayer || p_180658_1_.func_82736_K().func_82766_b("mobGriefing")) && p_180658_3_.field_70130_N * p_180658_3_.field_70130_N * p_180658_3_.field_70131_O > 0.512F) {
-+      if (!p_180658_1_.field_72995_K && net.minecraftforge.common.ForgeHooks.onFarmlandTrample(p_180658_1_, p_180658_2_, Blocks.field_150346_d.func_176223_P(), p_180658_4_, p_180658_3_)) { // Forge: Move logic to Entity#canTrample
-          func_199610_d(p_180658_1_.func_180495_p(p_180658_2_), p_180658_1_, p_180658_2_);
-       }
+     public void func_180658_a(World p_180658_1_, BlockPos p_180658_2_, Entity p_180658_3_, float p_180658_4_)
+     {
+-        if (!p_180658_1_.field_72995_K && p_180658_1_.field_73012_v.nextFloat() < p_180658_4_ - 0.5F && p_180658_3_ instanceof EntityLivingBase && (p_180658_3_ instanceof EntityPlayer || p_180658_1_.func_82736_K().func_82766_b("mobGriefing")) && p_180658_3_.field_70130_N * p_180658_3_.field_70130_N * p_180658_3_.field_70131_O > 0.512F)
++        if (net.minecraftforge.common.ForgeHooks.onFarmlandTrample(p_180658_1_, p_180658_2_, Blocks.field_150346_d.func_176223_P(), p_180658_4_, p_180658_3_)) // Forge: Move logic to Entity#canTrample
+         {
+             func_190970_b(p_180658_1_, p_180658_2_);
+         }
+@@ -95,7 +95,7 @@
+     private boolean func_176529_d(World p_176529_1_, BlockPos p_176529_2_)
+     {
+         Block block = p_176529_1_.func_180495_p(p_176529_2_.func_177984_a()).func_177230_c();
+-        return block instanceof BlockCrops || block instanceof BlockStem;
++        return block instanceof net.minecraftforge.common.IPlantable && canSustainPlant(p_176529_1_.func_180495_p(p_176529_2_), p_176529_1_, p_176529_2_, net.minecraft.util.EnumFacing.UP, (net.minecraftforge.common.IPlantable)block);
+     }
  
-@@ -90,9 +90,9 @@
-       p_199610_1_.func_175656_a(p_199610_2_, func_199601_a(p_199610_0_, Blocks.field_150346_d.func_176223_P(), p_199610_1_, p_199610_2_));
-    }
+     private boolean func_176530_e(World p_176530_1_, BlockPos p_176530_2_)
+@@ -108,7 +108,7 @@
+             }
+         }
  
--   private static boolean func_176529_d(IBlockReader p_176529_0_, BlockPos p_176529_1_) {
--      Block block = p_176529_0_.func_180495_p(p_176529_1_.func_177984_a()).func_177230_c();
--      return block instanceof BlockCrops || block instanceof BlockStem || block instanceof BlockAttachedStem;
-+   private boolean func_176529_d(IBlockReader p_176529_0_, BlockPos p_176529_1_) {
-+      IBlockState state = p_176529_0_.func_180495_p(p_176529_1_.func_177984_a());
-+      return state.func_177230_c() instanceof net.minecraftforge.common.IPlantable && canSustainPlant(state, p_176529_0_, p_176529_1_, EnumFacing.UP, (net.minecraftforge.common.IPlantable)state.func_177230_c());
-    }
+-        return false;
++        return net.minecraftforge.common.FarmlandWaterManager.hasBlockWaterTicket(p_176530_1_, p_176530_2_);
+     }
  
-    private static boolean func_176530_e(IWorldReaderBase p_176530_0_, BlockPos p_176530_1_) {
+     public void func_189540_a(IBlockState p_189540_1_, World p_189540_2_, BlockPos p_189540_3_, Block p_189540_4_, BlockPos p_189540_5_)

patches/minecraft/net/minecraft/block/BlockFence.java.patch

@@ -1,50 +1,38 @@
---- a/net/minecraft/block/BlockFence.java
-+++ b/net/minecraft/block/BlockFence.java
-@@ -64,15 +64,12 @@
-       IBlockReader iblockreader = p_196258_1_.func_195991_k();
-       BlockPos blockpos = p_196258_1_.func_195995_a();
-       IFluidState ifluidstate = p_196258_1_.func_195991_k().func_204610_c(p_196258_1_.func_195995_a());
--      BlockPos blockpos1 = blockpos.func_177978_c();
--      BlockPos blockpos2 = blockpos.func_177974_f();
--      BlockPos blockpos3 = blockpos.func_177968_d();
--      BlockPos blockpos4 = blockpos.func_177976_e();
--      IBlockState iblockstate = iblockreader.func_180495_p(blockpos1);
--      IBlockState iblockstate1 = iblockreader.func_180495_p(blockpos2);
--      IBlockState iblockstate2 = iblockreader.func_180495_p(blockpos3);
--      IBlockState iblockstate3 = iblockreader.func_180495_p(blockpos4);
--      return super.func_196258_a(p_196258_1_).func_206870_a(field_196409_a, Boolean.valueOf(this.func_196416_a(iblockstate, iblockstate.func_193401_d(iblockreader, blockpos1, EnumFacing.SOUTH)))).func_206870_a(field_196411_b, Boolean.valueOf(this.func_196416_a(iblockstate1, iblockstate1.func_193401_d(iblockreader, blockpos2, EnumFacing.WEST)))).func_206870_a(field_196413_c, Boolean.valueOf(this.func_196416_a(iblockstate2, iblockstate2.func_193401_d(iblockreader, blockpos3, EnumFacing.NORTH)))).func_206870_a(field_196414_y, Boolean.valueOf(this.func_196416_a(iblockstate3, iblockstate3.func_193401_d(iblockreader, blockpos4, EnumFacing.EAST)))).func_206870_a(field_204514_u, Boolean.valueOf(ifluidstate.func_206886_c() == Fluids.field_204546_a));
-+      return super.func_196258_a(p_196258_1_)
-+              .func_206870_a(field_196409_a, canFenceConnectTo(iblockreader, blockpos, EnumFacing.NORTH))
-+              .func_206870_a(field_196411_b, canFenceConnectTo(iblockreader, blockpos, EnumFacing.EAST))
-+              .func_206870_a(field_196413_c, canFenceConnectTo(iblockreader, blockpos, EnumFacing.SOUTH))
-+              .func_206870_a(field_196414_y, canFenceConnectTo(iblockreader, blockpos, EnumFacing.WEST))
-+              .func_206870_a(field_204514_u, Boolean.valueOf(ifluidstate.func_206886_c() == Fluids.field_204546_a));
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockFence.java
++++ ../src-work/minecraft/net/minecraft/block/BlockFence.java
+@@ -165,7 +165,10 @@
  
-    public IBlockState func_196271_a(IBlockState p_196271_1_, EnumFacing p_196271_2_, IBlockState p_196271_3_, IWorld p_196271_4_, BlockPos p_196271_5_, BlockPos p_196271_6_) {
-@@ -80,7 +77,7 @@
-          p_196271_4_.func_205219_F_().func_205360_a(p_196271_5_, Fluids.field_204546_a, Fluids.field_204546_a.func_205569_a(p_196271_4_));
-       }
+     public IBlockState func_176221_a(IBlockState p_176221_1_, IBlockAccess p_176221_2_, BlockPos p_176221_3_)
+     {
+-        return p_176221_1_.func_177226_a(field_176526_a, Boolean.valueOf(this.func_176524_e(p_176221_2_, p_176221_3_.func_177978_c(), EnumFacing.SOUTH))).func_177226_a(field_176525_b, Boolean.valueOf(this.func_176524_e(p_176221_2_, p_176221_3_.func_177974_f(), EnumFacing.WEST))).func_177226_a(field_176527_M, Boolean.valueOf(this.func_176524_e(p_176221_2_, p_176221_3_.func_177968_d(), EnumFacing.NORTH))).func_177226_a(field_176528_N, Boolean.valueOf(this.func_176524_e(p_176221_2_, p_176221_3_.func_177976_e(), EnumFacing.EAST)));
++        return p_176221_1_.func_177226_a(field_176526_a, canFenceConnectTo(p_176221_2_, p_176221_3_, EnumFacing.NORTH))
++                    .func_177226_a(field_176525_b,  canFenceConnectTo(p_176221_2_, p_176221_3_, EnumFacing.EAST))
++                    .func_177226_a(field_176527_M, canFenceConnectTo(p_176221_2_, p_176221_3_, EnumFacing.SOUTH))
++                    .func_177226_a(field_176528_N,  canFenceConnectTo(p_176221_2_, p_176221_3_, EnumFacing.WEST));
+     }
  
--      return p_196271_2_.func_176740_k().func_176716_d() == EnumFacing.Plane.HORIZONTAL ? p_196271_1_.func_206870_a(field_196415_z.get(p_196271_2_), Boolean.valueOf(this.func_196416_a(p_196271_3_, p_196271_3_.func_193401_d(p_196271_4_, p_196271_6_, p_196271_2_.func_176734_d())))) : super.func_196271_a(p_196271_1_, p_196271_2_, p_196271_3_, p_196271_4_, p_196271_5_, p_196271_6_);
-+      return p_196271_2_.func_176740_k().func_176716_d() == EnumFacing.Plane.HORIZONTAL ? p_196271_1_.func_206870_a(field_196415_z.get(p_196271_2_), Boolean.valueOf(this.canFenceConnectTo(p_196271_4_, p_196271_5_, p_196271_2_))) : super.func_196271_a(p_196271_1_, p_196271_2_, p_196271_3_, p_196271_4_, p_196271_5_, p_196271_6_);
-    }
+     public IBlockState func_185499_a(IBlockState p_185499_1_, Rotation p_185499_2_)
+@@ -201,6 +204,23 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176526_a, field_176525_b, field_176528_N, field_176527_M});
+     }
  
-    protected void func_206840_a(StateContainer.Builder<Block, IBlockState> p_206840_1_) {
-@@ -90,4 +87,16 @@
-    public BlockFaceShape func_193383_a(IBlockReader p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_) {
-       return p_193383_4_ != EnumFacing.UP && p_193383_4_ != EnumFacing.DOWN ? BlockFaceShape.MIDDLE_POLE : BlockFaceShape.CENTER;
-    }
++    /* ======================================== FORGE START ======================================== */
 +
-+   @Override
-+   public boolean canBeConnectedTo(IBlockState state, IBlockReader world, BlockPos pos, EnumFacing facing) {
-+      IBlockState other = world.func_180495_p(pos.func_177972_a(facing));
-+      return func_196416_a(other, other.func_193401_d(world, pos.func_177972_a(facing), facing.func_176734_d()));
-+   }
++    @Override
++    public boolean canBeConnectedTo(IBlockAccess world, BlockPos pos, EnumFacing facing)
++    {
++        return func_176524_e(world, pos.func_177972_a(facing), facing.func_176734_d());
++    }
 +
-+   private boolean canFenceConnectTo(IBlockReader world, BlockPos pos, EnumFacing facing) {
-+      BlockPos offset = pos.func_177972_a(facing);
-+      IBlockState other = world.func_180495_p(offset);
-+      return other.canBeConnectedTo(world, offset, facing.func_176734_d()) || func_176223_P().canBeConnectedTo(world, pos, facing);
-+   }
- }
++    private boolean canFenceConnectTo(IBlockAccess world, BlockPos pos, EnumFacing facing)
++    {
++        BlockPos other = pos.func_177972_a(facing);
++        Block block = world.func_180495_p(other).func_177230_c();
++        return block.canBeConnectedTo(world, other, facing.func_176734_d()) || func_176524_e(world, other, facing.func_176734_d());
++    }
++
++    /* ======================================== FORGE END ======================================== */
++
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         return p_193383_4_ != EnumFacing.UP && p_193383_4_ != EnumFacing.DOWN ? BlockFaceShape.MIDDLE_POLE : BlockFaceShape.CENTER;

patches/minecraft/net/minecraft/block/BlockFenceGate.java.patch

@@ -1,26 +1,35 @@
---- a/net/minecraft/block/BlockFenceGate.java
-+++ b/net/minecraft/block/BlockFenceGate.java
-@@ -100,7 +100,7 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockFenceGate.java
++++ ../src-work/minecraft/net/minecraft/block/BlockFenceGate.java
+@@ -59,7 +59,7 @@
+     {
+         EnumFacing.Axis enumfacing$axis = ((EnumFacing)p_176221_1_.func_177229_b(field_185512_D)).func_176740_k();
  
-    private boolean func_196380_i(IBlockState p_196380_1_) {
--      return p_196380_1_.func_177230_c() == Blocks.field_150463_bK || p_196380_1_.func_177230_c() == Blocks.field_196723_eg;
-+      return p_196380_1_.func_177230_c() == Blocks.field_150463_bK || p_196380_1_.func_177230_c() == Blocks.field_196723_eg || p_196380_1_.func_177230_c() instanceof BlockWall;
-    }
+-        if (enumfacing$axis == EnumFacing.Axis.Z && (p_176221_2_.func_180495_p(p_176221_3_.func_177976_e()).func_177230_c() == Blocks.field_150463_bK || p_176221_2_.func_180495_p(p_176221_3_.func_177974_f()).func_177230_c() == Blocks.field_150463_bK) || enumfacing$axis == EnumFacing.Axis.X && (p_176221_2_.func_180495_p(p_176221_3_.func_177978_c()).func_177230_c() == Blocks.field_150463_bK || p_176221_2_.func_180495_p(p_176221_3_.func_177968_d()).func_177230_c() == Blocks.field_150463_bK))
++        if (enumfacing$axis == EnumFacing.Axis.Z && (p_176221_2_.func_180495_p(p_176221_3_.func_177976_e()).func_177230_c() instanceof BlockWall || p_176221_2_.func_180495_p(p_176221_3_.func_177974_f()).func_177230_c() instanceof BlockWall) || enumfacing$axis == EnumFacing.Axis.X && (p_176221_2_.func_180495_p(p_176221_3_.func_177978_c()).func_177230_c() instanceof BlockWall || p_176221_2_.func_180495_p(p_176221_3_.func_177968_d()).func_177230_c() instanceof BlockWall))
+         {
+             p_176221_1_ = p_176221_1_.func_177226_a(field_176467_M, Boolean.valueOf(true));
+         }
+@@ -192,6 +192,23 @@
+         return new BlockStateContainer(this, new IProperty[] {field_185512_D, field_176466_a, field_176465_b, field_176467_M});
+     }
  
-    public boolean func_196250_a(IBlockState p_196250_1_, World p_196250_2_, BlockPos p_196250_3_, EntityPlayer p_196250_4_, EnumHand p_196250_5_, EnumFacing p_196250_6_, float p_196250_7_, float p_196250_8_, float p_196250_9_) {
-@@ -145,4 +145,14 @@
-          return BlockFaceShape.UNDEFINED;
-       }
-    }
++    /* ======================================== FORGE START ======================================== */
 +
-+   @Override
-+   public boolean canBeConnectedTo(IBlockState state, IBlockReader world, BlockPos pos, EnumFacing facing) {
-+      if (state.func_193401_d(world, pos, facing) == BlockFaceShape.MIDDLE_POLE) {
-+         Block other = world.func_180495_p(pos.func_177972_a(facing)).func_177230_c();
-+         return other instanceof BlockFence || other instanceof BlockWall;
-+      }
-+      return false;
-+   }
++    @Override
++    public boolean canBeConnectedTo(IBlockAccess world, BlockPos pos, EnumFacing facing)
++    {
++        IBlockState state = world.func_180495_p(pos);
++        if (state.func_177230_c() instanceof BlockFenceGate &&
++            state.func_193401_d(world, pos, facing) == BlockFaceShape.MIDDLE_POLE)
++        {
++            Block connector = world.func_180495_p(pos.func_177972_a(facing)).func_177230_c();
++            return connector instanceof BlockFence || connector instanceof BlockWall;
++        }
++        return false;
++    }
 +
- }
++    /* ======================================== FORGE END ======================================== */
++
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         if (p_193383_4_ != EnumFacing.UP && p_193383_4_ != EnumFacing.DOWN)

patches/minecraft/net/minecraft/block/BlockFire.java.patch

@@ -1,188 +1,218 @@
---- a/net/minecraft/block/BlockFire.java
-+++ b/net/minecraft/block/BlockFire.java
-@@ -64,13 +64,13 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockFire.java
++++ ../src-work/minecraft/net/minecraft/block/BlockFire.java
+@@ -39,7 +39,15 @@
  
-    public IBlockState func_196448_a(IBlockReader p_196448_1_, BlockPos p_196448_2_) {
-       IBlockState iblockstate = p_196448_1_.func_180495_p(p_196448_2_.func_177977_b());
--      if (!iblockstate.func_185896_q() && !this.func_196446_i(iblockstate)) {
-+      if (!iblockstate.func_185896_q() && !this.canCatchFire(p_196448_1_, p_196448_2_, EnumFacing.UP)) {
-          IBlockState iblockstate1 = this.func_176223_P();
+     public IBlockState func_176221_a(IBlockState p_176221_1_, IBlockAccess p_176221_2_, BlockPos p_176221_3_)
+     {
+-        return !p_176221_2_.func_180495_p(p_176221_3_.func_177977_b()).func_185896_q() && !Blocks.field_150480_ab.func_176535_e(p_176221_2_, p_176221_3_.func_177977_b()) ? p_176221_1_.func_177226_a(field_176545_N, Boolean.valueOf(this.func_176535_e(p_176221_2_, p_176221_3_.func_177978_c()))).func_177226_a(field_176546_O, Boolean.valueOf(this.func_176535_e(p_176221_2_, p_176221_3_.func_177974_f()))).func_177226_a(field_176541_P, Boolean.valueOf(this.func_176535_e(p_176221_2_, p_176221_3_.func_177968_d()))).func_177226_a(field_176539_Q, Boolean.valueOf(this.func_176535_e(p_176221_2_, p_176221_3_.func_177976_e()))).func_177226_a(field_176542_R, Boolean.valueOf(this.func_176535_e(p_176221_2_, p_176221_3_.func_177984_a()))) : this.func_176223_P();
++        if (!p_176221_2_.func_180495_p(p_176221_3_.func_177977_b()).isSideSolid(p_176221_2_, p_176221_3_.func_177977_b(), EnumFacing.UP) && !Blocks.field_150480_ab.canCatchFire(p_176221_2_, p_176221_3_.func_177977_b(), EnumFacing.UP))
++        {
++            return p_176221_1_.func_177226_a(field_176545_N, this.canCatchFire(p_176221_2_, p_176221_3_.func_177978_c(), EnumFacing.SOUTH))
++                        .func_177226_a(field_176546_O,  this.canCatchFire(p_176221_2_, p_176221_3_.func_177974_f(), EnumFacing.WEST))
++                        .func_177226_a(field_176541_P, this.canCatchFire(p_176221_2_, p_176221_3_.func_177968_d(), EnumFacing.NORTH))
++                        .func_177226_a(field_176539_Q,  this.canCatchFire(p_176221_2_, p_176221_3_.func_177976_e(), EnumFacing.EAST))
++                        .func_177226_a(field_176542_R, this.canCatchFire(p_176221_2_, p_176221_3_.func_177984_a(), EnumFacing.DOWN));
++        }
++        return this.func_176223_P();
+     }
  
-          for(EnumFacing enumfacing : EnumFacing.values()) {
-             BooleanProperty booleanproperty = field_196449_B.get(enumfacing);
-             if (booleanproperty != null) {
--               iblockstate1 = iblockstate1.func_206870_a(booleanproperty, Boolean.valueOf(this.func_196446_i(p_196448_1_.func_180495_p(p_196448_2_.func_177972_a(enumfacing)))));
-+               iblockstate1 = iblockstate1.func_206870_a(booleanproperty, Boolean.valueOf(this.canCatchFire(p_196448_1_, p_196448_2_.func_177972_a(enumfacing), enumfacing.func_176734_d())));
+     protected BlockFire()
+@@ -92,6 +100,7 @@
+ 
+     public void func_180686_a(Block p_180686_1_, int p_180686_2_, int p_180686_3_)
+     {
++        if (p_180686_1_ == Blocks.field_150350_a) throw new IllegalArgumentException("Tried to set air on fire... This is bad.");
+         this.field_149849_a.put(p_180686_1_, Integer.valueOf(p_180686_2_));
+         this.field_149848_b.put(p_180686_1_, Integer.valueOf(p_180686_3_));
+     }
+@@ -126,19 +135,15 @@
+     {
+         if (p_180650_1_.func_82736_K().func_82766_b("doFireTick"))
+         {
++            if (!p_180650_1_.func_175697_a(p_180650_2_, 2)) return; // Forge: prevent loading unloaded chunks when spreading fire
+             if (!this.func_176196_c(p_180650_1_, p_180650_2_))
+             {
+                 p_180650_1_.func_175698_g(p_180650_2_);
              }
-          }
  
-@@ -98,12 +98,13 @@
+             Block block = p_180650_1_.func_180495_p(p_180650_2_.func_177977_b()).func_177230_c();
+-            boolean flag = block == Blocks.field_150424_aL || block == Blocks.field_189877_df;
++            boolean flag = block.isFireSource(p_180650_1_, p_180650_2_.func_177977_b(), EnumFacing.UP);
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-       if (p_196267_2_.func_82736_K().func_82766_b("doFireTick")) {
-+         if (!p_196267_2_.func_205050_e(p_196267_3_, 2)) return; // Forge: prevent loading unloaded chunks when spreading fire
-          if (!p_196267_1_.func_196955_c(p_196267_2_, p_196267_3_)) {
-             p_196267_2_.func_175698_g(p_196267_3_);
-          }
+-            if (p_180650_1_.field_73011_w instanceof WorldProviderEnd && block == Blocks.field_150357_h)
+-            {
+-                flag = true;
+-            }
+-
+             int i = ((Integer)p_180650_3_.func_177229_b(field_176543_a)).intValue();
  
--         Block block = p_196267_2_.func_180495_p(p_196267_3_.func_177977_b()).func_177230_c();
--         boolean flag = p_196267_2_.field_73011_w instanceof EndDimension && block == Blocks.field_150357_h || block == Blocks.field_150424_aL || block == Blocks.field_196814_hQ;
-+         IBlockState other = p_196267_2_.func_180495_p(p_196267_3_.func_177977_b());
-+         boolean flag = other.isFireSource(p_196267_2_, p_196267_3_.func_177977_b(), EnumFacing.UP);
-          int i = p_196267_1_.func_177229_b(field_176543_a);
-          if (!flag && p_196267_2_.func_72896_J() && this.func_176537_d(p_196267_2_, p_196267_3_) && p_196267_4_.nextFloat() < 0.2F + (float)i * 0.03F) {
-             p_196267_2_.func_175698_g(p_196267_3_);
-@@ -117,14 +118,14 @@
-             if (!flag) {
-                p_196267_2_.func_205220_G_().func_205360_a(p_196267_3_, this, this.func_149738_a(p_196267_2_) + p_196267_4_.nextInt(10));
-                if (!this.func_196447_a(p_196267_2_, p_196267_3_)) {
--                  if (!p_196267_2_.func_180495_p(p_196267_3_.func_177977_b()).func_185896_q() || i > 3) {
-+                  if (p_196267_2_.func_180495_p(p_196267_3_.func_177977_b()).func_193401_d(p_196267_2_, p_196267_3_.func_177977_b(), EnumFacing.UP) != BlockFaceShape.SOLID || i > 3) {
-                      p_196267_2_.func_175698_g(p_196267_3_);
-                   }
+             if (!flag && p_180650_1_.func_72896_J() && this.func_176537_d(p_180650_1_, p_180650_2_) && p_180650_4_.nextFloat() < 0.2F + (float)i * 0.03F)
+@@ -159,7 +164,7 @@
+                 {
+                     if (!this.func_176533_e(p_180650_1_, p_180650_2_))
+                     {
+-                        if (!p_180650_1_.func_180495_p(p_180650_2_.func_177977_b()).func_185896_q() || i > 3)
++                        if (!p_180650_1_.func_180495_p(p_180650_2_.func_177977_b()).isSideSolid(p_180650_1_, p_180650_2_.func_177977_b(), EnumFacing.UP) || i > 3)
+                         {
+                             p_180650_1_.func_175698_g(p_180650_2_);
+                         }
+@@ -167,7 +172,7 @@
+                         return;
+                     }
  
-                   return;
-                }
+-                    if (!this.func_176535_e(p_180650_1_, p_180650_2_.func_177977_b()) && i == 15 && p_180650_4_.nextInt(4) == 0)
++                    if (!this.canCatchFire(p_180650_1_, p_180650_2_.func_177977_b(), EnumFacing.UP) && i == 15 && p_180650_4_.nextInt(4) == 0)
+                     {
+                         p_180650_1_.func_175698_g(p_180650_2_);
+                         return;
+@@ -182,12 +187,12 @@
+                     j = -50;
+                 }
  
--               if (i == 15 && p_196267_4_.nextInt(4) == 0 && !this.func_196446_i(p_196267_2_.func_180495_p(p_196267_3_.func_177977_b()))) {
-+               if (i == 15 && p_196267_4_.nextInt(4) == 0 && !this.canCatchFire(p_196267_2_, p_196267_3_.func_177977_b(), EnumFacing.UP)) {
-                   p_196267_2_.func_175698_g(p_196267_3_);
-                   return;
-                }
-@@ -132,12 +133,12 @@
+-                this.func_176536_a(p_180650_1_, p_180650_2_.func_177974_f(), 300 + j, p_180650_4_, i);
+-                this.func_176536_a(p_180650_1_, p_180650_2_.func_177976_e(), 300 + j, p_180650_4_, i);
+-                this.func_176536_a(p_180650_1_, p_180650_2_.func_177977_b(), 250 + j, p_180650_4_, i);
+-                this.func_176536_a(p_180650_1_, p_180650_2_.func_177984_a(), 250 + j, p_180650_4_, i);
+-                this.func_176536_a(p_180650_1_, p_180650_2_.func_177978_c(), 300 + j, p_180650_4_, i);
+-                this.func_176536_a(p_180650_1_, p_180650_2_.func_177968_d(), 300 + j, p_180650_4_, i);
++                this.tryCatchFire(p_180650_1_, p_180650_2_.func_177974_f(), 300 + j, p_180650_4_, i, EnumFacing.WEST);
++                this.tryCatchFire(p_180650_1_, p_180650_2_.func_177976_e(), 300 + j, p_180650_4_, i, EnumFacing.EAST);
++                this.tryCatchFire(p_180650_1_, p_180650_2_.func_177977_b(), 250 + j, p_180650_4_, i, EnumFacing.UP);
++                this.tryCatchFire(p_180650_1_, p_180650_2_.func_177984_a(), 250 + j, p_180650_4_, i, EnumFacing.DOWN);
++                this.tryCatchFire(p_180650_1_, p_180650_2_.func_177978_c(), 300 + j, p_180650_4_, i, EnumFacing.SOUTH);
++                this.tryCatchFire(p_180650_1_, p_180650_2_.func_177968_d(), 300 + j, p_180650_4_, i, EnumFacing.NORTH);
  
-             boolean flag1 = p_196267_2_.func_180502_D(p_196267_3_);
-             int k = flag1 ? -50 : 0;
--            this.func_176536_a(p_196267_2_, p_196267_3_.func_177974_f(), 300 + k, p_196267_4_, i);
--            this.func_176536_a(p_196267_2_, p_196267_3_.func_177976_e(), 300 + k, p_196267_4_, i);
--            this.func_176536_a(p_196267_2_, p_196267_3_.func_177977_b(), 250 + k, p_196267_4_, i);
--            this.func_176536_a(p_196267_2_, p_196267_3_.func_177984_a(), 250 + k, p_196267_4_, i);
--            this.func_176536_a(p_196267_2_, p_196267_3_.func_177978_c(), 300 + k, p_196267_4_, i);
--            this.func_176536_a(p_196267_2_, p_196267_3_.func_177968_d(), 300 + k, p_196267_4_, i);
-+            this.tryCatchFire(p_196267_2_, p_196267_3_.func_177974_f(), 300 + k, p_196267_4_, i, EnumFacing.WEST);
-+            this.tryCatchFire(p_196267_2_, p_196267_3_.func_177976_e(), 300 + k, p_196267_4_, i, EnumFacing.EAST);
-+            this.tryCatchFire(p_196267_2_, p_196267_3_.func_177977_b(), 250 + k, p_196267_4_, i, EnumFacing.UP);
-+            this.tryCatchFire(p_196267_2_, p_196267_3_.func_177984_a(), 250 + k, p_196267_4_, i, EnumFacing.DOWN);
-+            this.tryCatchFire(p_196267_2_, p_196267_3_.func_177978_c(), 300 + k, p_196267_4_, i, EnumFacing.SOUTH);
-+            this.tryCatchFire(p_196267_2_, p_196267_3_.func_177968_d(), 300 + k, p_196267_4_, i, EnumFacing.NORTH);
-             BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos();
+                 for (int k = -1; k <= 1; ++k)
+                 {
+@@ -246,22 +251,30 @@
+         return false;
+     }
  
-             for(int l = -1; l <= 1; ++l) {
-@@ -175,16 +176,18 @@
-       return p_176537_1_.func_175727_C(p_176537_2_) || p_176537_1_.func_175727_C(p_176537_2_.func_177976_e()) || p_176537_1_.func_175727_C(p_176537_2_.func_177974_f()) || p_176537_1_.func_175727_C(p_176537_2_.func_177978_c()) || p_176537_1_.func_175727_C(p_176537_2_.func_177968_d());
-    }
++    @Deprecated // Use Block.getFlammability
+     public int func_176532_c(Block p_176532_1_)
+     {
+         Integer integer = this.field_149848_b.get(p_176532_1_);
+         return integer == null ? 0 : integer.intValue();
+     }
  
-+   @Deprecated //Forge: Use IForgeBlockState.getFlammability
-    public int func_176532_c(Block p_176532_1_) {
-       return this.field_149848_b.getInt(p_176532_1_);
-    }
++    @Deprecated // Use Block.getFireSpreadSpeed
+     public int func_176534_d(Block p_176534_1_)
+     {
+         Integer integer = this.field_149849_a.get(p_176534_1_);
+         return integer == null ? 0 : integer.intValue();
+     }
  
-+   @Deprecated //Forge: Use IForgeBlockState.getFireSpreadSpeed
-    public int func_176534_d(Block p_176534_1_) {
-       return this.field_149849_a.getInt(p_176534_1_);
-    }
++    @Deprecated // Use tryCatchFire with face below
+     private void func_176536_a(World p_176536_1_, BlockPos p_176536_2_, int p_176536_3_, Random p_176536_4_, int p_176536_5_)
+     {
+-        int i = this.func_176532_c(p_176536_1_.func_180495_p(p_176536_2_).func_177230_c());
++        this.tryCatchFire(p_176536_1_, p_176536_2_, p_176536_3_, p_176536_4_, p_176536_5_, EnumFacing.UP);
++    }
  
--   private void func_176536_a(World p_176536_1_, BlockPos p_176536_2_, int p_176536_3_, Random p_176536_4_, int p_176536_5_) {
--      int i = this.func_176532_c(p_176536_1_.func_180495_p(p_176536_2_).func_177230_c());
-+   private void tryCatchFire(World p_176536_1_, BlockPos p_176536_2_, int p_176536_3_, Random p_176536_4_, int p_176536_5_, EnumFacing face) {
-+      int i = p_176536_1_.func_180495_p(p_176536_2_).getFlammability(p_176536_1_, p_176536_2_, face);
-       if (p_176536_4_.nextInt(p_176536_3_) < i) {
-          IBlockState iblockstate = p_176536_1_.func_180495_p(p_176536_2_);
-          if (p_176536_4_.nextInt(p_176536_5_ + 10) < 5 && !p_176536_1_.func_175727_C(p_176536_2_)) {
-@@ -204,7 +207,7 @@
- 
-    private boolean func_196447_a(IBlockReader p_196447_1_, BlockPos p_196447_2_) {
-       for(EnumFacing enumfacing : EnumFacing.values()) {
--         if (this.func_196446_i(p_196447_1_.func_180495_p(p_196447_2_.func_177972_a(enumfacing)))) {
-+         if (this.canCatchFire(p_196447_1_, p_196447_2_.func_177972_a(enumfacing), enumfacing.func_176734_d())) {
-             return true;
-          }
-       }
-@@ -219,7 +222,7 @@
-          int i = 0;
- 
-          for(EnumFacing enumfacing : EnumFacing.values()) {
--            i = Math.max(this.func_176534_d(p_176538_1_.func_180495_p(p_176538_2_.func_177972_a(enumfacing)).func_177230_c()), i);
-+            i = Math.max(p_176538_1_.func_180495_p(p_176538_2_.func_177972_a(enumfacing)).getFlammability(p_176538_1_, p_176538_2_.func_177972_a(enumfacing), enumfacing.func_176734_d()), i);
-          }
- 
-          return i;
-@@ -230,6 +233,7 @@
-       return false;
-    }
- 
-+   @Deprecated //Forge: Use canCatchFire with more context
-    public boolean func_196446_i(IBlockState p_196446_1_) {
-       return this.func_176534_d(p_196446_1_.func_177230_c()) > 0;
-    }
-@@ -252,8 +256,8 @@
-          p_180655_2_.func_184134_a((double)((float)p_180655_3_.func_177958_n() + 0.5F), (double)((float)p_180655_3_.func_177956_o() + 0.5F), (double)((float)p_180655_3_.func_177952_p() + 0.5F), SoundEvents.field_187643_bs, SoundCategory.BLOCKS, 1.0F + p_180655_4_.nextFloat(), p_180655_4_.nextFloat() * 0.7F + 0.3F, false);
-       }
- 
--      if (!p_180655_2_.func_180495_p(p_180655_3_.func_177977_b()).func_185896_q() && !this.func_196446_i(p_180655_2_.func_180495_p(p_180655_3_.func_177977_b()))) {
--         if (this.func_196446_i(p_180655_2_.func_180495_p(p_180655_3_.func_177976_e()))) {
-+      if (p_180655_2_.func_180495_p(p_180655_3_.func_177977_b()).func_193401_d(p_180655_2_, p_180655_3_.func_177977_b(), EnumFacing.UP) != BlockFaceShape.SOLID && !this.canCatchFire(p_180655_2_, p_180655_3_.func_177977_b(), EnumFacing.UP)) {
-+         if (this.canCatchFire(p_180655_2_, p_180655_3_.func_177976_e(), EnumFacing.EAST)) {
-             for(int j = 0; j < 2; ++j) {
-                double d3 = (double)p_180655_3_.func_177958_n() + p_180655_4_.nextDouble() * (double)0.1F;
-                double d8 = (double)p_180655_3_.func_177956_o() + p_180655_4_.nextDouble();
-@@ -262,7 +266,7 @@
-             }
-          }
- 
--         if (this.func_196446_i(p_180655_2_.func_180495_p(p_180655_3_.func_177974_f()))) {
-+         if (this.canCatchFire(p_180655_2_, p_180655_3_.func_177974_f(), EnumFacing.WEST)) {
-             for(int k = 0; k < 2; ++k) {
-                double d4 = (double)(p_180655_3_.func_177958_n() + 1) - p_180655_4_.nextDouble() * (double)0.1F;
-                double d9 = (double)p_180655_3_.func_177956_o() + p_180655_4_.nextDouble();
-@@ -271,7 +275,7 @@
-             }
-          }
- 
--         if (this.func_196446_i(p_180655_2_.func_180495_p(p_180655_3_.func_177978_c()))) {
-+         if (this.canCatchFire(p_180655_2_, p_180655_3_.func_177978_c(), EnumFacing.SOUTH)) {
-             for(int l = 0; l < 2; ++l) {
-                double d5 = (double)p_180655_3_.func_177958_n() + p_180655_4_.nextDouble();
-                double d10 = (double)p_180655_3_.func_177956_o() + p_180655_4_.nextDouble();
-@@ -280,7 +284,7 @@
-             }
-          }
- 
--         if (this.func_196446_i(p_180655_2_.func_180495_p(p_180655_3_.func_177968_d()))) {
-+         if (this.canCatchFire(p_180655_2_, p_180655_3_.func_177968_d(), EnumFacing.NORTH)) {
-             for(int i1 = 0; i1 < 2; ++i1) {
-                double d6 = (double)p_180655_3_.func_177958_n() + p_180655_4_.nextDouble();
-                double d11 = (double)p_180655_3_.func_177956_o() + p_180655_4_.nextDouble();
-@@ -289,7 +293,7 @@
-             }
-          }
- 
--         if (this.func_196446_i(p_180655_2_.func_180495_p(p_180655_3_.func_177984_a()))) {
-+         if (this.canCatchFire(p_180655_2_, p_180655_3_.func_177984_a(), EnumFacing.DOWN)) {
-             for(int j1 = 0; j1 < 2; ++j1) {
-                double d7 = (double)p_180655_3_.func_177958_n() + p_180655_4_.nextDouble();
-                double d12 = (double)(p_180655_3_.func_177956_o() + 1) - p_180655_4_.nextDouble() * (double)0.1F;
-@@ -321,10 +325,23 @@
-    }
- 
-    public void func_180686_a(Block p_180686_1_, int p_180686_2_, int p_180686_3_) {
-+      if (p_180686_1_ == Blocks.field_150350_a) throw new IllegalArgumentException("Tried to set air on fire... This is bad.");
-       this.field_149849_a.put(p_180686_1_, p_180686_2_);
-       this.field_149848_b.put(p_180686_1_, p_180686_3_);
-    }
- 
-+   /**
-+    * Side sensitive version that calls the block function.
-+    *
-+    * @param world The current world
-+    * @param pos Block position
-+    * @param face The side the fire is coming from
-+    * @return True if the face can catch fire.
-+    */
-+   public boolean canCatchFire(IBlockReader world, BlockPos pos, EnumFacing face) {
-+      return world.func_180495_p(pos).isFlammable(world, pos, face);
-+   }
++    private void tryCatchFire(World p_176536_1_, BlockPos p_176536_2_, int p_176536_3_, Random p_176536_4_, int p_176536_5_, EnumFacing face)
++    {
++        int i = p_176536_1_.func_180495_p(p_176536_2_).func_177230_c().getFlammability(p_176536_1_, p_176536_2_, face);
 +
-    public static void func_149843_e() {
-       BlockFire blockfire = (BlockFire)Blocks.field_150480_ab;
-       blockfire.func_180686_a(Blocks.field_196662_n, 5, 20);
+         if (p_176536_4_.nextInt(p_176536_3_) < i)
+         {
+             IBlockState iblockstate = p_176536_1_.func_180495_p(p_176536_2_);
+@@ -293,7 +306,7 @@
+     {
+         for (EnumFacing enumfacing : EnumFacing.values())
+         {
+-            if (this.func_176535_e(p_176533_1_, p_176533_2_.func_177972_a(enumfacing)))
++            if (this.canCatchFire(p_176533_1_, p_176533_2_.func_177972_a(enumfacing), enumfacing.func_176734_d()))
+             {
+                 return true;
+             }
+@@ -314,7 +327,7 @@
+ 
+             for (EnumFacing enumfacing : EnumFacing.values())
+             {
+-                i = Math.max(this.func_176534_d(p_176538_1_.func_180495_p(p_176538_2_.func_177972_a(enumfacing)).func_177230_c()), i);
++                i = Math.max(p_176538_1_.func_180495_p(p_176538_2_.func_177972_a(enumfacing)).func_177230_c().getFireSpreadSpeed(p_176538_1_, p_176538_2_.func_177972_a(enumfacing), enumfacing.func_176734_d()), i);
+             }
+ 
+             return i;
+@@ -326,9 +339,10 @@
+         return false;
+     }
+ 
++    @Deprecated // Use canCatchFire with face sensitive version below
+     public boolean func_176535_e(IBlockAccess p_176535_1_, BlockPos p_176535_2_)
+     {
+-        return this.func_176534_d(p_176535_1_.func_180495_p(p_176535_2_).func_177230_c()) > 0;
++        return canCatchFire(p_176535_1_, p_176535_2_, EnumFacing.UP);
+     }
+ 
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+@@ -372,9 +386,9 @@
+             p_180655_2_.func_184134_a((double)((float)p_180655_3_.func_177958_n() + 0.5F), (double)((float)p_180655_3_.func_177956_o() + 0.5F), (double)((float)p_180655_3_.func_177952_p() + 0.5F), SoundEvents.field_187643_bs, SoundCategory.BLOCKS, 1.0F + p_180655_4_.nextFloat(), p_180655_4_.nextFloat() * 0.7F + 0.3F, false);
+         }
+ 
+-        if (!p_180655_2_.func_180495_p(p_180655_3_.func_177977_b()).func_185896_q() && !Blocks.field_150480_ab.func_176535_e(p_180655_2_, p_180655_3_.func_177977_b()))
++        if (!p_180655_2_.func_180495_p(p_180655_3_.func_177977_b()).isSideSolid(p_180655_2_, p_180655_3_.func_177977_b(), EnumFacing.UP) && !Blocks.field_150480_ab.canCatchFire(p_180655_2_, p_180655_3_.func_177977_b(), EnumFacing.UP))
+         {
+-            if (Blocks.field_150480_ab.func_176535_e(p_180655_2_, p_180655_3_.func_177976_e()))
++            if (Blocks.field_150480_ab.canCatchFire(p_180655_2_, p_180655_3_.func_177976_e(), EnumFacing.EAST))
+             {
+                 for (int j = 0; j < 2; ++j)
+                 {
+@@ -385,7 +399,7 @@
+                 }
+             }
+ 
+-            if (Blocks.field_150480_ab.func_176535_e(p_180655_2_, p_180655_3_.func_177974_f()))
++            if (Blocks.field_150480_ab.canCatchFire(p_180655_2_, p_180655_3_.func_177974_f(), EnumFacing.WEST))
+             {
+                 for (int k = 0; k < 2; ++k)
+                 {
+@@ -396,7 +410,7 @@
+                 }
+             }
+ 
+-            if (Blocks.field_150480_ab.func_176535_e(p_180655_2_, p_180655_3_.func_177978_c()))
++            if (Blocks.field_150480_ab.canCatchFire(p_180655_2_, p_180655_3_.func_177978_c(), EnumFacing.SOUTH))
+             {
+                 for (int l = 0; l < 2; ++l)
+                 {
+@@ -407,7 +421,7 @@
+                 }
+             }
+ 
+-            if (Blocks.field_150480_ab.func_176535_e(p_180655_2_, p_180655_3_.func_177968_d()))
++            if (Blocks.field_150480_ab.canCatchFire(p_180655_2_, p_180655_3_.func_177968_d(), EnumFacing.NORTH))
+             {
+                 for (int i1 = 0; i1 < 2; ++i1)
+                 {
+@@ -418,7 +432,7 @@
+                 }
+             }
+ 
+-            if (Blocks.field_150480_ab.func_176535_e(p_180655_2_, p_180655_3_.func_177984_a()))
++            if (Blocks.field_150480_ab.canCatchFire(p_180655_2_, p_180655_3_.func_177984_a(), EnumFacing.DOWN))
+             {
+                 for (int j1 = 0; j1 < 2; ++j1)
+                 {
+@@ -462,6 +476,21 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176543_a, field_176545_N, field_176546_O, field_176541_P, field_176539_Q, field_176542_R});
+     }
+ 
++    /*================================= Forge Start ======================================*/
++    /**
++     * Side sensitive version that calls the block function.
++     *
++     * @param world The current world
++     * @param pos Block position
++     * @param face The side the fire is coming from
++     * @return True if the face can catch fire.
++     */
++    public boolean canCatchFire(IBlockAccess world, BlockPos pos, EnumFacing face)
++    {
++        return world.func_180495_p(pos).func_177230_c().isFlammable(world, pos, face);
++    }
++    /*================================= Forge Start ======================================*/
++
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         return BlockFaceShape.UNDEFINED;

patches/minecraft/net/minecraft/block/BlockFlowerPot.java.patch

@@ -1,11 +1,64 @@
---- a/net/minecraft/block/BlockFlowerPot.java
-+++ b/net/minecraft/block/BlockFlowerPot.java
-@@ -22,7 +22,7 @@
- import net.minecraft.world.World;
+--- ../src-base/minecraft/net/minecraft/block/BlockFlowerPot.java
++++ ../src-work/minecraft/net/minecraft/block/BlockFlowerPot.java
+@@ -152,12 +152,14 @@
  
- public class BlockFlowerPot extends Block {
--   private static final Map<Block, Block> field_196451_b = Maps.newHashMap();
-+   private static final Map<Block, Block> field_196451_b = Maps.newHashMap();  //TODO: Delegates
-    protected static final VoxelShape field_196450_a = Block.func_208617_a(5.0D, 0.0D, 5.0D, 11.0D, 6.0D, 11.0D);
-    private final Block field_196452_c;
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        return super.func_176196_c(p_176196_1_, p_176196_2_) && p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_185896_q();
++        IBlockState downState = p_176196_1_.func_180495_p(p_176196_2_.func_177977_b());
++        return super.func_176196_c(p_176196_1_, p_176196_2_) && (downState.func_185896_q() || downState.func_193401_d(p_176196_1_, p_176196_2_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID);
+     }
  
+     public void func_189540_a(IBlockState p_189540_1_, World p_189540_2_, BlockPos p_189540_3_, Block p_189540_4_, BlockPos p_189540_5_)
+     {
+-        if (!p_189540_2_.func_180495_p(p_189540_3_.func_177977_b()).func_185896_q())
++        IBlockState downState = p_189540_2_.func_180495_p(p_189540_3_.func_177977_b());
++        if (!downState.func_185896_q() && downState.func_193401_d(p_189540_2_, p_189540_3_.func_177977_b(), EnumFacing.UP) != BlockFaceShape.SOLID)
+         {
+             this.func_176226_b(p_189540_2_, p_189540_3_, p_189540_1_, 0);
+             p_189540_2_.func_175698_g(p_189540_3_);
+@@ -166,13 +168,6 @@
+ 
+     public void func_180663_b(World p_180663_1_, BlockPos p_180663_2_, IBlockState p_180663_3_)
+     {
+-        TileEntityFlowerPot tileentityflowerpot = this.func_176442_d(p_180663_1_, p_180663_2_);
+-
+-        if (tileentityflowerpot != null && tileentityflowerpot.func_145965_a() != null)
+-        {
+-            func_180635_a(p_180663_1_, p_180663_2_, new ItemStack(tileentityflowerpot.func_145965_a(), 1, tileentityflowerpot.func_145966_b()));
+-        }
+-
+         super.func_180663_b(p_180663_1_, p_180663_2_, p_180663_3_);
+     }
+ 
+@@ -398,6 +393,30 @@
+         return BlockFaceShape.UNDEFINED;
+     }
+ 
++
++    /*============================FORGE START=====================================*/
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        super.getDrops(drops, world, pos, state, fortune);
++        TileEntityFlowerPot te = world.func_175625_s(pos) instanceof TileEntityFlowerPot ? (TileEntityFlowerPot)world.func_175625_s(pos) : null;
++        if (te != null && te.func_145965_a() != null)
++            drops.add(new ItemStack(te.func_145965_a(), 1, te.func_145966_b()));
++    }
++    @Override
++    public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, EntityPlayer player, boolean willHarvest)
++    {
++        if (willHarvest) return true; //If it will harvest, delay deletion of the block until after getDrops
++        return super.removedByPlayer(state, world, pos, player, willHarvest);
++    }
++    @Override
++    public void func_180657_a(World world, EntityPlayer player, BlockPos pos, IBlockState state, @Nullable TileEntity te, ItemStack tool)
++    {
++        super.func_180657_a(world, player, pos, state, te, tool);
++        world.func_175698_g(pos);
++    }
++    /*===========================FORGE END==========================================*/
++
+     public static enum EnumFlowerType implements IStringSerializable
+     {
+         EMPTY("empty"),

patches/minecraft/net/minecraft/block/BlockGrass.java.patch

@@ -0,0 +1,42 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockGrass.java
++++ ../src-work/minecraft/net/minecraft/block/BlockGrass.java
+@@ -38,7 +38,8 @@
+     {
+         if (!p_180650_1_.field_72995_K)
+         {
+-            if (p_180650_1_.func_175671_l(p_180650_2_.func_177984_a()) < 4 && p_180650_1_.func_180495_p(p_180650_2_.func_177984_a()).func_185891_c() > 2)
++            if (!p_180650_1_.func_175697_a(p_180650_2_, 3)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light and spreading
++            if (p_180650_1_.func_175671_l(p_180650_2_.func_177984_a()) < 4 && p_180650_1_.func_180495_p(p_180650_2_.func_177984_a()).getLightOpacity(p_180650_1_, p_180650_2_.func_177984_a()) > 2)
+             {
+                 p_180650_1_.func_175656_a(p_180650_2_, Blocks.field_150346_d.func_176223_P());
+             }
+@@ -58,7 +59,7 @@
+                         IBlockState iblockstate = p_180650_1_.func_180495_p(blockpos.func_177984_a());
+                         IBlockState iblockstate1 = p_180650_1_.func_180495_p(blockpos);
+ 
+-                        if (iblockstate1.func_177230_c() == Blocks.field_150346_d && iblockstate1.func_177229_b(BlockDirt.field_176386_a) == BlockDirt.DirtType.DIRT && p_180650_1_.func_175671_l(blockpos.func_177984_a()) >= 4 && iblockstate.func_185891_c() <= 2)
++                        if (iblockstate1.func_177230_c() == Blocks.field_150346_d && iblockstate1.func_177229_b(BlockDirt.field_176386_a) == BlockDirt.DirtType.DIRT && p_180650_1_.func_175671_l(blockpos.func_177984_a()) >= 4 && iblockstate.getLightOpacity(p_180650_1_, p_180650_2_.func_177984_a()) <= 2)
+                         {
+                             p_180650_1_.func_175656_a(blockpos, Blocks.field_150349_c.func_176223_P());
+                         }
+@@ -96,18 +97,11 @@
+             {
+                 if (j >= i / 16)
+                 {
+-                    if (p_176474_1_.func_180495_p(blockpos1).func_177230_c().field_149764_J == Material.field_151579_a)
++                    if (p_176474_1_.func_175623_d(blockpos1))
+                     {
+                         if (p_176474_2_.nextInt(8) == 0)
+                         {
+-                            BlockFlower.EnumFlowerType blockflower$enumflowertype = p_176474_1_.func_180494_b(blockpos1).func_180623_a(p_176474_2_, blockpos1);
+-                            BlockFlower blockflower = blockflower$enumflowertype.func_176964_a().func_180346_a();
+-                            IBlockState iblockstate = blockflower.func_176223_P().func_177226_a(blockflower.func_176494_l(), blockflower$enumflowertype);
+-
+-                            if (blockflower.func_180671_f(p_176474_1_, blockpos1, iblockstate))
+-                            {
+-                                p_176474_1_.func_180501_a(blockpos1, iblockstate, 3);
+-                            }
++                            p_176474_1_.func_180494_b(blockpos1).plantFlower(p_176474_1_, p_176474_2_, blockpos1);
+                         }
+                         else
+                         {

patches/minecraft/net/minecraft/block/BlockHugeMushroom.java.patch

@@ -0,0 +1,23 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockHugeMushroom.java
++++ ../src-work/minecraft/net/minecraft/block/BlockHugeMushroom.java
+@@ -222,6 +222,20 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176380_a});
+     }
+ 
++    public boolean rotateBlock(World world, BlockPos pos, EnumFacing axis)
++    {
++        IBlockState state = world.func_180495_p(pos);
++        for (IProperty prop : (java.util.Set<IProperty<?>>)state.func_177228_b().keySet())
++        {
++            if (prop.func_177701_a().equals("variant"))
++            {
++                world.func_175656_a(pos, state.func_177231_a(prop));
++                return true;
++            }
++        }
++        return false;
++    }
++
+     public static enum EnumType implements IStringSerializable
+     {
+         NORTH_WEST(1, "north_west"),

patches/minecraft/net/minecraft/block/BlockIce.java.patch

@@ -1,25 +1,29 @@
---- a/net/minecraft/block/BlockIce.java
-+++ b/net/minecraft/block/BlockIce.java
-@@ -34,8 +34,10 @@
-    public void func_180657_a(World p_180657_1_, EntityPlayer p_180657_2_, BlockPos p_180657_3_, IBlockState p_180657_4_, @Nullable TileEntity p_180657_5_, ItemStack p_180657_6_) {
-       p_180657_2_.func_71029_a(StatList.field_188065_ae.func_199076_b(this));
-       p_180657_2_.func_71020_j(0.005F);
--      if (this.func_149700_E() && EnchantmentHelper.func_77506_a(Enchantments.field_185306_r, p_180657_6_) > 0) {
--         func_180635_a(p_180657_1_, p_180657_3_, this.func_180643_i(p_180657_4_));
-+      if (this.canSilkHarvest(p_180657_4_, p_180657_1_, p_180657_3_, p_180657_2_) && EnchantmentHelper.func_77506_a(Enchantments.field_185306_r, p_180657_6_) > 0) {
-+         net.minecraft.util.NonNullList<ItemStack> items = net.minecraft.util.NonNullList.func_193580_a(ItemStack.field_190927_a, func_180643_i(p_180657_4_));
-+         net.minecraftforge.event.ForgeEventFactory.fireBlockHarvesting(items, p_180657_1_, p_180657_3_, p_180657_4_, 0, 1.0f, true, p_180657_2_);
-+         items.stream().filter(e -> !e.func_190926_b()).forEach(e -> func_180635_a(p_180657_1_, p_180657_3_, e));
-       } else {
-          if (p_180657_1_.field_73011_w.func_177500_n()) {
-             p_180657_1_.func_175698_g(p_180657_3_);
-@@ -43,7 +45,9 @@
-          }
+--- ../src-base/minecraft/net/minecraft/block/BlockIce.java
++++ ../src-work/minecraft/net/minecraft/block/BlockIce.java
+@@ -41,9 +41,14 @@
+         p_180657_2_.func_71029_a(StatList.func_188055_a(this));
+         p_180657_2_.func_71020_j(0.005F);
  
-          int i = EnchantmentHelper.func_77506_a(Enchantments.field_185308_t, p_180657_6_);
-+         harvesters.set(p_180657_2_);
-          p_180657_4_.func_196949_c(p_180657_1_, p_180657_3_, i);
-+         harvesters.set(null);
-          Material material = p_180657_1_.func_180495_p(p_180657_3_.func_177977_b()).func_185904_a();
-          if (material.func_76230_c() || material.func_76224_d()) {
-             p_180657_1_.func_175656_a(p_180657_3_, Blocks.field_150355_j.func_176223_P());
+-        if (this.func_149700_E() && EnchantmentHelper.func_77506_a(Enchantments.field_185306_r, p_180657_6_) > 0)
++        if (this.canSilkHarvest(p_180657_1_, p_180657_3_, p_180657_4_, p_180657_2_) && EnchantmentHelper.func_77506_a(Enchantments.field_185306_r, p_180657_6_) > 0)
+         {
+-            func_180635_a(p_180657_1_, p_180657_3_, this.func_180643_i(p_180657_4_));
++            java.util.List<ItemStack> items = new java.util.ArrayList<ItemStack>();
++            items.add(this.func_180643_i(p_180657_4_));
++
++            net.minecraftforge.event.ForgeEventFactory.fireBlockHarvesting(items, p_180657_1_, p_180657_3_, p_180657_4_, 0, 1.0f, true, p_180657_2_);
++            for (ItemStack is : items)
++                func_180635_a(p_180657_1_, p_180657_3_, is);
+         }
+         else
+         {
+@@ -54,7 +59,9 @@
+             }
+ 
+             int i = EnchantmentHelper.func_77506_a(Enchantments.field_185308_t, p_180657_6_);
++            harvesters.set(p_180657_2_);
+             this.func_176226_b(p_180657_1_, p_180657_3_, p_180657_4_, i);
++            harvesters.set(null);
+             Material material = p_180657_1_.func_180495_p(p_180657_3_.func_177977_b()).func_185904_a();
+ 
+             if (material.func_76230_c() || material.func_76224_d())

patches/minecraft/net/minecraft/block/BlockLadder.java.patch

@@ -1,12 +1,11 @@
---- a/net/minecraft/block/BlockLadder.java
-+++ b/net/minecraft/block/BlockLadder.java
-@@ -151,4 +151,9 @@
-          return false;
-       }
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockLadder.java
++++ ../src-work/minecraft/net/minecraft/block/BlockLadder.java
+@@ -158,6 +158,8 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176382_a});
+     }
+ 
++    @Override public boolean isLadder(IBlockState state, IBlockAccess world, BlockPos pos, EntityLivingBase entity) { return true; }
 +
-+   @Override
-+   public boolean isLadder(IBlockState state, net.minecraft.world.IWorldReader world, BlockPos pos, net.minecraft.entity.EntityLivingBase entity) {
-+      return true;
-+   }
- }
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         return BlockFaceShape.UNDEFINED;

patches/minecraft/net/minecraft/block/BlockLeaves.java.patch

@@ -1,83 +1,139 @@
---- a/net/minecraft/block/BlockLeaves.java
-+++ b/net/minecraft/block/BlockLeaves.java
-@@ -26,7 +26,7 @@
- import net.minecraftforge.api.distmarker.Dist;
- import net.minecraftforge.api.distmarker.OnlyIn;
+--- ../src-base/minecraft/net/minecraft/block/BlockLeaves.java
++++ ../src-work/minecraft/net/minecraft/block/BlockLeaves.java
+@@ -17,7 +17,7 @@
+ import net.minecraftforge.fml.relauncher.Side;
+ import net.minecraftforge.fml.relauncher.SideOnly;
  
--public class BlockLeaves extends Block {
-+public class BlockLeaves extends Block implements net.minecraftforge.common.IShearable {
-    public static final IntegerProperty field_208494_a = BlockStateProperties.field_208514_aa;
-    public static final BooleanProperty field_208495_b = BlockStateProperties.field_208515_s;
-    protected static boolean field_196478_c;
-@@ -122,28 +122,37 @@
-    }
+-public abstract class BlockLeaves extends Block
++public abstract class BlockLeaves extends Block implements net.minecraftforge.common.IShearable
+ {
+     public static final PropertyBool field_176237_a = PropertyBool.func_177716_a("decayable");
+     public static final PropertyBool field_176236_b = PropertyBool.func_177716_a("check_decay");
+@@ -53,9 +53,9 @@
+                         BlockPos blockpos = p_180663_2_.func_177982_a(j1, k1, l1);
+                         IBlockState iblockstate = p_180663_1_.func_180495_p(blockpos);
  
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
--      if (!p_196255_2_.field_72995_K) {
--         int i = this.func_196472_i(p_196255_1_);
--         if (p_196255_5_ > 0) {
--            i -= 2 << p_196255_5_;
-+       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
-+   }
+-                        if (iblockstate.func_185904_a() == Material.field_151584_j && !((Boolean)iblockstate.func_177229_b(field_176236_b)).booleanValue())
++                        if (iblockstate.func_177230_c().isLeaves(iblockstate, p_180663_1_, blockpos))
+                         {
+-                            p_180663_1_.func_180501_a(blockpos, iblockstate.func_177226_a(field_176236_b, Boolean.valueOf(true)), 4);
++                            iblockstate.func_177230_c().beginLeavesDecay(iblockstate, p_180663_1_, blockpos);
+                         }
+                     }
+                 }
+@@ -83,7 +83,8 @@
+                     this.field_150128_a = new int[32768];
+                 }
+ 
+-                if (p_180650_1_.func_175707_a(new BlockPos(k - 5, l - 5, i1 - 5), new BlockPos(k + 5, l + 5, i1 + 5)))
++                if (!p_180650_1_.func_175697_a(p_180650_2_, 1)) return; // Forge: prevent decaying leaves from updating neighbors and loading unloaded chunks
++                if (p_180650_1_.func_175697_a(p_180650_2_, 6)) // Forge: extend range from 5 to 6 to account for neighbor checks in world.markAndNotifyBlock -> world.updateObservingBlocksAt
+                 {
+                     BlockPos.MutableBlockPos blockpos$mutableblockpos = new BlockPos.MutableBlockPos();
+ 
+@@ -96,9 +97,9 @@
+                                 IBlockState iblockstate = p_180650_1_.func_180495_p(blockpos$mutableblockpos.func_181079_c(k + i2, l + j2, i1 + k2));
+                                 Block block = iblockstate.func_177230_c();
+ 
+-                                if (block != Blocks.field_150364_r && block != Blocks.field_150363_s)
++                                if (!block.canSustainLeaves(iblockstate, p_180650_1_, blockpos$mutableblockpos.func_181079_c(k + i2, l + j2, i1 + k2)))
+                                 {
+-                                    if (iblockstate.func_185904_a() == Material.field_151584_j)
++                                    if (block.isLeaves(iblockstate, p_180650_1_, blockpos$mutableblockpos.func_181079_c(k + i2, l + j2, i1 + k2)))
+                                     {
+                                         this.field_150128_a[(i2 + 16) * 1024 + (j2 + 16) * 32 + k2 + 16] = -2;
+                                     }
+@@ -205,40 +206,7 @@
+ 
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+-        if (!p_180653_1_.field_72995_K)
+-        {
+-            int i = this.func_176232_d(p_180653_3_);
+-
+-            if (p_180653_5_ > 0)
+-            {
+-                i -= 2 << p_180653_5_;
+-
+-                if (i < 10)
+-                {
+-                    i = 10;
+-                }
+-            }
+-
+-            if (p_180653_1_.field_73012_v.nextInt(i) == 0)
+-            {
+-                Item item = this.func_180660_a(p_180653_3_, p_180653_1_.field_73012_v, p_180653_5_);
+-                func_180635_a(p_180653_1_, p_180653_2_, new ItemStack(item, 1, this.func_180651_a(p_180653_3_)));
+-            }
+-
+-            i = 200;
+-
+-            if (p_180653_5_ > 0)
+-            {
+-                i -= 10 << p_180653_5_;
+-
+-                if (i < 40)
+-                {
+-                    i = 40;
+-                }
+-            }
+-
+-            this.func_176234_a(p_180653_1_, p_180653_2_, p_180653_3_, i);
+-        }
++        super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
+     }
+ 
+     protected void func_176234_a(World p_176234_1_, BlockPos p_176234_2_, IBlockState p_176234_3_, int p_176234_4_)
+@@ -274,6 +242,51 @@
+ 
+     public abstract BlockPlanks.EnumType func_176233_b(int p_176233_1_);
+ 
++    @Override public boolean isShearable(ItemStack item, IBlockAccess world, BlockPos pos){ return true; }
++    @Override public boolean isLeaves(IBlockState state, IBlockAccess world, BlockPos pos){ return true; }
 +
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World worldIn, BlockPos pos, int fortune) {
-+      {
-+         int i = this.func_196472_i(state);
-+         if (fortune > 0) {
-+            i -= 2 << fortune;
-             if (i < 10) {
-                i = 10;
-             }
-          }
- 
--         if (p_196255_2_.field_73012_v.nextInt(i) == 0) {
--            func_180635_a(p_196255_2_, p_196255_3_, new ItemStack(this.func_199769_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_5_)));
-+         if (worldIn.field_73012_v.nextInt(i) == 0) {
-+            ItemStack drop = new ItemStack(this.func_199769_a(state, worldIn, pos, fortune));
++    @Override
++    public void beginLeavesDecay(IBlockState state, World world, BlockPos pos)
++    {
++        if (!(Boolean)state.func_177229_b(field_176236_b))
++        {
++            world.func_180501_a(pos, state.func_177226_a(field_176236_b, true), 4);
++        }
++    }
++
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        Random rand = world instanceof World ? ((World)world).field_73012_v : new Random();
++        int chance = this.func_176232_d(state);
++
++        if (fortune > 0)
++        {
++            chance -= 2 << fortune;
++            if (chance < 10) chance = 10;
++        }
++
++        if (rand.nextInt(chance) == 0)
++        {
++            ItemStack drop = new ItemStack(func_180660_a(state, rand, fortune), 1, func_180651_a(state));
 +            if (!drop.func_190926_b())
 +                drops.add(drop);
-          }
- 
-          i = 200;
--         if (p_196255_5_ > 0) {
--            i -= 10 << p_196255_5_;
-+         if (fortune > 0) {
-+            i -= 10 << fortune;
-             if (i < 40) {
-                i = 40;
-             }
-          }
- 
--         this.func_196474_a(p_196255_2_, p_196255_3_, p_196255_1_, i);
-+         captureDrops(true);
-+         this.func_196474_a(worldIn, pos, state, i);
-+         drops.addAll(captureDrops(false));
-       }
- 
-    }
-@@ -173,13 +182,7 @@
-    }
- 
-    public void func_180657_a(World p_180657_1_, EntityPlayer p_180657_2_, BlockPos p_180657_3_, IBlockState p_180657_4_, @Nullable TileEntity p_180657_5_, ItemStack p_180657_6_) {
--      if (!p_180657_1_.field_72995_K && p_180657_6_.func_77973_b() == Items.field_151097_aZ) {
--         p_180657_2_.func_71029_a(StatList.field_188065_ae.func_199076_b(this));
--         p_180657_2_.func_71020_j(0.005F);
--         func_180635_a(p_180657_1_, p_180657_3_, new ItemStack(this));
--      } else {
-          super.func_180657_a(p_180657_1_, p_180657_2_, p_180657_3_, p_180657_4_, p_180657_5_, p_180657_6_);
--      }
-    }
- 
-    protected void func_206840_a(StateContainer.Builder<Block, IBlockState> p_206840_1_) {
-@@ -189,4 +192,10 @@
-    public IBlockState func_196258_a(BlockItemUseContext p_196258_1_) {
-       return func_208493_b(this.func_176223_P().func_206870_a(field_208495_b, Boolean.valueOf(true)), p_196258_1_.func_195991_k(), p_196258_1_.func_195995_a());
-    }
++        }
 +
-+   @Override
-+   public java.util.List<ItemStack> onSheared(@javax.annotation.Nonnull ItemStack item, net.minecraft.world.IWorld world, BlockPos pos, int fortune) {
-+      world.func_180501_a(pos, Blocks.field_150350_a.func_176223_P(), 11);
-+      return java.util.Arrays.asList(new ItemStack(this));
-+   }
- }
++        chance = 200;
++        if (fortune > 0)
++        {
++            chance -= 10 << fortune;
++            if (chance < 40) chance = 40;
++        }
++
++        this.captureDrops(true);
++        if (world instanceof World)
++            this.func_176234_a((World)world, pos, state, chance); // Dammet mojang
++        drops.addAll(this.captureDrops(false));
++    }
++
++
+     @SideOnly(Side.CLIENT)
+     public boolean func_176225_a(IBlockState p_176225_1_, IBlockAccess p_176225_2_, BlockPos p_176225_3_, EnumFacing p_176225_4_)
+     {

patches/minecraft/net/minecraft/block/BlockLiquid.java.patch

@@ -17,7 +17,17 @@
                      this.func_180688_d(p_176365_1_, p_176365_2_);
                      return true;
                  }
-@@ -452,4 +452,29 @@
+@@ -448,8 +448,39 @@
+         return (float)p_190972_2_.func_177956_o() + func_190973_f(p_190972_0_, p_190972_1_, p_190972_2_);
+     }
+ 
++    @Override
++    public float getBlockLiquidHeight(World world, BlockPos pos, IBlockState state, Material material)
++    {
++        return BlockLiquid.func_190973_f(state, world, pos);
++    }
++
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
      {
          return BlockFaceShape.UNDEFINED;
      }

patches/minecraft/net/minecraft/block/BlockMobSpawner.java.patch

@@ -1,27 +1,19 @@
---- a/net/minecraft/block/BlockMobSpawner.java
-+++ b/net/minecraft/block/BlockMobSpawner.java
-@@ -13,6 +13,8 @@
- import net.minecraft.world.World;
+--- ../src-base/minecraft/net/minecraft/block/BlockMobSpawner.java
++++ ../src-work/minecraft/net/minecraft/block/BlockMobSpawner.java
+@@ -40,10 +40,14 @@
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+         super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
+-        int i = 15 + p_180653_1_.field_73012_v.nextInt(15) + p_180653_1_.field_73012_v.nextInt(15);
+-        this.func_180637_b(p_180653_1_, p_180653_2_, i);
+     }
  
- public class BlockMobSpawner extends BlockContainer {
-+   private static final java.util.Random RAND = new java.util.Random();
++    @Override
++    public int getExpDrop(IBlockState state, net.minecraft.world.IBlockAccess world, BlockPos pos, int fortune)
++    {
++        return 15 + RANDOM.nextInt(15) + RANDOM.nextInt(15);
++    }
 +
-    protected BlockMobSpawner(Block.Properties p_i48364_1_) {
-       super(p_i48364_1_);
-    }
-@@ -27,10 +29,13 @@
- 
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
-       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
--      int i = 15 + p_196255_2_.field_73012_v.nextInt(15) + p_196255_2_.field_73012_v.nextInt(15);
--      this.func_180637_b(p_196255_2_, p_196255_3_, i);
-    }
- 
-+   @Override
-+   public int getExpDrop(IBlockState state, net.minecraft.world.IWorldReader world, BlockPos pos, int fortune) {
-+      return 15 + RAND.nextInt(15) + RAND.nextInt(15);
-+   }
-+
-    public EnumBlockRenderType func_149645_b(IBlockState p_149645_1_) {
-       return EnumBlockRenderType.MODEL;
-    }
+     public boolean func_149662_c(IBlockState p_149662_1_)
+     {
+         return false;

patches/minecraft/net/minecraft/block/BlockMushroom.java.patch

@@ -1,11 +1,11 @@
---- a/net/minecraft/block/BlockMushroom.java
-+++ b/net/minecraft/block/BlockMushroom.java
-@@ -64,7 +64,7 @@
-       IBlockState iblockstate = p_196260_2_.func_180495_p(blockpos);
-       Block block = iblockstate.func_177230_c();
-       if (block != Blocks.field_150391_bh && block != Blocks.field_196661_l) {
--         return p_196260_2_.func_201669_a(p_196260_3_, 0) < 13 && this.func_200014_a_(iblockstate, p_196260_2_, blockpos);
-+         return p_196260_2_.func_201669_a(p_196260_3_, 0) < 13 && iblockstate.canSustainPlant(p_196260_2_, blockpos, net.minecraft.util.EnumFacing.UP, this);
-       } else {
-          return true;
-       }
+--- ../src-base/minecraft/net/minecraft/block/BlockMushroom.java
++++ ../src-work/minecraft/net/minecraft/block/BlockMushroom.java
+@@ -89,7 +89,7 @@
+             }
+             else
+             {
+-                return p_180671_1_.func_175699_k(p_180671_2_) < 13 && this.func_185514_i(iblockstate);
++                return p_180671_1_.func_175699_k(p_180671_2_) < 13 && iblockstate.func_177230_c().canSustainPlant(iblockstate, p_180671_1_, p_180671_2_.func_177977_b(), net.minecraft.util.EnumFacing.UP, this);
+             }
+         }
+         else

patches/minecraft/net/minecraft/block/BlockMycelium.java.patch

@@ -0,0 +1,21 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockMycelium.java
++++ ../src-work/minecraft/net/minecraft/block/BlockMycelium.java
+@@ -39,7 +39,8 @@
+     {
+         if (!p_180650_1_.field_72995_K)
+         {
+-            if (p_180650_1_.func_175671_l(p_180650_2_.func_177984_a()) < 4 && p_180650_1_.func_180495_p(p_180650_2_.func_177984_a()).func_185891_c() > 2)
++            if (!p_180650_1_.func_175697_a(p_180650_2_, 2)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light and spreading
++            if (p_180650_1_.func_175671_l(p_180650_2_.func_177984_a()) < 4 && p_180650_1_.func_180495_p(p_180650_2_.func_177984_a()).getLightOpacity(p_180650_1_, p_180650_2_.func_177984_a()) > 2)
+             {
+                 p_180650_1_.func_175656_a(p_180650_2_, Blocks.field_150346_d.func_176223_P().func_177226_a(BlockDirt.field_176386_a, BlockDirt.DirtType.DIRT));
+             }
+@@ -53,7 +54,7 @@
+                         IBlockState iblockstate = p_180650_1_.func_180495_p(blockpos);
+                         IBlockState iblockstate1 = p_180650_1_.func_180495_p(blockpos.func_177984_a());
+ 
+-                        if (iblockstate.func_177230_c() == Blocks.field_150346_d && iblockstate.func_177229_b(BlockDirt.field_176386_a) == BlockDirt.DirtType.DIRT && p_180650_1_.func_175671_l(blockpos.func_177984_a()) >= 4 && iblockstate1.func_185891_c() <= 2)
++                        if (iblockstate.func_177230_c() == Blocks.field_150346_d && iblockstate.func_177229_b(BlockDirt.field_176386_a) == BlockDirt.DirtType.DIRT && p_180650_1_.func_175671_l(blockpos.func_177984_a()) >= 4 && iblockstate1.getLightOpacity(p_180650_1_, blockpos.func_177984_a()) <= 2)
+                         {
+                             p_180650_1_.func_175656_a(blockpos, this.func_176223_P());
+                         }

patches/minecraft/net/minecraft/block/BlockNetherWart.java.patch

@@ -1,36 +1,60 @@
---- a/net/minecraft/block/BlockNetherWart.java
-+++ b/net/minecraft/block/BlockNetherWart.java
-@@ -33,16 +33,22 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockNetherWart.java
++++ ../src-work/minecraft/net/minecraft/block/BlockNetherWart.java
+@@ -42,25 +42,28 @@
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-       int i = p_196267_1_.func_177229_b(field_176486_a);
--      if (i < 3 && p_196267_4_.nextInt(10) == 0) {
-+      if (i < 3 && net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_196267_2_, p_196267_3_, p_196267_1_, p_196267_4_.nextInt(10) == 0)) {
-          p_196267_1_ = p_196267_1_.func_206870_a(field_176486_a, Integer.valueOf(i + 1));
-          p_196267_2_.func_180501_a(p_196267_3_, p_196267_1_, 2);
-+         net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_196267_2_, p_196267_3_, p_196267_1_);
-       }
+     public boolean func_180671_f(World p_180671_1_, BlockPos p_180671_2_, IBlockState p_180671_3_)
+     {
+-        return this.func_185514_i(p_180671_1_.func_180495_p(p_180671_2_.func_177977_b()));
++        return super.func_180671_f(p_180671_1_, p_180671_2_, p_180671_3_);
+     }
  
-       super.func_196267_b(p_196267_1_, p_196267_2_, p_196267_3_, p_196267_4_);
-    }
+     public void func_180650_b(World p_180650_1_, BlockPos p_180650_2_, IBlockState p_180650_3_, Random p_180650_4_)
+     {
+         int i = ((Integer)p_180650_3_.func_177229_b(field_176486_a)).intValue();
  
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
--      if (!p_196255_2_.field_72995_K) {
-+       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
+-        if (i < 3 && p_180650_4_.nextInt(10) == 0)
++        if (i < 3 && net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_.nextInt(10) == 0))
+         {
+-            p_180650_3_ = p_180650_3_.func_177226_a(field_176486_a, Integer.valueOf(i + 1));
+-            p_180650_1_.func_180501_a(p_180650_2_, p_180650_3_, 2);
++            IBlockState newState = p_180650_3_.func_177226_a(field_176486_a, Integer.valueOf(i + 1));
++            p_180650_1_.func_180501_a(p_180650_2_, newState, 2);
++            net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_180650_1_, p_180650_2_, p_180650_3_, newState);
+         }
+ 
+         super.func_180650_b(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_);
+     }
+ 
++    @SuppressWarnings("unused")
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+-        if (!p_180653_1_.field_72995_K)
++        super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
++        if (false && !p_180653_1_.field_72995_K)
+         {
+             int i = 1;
+ 
+@@ -106,6 +109,23 @@
+         return ((Integer)p_176201_1_.func_177229_b(field_176486_a)).intValue();
+     }
+ 
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, net.minecraft.world.IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        Random rand = world instanceof World ? ((World)world).field_73012_v : new Random();
++        int count = 1;
++
++        if (((Integer)state.func_177229_b(field_176486_a)) >= 3)
++        {
++            count = 2 + rand.nextInt(3) + (fortune > 0 ? rand.nextInt(fortune + 1) : 0);
++        }
++
++        for (int i = 0; i < count; i++)
++        {
++            drops.add(new ItemStack(Items.field_151075_bm));
++        }
 +    }
 +
-+   @Override
-+   public void getDrops(IBlockState p_196255_1_, net.minecraft.util.NonNullList<ItemStack> drops, World p_196255_2_, BlockPos p_196255_3_, int p_196255_5_) {
-+      {
-          int i = 1;
-          if (p_196255_1_.func_177229_b(field_176486_a) >= 3) {
-             i = 2 + p_196255_2_.field_73012_v.nextInt(3);
-@@ -52,7 +58,7 @@
-          }
- 
-          for(int j = 0; j < i; ++j) {
--            func_180635_a(p_196255_2_, p_196255_3_, new ItemStack(Items.field_151075_bm));
-+            drops.add(new ItemStack(Items.field_151075_bm));
-          }
- 
-       }
+     protected BlockStateContainer func_180661_e()
+     {
+         return new BlockStateContainer(this, new IProperty[] {field_176486_a});

patches/minecraft/net/minecraft/block/BlockNewLeaf.java.patch

@@ -0,0 +1,13 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockNewLeaf.java
++++ ../src-work/minecraft/net/minecraft/block/BlockNewLeaf.java
+@@ -106,4 +106,10 @@
+             super.func_180657_a(p_180657_1_, p_180657_2_, p_180657_3_, p_180657_4_, p_180657_5_, p_180657_6_);
+         }
+     }
++
++    @Override
++    public NonNullList<ItemStack> onSheared(ItemStack item, net.minecraft.world.IBlockAccess world, BlockPos pos, int fortune)
++    {
++        return NonNullList.func_191197_a(1, new ItemStack(this, 1, world.func_180495_p(pos).func_177229_b(field_176240_P).func_176839_a() - 4));
++    }
+ }

patches/minecraft/net/minecraft/block/BlockNote.java.patch

@@ -1,32 +1,23 @@
---- a/net/minecraft/block/BlockNote.java
-+++ b/net/minecraft/block/BlockNote.java
-@@ -49,7 +49,7 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockNote.java
++++ ../src-work/minecraft/net/minecraft/block/BlockNote.java
+@@ -63,7 +63,9 @@
+             if (tileentity instanceof TileEntityNote)
+             {
+                 TileEntityNote tileentitynote = (TileEntityNote)tileentity;
++                int old = tileentitynote.field_145879_a;
+                 tileentitynote.func_145877_a();
++                if (old == tileentitynote.field_145879_a) return false;
+                 tileentitynote.func_175108_a(p_180639_1_, p_180639_2_);
+                 p_180639_4_.func_71029_a(StatList.field_188087_U);
+             }
+@@ -103,6 +105,10 @@
  
-    private void func_196482_a(World p_196482_1_, BlockPos p_196482_2_) {
--      if (p_196482_1_.func_180495_p(p_196482_2_.func_177984_a()).func_196958_f()) {
-+      if (p_196482_1_.func_175623_d(p_196482_2_.func_177984_a())) {
-          p_196482_1_.func_175641_c(p_196482_2_, this, 0, 0);
-       }
- 
-@@ -59,7 +59,9 @@
-       if (p_196250_2_.field_72995_K) {
-          return true;
-       } else {
--         p_196250_1_ = p_196250_1_.func_177231_a(field_196485_c);
-+         int _new = net.minecraftforge.common.ForgeHooks.onNoteChange(p_196250_2_, p_196250_3_, p_196250_1_, p_196250_1_.func_177229_b(field_196485_c), p_196250_1_.func_177231_a(field_196485_c).func_177229_b(field_196485_c));
-+         if (_new == -1) return false;
-+         p_196250_1_ = (IBlockState)p_196250_1_.func_206870_a(field_196485_c, _new);
-          p_196250_2_.func_180501_a(p_196250_3_, p_196250_1_, 3);
-          this.func_196482_a(p_196250_2_, p_196250_3_);
-          p_196250_4_.func_195066_a(StatList.field_188087_U);
-@@ -75,6 +77,9 @@
-    }
- 
-    public boolean func_189539_a(IBlockState p_189539_1_, World p_189539_2_, BlockPos p_189539_3_, int p_189539_4_, int p_189539_5_) {
-+      net.minecraftforge.event.world.NoteBlockEvent.Play e = new net.minecraftforge.event.world.NoteBlockEvent.Play(p_189539_2_, p_189539_3_, p_189539_1_, p_189539_1_.func_177229_b(field_196485_c), p_189539_1_.func_177229_b(field_196483_a));
-+      if (net.minecraftforge.common.MinecraftForge.EVENT_BUS.post(e)) return false;
-+      p_189539_1_ = p_189539_1_.func_206870_a(field_196485_c, e.getVanillaNoteId()).func_206870_a(field_196483_a, e.getInstrument());
-       int i = p_189539_1_.func_177229_b(field_196485_c);
-       float f = (float)Math.pow(2.0D, (double)(i - 12) / 12.0D);
-       p_189539_2_.func_184133_a((EntityPlayer)null, p_189539_3_, p_189539_1_.func_177229_b(field_196483_a).func_208088_a(), SoundCategory.RECORDS, 3.0F, f);
+     public boolean func_189539_a(IBlockState p_189539_1_, World p_189539_2_, BlockPos p_189539_3_, int p_189539_4_, int p_189539_5_)
+     {
++        net.minecraftforge.event.world.NoteBlockEvent.Play e = new net.minecraftforge.event.world.NoteBlockEvent.Play(p_189539_2_, p_189539_3_, p_189539_1_, p_189539_5_, p_189539_4_);
++        if (net.minecraftforge.common.MinecraftForge.EVENT_BUS.post(e)) return false;
++        p_189539_4_ = e.getInstrument().ordinal();
++        p_189539_5_ = e.getVanillaNoteId();
+         float f = (float)Math.pow(2.0D, (double)(p_189539_5_ - 12) / 12.0D);
+         p_189539_2_.func_184133_a((EntityPlayer)null, p_189539_3_, this.func_185576_e(p_189539_4_), SoundCategory.RECORDS, 3.0F, f);
+         p_189539_2_.func_175688_a(EnumParticleTypes.NOTE, (double)p_189539_3_.func_177958_n() + 0.5D, (double)p_189539_3_.func_177956_o() + 1.2D, (double)p_189539_3_.func_177952_p() + 0.5D, (double)p_189539_5_ / 24.0D, 0.0D, 0.0D);

patches/minecraft/net/minecraft/block/BlockOldLeaf.java.patch

@@ -0,0 +1,20 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockOldLeaf.java
++++ ../src-work/minecraft/net/minecraft/block/BlockOldLeaf.java
+@@ -101,11 +101,16 @@
+         if (!p_180657_1_.field_72995_K && p_180657_6_.func_77973_b() == Items.field_151097_aZ)
+         {
+             p_180657_2_.func_71029_a(StatList.func_188055_a(this));
+-            func_180635_a(p_180657_1_, p_180657_3_, new ItemStack(Item.func_150898_a(this), 1, ((BlockPlanks.EnumType)p_180657_4_.func_177229_b(field_176239_P)).func_176839_a()));
+         }
+         else
+         {
+             super.func_180657_a(p_180657_1_, p_180657_2_, p_180657_3_, p_180657_4_, p_180657_5_, p_180657_6_);
+         }
+     }
++
++    @Override
++    public NonNullList<ItemStack> onSheared(ItemStack item, net.minecraft.world.IBlockAccess world, BlockPos pos, int fortune)
++    {
++        return NonNullList.func_191197_a(1, new ItemStack(this, 1, world.func_180495_p(pos).func_177229_b(field_176239_P).func_176839_a()));
++    }
+ }

patches/minecraft/net/minecraft/block/BlockOre.java.patch

@@ -1,39 +1,50 @@
---- a/net/minecraft/block/BlockOre.java
-+++ b/net/minecraft/block/BlockOre.java
-@@ -49,23 +49,27 @@
- 
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
-       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
--      if (this.func_199769_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_5_) != this) {
-+   }
-+
-+   @Override
-+   public int getExpDrop(IBlockState state, net.minecraft.world.IWorldReader reader, BlockPos pos, int fortune) {
-+      World world = reader instanceof World ? (World)reader : null;
-+      if (world == null || this.func_199769_a(state, world, pos, fortune) != this) {
-          int i = 0;
-          if (this == Blocks.field_150365_q) {
--            i = MathHelper.func_76136_a(p_196255_2_.field_73012_v, 0, 2);
-+            i = MathHelper.func_76136_a(RANDOM, 0, 2);
-          } else if (this == Blocks.field_150482_ag) {
--            i = MathHelper.func_76136_a(p_196255_2_.field_73012_v, 3, 7);
-+            i = MathHelper.func_76136_a(RANDOM, 3, 7);
-          } else if (this == Blocks.field_150412_bA) {
--            i = MathHelper.func_76136_a(p_196255_2_.field_73012_v, 3, 7);
-+            i = MathHelper.func_76136_a(RANDOM, 3, 7);
-          } else if (this == Blocks.field_150369_x) {
--            i = MathHelper.func_76136_a(p_196255_2_.field_73012_v, 2, 5);
-+            i = MathHelper.func_76136_a(RANDOM, 2, 5);
-          } else if (this == Blocks.field_196766_fg) {
--            i = MathHelper.func_76136_a(p_196255_2_.field_73012_v, 2, 5);
-+            i = MathHelper.func_76136_a(RANDOM, 2, 5);
-          }
+--- ../src-base/minecraft/net/minecraft/block/BlockOre.java
++++ ../src-work/minecraft/net/minecraft/block/BlockOre.java
+@@ -78,34 +78,39 @@
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+         super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
 -
--         this.func_180637_b(p_196255_2_, p_196255_3_, i);
-+         return i;
-       }
--
-+      return 0;
-    }
+-        if (this.func_180660_a(p_180653_3_, p_180653_1_.field_73012_v, p_180653_5_) != Item.func_150898_a(this))
++    }
++    @Override
++    public int getExpDrop(IBlockState state, net.minecraft.world.IBlockAccess world, BlockPos pos, int fortune)
++    {
++        Random rand = world instanceof World ? ((World)world).field_73012_v : new Random();
++        if (this.func_180660_a(state, rand, fortune) != Item.func_150898_a(this))
+         {
+             int i = 0;
  
-    public ItemStack func_185473_a(IBlockReader p_185473_1_, BlockPos p_185473_2_, IBlockState p_185473_3_) {
+             if (this == Blocks.field_150365_q)
+             {
+-                i = MathHelper.func_76136_a(p_180653_1_.field_73012_v, 0, 2);
++                i = MathHelper.func_76136_a(rand, 0, 2);
+             }
+             else if (this == Blocks.field_150482_ag)
+             {
+-                i = MathHelper.func_76136_a(p_180653_1_.field_73012_v, 3, 7);
++                i = MathHelper.func_76136_a(rand, 3, 7);
+             }
+             else if (this == Blocks.field_150412_bA)
+             {
+-                i = MathHelper.func_76136_a(p_180653_1_.field_73012_v, 3, 7);
++                i = MathHelper.func_76136_a(rand, 3, 7);
+             }
+             else if (this == Blocks.field_150369_x)
+             {
+-                i = MathHelper.func_76136_a(p_180653_1_.field_73012_v, 2, 5);
++                i = MathHelper.func_76136_a(rand, 2, 5);
+             }
+             else if (this == Blocks.field_150449_bY)
+             {
+-                i = MathHelper.func_76136_a(p_180653_1_.field_73012_v, 2, 5);
++                i = MathHelper.func_76136_a(rand, 2, 5);
+             }
+ 
+-            this.func_180637_b(p_180653_1_, p_180653_2_, i);
++            return i;
+         }
++        return 0;
+     }
+ 
+     public ItemStack func_185473_a(World p_185473_1_, BlockPos p_185473_2_, IBlockState p_185473_3_)

patches/minecraft/net/minecraft/block/BlockPane.java.patch

@@ -1,50 +1,39 @@
---- a/net/minecraft/block/BlockPane.java
-+++ b/net/minecraft/block/BlockPane.java
-@@ -25,15 +25,12 @@
-       IBlockReader iblockreader = p_196258_1_.func_195991_k();
-       BlockPos blockpos = p_196258_1_.func_195995_a();
-       IFluidState ifluidstate = p_196258_1_.func_195991_k().func_204610_c(p_196258_1_.func_195995_a());
--      BlockPos blockpos1 = blockpos.func_177978_c();
--      BlockPos blockpos2 = blockpos.func_177968_d();
--      BlockPos blockpos3 = blockpos.func_177976_e();
--      BlockPos blockpos4 = blockpos.func_177974_f();
--      IBlockState iblockstate = iblockreader.func_180495_p(blockpos1);
--      IBlockState iblockstate1 = iblockreader.func_180495_p(blockpos2);
--      IBlockState iblockstate2 = iblockreader.func_180495_p(blockpos3);
--      IBlockState iblockstate3 = iblockreader.func_180495_p(blockpos4);
--      return this.func_176223_P().func_206870_a(field_196409_a, Boolean.valueOf(this.func_196417_a(iblockstate, iblockstate.func_193401_d(iblockreader, blockpos1, EnumFacing.SOUTH)))).func_206870_a(field_196413_c, Boolean.valueOf(this.func_196417_a(iblockstate1, iblockstate1.func_193401_d(iblockreader, blockpos2, EnumFacing.NORTH)))).func_206870_a(field_196414_y, Boolean.valueOf(this.func_196417_a(iblockstate2, iblockstate2.func_193401_d(iblockreader, blockpos3, EnumFacing.EAST)))).func_206870_a(field_196411_b, Boolean.valueOf(this.func_196417_a(iblockstate3, iblockstate3.func_193401_d(iblockreader, blockpos4, EnumFacing.WEST)))).func_206870_a(field_204514_u, Boolean.valueOf(ifluidstate.func_206886_c() == Fluids.field_204546_a));
-+      return this.func_176223_P()
-+          .func_206870_a(field_196409_a, canPaneConnectTo(iblockreader, blockpos, EnumFacing.NORTH))
-+          .func_206870_a(field_196413_c, canPaneConnectTo(iblockreader, blockpos, EnumFacing.SOUTH))
-+          .func_206870_a(field_196414_y, canPaneConnectTo(iblockreader, blockpos, EnumFacing.WEST))
-+          .func_206870_a(field_196411_b, canPaneConnectTo(iblockreader, blockpos, EnumFacing.EAST))
-+          .func_206870_a(field_204514_u, Boolean.valueOf(ifluidstate.func_206886_c() == Fluids.field_204546_a));
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockPane.java
++++ ../src-work/minecraft/net/minecraft/block/BlockPane.java
+@@ -112,7 +112,10 @@
  
-    public IBlockState func_196271_a(IBlockState p_196271_1_, EnumFacing p_196271_2_, IBlockState p_196271_3_, IWorld p_196271_4_, BlockPos p_196271_5_, BlockPos p_196271_6_) {
-@@ -41,7 +38,7 @@
-          p_196271_4_.func_205219_F_().func_205360_a(p_196271_5_, Fluids.field_204546_a, Fluids.field_204546_a.func_205569_a(p_196271_4_));
-       }
+     public IBlockState func_176221_a(IBlockState p_176221_1_, IBlockAccess p_176221_2_, BlockPos p_176221_3_)
+     {
+-        return p_176221_1_.func_177226_a(field_176241_b, Boolean.valueOf(this.func_193393_b(p_176221_2_, p_176221_2_.func_180495_p(p_176221_3_.func_177978_c()), p_176221_3_.func_177978_c(), EnumFacing.SOUTH))).func_177226_a(field_176243_N, Boolean.valueOf(this.func_193393_b(p_176221_2_, p_176221_2_.func_180495_p(p_176221_3_.func_177968_d()), p_176221_3_.func_177968_d(), EnumFacing.NORTH))).func_177226_a(field_176244_O, Boolean.valueOf(this.func_193393_b(p_176221_2_, p_176221_2_.func_180495_p(p_176221_3_.func_177976_e()), p_176221_3_.func_177976_e(), EnumFacing.EAST))).func_177226_a(field_176242_M, Boolean.valueOf(this.func_193393_b(p_176221_2_, p_176221_2_.func_180495_p(p_176221_3_.func_177974_f()), p_176221_3_.func_177974_f(), EnumFacing.WEST)));
++        return p_176221_1_.func_177226_a(field_176241_b, canPaneConnectTo(p_176221_2_, p_176221_3_, EnumFacing.NORTH))
++                    .func_177226_a(field_176243_N, canPaneConnectTo(p_176221_2_, p_176221_3_, EnumFacing.SOUTH))
++                    .func_177226_a(field_176244_O,  canPaneConnectTo(p_176221_2_, p_176221_3_, EnumFacing.WEST))
++                    .func_177226_a(field_176242_M,  canPaneConnectTo(p_176221_2_, p_176221_3_, EnumFacing.EAST));
+     }
  
--      return p_196271_2_.func_176740_k().func_176722_c() ? p_196271_1_.func_206870_a(field_196415_z.get(p_196271_2_), Boolean.valueOf(this.func_196417_a(p_196271_3_, p_196271_3_.func_193401_d(p_196271_4_, p_196271_6_, p_196271_2_.func_176734_d())))) : super.func_196271_a(p_196271_1_, p_196271_2_, p_196271_3_, p_196271_4_, p_196271_5_, p_196271_6_);
-+      return p_196271_2_.func_176740_k().func_176722_c() ? p_196271_1_.func_206870_a(field_196415_z.get(p_196271_2_), Boolean.valueOf(this.canPaneConnectTo(p_196271_4_, p_196271_5_, p_196271_2_))) : super.func_196271_a(p_196271_1_, p_196271_2_, p_196271_3_, p_196271_4_, p_196271_5_, p_196271_6_);
-    }
+     public Item func_180660_a(IBlockState p_180660_1_, Random p_180660_2_, int p_180660_3_)
+@@ -197,6 +200,24 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176241_b, field_176242_M, field_176244_O, field_176243_N});
+     }
  
-    public boolean func_149686_d(IBlockState p_149686_1_) {
-@@ -87,4 +84,16 @@
-    public BlockFaceShape func_193383_a(IBlockReader p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_) {
-       return p_193383_4_ != EnumFacing.UP && p_193383_4_ != EnumFacing.DOWN ? BlockFaceShape.MIDDLE_POLE_THIN : BlockFaceShape.CENTER_SMALL;
-    }
++    /* ======================================== FORGE START ======================================== */
 +
-+   @Override
-+   public boolean canBeConnectedTo(IBlockState state, IBlockReader world, BlockPos pos, EnumFacing facing) {
-+      IBlockState other = world.func_180495_p(pos.func_177972_a(facing));
-+      return func_196417_a(other, other.func_193401_d(world, pos.func_177972_a(facing), facing.func_176734_d()));
-+   }
++    @Override
++    public boolean canBeConnectedTo(IBlockAccess world, BlockPos pos, EnumFacing facing)
++    {
++        BlockPos offset = pos.func_177972_a(facing);
++        return func_193393_b(world, world.func_180495_p(offset), offset, facing.func_176734_d());
++    }
 +
-+   private boolean canPaneConnectTo(IBlockReader world, BlockPos pos, EnumFacing facing) {
-+      BlockPos offset = pos.func_177972_a(facing);
-+      IBlockState other = world.func_180495_p(offset);
-+      return other.canBeConnectedTo(world, offset, facing.func_176734_d()) || func_176223_P().canBeConnectedTo(world, pos, facing);
-+   }
- }
++    public boolean canPaneConnectTo(IBlockAccess world, BlockPos pos, EnumFacing dir)
++    {
++        BlockPos other = pos.func_177972_a(dir);
++        IBlockState state = world.func_180495_p(other);
++        return state.func_177230_c().canBeConnectedTo(world, other, dir.func_176734_d()) || func_193393_b(world, state, other, dir.func_176734_d());
++    }
++
++    /* ======================================== FORGE END ======================================== */
++
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         return p_193383_4_ != EnumFacing.UP && p_193383_4_ != EnumFacing.DOWN ? BlockFaceShape.MIDDLE_POLE_THIN : BlockFaceShape.CENTER_SMALL;

patches/minecraft/net/minecraft/block/BlockPistonBase.java.patch

@@ -1,33 +1,45 @@
---- a/net/minecraft/block/BlockPistonBase.java
-+++ b/net/minecraft/block/BlockPistonBase.java
-@@ -244,7 +244,7 @@
-                return false;
+--- ../src-base/minecraft/net/minecraft/block/BlockPistonBase.java
++++ ../src-work/minecraft/net/minecraft/block/BlockPistonBase.java
+@@ -241,7 +241,7 @@
+                     }
+                 }
+ 
+-                if (!flag1 && iblockstate.func_185904_a() != Material.field_151579_a && func_185646_a(iblockstate, p_189539_2_, blockpos, enumfacing.func_176734_d(), false, enumfacing) && (iblockstate.func_185905_o() == EnumPushReaction.NORMAL || block == Blocks.field_150331_J || block == Blocks.field_150320_F))
++                if (!flag1 && !iblockstate.func_177230_c().isAir(iblockstate, p_189539_2_, blockpos) && func_185646_a(iblockstate, p_189539_2_, blockpos, enumfacing.func_176734_d(), false, enumfacing) && (iblockstate.func_185905_o() == EnumPushReaction.NORMAL || block == Blocks.field_150331_J || block == Blocks.field_150320_F))
+                 {
+                     this.func_176319_a(p_189539_2_, p_189539_3_, enumfacing, false);
+                 }
+@@ -307,7 +307,7 @@
+                     return false;
+                 }
+ 
+-                return !block.func_149716_u();
++                return !block.hasTileEntity(p_185646_0_);
              }
+             else
+             {
+@@ -353,7 +353,9 @@
+             {
+                 BlockPos blockpos1 = list2.get(j);
+                 IBlockState iblockstate = p_176319_1_.func_180495_p(blockpos1);
+-                iblockstate.func_177230_c().func_176226_b(p_176319_1_, blockpos1, iblockstate, 0);
++                // Forge: With our change to how snowballs are dropped this needs to disallow to mimic vanilla behavior.
++                float chance = iblockstate.func_177230_c() instanceof BlockSnow ? -1.0f : 1.0f;
++                iblockstate.func_177230_c().func_180653_a(p_176319_1_, blockpos1, iblockstate, chance, 0);
+                 p_176319_1_.func_180501_a(blockpos1, Blocks.field_150350_a.func_176223_P(), 4);
+                 --k;
+                 aiblockstate[k] = iblockstate;
+@@ -434,6 +436,13 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176387_N, field_176320_b});
+     }
  
--            return !block.func_149716_u();
-+            return !p_185646_0_.hasTileEntity();
-          } else {
-             return false;
-          }
-@@ -280,7 +280,9 @@
-          for(int j = list2.size() - 1; j >= 0; --j) {
-             BlockPos blockpos2 = list2.get(j);
-             IBlockState iblockstate = p_176319_1_.func_180495_p(blockpos2);
--            iblockstate.func_196949_c(p_176319_1_, blockpos2, 0);
-+            // Forge: With our change to how snowballs are dropped this needs to disallow to mimic vanilla behavior.
-+            float chance = iblockstate.func_177230_c() instanceof BlockSnow ? -1.0f : 1.0f;
-+            iblockstate.func_196941_a(p_176319_1_, blockpos2, chance, 0);
-             p_176319_1_.func_180501_a(blockpos2, Blocks.field_150350_a.func_176223_P(), 18);
-             --k;
-             aiblockstate[k] = iblockstate;
-@@ -333,6 +335,10 @@
-       return p_185499_1_.func_206870_a(field_176387_N, p_185499_2_.func_185831_a(p_185499_1_.func_177229_b(field_176387_N)));
-    }
- 
-+   public IBlockState rotate(IBlockState state, net.minecraft.world.IWorld world, BlockPos pos, Rotation direction) {
-+       return state.func_177229_b(field_176320_b) ? state : super.rotate(state, world, pos, direction);
-+   }
++    /* ======================================== FORGE START =====================================*/
++    public boolean rotateBlock(World world, BlockPos pos, EnumFacing axis)
++    {
++        IBlockState state = world.func_180495_p(pos);
++        return !state.func_177229_b(field_176320_b) && super.rotateBlock(world, pos, axis);
++    }
 +
-    public IBlockState func_185471_a(IBlockState p_185471_1_, Mirror p_185471_2_) {
-       return p_185471_1_.func_185907_a(p_185471_2_.func_185800_a(p_185471_1_.func_177229_b(field_176387_N)));
-    }
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         p_193383_2_ = this.func_176221_a(p_193383_2_, p_193383_1_, p_193383_3_);

patches/minecraft/net/minecraft/block/BlockPistonMoving.java.patch

@@ -1,26 +1,37 @@
---- a/net/minecraft/block/BlockPistonMoving.java
-+++ b/net/minecraft/block/BlockPistonMoving.java
-@@ -86,14 +86,22 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockPistonMoving.java
++++ ../src-work/minecraft/net/minecraft/block/BlockPistonMoving.java
+@@ -116,7 +116,7 @@
  
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
--      if (!p_196255_2_.field_72995_K) {
-+      if (false && !p_196255_2_.field_72995_K) { //Forge: Noop this out
-          TileEntityPiston tileentitypiston = this.func_196342_a(p_196255_2_, p_196255_3_);
-          if (tileentitypiston != null) {
-             tileentitypiston.func_200230_i().func_196949_c(p_196255_2_, p_196255_3_, 0);
-          }
-       }
-+      super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, 1, p_196255_5_); // mimic vanilla behavior from above and ignore chance
-    }
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+-        if (!p_180653_1_.field_72995_K)
++        if (false && !p_180653_1_.field_72995_K) // Forge: Noop this out
+         {
+             TileEntityPiston tileentitypiston = this.func_185589_c(p_180653_1_, p_180653_2_);
  
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World world, BlockPos pos, int fortune) {
-+      TileEntityPiston te = this.func_196342_a(world, pos);
-+      if (te != null)
-+         te.func_200230_i().getDrops(drops, world, pos, fortune);
-+   }
+@@ -126,6 +126,7 @@
+                 iblockstate.func_177230_c().func_176226_b(p_180653_1_, p_180653_2_, iblockstate, 0);
+             }
+         }
++        super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, 1, p_180653_5_); // mimic vanilla behavior from above and ignore chance
+     }
+ 
+     @Nullable
+@@ -210,6 +211,17 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176426_a, field_176425_b});
+     }
+ 
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<net.minecraft.item.ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        TileEntityPiston tileentitypiston = this.func_185589_c(world, pos);
++        if (tileentitypiston != null)
++        {
++            IBlockState pushed = tileentitypiston.func_174927_b();
++            drops.addAll(pushed.func_177230_c().getDrops(world, pos, pushed, fortune)); // use the old method until it gets removed, for backward compatibility
++        }
++    }
 +
-    public VoxelShape func_196244_b(IBlockState p_196244_1_, IBlockReader p_196244_2_, BlockPos p_196244_3_) {
-       return VoxelShapes.func_197880_a();
-    }
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         return BlockFaceShape.UNDEFINED;

patches/minecraft/net/minecraft/block/BlockPortal.java.patch

@@ -1,11 +1,20 @@
---- a/net/minecraft/block/BlockPortal.java
-+++ b/net/minecraft/block/BlockPortal.java
-@@ -76,7 +76,7 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockPortal.java
++++ ../src-work/minecraft/net/minecraft/block/BlockPortal.java
+@@ -111,7 +111,7 @@
+     {
+         BlockPortal.Size blockportal$size = new BlockPortal.Size(p_176548_1_, p_176548_2_, EnumFacing.Axis.X);
  
-    public boolean func_176548_d(IWorld p_176548_1_, BlockPos p_176548_2_) {
-       BlockPortal.Size blockportal$size = this.func_201816_b(p_176548_1_, p_176548_2_);
--      if (blockportal$size != null) {
-+      if (blockportal$size != null && !net.minecraftforge.event.ForgeEventFactory.onTrySpawnPortal(p_176548_1_, p_176548_2_, blockportal$size)) {
-          blockportal$size.func_150859_c();
-          return true;
-       } else {
+-        if (blockportal$size.func_150860_b() && blockportal$size.field_150864_e == 0)
++        if (blockportal$size.func_150860_b() && blockportal$size.field_150864_e == 0 && !net.minecraftforge.event.ForgeEventFactory.onTrySpawnPortal(p_176548_1_, p_176548_2_, blockportal$size))
+         {
+             blockportal$size.func_150859_c();
+             return true;
+@@ -120,7 +120,7 @@
+         {
+             BlockPortal.Size blockportal$size1 = new BlockPortal.Size(p_176548_1_, p_176548_2_, EnumFacing.Axis.Z);
+ 
+-            if (blockportal$size1.func_150860_b() && blockportal$size1.field_150864_e == 0)
++            if (blockportal$size1.func_150860_b() && blockportal$size1.field_150864_e == 0 && !net.minecraftforge.event.ForgeEventFactory.onTrySpawnPortal(p_176548_1_, p_176548_2_, blockportal$size1))
+             {
+                 blockportal$size1.func_150859_c();
+                 return true;

patches/minecraft/net/minecraft/block/BlockPotato.java.patch

@@ -1,25 +1,24 @@
---- a/net/minecraft/block/BlockPotato.java
-+++ b/net/minecraft/block/BlockPotato.java
-@@ -26,7 +26,7 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockPotato.java
++++ ../src-work/minecraft/net/minecraft/block/BlockPotato.java
+@@ -27,7 +27,7 @@
+     {
+         super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
  
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
-       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
--      if (!p_196255_2_.field_72995_K) {
-+      if (false && !p_196255_2_.field_72995_K) { //Forge: Moved to getDrops
-          if (this.func_185525_y(p_196255_1_) && p_196255_2_.field_73012_v.nextInt(50) == 0) {
-             func_180635_a(p_196255_2_, p_196255_3_, new ItemStack(Items.field_151170_bI));
-          }
-@@ -34,6 +34,13 @@
-       }
-    }
- 
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World world, BlockPos pos, int fortune) {
-+      super.getDrops(state, drops, world, pos, fortune);
-+      if (this.func_185525_y(state) && world.field_73012_v.nextInt(50) == 0)
-+          drops.add(new ItemStack(Items.field_151170_bI));
-+   }
+-        if (!p_180653_1_.field_72995_K)
++        if (false && !p_180653_1_.field_72995_K) //Forge: Moved to getDrops
+         {
+             if (this.func_185525_y(p_180653_3_) && p_180653_1_.field_73012_v.nextInt(50) == 0)
+             {
+@@ -40,4 +40,12 @@
+     {
+         return field_185534_a[((Integer)p_185496_1_.func_177229_b(this.func_185524_e())).intValue()];
+     }
 +
-    public VoxelShape func_196244_b(IBlockState p_196244_1_, IBlockReader p_196244_2_, BlockPos p_196244_3_) {
-       return field_196396_a[p_196244_1_.func_177229_b(this.func_185524_e())];
-    }
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, net.minecraft.world.IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
++        super.getDrops(drops, world, pos, state, fortune);
++        if (this.func_185525_y(state) && RANDOM.nextInt(50) == 0)
++            drops.add(new ItemStack(Items.field_151170_bI));
++    }
+ }

patches/minecraft/net/minecraft/block/BlockPumpkin.java.patch

@@ -0,0 +1,11 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockPumpkin.java
++++ ../src-work/minecraft/net/minecraft/block/BlockPumpkin.java
+@@ -136,7 +136,7 @@
+ 
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        return p_176196_1_.func_180495_p(p_176196_2_).func_177230_c().field_149764_J.func_76222_j() && p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_185896_q();
++        return p_176196_1_.func_180495_p(p_176196_2_).func_177230_c().func_176200_f(p_176196_1_, p_176196_2_) && p_176196_1_.isSideSolid(p_176196_2_.func_177977_b(), EnumFacing.UP);
+     }
+ 
+     public IBlockState func_185499_a(IBlockState p_185499_1_, Rotation p_185499_2_)

patches/minecraft/net/minecraft/block/BlockQuartz.java.patch

@@ -0,0 +1,29 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockQuartz.java
++++ ../src-work/minecraft/net/minecraft/block/BlockQuartz.java
+@@ -108,6 +108,26 @@
+         return new BlockStateContainer(this, new IProperty[] {field_176335_a});
+     }
+ 
++    public boolean rotateBlock(World world, BlockPos pos, EnumFacing axis)
++    {
++        IBlockState state = world.func_180495_p(pos);
++        for (IProperty prop : state.func_177228_b().keySet())
++        {
++            if (prop.func_177701_a().equals("variant") && prop.func_177699_b() == EnumType.class)
++            {
++                EnumType current = (EnumType)state.func_177229_b(prop);
++                EnumType next = current == EnumType.LINES_X ? EnumType.LINES_Y :
++                                current == EnumType.LINES_Y ? EnumType.LINES_Z :
++                                current == EnumType.LINES_Z ? EnumType.LINES_X : current;
++                if (next == current)
++                    return false;
++                world.func_175656_a(pos, state.func_177226_a(prop, next));
++                return true;
++            }
++        }
++        return false;
++    }
++
+     public static enum EnumType implements IStringSerializable
+     {
+         DEFAULT(0, "default", "default"),

patches/minecraft/net/minecraft/block/BlockRailBase.java.patch

@@ -1,122 +1,237 @@
---- a/net/minecraft/block/BlockRailBase.java
-+++ b/net/minecraft/block/BlockRailBase.java
-@@ -37,7 +37,7 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockRailBase.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRailBase.java
+@@ -34,7 +34,7 @@
+     public static boolean func_176563_d(IBlockState p_176563_0_)
+     {
+         Block block = p_176563_0_.func_177230_c();
+-        return block == Blocks.field_150448_aq || block == Blocks.field_150318_D || block == Blocks.field_150319_E || block == Blocks.field_150408_cc;
++        return block instanceof BlockRailBase;
+     }
  
-    public VoxelShape func_196244_b(IBlockState p_196244_1_, IBlockReader p_196244_2_, BlockPos p_196244_3_) {
--      RailShape railshape = p_196244_1_.func_177230_c() == this ? p_196244_1_.func_177229_b(this.func_176560_l()) : null;
-+      RailShape railshape = p_196244_1_.func_177230_c() == this ? getRailDirection(p_196244_1_, p_196244_2_, p_196244_3_, null) : null;
-       return railshape != null && railshape.func_208092_c() ? field_190959_b : field_185590_a;
-    }
+     protected BlockRailBase(boolean p_i45389_1_)
+@@ -57,7 +57,7 @@
  
-@@ -50,7 +50,7 @@
-    }
+     public AxisAlignedBB func_185496_a(IBlockState p_185496_1_, IBlockAccess p_185496_2_, BlockPos p_185496_3_)
+     {
+-        BlockRailBase.EnumRailDirection blockrailbase$enumraildirection = p_185496_1_.func_177230_c() == this ? (BlockRailBase.EnumRailDirection)p_185496_1_.func_177229_b(this.func_176560_l()) : null;
++        BlockRailBase.EnumRailDirection blockrailbase$enumraildirection = p_185496_1_.func_177230_c() == this ? getRailDirection(p_185496_2_, p_185496_3_, p_185496_1_, null) : null;
+         return blockrailbase$enumraildirection != null && blockrailbase$enumraildirection.func_177018_c() ? field_190959_b : field_185590_a;
+     }
  
-    public boolean func_196260_a(IBlockState p_196260_1_, IWorldReaderBase p_196260_2_, BlockPos p_196260_3_) {
--      return p_196260_2_.func_180495_p(p_196260_3_.func_177977_b()).func_185896_q();
-+      return p_196260_2_.func_180495_p(p_196260_3_.func_177977_b()).func_193401_d(p_196260_2_, p_196260_3_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID;
-    }
+@@ -73,7 +73,7 @@
  
-    public void func_196259_b(IBlockState p_196259_1_, World p_196259_2_, BlockPos p_196259_3_, IBlockState p_196259_4_) {
-@@ -67,19 +67,19 @@
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        return p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_185896_q();
++        return p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).isSideSolid(p_176196_1_, p_176196_2_.func_177977_b(), EnumFacing.UP);
+     }
  
-    public void func_189540_a(IBlockState p_189540_1_, World p_189540_2_, BlockPos p_189540_3_, Block p_189540_4_, BlockPos p_189540_5_) {
-       if (!p_189540_2_.field_72995_K) {
--         RailShape railshape = p_189540_1_.func_177229_b(this.func_176560_l());
-+         RailShape railshape = getRailDirection(p_189540_1_, p_189540_2_, p_189540_3_, null);
-          boolean flag = false;
--         if (!p_189540_2_.func_180495_p(p_189540_3_.func_177977_b()).func_185896_q()) {
-+         if (p_189540_2_.func_180495_p(p_189540_3_.func_177977_b()).func_193401_d(p_189540_2_, p_189540_3_.func_177977_b(), EnumFacing.UP) != BlockFaceShape.SOLID) {
-             flag = true;
-          }
+     public void func_176213_c(World p_176213_1_, BlockPos p_176213_2_, IBlockState p_176213_3_)
+@@ -93,32 +93,33 @@
+     {
+         if (!p_189540_2_.field_72995_K)
+         {
+-            BlockRailBase.EnumRailDirection blockrailbase$enumraildirection = (BlockRailBase.EnumRailDirection)p_189540_1_.func_177229_b(this.func_176560_l());
++            final IBlockState currentState = p_189540_2_.func_180495_p(p_189540_3_);
++            BlockRailBase.EnumRailDirection blockrailbase$enumraildirection = getRailDirection(p_189540_2_, p_189540_3_, currentState.func_177230_c() == this ? currentState : p_189540_1_, null);
+             boolean flag = false;
  
--         if (railshape == RailShape.ASCENDING_EAST && !p_189540_2_.func_180495_p(p_189540_3_.func_177974_f()).func_185896_q()) {
-+         if (railshape == RailShape.ASCENDING_EAST && p_189540_2_.func_180495_p(p_189540_3_.func_177974_f()).func_193401_d(p_189540_2_, p_189540_3_.func_177974_f(), EnumFacing.UP) != BlockFaceShape.SOLID) {
-             flag = true;
--         } else if (railshape == RailShape.ASCENDING_WEST && !p_189540_2_.func_180495_p(p_189540_3_.func_177976_e()).func_185896_q()) {
-+         } else if (railshape == RailShape.ASCENDING_WEST && p_189540_2_.func_180495_p(p_189540_3_.func_177976_e()).func_193401_d(p_189540_2_, p_189540_3_.func_177976_e(), EnumFacing.UP) != BlockFaceShape.SOLID) {
-             flag = true;
--         } else if (railshape == RailShape.ASCENDING_NORTH && !p_189540_2_.func_180495_p(p_189540_3_.func_177978_c()).func_185896_q()) {
-+         } else if (railshape == RailShape.ASCENDING_NORTH && p_189540_2_.func_180495_p(p_189540_3_.func_177978_c()).func_193401_d(p_189540_2_, p_189540_3_.func_177978_c(), EnumFacing.UP) != BlockFaceShape.SOLID) {
-             flag = true;
--         } else if (railshape == RailShape.ASCENDING_SOUTH && !p_189540_2_.func_180495_p(p_189540_3_.func_177968_d()).func_185896_q()) {
-+         } else if (railshape == RailShape.ASCENDING_SOUTH && p_189540_2_.func_180495_p(p_189540_3_.func_177968_d()).func_193401_d(p_189540_2_, p_189540_3_.func_177968_d(), EnumFacing.UP) != BlockFaceShape.SOLID) {
-             flag = true;
-          }
+-            if (!p_189540_2_.func_180495_p(p_189540_3_.func_177977_b()).func_185896_q())
++            if (!p_189540_2_.func_180495_p(p_189540_3_.func_177977_b()).isSideSolid(p_189540_2_, p_189540_3_.func_177977_b(), EnumFacing.UP))
+             {
+                 flag = true;
+             }
  
-@@ -111,7 +111,7 @@
-    public void func_196243_a(IBlockState p_196243_1_, World p_196243_2_, BlockPos p_196243_3_, IBlockState p_196243_4_, boolean p_196243_5_) {
-       if (!p_196243_5_) {
-          super.func_196243_a(p_196243_1_, p_196243_2_, p_196243_3_, p_196243_4_, p_196243_5_);
--         if (p_196243_1_.func_177229_b(this.func_176560_l()).func_208092_c()) {
-+         if (getRailDirection(p_196243_1_, p_196243_2_, p_196243_3_, null).func_208092_c()) {
-             p_196243_2_.func_195593_d(p_196243_3_.func_177984_a(), this);
-          }
+-            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_EAST && !p_189540_2_.func_180495_p(p_189540_3_.func_177974_f()).func_185896_q())
++            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_EAST && !p_189540_2_.func_180495_p(p_189540_3_.func_177974_f()).isSideSolid(p_189540_2_, p_189540_3_.func_177974_f(), EnumFacing.UP))
+             {
+                 flag = true;
+             }
+-            else if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_WEST && !p_189540_2_.func_180495_p(p_189540_3_.func_177976_e()).func_185896_q())
++            else if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_WEST && !p_189540_2_.func_180495_p(p_189540_3_.func_177976_e()).isSideSolid(p_189540_2_, p_189540_3_.func_177976_e(), EnumFacing.UP))
+             {
+                 flag = true;
+             }
+-            else if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_NORTH && !p_189540_2_.func_180495_p(p_189540_3_.func_177978_c()).func_185896_q())
++            else if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_NORTH && !p_189540_2_.func_180495_p(p_189540_3_.func_177978_c()).isSideSolid(p_189540_2_, p_189540_3_.func_177978_c(), EnumFacing.UP))
+             {
+                 flag = true;
+             }
+-            else if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_SOUTH && !p_189540_2_.func_180495_p(p_189540_3_.func_177968_d()).func_185896_q())
++            else if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.ASCENDING_SOUTH && !p_189540_2_.func_180495_p(p_189540_3_.func_177968_d()).isSideSolid(p_189540_2_, p_189540_3_.func_177968_d(), EnumFacing.UP))
+             {
+                 flag = true;
+             }
  
-@@ -123,5 +123,66 @@
-       }
-    }
+-            if (flag && !p_189540_2_.func_175623_d(p_189540_3_))
++            if (flag && !currentState.func_177230_c().isAir(currentState, p_189540_2_, p_189540_3_))
+             {
+                 this.func_176226_b(p_189540_2_, p_189540_3_, p_189540_1_, 0);
+                 p_189540_2_.func_175698_g(p_189540_3_);
+@@ -154,7 +155,7 @@
+     {
+         super.func_180663_b(p_180663_1_, p_180663_2_, p_180663_3_);
  
-+   //Forge: Use getRailDirection(IBlockAccess, BlockPos, IBlockState, EntityMinecart) for enhanced ability
-    public abstract IProperty<RailShape> func_176560_l();
+-        if (((BlockRailBase.EnumRailDirection)p_180663_3_.func_177229_b(this.func_176560_l())).func_177018_c())
++        if (getRailDirection(p_180663_1_, p_180663_2_, p_180663_3_, null).func_177018_c())
+         {
+             p_180663_1_.func_175685_c(p_180663_2_.func_177984_a(), this, false);
+         }
+@@ -166,8 +167,101 @@
+         }
+     }
+ 
++    //Forge: Use getRailDirection(IBlockAccess, BlockPos, IBlockState, EntityMinecart) for enhanced ability
+     public abstract IProperty<BlockRailBase.EnumRailDirection> func_176560_l();
+ 
++    /* ======================================== FORGE START =====================================*/
++    /**
++     * Return true if the rail can make corners.
++     * Used by placement logic.
++     * @param world The world.
++     * @param pos Block's position in world
++     * @return True if the rail can make corners.
++     */
++    public boolean isFlexibleRail(IBlockAccess world, BlockPos pos)
++    {
++        return !this.field_150053_a;
++    }
 +
-+   /* ======================================== FORGE START =====================================*/
-+   /**
-+    * Return true if the rail can make corners.
-+    * Used by placement logic.
-+    * @param world The world.
-+    * @param pos Block's position in world
-+    * @return True if the rail can make corners.
-+    */
-+   public boolean isFlexibleRail(IBlockState state, IBlockReader world, BlockPos pos)
-+   {
-+       return !this.field_196277_c;
-+   }
++    /**
++     * Returns true if the rail can make up and down slopes.
++     * Used by placement logic.
++     * @param world The world.
++     * @param pos Block's position in world
++     * @return True if the rail can make slopes.
++     */
++    public boolean canMakeSlopes(IBlockAccess world, BlockPos pos)
++    {
++        return true;
++    }
 +
-+   /**
-+    * Returns true if the rail can make up and down slopes.
-+    * Used by placement logic.
-+    * @param world The world.
-+    * @param pos Block's position in world
-+    * @return True if the rail can make slopes.
-+    */
-+   public boolean canMakeSlopes(IBlockState state, IBlockReader world, BlockPos pos) {
-+       return true;
-+   }
++    /**
++     * Return the rail's direction.
++     * Can be used to make the cart think the rail is a different shape,
++     * for example when making diamond junctions or switches.
++     * The cart parameter will often be null unless it it called from EntityMinecart.
++     *
++     * @param world The world.
++     * @param pos Block's position in world
++     * @param state The BlockState
++     * @param cart The cart asking for the metadata, null if it is not called by EntityMinecart.
++     * @return The direction.
++     */
++    public EnumRailDirection getRailDirection(IBlockAccess world, BlockPos pos, IBlockState state, @javax.annotation.Nullable net.minecraft.entity.item.EntityMinecart cart)
++    {
++        return state.func_177229_b(func_176560_l());
++    }
 +
-+   /**
-+    * Return the rail's direction.
-+    * Can be used to make the cart think the rail is a different shape,
-+    * for example when making diamond junctions or switches.
-+    * The cart parameter will often be null unless it it called from EntityMinecart.
-+    *
-+    * @param world The world.
-+    * @param pos Block's position in world
-+    * @param state The BlockState
-+    * @param cart The cart asking for the metadata, null if it is not called by EntityMinecart.
-+    * @return The direction.
-+    */
-+   public RailShape getRailDirection(IBlockState state, IBlockReader world, BlockPos pos, @javax.annotation.Nullable net.minecraft.entity.item.EntityMinecart cart) {
-+       return state.func_177229_b(func_176560_l());
-+   }
++    /**
++     * Returns the max speed of the rail at the specified position.
++     * @param world The world.
++     * @param cart The cart on the rail, may be null.
++     * @param pos Block's position in world
++     * @return The max speed of the current rail.
++     */
++    public float getRailMaxSpeed(World world, net.minecraft.entity.item.EntityMinecart cart, BlockPos pos)
++    {
++        return 0.4f;
++    }
 +
-+   /**
-+    * Returns the max speed of the rail at the specified position.
-+    * @param world The world.
-+    * @param cart The cart on the rail, may be null.
-+    * @param pos Block's position in world
-+    * @return The max speed of the current rail.
-+    */
-+   public float getRailMaxSpeed(IBlockState state, World world, BlockPos pos, net.minecraft.entity.item.EntityMinecart cart) {
-+       return 0.4f;
-+   }
++    /**
++     * This function is called by any minecart that passes over this rail.
++     * It is called once per update tick that the minecart is on the rail.
++     * @param world The world.
++     * @param cart The cart on the rail.
++     * @param pos Block's position in world
++     */
++    public void onMinecartPass(World world, net.minecraft.entity.item.EntityMinecart cart, BlockPos pos)
++    {
++    }
 +
-+   /**
-+    * This function is called by any minecart that passes over this rail.
-+    * It is called once per update tick that the minecart is on the rail.
-+    * @param world The world.
-+    * @param cart The cart on the rail.
-+    * @param pos Block's position in world
-+    */
-+   public void onMinecartPass(IBlockState state, World world, BlockPos pos, net.minecraft.entity.item.EntityMinecart cart) { }
- }
++    /**
++     * Rotate the block. For vanilla blocks this rotates around the axis passed in (generally, it should be the "face" that was hit).
++     * Note: for mod blocks, this is up to the block and modder to decide. It is not mandated that it be a rotation around the
++     * face, but could be a rotation to orient *to* that face, or a visiting of possible rotations.
++     * The method should return true if the rotation was successful though.
++     *
++     * @param world The world
++     * @param pos Block position in world
++     * @param axis The axis to rotate around
++     * @return True if the rotation was successful, False if the rotation failed, or is not possible
++     */
++    public boolean rotateBlock(World world, BlockPos pos, EnumFacing axis)
++    {
++        IBlockState state = world.func_180495_p(pos);
++        for (IProperty prop : state.func_177228_b().keySet())
++        {
++            if (prop.func_177701_a().equals("shape"))
++            {
++                world.func_175656_a(pos, state.func_177231_a(prop));
++                return true;
++            }
++        }
++        return false;
++    }
++
++    /* ======================================== FORGE END =====================================*/
++
+     public static enum EnumRailDirection implements IStringSerializable
+     {
+         NORTH_SOUTH(0, "north_south"),
+@@ -238,6 +332,7 @@
+         private IBlockState field_180366_e;
+         private final boolean field_150656_f;
+         private final List<BlockPos> field_150657_g = Lists.<BlockPos>newArrayList();
++        private final boolean canMakeSlopes;
+ 
+         public Rail(World p_i45739_2_, BlockPos p_i45739_3_, IBlockState p_i45739_4_)
+         {
+@@ -245,8 +340,9 @@
+             this.field_180367_c = p_i45739_3_;
+             this.field_180366_e = p_i45739_4_;
+             this.field_180365_d = (BlockRailBase)p_i45739_4_.func_177230_c();
+-            BlockRailBase.EnumRailDirection blockrailbase$enumraildirection = (BlockRailBase.EnumRailDirection)p_i45739_4_.func_177229_b(this.field_180365_d.func_176560_l());
+-            this.field_150656_f = this.field_180365_d.field_150053_a;
++            BlockRailBase.EnumRailDirection blockrailbase$enumraildirection = field_180365_d.getRailDirection(p_i45739_2_, p_i45739_3_, p_i45739_4_, null);
++            this.field_150656_f = !this.field_180365_d.isFlexibleRail(p_i45739_2_, p_i45739_3_);
++            this.canMakeSlopes = this.field_180365_d.canMakeSlopes(p_i45739_2_, p_i45739_3_);
+             this.func_180360_a(blockrailbase$enumraildirection);
+         }
+ 
+@@ -438,7 +534,7 @@
+                 }
+             }
+ 
+-            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.NORTH_SOUTH)
++            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.NORTH_SOUTH && canMakeSlopes)
+             {
+                 if (BlockRailBase.func_176562_d(this.field_150660_b, blockpos.func_177984_a()))
+                 {
+@@ -451,7 +547,7 @@
+                 }
+             }
+ 
+-            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.EAST_WEST)
++            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.EAST_WEST && canMakeSlopes)
+             {
+                 if (BlockRailBase.func_176562_d(this.field_150660_b, blockpos3.func_177984_a()))
+                 {
+@@ -594,7 +690,7 @@
+                 }
+             }
+ 
+-            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.NORTH_SOUTH)
++            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.NORTH_SOUTH && canMakeSlopes)
+             {
+                 if (BlockRailBase.func_176562_d(this.field_150660_b, blockpos.func_177984_a()))
+                 {
+@@ -607,7 +703,7 @@
+                 }
+             }
+ 
+-            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.EAST_WEST)
++            if (blockrailbase$enumraildirection == BlockRailBase.EnumRailDirection.EAST_WEST && canMakeSlopes)
+             {
+                 if (BlockRailBase.func_176562_d(this.field_150660_b, blockpos3.func_177984_a()))
+                 {

patches/minecraft/net/minecraft/block/BlockRailDetector.java.patch

@@ -1,11 +1,11 @@
---- a/net/minecraft/block/BlockRailDetector.java
-+++ b/net/minecraft/block/BlockRailDetector.java
-@@ -127,6 +127,8 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockRailDetector.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRailDetector.java
+@@ -163,6 +163,8 @@
+     {
+         if (((Boolean)p_180641_1_.func_177229_b(field_176574_M)).booleanValue())
+         {
++            List<EntityMinecart> carts = this.func_176571_a(p_180641_2_, p_180641_3_, EntityMinecart.class);
++            if (!carts.isEmpty() && carts.get(0).getComparatorLevel() > -1) return carts.get(0).getComparatorLevel();
+             List<EntityMinecartCommandBlock> list = this.<EntityMinecartCommandBlock>func_176571_a(p_180641_2_, p_180641_3_, EntityMinecartCommandBlock.class);
  
-    public int func_180641_l(IBlockState p_180641_1_, World p_180641_2_, BlockPos p_180641_3_) {
-       if (p_180641_1_.func_177229_b(field_176574_M)) {
-+         List<EntityMinecart> carts = this.func_200878_a(p_180641_2_, p_180641_3_, EntityMinecart.class, null);
-+         if (!carts.isEmpty() && carts.get(0).getComparatorLevel() > -1) return carts.get(0).getComparatorLevel();
-          List<EntityMinecartCommandBlock> list = this.func_200878_a(p_180641_2_, p_180641_3_, EntityMinecartCommandBlock.class, (Predicate<Entity>)null);
-          if (!list.isEmpty()) {
-             return list.get(0).func_145822_e().func_145760_g();
+             if (!list.isEmpty())

patches/minecraft/net/minecraft/block/BlockRailPowered.java.patch

@@ -1,29 +1,29 @@
---- a/net/minecraft/block/BlockRailPowered.java
-+++ b/net/minecraft/block/BlockRailPowered.java
-@@ -15,10 +15,16 @@
- public class BlockRailPowered extends BlockRailBase {
-    public static final EnumProperty<RailShape> field_176568_b = BlockStateProperties.field_208166_S;
-    public static final BooleanProperty field_176569_M = BlockStateProperties.field_208194_u;
-+   private final boolean isActivator;
+--- ../src-base/minecraft/net/minecraft/block/BlockRailPowered.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRailPowered.java
+@@ -23,9 +23,17 @@
+     });
+     public static final PropertyBool field_176569_M = PropertyBool.func_177716_a("powered");
  
-    protected BlockRailPowered(Block.Properties p_i48349_1_) {
--      super(true, p_i48349_1_);
-+      this(p_i48349_1_, false);
-+   }
++    private final boolean isActivator;
 +
-+   protected BlockRailPowered(Block.Properties builder, boolean isActivator) {
-+      super(true, builder);
-       this.func_180632_j(this.field_176227_L.func_177621_b().func_206870_a(field_176568_b, RailShape.NORTH_SOUTH).func_206870_a(field_176569_M, Boolean.valueOf(false)));
-+      this.isActivator = isActivator;
-    }
+     protected BlockRailPowered()
+     {
++        this(false);
++    }
++
++    protected BlockRailPowered(boolean isActivator)
++    {
+         super(true);
++        this.isActivator = isActivator;
+         this.func_180632_j(this.field_176227_L.func_177621_b().func_177226_a(field_176568_b, BlockRailBase.EnumRailDirection.NORTH_SOUTH).func_177226_a(field_176569_M, Boolean.valueOf(false)));
+     }
  
-    protected boolean func_176566_a(World p_176566_1_, BlockPos p_176566_2_, IBlockState p_176566_3_, boolean p_176566_4_, int p_176566_5_) {
-@@ -100,7 +106,7 @@
+@@ -146,7 +154,7 @@
+     {
+         IBlockState iblockstate = p_176567_1_.func_180495_p(p_176567_2_);
  
-    protected boolean func_208071_a(World p_208071_1_, BlockPos p_208071_2_, boolean p_208071_3_, int p_208071_4_, RailShape p_208071_5_) {
-       IBlockState iblockstate = p_208071_1_.func_180495_p(p_208071_2_);
--      if (iblockstate.func_177230_c() != this) {
-+      if (!(iblockstate.func_177230_c() instanceof BlockRailPowered) || isActivator != ((BlockRailPowered)iblockstate.func_177230_c()).isActivator) {
-          return false;
-       } else {
-          RailShape railshape = iblockstate.func_177229_b(field_176568_b);
+-        if (iblockstate.func_177230_c() != this)
++        if (!(iblockstate.func_177230_c() instanceof BlockRailPowered) || isActivator != ((BlockRailPowered)iblockstate.func_177230_c()).isActivator)
+         {
+             return false;
+         }

patches/minecraft/net/minecraft/block/BlockRailState.java.patch

@@ -1,57 +0,0 @@
---- a/net/minecraft/block/BlockRailState.java
-+++ b/net/minecraft/block/BlockRailState.java
-@@ -16,14 +16,16 @@
-    private IBlockState field_196923_d;
-    private final boolean field_208513_e;
-    private final List<BlockPos> field_196924_e = Lists.newArrayList();
-+   private final boolean canMakeSlopes;
- 
-    public BlockRailState(World p_i47755_1_, BlockPos p_i47755_2_, IBlockState p_i47755_3_) {
-       this.field_196920_a = p_i47755_1_;
-       this.field_196921_b = p_i47755_2_;
-       this.field_196923_d = p_i47755_3_;
-       this.field_196922_c = (BlockRailBase)p_i47755_3_.func_177230_c();
--      RailShape railshape = p_i47755_3_.func_177229_b(this.field_196922_c.func_176560_l());
--      this.field_208513_e = this.field_196922_c.func_208490_b();
-+      RailShape railshape = this.field_196922_c.getRailDirection(field_196923_d, p_i47755_1_, p_i47755_2_, null);
-+      this.field_208513_e = this.field_196922_c.isFlexibleRail(field_196923_d, p_i47755_1_, p_i47755_2_);
-+      this.canMakeSlopes = this.field_196922_c.canMakeSlopes(field_196923_d, p_i47755_1_, p_i47755_2_);
-       this.func_208509_a(railshape);
-    }
- 
-@@ -179,7 +181,7 @@
-          }
-       }
- 
--      if (railshape == RailShape.NORTH_SOUTH) {
-+      if (railshape == RailShape.NORTH_SOUTH && canMakeSlopes) {
-          if (BlockRailBase.func_208488_a(this.field_196920_a, blockpos.func_177984_a())) {
-             railshape = RailShape.ASCENDING_NORTH;
-          }
-@@ -189,7 +191,7 @@
-          }
-       }
- 
--      if (railshape == RailShape.EAST_WEST) {
-+      if (railshape == RailShape.EAST_WEST && canMakeSlopes) {
-          if (BlockRailBase.func_208488_a(this.field_196920_a, blockpos3.func_177984_a())) {
-             railshape = RailShape.ASCENDING_EAST;
-          }
-@@ -299,7 +301,7 @@
-          }
-       }
- 
--      if (railshape == RailShape.NORTH_SOUTH) {
-+      if (railshape == RailShape.NORTH_SOUTH && canMakeSlopes) {
-          if (BlockRailBase.func_208488_a(this.field_196920_a, blockpos.func_177984_a())) {
-             railshape = RailShape.ASCENDING_NORTH;
-          }
-@@ -309,7 +311,7 @@
-          }
-       }
- 
--      if (railshape == RailShape.EAST_WEST) {
-+      if (railshape == RailShape.EAST_WEST && canMakeSlopes) {
-          if (BlockRailBase.func_208488_a(this.field_196920_a, blockpos3.func_177984_a())) {
-             railshape = RailShape.ASCENDING_EAST;
-          }

patches/minecraft/net/minecraft/block/BlockRedstoneComparator.java.patch

@@ -1,19 +1,24 @@
---- a/net/minecraft/block/BlockRedstoneComparator.java
-+++ b/net/minecraft/block/BlockRedstoneComparator.java
-@@ -156,4 +156,16 @@
-    protected void func_206840_a(StateContainer.Builder<Block, IBlockState> p_206840_1_) {
-       p_206840_1_.func_206894_a(field_185512_D, field_176463_b, field_196348_c);
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockRedstoneComparator.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRedstoneComparator.java
+@@ -319,6 +319,21 @@
+         return this.func_176223_P().func_177226_a(field_185512_D, p_180642_8_.func_174811_aO().func_176734_d()).func_177226_a(field_176464_a, Boolean.valueOf(false)).func_177226_a(field_176463_b, BlockRedstoneComparator.Mode.COMPARE);
+     }
+ 
++    @Override
++    public void onNeighborChange(IBlockAccess world, BlockPos pos, BlockPos neighbor)
++    {
++        if (pos.func_177956_o() == neighbor.func_177956_o() && world instanceof World && !((World) world).field_72995_K)
++        {
++            func_189540_a(world.func_180495_p(pos), (World)world, pos, world.func_180495_p(neighbor).func_177230_c(), neighbor);
++        }
++    }
 +
-+   @Override
-+   public boolean getWeakChanges(IBlockState state, net.minecraft.world.IWorldReader world, BlockPos pos) {
-+      return true;
-+   }
++    @Override
++    public boolean getWeakChanges(IBlockAccess world, BlockPos pos)
++    {
++        return true;
++    }
 +
-+   @Override
-+   public void onNeighborChange(IBlockState state, net.minecraft.world.IWorldReader world, BlockPos pos, BlockPos neighbor) {
-+      if (pos.func_177956_o() == neighbor.func_177956_o() && world instanceof World && !((World)world).func_201670_d()) {
-+         func_189540_a(state, (World)world, pos, world.func_180495_p(neighbor).func_177230_c(), neighbor);
-+      }
-+   }
- }
+     public static enum Mode implements IStringSerializable
+     {
+         COMPARE("compare"),

patches/minecraft/net/minecraft/block/BlockRedstoneDiode.java.patch

@@ -1,20 +1,54 @@
---- a/net/minecraft/block/BlockRedstoneDiode.java
-+++ b/net/minecraft/block/BlockRedstoneDiode.java
-@@ -35,7 +35,7 @@
-    }
+--- ../src-base/minecraft/net/minecraft/block/BlockRedstoneDiode.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRedstoneDiode.java
+@@ -39,12 +39,14 @@
  
-    public boolean func_196260_a(IBlockState p_196260_1_, IWorldReaderBase p_196260_2_, BlockPos p_196260_3_) {
--      return p_196260_2_.func_180495_p(p_196260_3_.func_177977_b()).func_185896_q();
-+      return p_196260_2_.func_180495_p(p_196260_3_.func_177977_b()).func_185896_q() || p_196260_2_.func_180495_p(p_196260_3_.func_177977_b()).func_193401_d(p_196260_2_, p_196260_3_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID;
-    }
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        return p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_185896_q() ? super.func_176196_c(p_176196_1_, p_176196_2_) : false;
++        IBlockState downState = p_176196_1_.func_180495_p(p_176196_2_.func_177977_b());
++        return (downState.func_185896_q() || downState.func_193401_d(p_176196_1_, p_176196_2_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID) ? super.func_176196_c(p_176196_1_, p_176196_2_) : false;
+     }
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-@@ -172,6 +172,8 @@
-    protected void func_176400_h(World p_176400_1_, BlockPos p_176400_2_, IBlockState p_176400_3_) {
-       EnumFacing enumfacing = p_176400_3_.func_177229_b(field_185512_D);
-       BlockPos blockpos = p_176400_2_.func_177972_a(enumfacing.func_176734_d());
-+      if (net.minecraftforge.event.ForgeEventFactory.onNeighborNotify(p_176400_1_, p_176400_2_, p_176400_1_.func_180495_p(p_176400_2_), java.util.EnumSet.of(enumfacing.func_176734_d()), false).isCanceled())
-+         return;
-       p_176400_1_.func_190524_a(blockpos, this, p_176400_2_);
-       p_176400_1_.func_175695_a(blockpos, this, enumfacing);
-    }
+     public boolean func_176409_d(World p_176409_1_, BlockPos p_176409_2_)
+     {
+-        return p_176409_1_.func_180495_p(p_176409_2_.func_177977_b()).func_185896_q();
++        IBlockState downState = p_176409_1_.func_180495_p(p_176409_2_.func_177977_b());
++        return downState.func_185896_q() || downState.func_193401_d(p_176409_1_, p_176409_2_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID;
+     }
+ 
+     public void func_180645_a(World p_180645_1_, BlockPos p_180645_2_, IBlockState p_180645_3_, Random p_180645_4_)
+@@ -227,6 +229,8 @@
+     {
+         EnumFacing enumfacing = (EnumFacing)p_176400_3_.func_177229_b(field_185512_D);
+         BlockPos blockpos = p_176400_2_.func_177972_a(enumfacing.func_176734_d());
++        if(net.minecraftforge.event.ForgeEventFactory.onNeighborNotify(p_176400_1_, p_176400_2_, p_176400_1_.func_180495_p(p_176400_2_), java.util.EnumSet.of(enumfacing.func_176734_d()), false).isCanceled())
++            return;
+         p_176400_1_.func_190524_a(blockpos, this, p_176400_2_);
+         p_176400_1_.func_175695_a(blockpos, this, enumfacing);
+     }
+@@ -307,6 +311,25 @@
+         return BlockRenderLayer.CUTOUT;
+     }
+ 
++    /* ======================================== FORGE START =====================================*/
++    @Override
++    public boolean rotateBlock(World world, BlockPos pos, EnumFacing axis)
++    {
++        if (super.rotateBlock(world, pos, axis))
++        {
++            IBlockState state = world.func_180495_p(pos);
++            state = func_180675_k(state);
++            world.func_175656_a(pos, state);
++
++            if (func_176404_e(world, pos, state))
++            {
++                world.func_175684_a(pos, this, 1);
++            }
++            return true;
++        }
++        return false;
++    }
++
+     public BlockFaceShape func_193383_a(IBlockAccess p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_)
+     {
+         return p_193383_4_ == EnumFacing.DOWN ? BlockFaceShape.SOLID : BlockFaceShape.UNDEFINED;

patches/minecraft/net/minecraft/block/BlockRedstoneOre.java.patch

@@ -1,21 +1,22 @@
---- a/net/minecraft/block/BlockRedstoneOre.java
-+++ b/net/minecraft/block/BlockRedstoneOre.java
-@@ -72,11 +72,17 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockRedstoneOre.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRedstoneOre.java
+@@ -92,12 +92,16 @@
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+         super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
++    }
  
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
-       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
--      if (this.func_199769_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_5_) != this) {
-+      if (false && this.func_199769_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_5_) != this) {
-          int i = 1 + p_196255_2_.field_73012_v.nextInt(5);
-          this.func_180637_b(p_196255_2_, p_196255_3_, i);
-       }
-+   }
+-        if (this.func_180660_a(p_180653_3_, p_180653_1_.field_73012_v, p_180653_5_) != Item.func_150898_a(this))
++    @Override
++    public int getExpDrop(IBlockState state, net.minecraft.world.IBlockAccess world, BlockPos pos, int fortune)
++    {
++        if (this.func_180660_a(state, RANDOM, fortune) != Item.func_150898_a(this))
+         {
+-            int i = 1 + p_180653_1_.field_73012_v.nextInt(5);
+-            this.func_180637_b(p_180653_1_, p_180653_2_, i);
++            return 1 + RANDOM.nextInt(5);
+         }
++        return 0;
+     }
  
-+   @Override
-+   public int getExpDrop(IBlockState state, net.minecraft.world.IWorldReader world, BlockPos pos, int fortune) {
-+      if (!(world instanceof World) || func_199769_a(state, (World)world, pos, fortune) != this)
-+         return 1 + RANDOM.nextInt(5);
-+      return 0;
-    }
- 
-    @OnlyIn(Dist.CLIENT)
+     @SideOnly(Side.CLIENT)

patches/minecraft/net/minecraft/block/BlockRedstoneTorch.java.patch

@@ -1,11 +1,11 @@
---- a/net/minecraft/block/BlockRedstoneTorch.java
-+++ b/net/minecraft/block/BlockRedstoneTorch.java
-@@ -24,7 +24,7 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockRedstoneTorch.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRedstoneTorch.java
+@@ -23,7 +23,7 @@
  
- public class BlockRedstoneTorch extends BlockTorch {
-    public static final BooleanProperty field_196528_a = BlockStateProperties.field_208190_q;
--   private static final Map<IBlockReader, List<BlockRedstoneTorch.Toggle>> field_196529_b = Maps.newHashMap();
-+   private static final Map<IBlockReader, List<BlockRedstoneTorch.Toggle>> field_196529_b = new java.util.WeakHashMap<IBlockReader, List<BlockRedstoneTorch.Toggle>>(); // FORGE - fix vanilla MC-101233
+ public class BlockRedstoneTorch extends BlockTorch
+ {
+-    private static final Map<World, List<BlockRedstoneTorch.Toggle>> field_150112_b = Maps.<World, List<BlockRedstoneTorch.Toggle>>newHashMap();
++    private static final Map<World, List<BlockRedstoneTorch.Toggle>> field_150112_b = new java.util.WeakHashMap<World, List<Toggle>>(); // FORGE - fix vanilla MC-101233
+     private final boolean field_150113_a;
  
-    protected BlockRedstoneTorch(Block.Properties p_i48342_1_) {
-       super(p_i48342_1_);
+     private boolean func_176598_a(World p_176598_1_, BlockPos p_176598_2_, boolean p_176598_3_)

patches/minecraft/net/minecraft/block/BlockRedstoneWire.java.patch

@@ -1,71 +1,68 @@
---- a/net/minecraft/block/BlockRedstoneWire.java
-+++ b/net/minecraft/block/BlockRedstoneWire.java
-@@ -124,8 +124,8 @@
-       IBlockState iblockstate = p_208074_1_.func_180495_p(p_208074_2_.func_177972_a(p_208074_3_));
-       IBlockState iblockstate1 = p_208074_1_.func_180495_p(p_208074_2_.func_177984_a());
-       if (!iblockstate1.func_185915_l()) {
--         boolean flag = p_208074_1_.func_180495_p(blockpos).func_185896_q() || p_208074_1_.func_180495_p(blockpos).func_177230_c() == Blocks.field_150426_aN;
--         if (flag && func_176346_d(p_208074_1_.func_180495_p(blockpos.func_177984_a()))) {
-+         boolean flag = iblockstate.func_193401_d(p_208074_1_, blockpos, EnumFacing.UP) == BlockFaceShape.SOLID || iblockstate.func_177230_c() == Blocks.field_150426_aN;
-+         if (flag && canConnectTo(p_208074_1_.func_180495_p(blockpos.func_177984_a()), p_208074_1_, blockpos.func_177984_a(), null)) {
-             if (iblockstate.func_185898_k()) {
-                return RedstoneSide.UP;
-             }
-@@ -134,7 +134,7 @@
-          }
-       }
+--- ../src-base/minecraft/net/minecraft/block/BlockRedstoneWire.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRedstoneWire.java
+@@ -99,15 +99,15 @@
+         BlockPos blockpos = p_176341_2_.func_177972_a(p_176341_3_);
+         IBlockState iblockstate = p_176341_1_.func_180495_p(p_176341_2_.func_177972_a(p_176341_3_));
  
--      return !func_176343_a(p_208074_1_.func_180495_p(blockpos), p_208074_3_) && (iblockstate.func_185915_l() || !func_176346_d(p_208074_1_.func_180495_p(blockpos.func_177977_b()))) ? RedstoneSide.NONE : RedstoneSide.SIDE;
-+      return !canConnectTo(p_208074_1_.func_180495_p(blockpos), p_208074_1_, blockpos, p_208074_3_) && (iblockstate.func_185915_l() || !canConnectTo(p_208074_1_.func_180495_p(blockpos.func_177977_b()), p_208074_1_, blockpos.func_177977_b(), null)) ? RedstoneSide.NONE : RedstoneSide.SIDE;
-    }
+-        if (!func_176343_a(p_176341_1_.func_180495_p(blockpos), p_176341_3_) && (iblockstate.func_185915_l() || !func_176346_d(p_176341_1_.func_180495_p(blockpos.func_177977_b()))))
++        if (!canConnectTo(p_176341_1_.func_180495_p(blockpos), p_176341_3_, p_176341_1_, blockpos) && (iblockstate.func_185915_l() || !func_176340_e(p_176341_1_, blockpos.func_177977_b())))
+         {
+             IBlockState iblockstate1 = p_176341_1_.func_180495_p(p_176341_2_.func_177984_a());
  
-    public boolean func_149686_d(IBlockState p_149686_1_) {
-@@ -143,7 +143,7 @@
+             if (!iblockstate1.func_185915_l())
+             {
+-                boolean flag = p_176341_1_.func_180495_p(blockpos).func_185896_q() || p_176341_1_.func_180495_p(blockpos).func_177230_c() == Blocks.field_150426_aN;
++                boolean flag = p_176341_1_.func_180495_p(blockpos).isSideSolid(p_176341_1_, blockpos, EnumFacing.UP) || p_176341_1_.func_180495_p(blockpos).func_177230_c() == Blocks.field_150426_aN;
  
-    public boolean func_196260_a(IBlockState p_196260_1_, IWorldReaderBase p_196260_2_, BlockPos p_196260_3_) {
-       IBlockState iblockstate = p_196260_2_.func_180495_p(p_196260_3_.func_177977_b());
--      return iblockstate.func_185896_q() || iblockstate.func_177230_c() == Blocks.field_150426_aN;
-+      return iblockstate.func_185896_q() || iblockstate.func_177230_c() == Blocks.field_150426_aN || iblockstate.func_193401_d(p_196260_2_, p_196260_3_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID;
-    }
+-                if (flag && func_176346_d(p_176341_1_.func_180495_p(blockpos.func_177984_a())))
++                if (flag && func_176340_e(p_176341_1_, blockpos.func_177984_a()))
+                 {
+                     if (iblockstate.func_185898_k())
+                     {
+@@ -144,7 +144,8 @@
  
-    private IBlockState func_176338_e(World p_176338_1_, BlockPos p_176338_2_, IBlockState p_176338_3_) {
-@@ -338,26 +338,18 @@
-       IBlockState iblockstate = p_176339_1_.func_180495_p(blockpos);
-       boolean flag = iblockstate.func_185915_l();
-       boolean flag1 = p_176339_1_.func_180495_p(p_176339_2_.func_177984_a()).func_185915_l();
--      if (!flag1 && flag && func_176340_e(p_176339_1_, blockpos.func_177984_a())) {
-+      if (!flag1 && flag && canConnectTo(p_176339_1_.func_180495_p(blockpos.func_177984_a()), p_176339_1_, blockpos.func_177984_a(), null)) {
-          return true;
--      } else if (func_176343_a(iblockstate, p_176339_3_)) {
-+      } else if (canConnectTo(iblockstate, p_176339_1_, blockpos, p_176339_3_)) {
-          return true;
-       } else if (iblockstate.func_177230_c() == Blocks.field_196633_cV && iblockstate.func_177229_b(BlockRedstoneDiode.field_196348_c) && iblockstate.func_177229_b(BlockRedstoneDiode.field_185512_D) == p_176339_3_) {
-          return true;
-       } else {
--         return !flag && func_176340_e(p_176339_1_, blockpos.func_177977_b());
-+         return !flag && canConnectTo(p_176339_1_.func_180495_p(blockpos.func_177977_b()), p_176339_1_, blockpos.func_177977_b(), null);
-       }
-    }
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        return p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_185896_q() || p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_177230_c() == Blocks.field_150426_aN;
++        IBlockState downState = p_176196_1_.func_180495_p(p_176196_2_.func_177977_b());
++        return downState.func_185896_q() || downState.func_193401_d(p_176196_1_, p_176196_2_.func_177977_b(), EnumFacing.UP) == BlockFaceShape.SOLID || p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_177230_c() == Blocks.field_150426_aN;
+     }
  
--   protected static boolean func_176340_e(IBlockReader p_176340_0_, BlockPos p_176340_1_) {
--      return func_176346_d(p_176340_0_.func_180495_p(p_176340_1_));
--   }
+     private IBlockState func_176338_e(World p_176338_1_, BlockPos p_176338_2_, IBlockState p_176338_3_)
+@@ -414,7 +415,7 @@
+         {
+             return true;
+         }
+-        else if (func_176343_a(iblockstate, p_176339_3_))
++        else if (canConnectTo(iblockstate, p_176339_3_, p_176339_1_, p_176339_2_))
+         {
+             return true;
+         }
+@@ -430,16 +431,11 @@
+ 
+     protected static boolean func_176340_e(IBlockAccess p_176340_0_, BlockPos p_176340_1_)
+     {
+-        return func_176346_d(p_176340_0_.func_180495_p(p_176340_1_));
++        return canConnectTo(p_176340_0_.func_180495_p(p_176340_1_), null, p_176340_0_, p_176340_1_);
+     }
+ 
+-    protected static boolean func_176346_d(IBlockState p_176346_0_)
++    protected static boolean canConnectTo(IBlockState p_176343_0_, @Nullable EnumFacing p_176343_1_, IBlockAccess world, BlockPos pos)
+     {
+-        return func_176343_a(p_176346_0_, (EnumFacing)null);
+-    }
 -
--   protected static boolean func_176346_d(IBlockState p_176346_0_) {
--      return func_176343_a(p_176346_0_, (EnumFacing)null);
--   }
--
--   protected static boolean func_176343_a(IBlockState p_176343_0_, @Nullable EnumFacing p_176343_1_) {
-+   protected boolean canConnectTo(IBlockState p_176343_0_, IBlockReader world, BlockPos pos, @Nullable EnumFacing p_176343_1_) {
-       Block block = p_176343_0_.func_177230_c();
-       if (block == Blocks.field_150488_af) {
-          return true;
-@@ -367,7 +359,7 @@
-       } else if (Blocks.field_190976_dk == p_176343_0_.func_177230_c()) {
-          return p_176343_1_ == p_176343_0_.func_177229_b(BlockObserver.field_176387_N);
-       } else {
--         return p_176343_0_.func_185897_m() && p_176343_1_ != null;
-+         return p_176343_0_.canConnectRedstone(world, pos, p_176343_1_) && p_176343_1_ != null;
-       }
-    }
+-    protected static boolean func_176343_a(IBlockState p_176343_0_, @Nullable EnumFacing p_176343_1_)
+-    {
+         Block block = p_176343_0_.func_177230_c();
+ 
+         if (block == Blocks.field_150488_af)
+@@ -457,7 +453,7 @@
+         }
+         else
+         {
+-            return p_176343_0_.func_185897_m() && p_176343_1_ != null;
++            return p_176343_0_.func_177230_c().canConnectRedstone(p_176343_0_, world, pos, p_176343_1_);
+         }
+     }
  

patches/minecraft/net/minecraft/block/BlockReed.java.patch

@@ -1,52 +1,58 @@
---- a/net/minecraft/block/BlockReed.java
-+++ b/net/minecraft/block/BlockReed.java
-@@ -18,7 +18,7 @@
- import net.minecraft.world.IWorldReaderBase;
- import net.minecraft.world.World;
+--- ../src-base/minecraft/net/minecraft/block/BlockReed.java
++++ ../src-work/minecraft/net/minecraft/block/BlockReed.java
+@@ -21,7 +21,7 @@
+ import net.minecraftforge.fml.relauncher.Side;
+ import net.minecraftforge.fml.relauncher.SideOnly;
  
--public class BlockReed extends Block {
-+public class BlockReed extends Block implements net.minecraftforge.common.IPlantable {
-    public static final IntegerProperty field_176355_a = BlockStateProperties.field_208171_X;
-    protected static final VoxelShape field_196503_b = Block.func_208617_a(2.0D, 0.0D, 2.0D, 14.0D, 16.0D, 14.0D);
+-public class BlockReed extends Block
++public class BlockReed extends Block implements net.minecraftforge.common.IPlantable
+ {
+     public static final PropertyInteger field_176355_a = PropertyInteger.func_177719_a("age", 0, 15);
+     protected static final AxisAlignedBB field_185701_b = new AxisAlignedBB(0.125D, 0.0D, 0.125D, 0.875D, 1.0D, 0.875D);
+@@ -55,6 +55,8 @@
+                 {
+                     int j = ((Integer)p_180650_3_.func_177229_b(field_176355_a)).intValue();
  
-@@ -40,12 +40,15 @@
- 
-          if (i < 3) {
-             int j = p_196267_1_.func_177229_b(field_176355_a);
-+            if (net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_196267_2_, p_196267_3_, p_196267_1_, true)) {
-             if (j == 15) {
-                p_196267_2_.func_175656_a(p_196267_3_.func_177984_a(), this.func_176223_P());
-                p_196267_2_.func_180501_a(p_196267_3_, p_196267_1_.func_206870_a(field_176355_a, Integer.valueOf(0)), 4);
-             } else {
-                p_196267_2_.func_180501_a(p_196267_3_, p_196267_1_.func_206870_a(field_176355_a, Integer.valueOf(j + 1)), 4);
++                    if(net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_180650_1_, p_180650_2_, p_180650_3_, true))
++                    {
+                     if (j == 15)
+                     {
+                         p_180650_1_.func_175656_a(p_180650_2_.func_177984_a(), this.func_176223_P());
+@@ -64,6 +66,8 @@
+                     {
+                         p_180650_1_.func_180501_a(p_180650_2_, p_180650_3_.func_177226_a(field_176355_a, Integer.valueOf(j + 1)), 4);
+                     }
++                    net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_1_.func_180495_p(p_180650_2_));
++                    }
+                 }
              }
-+            net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_196267_2_, p_196267_3_, p_196267_1_);
-+            }
-          }
-       }
+         }
+@@ -71,7 +75,9 @@
  
-@@ -56,6 +59,9 @@
-    }
+     public boolean func_176196_c(World p_176196_1_, BlockPos p_176196_2_)
+     {
+-        Block block = p_176196_1_.func_180495_p(p_176196_2_.func_177977_b()).func_177230_c();
++        IBlockState state = p_176196_1_.func_180495_p(p_176196_2_.func_177977_b());
++        Block block = state.func_177230_c();
++        if (block.canSustainPlant(state, p_176196_1_, p_176196_2_.func_177977_b(), EnumFacing.UP, this)) return true;
  
-    public boolean func_196260_a(IBlockState p_196260_1_, IWorldReaderBase p_196260_2_, BlockPos p_196260_3_) {
-+      IBlockState soil = p_196260_2_.func_180495_p(p_196260_3_.func_177977_b());
-+      if (soil.canSustainPlant(p_196260_2_, p_196260_3_.func_177977_b(), EnumFacing.UP, this)) return true;
+         if (block == this)
+         {
+@@ -165,6 +171,17 @@
+         return ((Integer)p_176201_1_.func_177229_b(field_176355_a)).intValue();
+     }
+ 
++    @Override
++    public net.minecraftforge.common.EnumPlantType getPlantType(IBlockAccess world, BlockPos pos)
++    {
++        return net.minecraftforge.common.EnumPlantType.Beach;
++    }
++    @Override
++    public IBlockState getPlant(IBlockAccess world, BlockPos pos)
++    {
++        return this.func_176223_P();
++    }
 +
-       Block block = p_196260_2_.func_180495_p(p_196260_3_.func_177977_b()).func_177230_c();
-       if (block == this) {
-          return true;
-@@ -91,4 +97,14 @@
-    public BlockFaceShape func_193383_a(IBlockReader p_193383_1_, IBlockState p_193383_2_, BlockPos p_193383_3_, EnumFacing p_193383_4_) {
-       return BlockFaceShape.UNDEFINED;
-    }
-+
-+   @Override
-+   public net.minecraftforge.common.EnumPlantType getPlantType(IBlockReader world, BlockPos pos) {
-+       return net.minecraftforge.common.EnumPlantType.Beach;
-+   }
-+
-+   @Override
-+   public IBlockState getPlant(IBlockReader world, BlockPos pos) {
-+      return func_176223_P();
-+   }
- }
+     protected BlockStateContainer func_180661_e()
+     {
+         return new BlockStateContainer(this, new IProperty[] {field_176355_a});

patches/minecraft/net/minecraft/block/BlockRotatedPillar.java.patch

@@ -0,0 +1,24 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockRotatedPillar.java
++++ ../src-work/minecraft/net/minecraft/block/BlockRotatedPillar.java
+@@ -28,6 +28,21 @@
+         super(p_i46385_1_, p_i46385_2_);
+     }
+ 
++    @Override
++    public boolean rotateBlock(net.minecraft.world.World world, BlockPos pos, EnumFacing axis)
++    {
++        net.minecraft.block.state.IBlockState state = world.func_180495_p(pos);
++        for (net.minecraft.block.properties.IProperty<?> prop : state.func_177228_b().keySet())
++        {
++            if (prop.func_177701_a().equals("axis"))
++            {
++                world.func_175656_a(pos, state.func_177231_a(prop));
++                return true;
++            }
++        }
++        return false;
++    }
++
+     public IBlockState func_185499_a(IBlockState p_185499_1_, Rotation p_185499_2_)
+     {
+         switch (p_185499_2_)

patches/minecraft/net/minecraft/block/BlockSapling.java.patch

@@ -1,18 +1,18 @@
---- a/net/minecraft/block/BlockSapling.java
-+++ b/net/minecraft/block/BlockSapling.java
-@@ -29,6 +29,7 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockSapling.java
++++ ../src-work/minecraft/net/minecraft/block/BlockSapling.java
+@@ -53,6 +53,7 @@
+         {
+             super.func_180650_b(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_);
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-       super.func_196267_b(p_196267_1_, p_196267_2_, p_196267_3_, p_196267_4_);
-+      if (!p_196267_2_.func_205050_e(p_196267_3_, 1)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light
-       if (p_196267_2_.func_201696_r(p_196267_3_.func_177984_a()) >= 9 && p_196267_4_.nextInt(7) == 0) {
-          this.func_176478_d(p_196267_2_, p_196267_3_, p_196267_1_, p_196267_4_);
-       }
-@@ -39,6 +40,7 @@
-       if (p_176478_3_.func_177229_b(field_176479_b) == 0) {
-          p_176478_1_.func_180501_a(p_176478_2_, p_176478_3_.func_177231_a(field_176479_b), 4);
-       } else {
-+         if (!net.minecraftforge.event.ForgeEventFactory.saplingGrowTree(p_176478_1_, p_176478_4_, p_176478_2_)) return;
-          this.field_196387_c.func_196935_a(p_176478_1_, p_176478_2_, p_176478_3_, p_176478_4_);
-       }
++            if (!p_180650_1_.func_175697_a(p_180650_2_, 1)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light
+             if (p_180650_1_.func_175671_l(p_180650_2_.func_177984_a()) >= 9 && p_180650_4_.nextInt(7) == 0)
+             {
+                 this.func_176478_d(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_);
+@@ -74,6 +75,7 @@
  
+     public void func_176476_e(World p_176476_1_, BlockPos p_176476_2_, IBlockState p_176476_3_, Random p_176476_4_)
+     {
++        if (!net.minecraftforge.event.terraingen.TerrainGen.saplingGrowTree(p_176476_1_, p_176476_4_, p_176476_2_)) return;
+         WorldGenerator worldgenerator = (WorldGenerator)(p_176476_4_.nextInt(10) == 0 ? new WorldGenBigTree(true) : new WorldGenTrees(true));
+         int i = 0;
+         int j = 0;

patches/minecraft/net/minecraft/block/BlockShearableDoublePlant.java.patch

@@ -1,38 +0,0 @@
---- a/net/minecraft/block/BlockShearableDoublePlant.java
-+++ b/net/minecraft/block/BlockShearableDoublePlant.java
-@@ -11,7 +11,7 @@
- import net.minecraft.util.math.BlockPos;
- import net.minecraft.world.World;
- 
--public class BlockShearableDoublePlant extends BlockDoublePlant {
-+public class BlockShearableDoublePlant extends BlockDoublePlant implements net.minecraftforge.common.IShearable {
-    public static final EnumProperty<DoubleBlockHalf> field_208063_b = BlockDoublePlant.field_176492_b;
-    private final Block field_196392_b;
- 
-@@ -26,9 +26,7 @@
-    }
- 
-    protected void func_196391_a(IBlockState p_196391_1_, World p_196391_2_, BlockPos p_196391_3_, ItemStack p_196391_4_) {
--      if (p_196391_4_.func_77973_b() == Items.field_151097_aZ) {
--         func_180635_a(p_196391_2_, p_196391_3_, new ItemStack(this.field_196392_b, 2));
--      } else {
-+      {
-          super.func_196391_a(p_196391_1_, p_196391_2_, p_196391_3_, p_196391_4_);
-       }
- 
-@@ -37,4 +35,15 @@
-    public IItemProvider func_199769_a(IBlockState p_199769_1_, World p_199769_2_, BlockPos p_199769_3_, int p_199769_4_) {
-       return p_199769_1_.func_177229_b(field_208063_b) == DoubleBlockHalf.LOWER && this == Blocks.field_196804_gh && p_199769_2_.field_73012_v.nextInt(8) == 0 ? Items.field_151014_N : Items.field_190931_a;
-    }
-+
-+   @Override
-+   public boolean isShearable(ItemStack item, net.minecraft.world.IWorldReader world, BlockPos pos) {
-+      return false;
-+   }
-+
-+   @Override
-+   public java.util.List<ItemStack> onSheared(ItemStack item, net.minecraft.world.IWorld world, BlockPos pos, int fortune) {
-+      world.func_180501_a(pos, Blocks.field_150350_a.func_176223_P(), 11);
-+      return java.util.Arrays.asList(new ItemStack(this.field_196392_b, 2));
-+   }
- }

patches/minecraft/net/minecraft/block/BlockSkull.java.patch

@@ -0,0 +1,54 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockSkull.java
++++ ../src-work/minecraft/net/minecraft/block/BlockSkull.java
+@@ -128,10 +128,6 @@
+         return new ItemStack(Items.field_151144_bL, 1, i);
+     }
+ 
+-    public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+-    {
+-    }
+-
+     public void func_176208_a(World p_176208_1_, BlockPos p_176208_2_, IBlockState p_176208_3_, EntityPlayer p_176208_4_)
+     {
+         if (p_176208_4_.field_71075_bZ.field_75098_d)
+@@ -139,13 +135,17 @@
+             p_176208_3_ = p_176208_3_.func_177226_a(field_176417_b, Boolean.valueOf(true));
+             p_176208_1_.func_180501_a(p_176208_2_, p_176208_3_, 4);
+         }
++        this.func_176226_b(p_176208_1_, p_176208_2_, p_176208_3_, 0);
+ 
+         super.func_176208_a(p_176208_1_, p_176208_2_, p_176208_3_, p_176208_4_);
+     }
+ 
+     public void func_180663_b(World p_180663_1_, BlockPos p_180663_2_, IBlockState p_180663_3_)
+     {
+-        if (!p_180663_1_.field_72995_K)
++        super.func_180663_b(p_180663_1_, p_180663_2_, p_180663_3_);
++    }
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, IBlockAccess p_180663_1_, BlockPos p_180663_2_, IBlockState p_180663_3_, int fortune)
++    {
+         {
+             if (!((Boolean)p_180663_3_.func_177229_b(field_176417_b)).booleanValue())
+             {
+@@ -154,7 +154,7 @@
+                 if (tileentity instanceof TileEntitySkull)
+                 {
+                     TileEntitySkull tileentityskull = (TileEntitySkull)tileentity;
+-                    ItemStack itemstack = this.func_185473_a(p_180663_1_, p_180663_2_, p_180663_3_);
++                    ItemStack itemstack = new ItemStack(Items.field_151144_bL, 1, tileentityskull.func_145904_a());
+ 
+                     if (tileentityskull.func_145904_a() == 3 && tileentityskull.func_152108_a() != null)
+                     {
+@@ -164,11 +164,9 @@
+                         itemstack.func_77978_p().func_74782_a("SkullOwner", nbttagcompound);
+                     }
+ 
+-                    func_180635_a(p_180663_1_, p_180663_2_, itemstack);
++                    drops.add(itemstack);
+                 }
+             }
+-
+-            super.func_180663_b(p_180663_1_, p_180663_2_, p_180663_3_);
+         }
+     }
+ 

patches/minecraft/net/minecraft/block/BlockSnow.java.patch

@@ -0,0 +1,55 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockSnow.java
++++ ../src-work/minecraft/net/minecraft/block/BlockSnow.java
+@@ -85,7 +85,7 @@
+         if (block != Blocks.field_150432_aD && block != Blocks.field_150403_cj && block != Blocks.field_180401_cv)
+         {
+             BlockFaceShape blockfaceshape = iblockstate.func_193401_d(p_176196_1_, p_176196_2_.func_177977_b(), EnumFacing.UP);
+-            return blockfaceshape == BlockFaceShape.SOLID || iblockstate.func_185904_a() == Material.field_151584_j || block == this && ((Integer)iblockstate.func_177229_b(field_176315_a)).intValue() == 8;
++            return blockfaceshape == BlockFaceShape.SOLID || iblockstate.func_177230_c().isLeaves(iblockstate, p_176196_1_, p_176196_2_.func_177977_b()) || block == this && ((Integer)iblockstate.func_177229_b(field_176315_a)).intValue() == 8;
+         }
+         else
+         {
+@@ -102,7 +102,6 @@
+     {
+         if (!this.func_176196_c(p_176314_1_, p_176314_2_))
+         {
+-            this.func_176226_b(p_176314_1_, p_176314_2_, p_176314_3_, 0);
+             p_176314_1_.func_175698_g(p_176314_2_);
+             return false;
+         }
+@@ -114,9 +113,8 @@
+ 
+     public void func_180657_a(World p_180657_1_, EntityPlayer p_180657_2_, BlockPos p_180657_3_, IBlockState p_180657_4_, @Nullable TileEntity p_180657_5_, ItemStack p_180657_6_)
+     {
+-        func_180635_a(p_180657_1_, p_180657_3_, new ItemStack(Items.field_151126_ay, ((Integer)p_180657_4_.func_177229_b(field_176315_a)).intValue() + 1, 0));
++        super.func_180657_a(p_180657_1_, p_180657_2_, p_180657_3_, p_180657_4_, p_180657_5_, p_180657_6_);
+         p_180657_1_.func_175698_g(p_180657_3_);
+-        p_180657_2_.func_71029_a(StatList.func_188055_a(this));
+     }
+ 
+     public Item func_180660_a(IBlockState p_180660_1_, Random p_180660_2_, int p_180660_3_)
+@@ -126,14 +124,13 @@
+ 
+     public int func_149745_a(Random p_149745_1_)
+     {
+-        return 0;
++        return 1;
+     }
+ 
+     public void func_180650_b(World p_180650_1_, BlockPos p_180650_2_, IBlockState p_180650_3_, Random p_180650_4_)
+     {
+         if (p_180650_1_.func_175642_b(EnumSkyBlock.BLOCK, p_180650_2_) > 11)
+         {
+-            this.func_176226_b(p_180650_1_, p_180650_2_, p_180650_1_.func_180495_p(p_180650_2_), 0);
+             p_180650_1_.func_175698_g(p_180650_2_);
+         }
+     }
+@@ -167,6 +164,8 @@
+         return ((Integer)p_176201_1_.func_177229_b(field_176315_a)).intValue() - 1;
+     }
+ 
++    @Override public int quantityDropped(IBlockState state, int fortune, Random random){ return ((Integer)state.func_177229_b(field_176315_a)) + 1; }
++
+     protected BlockStateContainer func_180661_e()
+     {
+         return new BlockStateContainer(this, new IProperty[] {field_176315_a});

patches/minecraft/net/minecraft/block/BlockSnowLayer.java.patch

@@ -1,54 +0,0 @@
---- a/net/minecraft/block/BlockSnowLayer.java
-+++ b/net/minecraft/block/BlockSnowLayer.java
-@@ -84,30 +84,45 @@
- 
-    public void func_180657_a(World p_180657_1_, EntityPlayer p_180657_2_, BlockPos p_180657_3_, IBlockState p_180657_4_, @Nullable TileEntity p_180657_5_, ItemStack p_180657_6_) {
-       Integer integer = p_180657_4_.func_177229_b(field_176315_a);
--      if (this.func_149700_E() && EnchantmentHelper.func_77506_a(Enchantments.field_185306_r, p_180657_6_) > 0) {
-+      net.minecraft.util.NonNullList<ItemStack> items = net.minecraft.util.NonNullList.func_191196_a();
-+      int fortune = EnchantmentHelper.func_77506_a(Enchantments.field_185308_t, p_180657_6_);
-+      float chance = 1.0f;
-+
-+      if (this.canSilkHarvest(p_180657_4_, p_180657_1_, p_180657_3_, p_180657_2_) && EnchantmentHelper.func_77506_a(Enchantments.field_185306_r, p_180657_6_) > 0) {
-          if (integer == 8) {
--            func_180635_a(p_180657_1_, p_180657_3_, new ItemStack(Blocks.field_196604_cC));
-+            items.add(new ItemStack(Blocks.field_196604_cC));
-          } else {
-             for(int i = 0; i < integer; ++i) {
--               func_180635_a(p_180657_1_, p_180657_3_, this.func_180643_i(p_180657_4_));
-+               items.add(this.func_180643_i(p_180657_4_));
-             }
-          }
-+         chance = net.minecraftforge.event.ForgeEventFactory.fireBlockHarvesting(items, p_180657_1_, p_180657_3_, p_180657_4_, 0, 1.0f, true, p_180657_2_);
-       } else {
--         func_180635_a(p_180657_1_, p_180657_3_, new ItemStack(Items.field_151126_ay, integer));
-+         getDrops(p_180657_4_, items, p_180657_1_, p_180657_3_, fortune);
-+         chance = net.minecraftforge.event.ForgeEventFactory.fireBlockHarvesting(items, p_180657_1_, p_180657_3_, p_180657_4_, fortune, 1.0f, false, p_180657_2_);
-       }
- 
-+      for (ItemStack item : items) {
-+         if (p_180657_1_.field_73012_v.nextFloat() <= chance)
-+            func_180635_a(p_180657_1_, p_180657_3_, item);
-+      }
-+
-       p_180657_1_.func_175698_g(p_180657_3_);
-       p_180657_2_.func_71029_a(StatList.field_188065_ae.func_199076_b(this));
-       p_180657_2_.func_71020_j(0.005F);
-    }
- 
-    public IItemProvider func_199769_a(IBlockState p_199769_1_, World p_199769_2_, BlockPos p_199769_3_, int p_199769_4_) {
--      return Items.field_190931_a;
-+      return Items.field_151126_ay;
-    }
- 
-+   @Override
-+   public int func_196264_a(IBlockState state, Random random) {
-+      return state.func_177229_b(field_176315_a) + 1;
-+   }
-+
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-       if (p_196267_2_.func_175642_b(EnumLightType.BLOCK, p_196267_3_) > 11) {
--         p_196267_1_.func_196949_c(p_196267_2_, p_196267_3_, 0);
-          p_196267_2_.func_175698_g(p_196267_3_);
-       }
- 

patches/minecraft/net/minecraft/block/BlockStem.java.patch

@@ -1,55 +1,71 @@
---- a/net/minecraft/block/BlockStem.java
-+++ b/net/minecraft/block/BlockStem.java
-@@ -39,22 +39,24 @@
+--- ../src-base/minecraft/net/minecraft/block/BlockStem.java
++++ ../src-work/minecraft/net/minecraft/block/BlockStem.java
+@@ -66,18 +66,19 @@
+     {
+         super.func_180650_b(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_);
  
-    public void func_196267_b(IBlockState p_196267_1_, World p_196267_2_, BlockPos p_196267_3_, Random p_196267_4_) {
-       super.func_196267_b(p_196267_1_, p_196267_2_, p_196267_3_, p_196267_4_);
-+      if (!p_196267_2_.func_205050_e(p_196267_3_, 1)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light
-       if (p_196267_2_.func_201669_a(p_196267_3_.func_177984_a(), 0) >= 9) {
-          float f = BlockCrops.func_180672_a(this, p_196267_2_, p_196267_3_);
--         if (p_196267_4_.nextInt((int)(25.0F / f) + 1) == 0) {
-+         if (net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_196267_2_, p_196267_3_, p_196267_1_, p_196267_4_.nextInt((int)(25.0F / f) + 1) == 0)) {
-             int i = p_196267_1_.func_177229_b(field_176484_a);
-             if (i < 7) {
--               p_196267_1_ = p_196267_1_.func_206870_a(field_176484_a, Integer.valueOf(i + 1));
--               p_196267_2_.func_180501_a(p_196267_3_, p_196267_1_, 2);
-+               p_196267_2_.func_180501_a(p_196267_3_, p_196267_1_.func_206870_a(field_176484_a, i + 1), 2);
-             } else {
-                EnumFacing enumfacing = EnumFacing.Plane.HORIZONTAL.func_179518_a(p_196267_4_);
-                BlockPos blockpos = p_196267_3_.func_177972_a(enumfacing);
--               Block block = p_196267_2_.func_180495_p(blockpos.func_177977_b()).func_177230_c();
--               if (p_196267_2_.func_180495_p(blockpos).func_196958_f() && (block == Blocks.field_150458_ak || block == Blocks.field_150346_d || block == Blocks.field_196660_k || block == Blocks.field_196661_l || block == Blocks.field_196658_i)) {
-+               IBlockState soil = p_196267_2_.func_180495_p(blockpos.func_177977_b());
-+               Block block = soil.func_177230_c();
-+               if (p_196267_2_.func_180495_p(blockpos).isAir(p_196267_2_, blockpos) && (soil.canSustainPlant(p_196267_2_, blockpos.func_177977_b(), EnumFacing.UP, this) || block == Blocks.field_150346_d || block == Blocks.field_196660_k || block == Blocks.field_196661_l || block == Blocks.field_196658_i)) {
-                   p_196267_2_.func_175656_a(blockpos, this.field_149877_a.func_176223_P());
-                   p_196267_2_.func_175656_a(p_196267_3_, this.field_149877_a.func_196523_e().func_176223_P().func_206870_a(BlockHorizontal.field_185512_D, enumfacing));
-                }
++        if (!p_180650_1_.func_175697_a(p_180650_2_, 1)) return; // Forge: prevent loading unloaded chunks when checking neighbor's light
+         if (p_180650_1_.func_175671_l(p_180650_2_.func_177984_a()) >= 9)
+         {
+             float f = BlockCrops.func_180672_a(this, p_180650_1_, p_180650_2_);
+ 
+-            if (p_180650_4_.nextInt((int)(25.0F / f) + 1) == 0)
++            if(net.minecraftforge.common.ForgeHooks.onCropsGrowPre(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_4_.nextInt((int)(25.0F / f) + 1) == 0))
+             {
+                 int i = ((Integer)p_180650_3_.func_177229_b(field_176484_a)).intValue();
+ 
+                 if (i < 7)
+                 {
+-                    p_180650_3_ = p_180650_3_.func_177226_a(field_176484_a, Integer.valueOf(i + 1));
+-                    p_180650_1_.func_180501_a(p_180650_2_, p_180650_3_, 2);
++                    IBlockState newState = p_180650_3_.func_177226_a(field_176484_a, Integer.valueOf(i + 1));
++                    p_180650_1_.func_180501_a(p_180650_2_, newState, 2);
+                 }
+                 else
+                 {
+@@ -90,13 +91,15 @@
+                     }
+ 
+                     p_180650_2_ = p_180650_2_.func_177972_a(EnumFacing.Plane.HORIZONTAL.func_179518_a(p_180650_4_));
+-                    Block block = p_180650_1_.func_180495_p(p_180650_2_.func_177977_b()).func_177230_c();
++                    IBlockState soil = p_180650_1_.func_180495_p(p_180650_2_.func_177977_b());
++                    Block block = soil.func_177230_c();
+ 
+-                    if (p_180650_1_.func_180495_p(p_180650_2_).func_177230_c().field_149764_J == Material.field_151579_a && (block == Blocks.field_150458_ak || block == Blocks.field_150346_d || block == Blocks.field_150349_c))
++                    if (p_180650_1_.func_175623_d(p_180650_2_) && (block.canSustainPlant(soil, p_180650_1_, p_180650_2_.func_177977_b(), EnumFacing.UP, this) || block == Blocks.field_150346_d || block == Blocks.field_150349_c))
+                     {
+                         p_180650_1_.func_175656_a(p_180650_2_, this.field_149877_a.func_176223_P());
+                     }
+                 }
++                net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_180650_1_, p_180650_2_, p_180650_3_, p_180650_1_.func_180495_p(p_180650_2_));
              }
-+            net.minecraftforge.common.ForgeHooks.onCropsGrowPost(p_196267_2_, p_196267_3_, p_196267_1_);
-          }
+         }
+     }
+@@ -110,20 +113,23 @@
+     public void func_180653_a(World p_180653_1_, BlockPos p_180653_2_, IBlockState p_180653_3_, float p_180653_4_, int p_180653_5_)
+     {
+         super.func_180653_a(p_180653_1_, p_180653_2_, p_180653_3_, p_180653_4_, p_180653_5_);
++    }
  
-       }
-@@ -62,14 +64,18 @@
+-        if (!p_180653_1_.field_72995_K)
++    @Override
++    public void getDrops(net.minecraft.util.NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune)
++    {
+         {
+             Item item = this.func_176481_j();
  
-    public void func_196255_a(IBlockState p_196255_1_, World p_196255_2_, BlockPos p_196255_3_, float p_196255_4_, int p_196255_5_) {
-       super.func_196255_a(p_196255_1_, p_196255_2_, p_196255_3_, p_196255_4_, p_196255_5_);
--      if (!p_196255_2_.field_72995_K) {
-+   }
-+
-+   @Override
-+   public void getDrops(IBlockState state, net.minecraft.util.NonNullList<ItemStack> drops, World world, BlockPos pos, int fortune) {
-+      {
-          Item item = this.func_176481_j();
-          if (item != null) {
--            int i = p_196255_1_.func_177229_b(field_176484_a);
-+            int i = state.func_177229_b(field_176484_a);
+             if (item != null)
+             {
+-                int i = ((Integer)p_180653_3_.func_177229_b(field_176484_a)).intValue();
++                int i = ((Integer)state.func_177229_b(field_176484_a)).intValue();
  
-             for(int j = 0; j < 3; ++j) {
--               if (p_196255_2_.field_73012_v.nextInt(15) <= i) {
--                  func_180635_a(p_196255_2_, p_196255_3_, new ItemStack(item));
-+               if (world.field_73012_v.nextInt(15) <= i) {
-+                  drops.add(new ItemStack(item));
-                }
+                 for (int j = 0; j < 3; ++j)
+                 {
+-                    if (p_180653_1_.field_73012_v.nextInt(15) <= i)
++                    if (RANDOM.nextInt(15) <= i)
+                     {
+-                        func_180635_a(p_180653_1_, p_180653_2_, new ItemStack(item));
++                        drops.add(new ItemStack(item));
+                     }
+                 }
              }
-