Merge pull request #9 from DrParadox7/patch-1

ExtraTrees' Butterfly crashing on Escritoire

.github/scripts/test-no-crash-reports.sh

@@ -0,0 +1,9 @@
+directory="run/crash-reports"
+if [ -d $directory ]; then
+  echo "Crash reports detected:"
+  cat $directory/*
+  exit 1
+else
+  echo "No crash reports detected"
+  exit 0
+fi

.github/workflows/build-and-test.yml

@@ -0,0 +1,45 @@
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Build and test
+
+on:
+  pull_request:
+    branches: [ master, main ]
+  push:
+    branches: [ master, main ]
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with: 
+        fetch-depth: 0
+    
+    - name: Set up JDK 8
+      uses: actions/setup-java@v2
+      with:
+        java-version: '8'
+        distribution: 'adopt'
+        cache: gradle
+        
+    - name: Grant execute permission for gradlew
+      run: chmod +x gradlew
+
+    - name: Setup the workspace
+      run: ./gradlew setupCIWorkspace
+    
+    - name: Build the mod
+      run: ./gradlew build
+
+    - name: Run server for 1 minute
+      run: |
+        mkdir run
+        echo "eula=true" > run/eula.txt  
+        timeout 60 ./gradlew runServer || true
+
+    - name: Test no crashes happend
+      run: |
+        chmod +x .github/scripts/test-no-crash-reports.sh
+        .github/scripts/test-no-crash-reports.sh

.github/workflows/release-tags.yml

@@ -0,0 +1,45 @@
+# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
+
+name: Release tagged build
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set release version
+        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+
+      - name: Set up JDK 8
+        uses: actions/setup-java@v2
+        with:
+          java-version: '8'
+          distribution: 'adopt'
+          cache: gradle
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      - name: Setup the workspace
+        run: ./gradlew setupCIWorkspace
+
+      - name: Build the mod
+        run: ./gradlew build
+
+      - name: Release under current tag
+        uses: "marvinpinto/action-automatic-releases@latest"
+        with:
+          repo_token: "${{ secrets.GITHUB_TOKEN }}"
+          automatic_release_tag: "${{ env.RELEASE_VERSION }}"
+          prerelease: false
+          title: "${{ env.RELEASE_VERSION }}"
+          files: build/libs/*.jar

.gitignore

@@ -1,28 +1,29 @@
-# everything
-/*
-
 .gradle
-# IntelliJ
-/build
-/run
-/out
-.idea
+.settings
+/.idea/
+/run/
+/build/
+/eclipse/
+.classpath
+.project
+/bin/
+/config/
+/crash-reports/
+/logs/
+options.txt
+/saves/
+usernamecache.json
+banned-ips.json
+banned-players.json
+eula.txt
+ops.json
+server.properties
+servers.dat
+usercache.json
+whitelist.json
+/out/
 *.iml
 *.ipr
 *.iws
-classes/
-
-
-# folders
-!/gradle/wrapper
-!/src
-
-# files
-!/.gitignore
-!/LICENSE.txt
-!/license-header.txt
-!/README.md
-!/gradle.properties
-!/build.gradle
-!/gradlew
-!/gradlew.bat
+src/main/resources/mixins.*.json
+*.bat

.travis.yml

@@ -1,24 +0,0 @@
-sudo: required
-dist: trusty
-
-language: java
-jdk: oraclejdk8
-
-before_cache:
-  - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
-  - rm -fr $HOME/.gradle/caches/*/plugin-resolution/
-  - rm -f  $HOME/.gradle/caches/minecraft/deobfedDeps/providedDummy.jar
-  - rm -f  $HOME/.gradle/caches/minecraft/deobfedDeps/compileDummy.jar
-cache:
-  directories:
-    - $HOME/.gradle/caches/
-    - $HOME/.gradle/wrapper/
-
-before_install: chmod +x gradlew
-install:
-  - ./gradlew setupCIWorkspace -S
-script:
-  - ./gradlew build
-
-notifications:
-  email: false

README.md

@@ -1,4 +1,46 @@
-## Binnie mods
+[Binnie mods](https://minecraft.curseforge.com/projects/binnies-mods/files)
+====================================
+
+### What is it?
+Binnie’s Mods is a suite of mods designed to expand the [Forestry](https://github.com/ForestryMC/ForestryMC) mod. 
+It both extends the bee and tree breeding aspect by adding many new species with varied products,
+along with new features such as fully breedable flowers and genetic manipulation.
+
+### Homepage
+
+[Wiki](https://binnie.mods.wiki/wiki/Main_Page)
+
+[Latest Builds for 1.7.10](https://ci.bymarcin.com/job/Binnie-Mods-MC1.7.10/)
+
+### Mods
+
+[![](https://binnie.mods.wiki/w/images/binnie/9/91/Extra_Bees_Header.png)](https://binnie.mods.wiki/wiki/Extra_Bees)
+
+Extra Bees expands upon the bee breeding of Forestry by adding 107 new bee species to forestry. These bees cover a large spectrum of different effects and products, giving you the ability to produce everything from dyes to rare metal dusts purely from bees. It also adds the Apiarist Database, a tool to keep track of discovered species, mutations and traits. There are also new alveary components which help improve and streamline bee production. 
+
+
+[![](https://binnie.mods.wiki/w/images/binnie/5/59/Extra_Trees_Header.png)](https://binnie.mods.wiki/wiki/Extra_Trees)
+
+Extra Trees both increases the number of tree species and adds many new aesthetic uses. There are 96 new tree species, such as Banana, Brazil nut and Douglas-fir. This comes with many new fruits as well as 35 new wooden planks. Extra Trees allows these, as well as Forestry and vanilla planks, to be combined to give doors, gates and various designs of fences. The woodworker allows planks to be combined to give patterned tiles, allowing you to build beautiful wooden floors, and the same can be done with stained glass. A group of machines such as the brewery and distillery allow you to use the fruits you grow to make a variety of wines, ciders and spirits.
+
+
+[![](https://binnie.mods.wiki/w/images/binnie/3/34/Botany_Header.png)](https://binnie.mods.wiki/wiki/Botany)
+
+Botany adds an entirely new breeding system to Forestry: flowers. There are 46 different species that can be bred, including both vanilla flowers and new ones such as Fuschia and Lilies. The colour of the flowers can be transferred and selectively bred, meaning that each flower can be one of a possible 80 different colours. These new flowers can be bred manually in small gardens using a trowel and fertiliser, with careful care taken to maintain the desired pH or moisture, or grown on the large scale in Forestry farms. 
+
+[![](https://binnie.mods.wiki/w/images/binnie/4/4e/Genetics_Header.png)](https://binnie.mods.wiki/wiki/Genetics)
+
+Genetics is for those who want to eschew conventional breeding, and want to enter the realm of genetic manipulation. Here, genes can be isolated, sequenced and then inoculated back into different species, making it easier to obtain the perfect genome. Bees, trees, butterflies and flowers can all be manipulated in this way. They can also be acclimatised to different environments to build tolerance to hostile climates.
+
+[![](https://binnie.mods.wiki/w/images/binnie/d/d7/Binnie_Core_Header.png)](https://binnie.mods.wiki/wiki/Binnie_Core)
+
+Binnie Core is a mod which contains a lot of the core functionality such as networking and GUI's for the other mods. The only in game features it currently contains are the Compartments
+
+### Warning
+
+Removed unused (unfinished) items and blocks: Honey Crystal, Alcohol, etc.
+
+### Building
 
 The master branch will always contain the latest released version with possibly some bug fixes for that version that will eventually be released.
 New versions will be created in branched named like {mc_version}-{mod_version}

build.gradle

@@ -1,127 +1,529 @@
+//version: 928ecf7feb33a1149538b0e2cd17e3bc5f281428
+/*
+DO NOT CHANGE THIS FILE!
+
+Also, you may replace this file at any time if there is an update available.
+Please check https://github.com/SinTh0r4s/ExampleMod1.7.10/blob/main/build.gradle for updates.
+ */
+
+
+import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+import java.util.concurrent.TimeUnit
+
 buildscript {
     repositories {
-        jcenter()
         maven {
             name = "forge"
-            url = "http://files.minecraftforge.net/maven"
+            url = "https://maven.minecraftforge.net"
+        }
+        maven {
+            name = "sonatype"
+            url = "https://oss.sonatype.org/content/repositories/snapshots/"
+        }
+        maven {
+            name = "Scala CI dependencies"
+            url = "https://repo1.maven.org/maven2/"
+        }
+        maven {
+            name = "jitpack"
+            url = "https://jitpack.io"
         }
     }
     dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:2.2-SNAPSHOT'
-        classpath "gradle.plugin.se.bjurr.gitchangelog:git-changelog-gradle-plugin:1.47"
+        classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.4'
     }
 }
 
 plugins {
-    id "com.matthewprenger.cursegradle" version "1.0.9"
+    id 'idea'
+    id 'scala'
+    id("org.ajoberstar.grgit") version("3.1.1")
+    id("com.github.johnrengelman.shadow") version("4.0.4")
+    id("com.palantir.git-version") version("0.12.3")
 }
 
-apply plugin: 'net.minecraftforge.gradle.forge'
-apply plugin: 'idea'
-apply plugin: 'maven'
-apply plugin: "se.bjurr.gitchangelog.git-changelog-gradle-plugin"
+apply plugin: 'forge'
 
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
+def projectJavaVersion = JavaLanguageVersion.of(8)
 
-version = version_major + '.' + version_minor + '.' + version_patch
-if (System.getenv("BUILD_NUMBER") != null) {
-    version = version + "-" + System.getenv("BUILD_NUMBER")
+java {
+    toolchain {
+        languageVersion.set(projectJavaVersion)
+    }
+}
+
+idea {
+    module {
+        inheritOutputDirs = true
+        downloadJavadoc = true
+        downloadSources = true
+    }
+}
+
+if(JavaVersion.current() != JavaVersion.VERSION_1_8) {
+    throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current())
+}
+
+checkPropertyExists("modName")
+checkPropertyExists("modId")
+checkPropertyExists("modGroup")
+checkPropertyExists("autoUpdateBuildScript")
+checkPropertyExists("minecraftVersion")
+checkPropertyExists("forgeVersion")
+checkPropertyExists("replaceGradleTokenInFile")
+checkPropertyExists("gradleTokenModId")
+checkPropertyExists("gradleTokenModName")
+checkPropertyExists("gradleTokenVersion")
+checkPropertyExists("gradleTokenGroupName")
+checkPropertyExists("apiPackage")
+checkPropertyExists("accessTransformersFile")
+checkPropertyExists("usesMixins")
+checkPropertyExists("mixinPlugin")
+checkPropertyExists("mixinsPackage")
+checkPropertyExists("coreModClass")
+checkPropertyExists("containsMixinsAndOrCoreModOnly")
+checkPropertyExists("usesShadowedDependencies")
+checkPropertyExists("developmentEnvironmentUserName")
+
+
+String javaSourceDir = "src/main/java/"
+String scalaSourceDir = "src/main/scala/"
+
+String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/")
+String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/")
+if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
+    throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
+}
+
+if(apiPackage) {
+    targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
+    targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
+    if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
+        throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
+    }
+}
+
+if(accessTransformersFile) {
+    String targetFile = "src/main/resources/META-INF/" + accessTransformersFile
+    if(getFile(targetFile).exists() == false) {
+        throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile)
+    }
+}
+
+if(usesMixins.toBoolean()) {
+    if(mixinsPackage.isEmpty() || mixinPlugin.isEmpty()) {
+        throw new GradleException("\"mixinPlugin\" requires \"mixinsPackage\" and \"mixinPlugin\" to be set!")
+    }
+
+    targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
+    targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
+    if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
+        throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
+    }
+
+    String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
+    String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".scala"
+    String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
+    if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
+        throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
+    }
+}
+
+if(coreModClass) {
+    String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
+    String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".scala"
+    String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
+    if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
+        throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
+    }
+}
+
+configurations.all {
+    resolutionStrategy.cacheChangingModulesFor(0, TimeUnit.SECONDS)
+
+    // Make sure GregTech build won't time out
+    System.setProperty("org.gradle.internal.http.connectionTimeout", 120000 as String)
+    System.setProperty("org.gradle.internal.http.socketTimeout", 120000 as String)
+}
+
+// Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version
+'git config core.fileMode false'.execute()
+// Pulls version from git tag
+try {
+    version = minecraftVersion + "-" + gitVersion()
+}
+catch (Exception e) {
+    throw new IllegalStateException("This mod must be version controlled by Git AND the repository must provide at least one tag!");
+}
+
+group = modGroup
+if(project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
+    archivesBaseName = customArchiveBaseName
+}
+else {
+    archivesBaseName = modId
 }
-group = "binnie" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
-archivesBaseName = "binnie-mods-1.11.2"
 
 minecraft {
-    version = mcversion + "-" + forgeversion
-    mappings = mcp_mappings
+    version = minecraftVersion + "-" + forgeVersion + "-" + minecraftVersion
     runDir = "run"
+
+    if (replaceGradleTokenInFile) {
+        replaceIn replaceGradleTokenInFile
+        if(gradleTokenModId) {
+            replace gradleTokenModId, modId
+        }
+        if(gradleTokenModName) {
+            replace gradleTokenModName, modName
+        }
+        if(gradleTokenVersion) {
+            replace gradleTokenVersion, versionDetails().lastTag
+        }
+        if(gradleTokenGroupName) {
+            replace gradleTokenGroupName, modGroup
+        }
+    }
+}
+
+if(file("addon.gradle").exists()) {
+    apply from: "addon.gradle"
+}
+
+apply from: 'repositories.gradle'
+
+configurations {
+    implementation.extendsFrom(shadowImplementation)
 }
 
 repositories {
     maven {
-        name = "jei"
-        url "http://dvs1.progwml6.com/files/maven"
+        name = "Overmind forge repo mirror"
+        url = "https://gregtech.overminddl1.com/"
     }
-    maven {
-        name = "ic2, forestry"
-        url = "http://maven.ic2.player.to/"
-    }
-    maven {
-        name = "CurseForge"
-        url = "https://minecraft.curseforge.com/api/maven/"
+    if(usesMixins.toBoolean()) {
+        maven {
+            name = "sponge"
+            url = "https://repo.spongepowered.org/repository/maven-public"
+        }
+        maven {
+            url = "https://jitpack.io"
+        }
     }
 }
 
 dependencies {
-    deobfCompile("net.sengir.forestry:forestry_${mcversion}:${forestry_version}") {
-        transitive = false;
-    }
-    deobfProvided "mezz.jei:jei_${mcversion}:${jei_version}:api"
-    runtime "mezz.jei:jei_${mcversion}:${jei_version}"
-    runtime "jei-bees:jeibees:${jeibees_version}:mc${mcversion}"
-    deobfProvided "net.industrial-craft:industrialcraft-2:${ic2_version}:api"
-    runtime "net.industrial-craft:industrialcraft-2:${ic2_version}"
-}
-
-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'
-        expand 'version': project.version,
-                'mcversion': project.minecraft.version,
-                'modid': "binniemods"
-    }
-
-    // copy everything else, thats not the mcmod.info
-    from(sourceSets.main.resources.srcDirs) {
-        exclude 'mcmod.info'
-    }
-}
-
-// prevent java 8's strict doclint for javadocs from failing builds
-allprojects {
-    tasks.withType(Javadoc) {
-        options.addStringOption('Xdoclint:none', '-quiet')
-    }
-}
-
-uploadArchives {
-    repositories {
-        if (project.hasProperty('mavenDir')) {
-            mavenDeployer {
-                repository(url: "file://" + mavenDir)
-            }
-        } else {
-            println 'Archives upload disabled, mavenDir in gradle.properties is missing.'
+    if(usesMixins.toBoolean()) {
+        annotationProcessor("org.ow2.asm:asm-debug-all:5.0.3")
+        annotationProcessor("com.google.guava:guava:24.1.1-jre")
+        annotationProcessor("com.google.code.gson:gson:2.8.6")
+        annotationProcessor("org.spongepowered:mixin:0.8-SNAPSHOT")
+        // using 0.8 to workaround a issue in 0.7 which fails mixin application
+        compile("org.spongepowered:mixin:0.7.11-SNAPSHOT") {
+            // Mixin includes a lot of dependencies that are too up-to-date
+            exclude module: "launchwrapper"
+            exclude module: "guava"
+            exclude module: "gson"
+            exclude module: "commons-io"
+            exclude module: "log4j-core"
         }
+        compile("com.github.GTNewHorizons:SpongeMixins:1.3.3:dev")
     }
 }
 
-task makeChangelog(type: se.bjurr.gitchangelog.plugin.gradle.GitChangelogTask) {
-    filePath = "changelog.html"
-    untaggedName = "Current release ${project.version}"
-    fromCommit = "dbc5c1a564c39e4a9c042411d1bdbe450985ce2c"
-    toRef =  "HEAD"
-    templateContent = file('changelog.mustache').getText('UTF-8')
+apply from: 'dependencies.gradle'
+
+def mixingConfigRefMap = "mixins." + modId + ".refmap.json"
+def refMap = "${tasks.compileJava.temporaryDir}" + File.separator + mixingConfigRefMap
+def mixinSrg = "${tasks.reobf.temporaryDir}" + File.separator + "mixins.srg"
+
+task generateAssets {
+    if(usesMixins.toBoolean()) {
+        getFile("/src/main/resources/mixins." + modId + ".json").text = """{
+  "required": true,
+  "minVersion": "0.7.11",
+  "package": "${modGroup}.${mixinsPackage}",
+  "plugin": "${modGroup}.${mixinPlugin}",
+  "refmap": "${mixingConfigRefMap}",
+  "target": "@env(DEFAULT)",
+  "compatibilityLevel": "JAVA_8"
 }
 
-curseforge {
-    apiKey = project.hasProperty('curseforge_apikey') ? project.curseforge_apikey : '0'
-    project {
-        id = curse_project_id
-        changelog = file('changelog.html')
-        changelogType = 'html'
-        releaseType = 'alpha'
-        relations {
-            requiredLibrary 'forestry'
-        }
+"""
+    }
+}
+
+task relocateShadowJar(type: ConfigureShadowRelocation) {
+    target = tasks.shadowJar
+    prefix = modGroup + ".shadow"
+}
+
+shadowJar {
+    manifest {
+        attributes(getManifestAttributes())
+    }
+
+    minimize()  // This will only allow shading for actually used classes
+    configurations = [project.configurations.shadowImplementation]
+    dependsOn(relocateShadowJar)
+}
+
+jar {
+    manifest {
+        attributes(getManifestAttributes())
+    }
+
+    if(usesShadowedDependencies.toBoolean()) {
+        dependsOn(shadowJar)
+        enabled = false
+    }
+}
+
+reobf {
+    if(usesMixins.toBoolean()) {
+        addExtraSrgFile mixinSrg
     }
 }
 
 afterEvaluate {
-    tasks.curseforge223525.dependsOn.add(makeChangelog)
+    if(usesMixins.toBoolean()) {
+        tasks.compileJava {
+            options.compilerArgs += [
+                    "-AreobfSrgFile=${tasks.reobf.srg}",
+                    "-AoutSrgFile=${mixinSrg}",
+                    "-AoutRefMapFile=${refMap}",
+                    // Elan: from what I understand they are just some linter configs so you get some warning on how to properly code
+                    "-XDenableSunApiLintControl",
+                    "-XDignore.symbol.file"
+            ]
+        }
+    }
+}
+
+runClient {
+    def arguments = []
+
+    if(usesMixins.toBoolean()) {
+        arguments += [
+                "--mods=../build/libs/$modId-${version}.jar",
+                "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
+        ]
+    }
+
+    if(developmentEnvironmentUserName) {
+        arguments += [
+                "--username",
+                developmentEnvironmentUserName
+        ]
+    }
+
+    args(arguments)
+}
+
+runServer {
+    def arguments = []
+
+    if (usesMixins.toBoolean()) {
+        arguments += [
+                "--mods=../build/libs/$modId-${version}.jar",
+                "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
+        ]
+    }
+
+    args(arguments)
+}
+
+tasks.withType(JavaExec).configureEach {
+    javaLauncher.set(
+            javaToolchains.launcherFor {
+                languageVersion = projectJavaVersion
+            }
+    )
+}
+
+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 "minecraftVersion": project.minecraft.version,
+                        "modVersion": versionDetails().lastTag,
+                        "modId": modId,
+                        "modName": modName
+            }
+
+            if(usesMixins.toBoolean()) {
+                from refMap
+            }
+
+            // copy everything else, thats not the mcmod.info
+            from(sourceSets.main.resources.srcDirs) {
+                exclude 'mcmod.info'
+            }
+        }
+
+def getManifestAttributes() {
+    def manifestAttributes = [:]
+    if(containsMixinsAndOrCoreModOnly.toBoolean() == false && (usesMixins.toBoolean() || coreModClass)) {
+        manifestAttributes += ["FMLCorePluginContainsFMLMod": true]
+    }
+
+    if(accessTransformersFile) {
+        manifestAttributes += ["FMLAT" : accessTransformersFile.toString()]
+    }
+
+    if(coreModClass) {
+        manifestAttributes += ["FMLCorePlugin": modGroup + "." + coreModClass]
+    }
+
+    if(usesMixins.toBoolean()) {
+        manifestAttributes += [
+                "TweakClass" : "org.spongepowered.asm.launch.MixinTweaker",
+                "MixinConfigs" : "mixins." + modId + ".json",
+                "ForceLoadAsMod" : containsMixinsAndOrCoreModOnly.toBoolean() == false
+        ]
+    }
+    return manifestAttributes
+}
+
+task sourcesJar(type: Jar) {
+    from (sourceSets.main.allJava)
+    from (file("$projectDir/LICENSE"))
+    getArchiveClassifier().set('sources')
+}
+
+task shadowDevJar(type: ShadowJar) {
+    from sourceSets.main.output
+    getArchiveClassifier().set("dev")
+
+    manifest {
+        attributes(getManifestAttributes())
+    }
+
+    minimize()  // This will only allow shading for actually used classes
+    configurations = [project.configurations.shadowImplementation]
+}
+
+task relocateShadowDevJar(type: ConfigureShadowRelocation) {
+    target = tasks.shadowDevJar
+    prefix = modGroup + ".shadow"
+}
+
+task circularResolverJar(type: Jar) {
+    dependsOn(relocateShadowDevJar)
+    dependsOn(shadowDevJar)
+    enabled = false
+}
+
+task devJar(type: Jar) {
+    from sourceSets.main.output
+    getArchiveClassifier().set("dev")
+
+    manifest {
+        attributes(getManifestAttributes())
+    }
+
+    if(usesShadowedDependencies.toBoolean()) {
+        dependsOn(circularResolverJar)
+        enabled = false
+    }
+}
+
+task apiJar(type: Jar) {
+    from (sourceSets.main.allJava) {
+        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
+    }
+
+    from (sourceSets.main.output) {
+        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
+    }
+
+    from (sourceSets.main.resources.srcDirs) {
+        include("LICENSE")
+    }
+
+    getArchiveClassifier().set('api')
+}
+
+artifacts {
+    archives sourcesJar
+    archives devJar
+    if(apiPackage) {
+        archives apiJar
+    }
+}
+
+// Updating
+task updateBuildScript {
+    doLast {
+        if (performBuildScriptUpdate(projectDir.toString())) return
+
+        print("Build script already up-to-date!")
+    }
+}
+
+if (isNewBuildScriptVersionAvailable(projectDir.toString())) {
+    if (autoUpdateBuildScript.toBoolean()) {
+        performBuildScriptUpdate(projectDir.toString())
+    } else {
+        println("Build script update available! Run 'gradle updateBuildScript'")
+    }
+}
+
+static URL availableBuildScriptUrl() {
+    new URL("https://raw.githubusercontent.com/SinTh0r4s/ExampleMod1.7.10/main/build.gradle")
+}
+
+boolean performBuildScriptUpdate(String projectDir) {
+    if (isNewBuildScriptVersionAvailable(projectDir)) {
+        def buildscriptFile = getFile("build.gradle")
+        availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } }
+        print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
+        return true
+    }
+    return false
+}
+
+boolean isNewBuildScriptVersionAvailable(String projectDir) {
+    Map parameters = ["connectTimeout": 2000, "readTimeout": 2000]
+
+    String currentBuildScript = getFile("build.gradle").getText()
+    String currentBuildScriptHash = getVersionHash(currentBuildScript)
+    String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText()
+    String availableBuildScriptHash = getVersionHash(availableBuildScript)
+
+    boolean isUpToDate = currentBuildScriptHash.empty || availableBuildScriptHash.empty || currentBuildScriptHash == availableBuildScriptHash
+    return !isUpToDate
+}
+
+static String getVersionHash(String buildScriptContent) {
+    String versionLine = buildScriptContent.find("^//version: [a-z0-9]*")
+    if(versionLine != null) {
+        return versionLine.split(": ").last()
+    }
+    return ""
+}
+
+configure(updateBuildScript) {
+    group = 'forgegradle'
+    description = 'Updates the build script to the latest version'
+}
+
+// Helper methods
+
+def checkPropertyExists(String propertyName) {
+    if (project.hasProperty(propertyName) == false) {
+        throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/SinTh0r4s/ExampleMod1.7.10/blob/main/gradle.properties")
+    }
+}
+
+def getFile(String relativePath) {
+    return new File(projectDir, relativePath)
 }

changelog.mustache

@@ -1,10 +1,8 @@
-Alpha version. Do not create a world you care about with this version, it may break things severely.<br/>
-Please help the project by trying it out and <a href="https://github.com/ForestryMC/Binnie/issues">reporting issues here.</a><br/>
-{{#tags}}
-    <h3>{{name}}</h3>
-    <ul>
-        {{#commits}}
-            <li>{{{message}}} - {{authorName}}</li>
-        {{/commits}}
-    </ul>
+{{#tags}}
+  <h3>{{name}}</h3>
+  <ul>
+    {{#commits}}
+    <li>{{{message}}} - {{authorName}}</li>
+    {{/commits}}
+  </ul>
 {{/tags}}

dependencies.gradle

@@ -0,0 +1,16 @@
+// Add your dependencies here
+
+dependencies {
+    compile("com.github.GTNewHorizons:ForestryMC:master-SNAPSHOT:dev")
+
+
+    /*compileOnly("net.industrial-craft:industrialcraft-2:2.2.828-experimental:api") {  // Transitive by ForestryMC
+        transitive = false
+    }
+    compileOnly("com.mod-buildcraft:buildcraft:7.1.23:dev") {  // Transitive by ForestryMC
+        transitive = false
+    }
+    compileOnly("curse.maven:cofh-lib-220333:2388748") {  // Transitive by ForestryMC
+        transitive = false
+    }*/
+}

gradle.properties

@@ -1,18 +1,64 @@
-# 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
+modName = Binnie Core
 
-mcversion=1.11.2
-forgeversion=13.20.1.2393
-mcp_mappings=snapshot_20161220
-curse_project_id=223525
+# This is a case-sensitive string to identify your mod. Convention is to use lower case.
+modId = BinnieCore
 
-forestry_version=5.3.4.132
-ic2_version=2.7.71-ex111
+modGroup = binnie
 
-version_major=2
-version_minor=1
-version_patch=0
+# WHY is there no version field?
+# The build script relies on git to provide a version via tags. It is super easy and will enable you to always know the
+# code base or your binary. Check out this tutorial: https://blog.mattclemente.com/2017/10/13/versioning-with-git-tags/
 
-jei_version=4.5.0.292
-jeibees_version=0.9.0.5
+# Will update your build.gradle automatically whenever an update is available
+autoUpdateBuildScript = false
+
+minecraftVersion = 1.7.10
+forgeVersion = 10.13.4.1614
+
+# Select a username for testing your mod with breakpoints. You may leave this empty for a random user name each time you
+# restart Minecraft in development. Choose this dependent on your mod:
+# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
+# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
+developmentEnvironmentUserName = "Developer"
+
+# Define a source file of your project with:
+# public static final String VERSION = "GRADLETOKEN_VERSION";
+# The string's content will be replaced with your mods version when compiled. You should use this to specify your mod's
+# version in @Mod([...], version = VERSION, [...])
+# Leave these properties empty to skip individual token replacements
+replaceGradleTokenInFile =
+gradleTokenModId =
+gradleTokenModName =
+gradleTokenVersion =
+gradleTokenGroupName =
+
+# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise you can
+# leave this property empty.
+# Example value: apiPackage = api + modGroup = com.myname.mymodid -> com.myname.mymodid.api
+apiPackage =
+
+# Specify the configuration file for Forge's access transformers here. I must be placed into /src/main/resources/META-INF/
+# Example value: mymodid_at.cfg
+accessTransformersFile =
+
+# Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled!
+usesMixins = false
+# Specify the location of your implementation of IMixinConfigPlugin. Leave it empty otherwise.
+mixinPlugin =
+# Specify the package that contains all of your Mixins. You may only place Mixins in this package or the build will fail!
+mixinsPackage =
+# Specify the core mod entry class if you use a core mod. This class must implement IFMLLoadingPlugin!
+# This parameter is for legacy compatability only
+# Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
+coreModClass =
+# If your project is only a consolidation of mixins or a core mod and does NOT contain a 'normal' mod ( = some class
+# that is annotated with @Mod) you want this to be true. When in doubt: leave it on false!
+containsMixinsAndOrCoreModOnly = false
+
+# If enabled, you may use 'shadowImplementation' for dependencies. They will be integrated in your jar. It is your
+# responsibility check the licence and request permission for distribution, if required.
+usesShadowedDependencies = false
+
+# Optional parameter to customize the produced artifacts. Use this to preserver artifact naming when migrating older
+# projects. New projects should not use this parameter.
+customArchiveBaseName = binnie-mods

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Thu Jul 13 23:08:17 PDT 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.9.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.0.1-all.zip

gradlew

@@ -1,4 +1,20 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
 
 ##############################################################################
 ##
@@ -28,16 +44,16 @@ 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=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
-warn ( ) {
+warn () {
     echo "$*"
 }
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
@@ -109,8 +125,8 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
     JAVACMD=`cygpath --unix "$JAVACMD"`
@@ -154,11 +170,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# 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" "$@"

gradlew.bat

@@ -1,90 +1,100 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-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
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows 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.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-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
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+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="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

jitpack.yml

@@ -0,0 +1,2 @@
+before_install:
+  - ./gradlew setupCIWorkspace

repositories.gradle

@@ -0,0 +1,18 @@
+// Add any additional repositories for your dependencies here
+
+repositories {
+    maven {
+        name = "ic2"
+        url = "http://maven.ic2.player.to/"
+        metadataSources {
+            mavenPom()
+            artifact()
+        }
+    }
+    maven {
+        url "https://cursemaven.com"
+    }
+    maven {
+        url = "https://jitpack.io"
+    }
+}

src/main/java/binnie/Binnie.java

@@ -1,20 +1,22 @@
 package binnie;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import binnie.core.ManagerBase;
 import binnie.core.genetics.ManagerGenetics;
+import binnie.core.item.ManagerItem;
 import binnie.core.liquid.ManagerLiquid;
 import binnie.core.machines.ManagerMachine;
 import binnie.core.mod.config.ManagerConfig;
 import binnie.core.resource.ManagerResource;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public final class Binnie {
-	public static final List<ManagerBase> MANAGERS = new ArrayList<>();
-	public static final ManagerGenetics GENETICS = new ManagerGenetics();
-	public static final ManagerConfig CONFIGURATION = new ManagerConfig();
-	public static final ManagerLiquid LIQUID = new ManagerLiquid();
-	public static final ManagerMachine MACHINE = new ManagerMachine();
-	public static final ManagerResource RESOURCE = new ManagerResource();
+	public static List<ManagerBase> Managers = new ArrayList<>();
+	public static ManagerGenetics Genetics = new ManagerGenetics();
+	public static ManagerConfig Configuration = new ManagerConfig();
+	public static ManagerLiquid Liquid = new ManagerLiquid();
+	public static ManagerMachine Machine = new ManagerMachine();
+	public static ManagerItem Item = new ManagerItem();
+	public static ManagerResource Resource = new ManagerResource();
 }

src/main/java/binnie/Constants.java

@@ -1,16 +0,0 @@
-package binnie;
-
-public final class Constants {
-
-	public static final String CORE_MOD_ID = "binniecore";
-	public static final String BOTANY_MOD_ID = "botany";
-	public static final String EXTRA_TREES_MOD_ID = "extratrees";
-	public static final String GENETICS_MOD_ID = "genetics";
-
-	public static final String LIQUID_JUICE = "juice";
-	public static final String LIQUID_WATER = "water";
-	public static final String LIQUID_SEED_OIL = "seedoil";
-	public static final String LIQUID_CREOSOTE = "Creosote Oil";
-	public static final String LIQUID_BIO_ETHANOL = "bioethanol";
-	public static final String LIQUID_FOR_HONEY = "for.honey";
-}

src/main/java/binnie/botany/Botany.java

@@ -1,48 +1,23 @@
 package binnie.botany;
 
-import javax.annotation.Nullable;
-
-import net.minecraft.block.Block;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.Items;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
-import net.minecraftforge.event.entity.player.BonemealEvent;
-import net.minecraftforge.event.entity.player.PlayerInteractEvent;
-import net.minecraftforge.event.world.BlockEvent;
-
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.SidedProxy;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-import net.minecraftforge.fml.common.eventhandler.Event;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-
-import binnie.Constants;
 import binnie.botany.api.EnumAcidity;
 import binnie.botany.api.EnumSoilType;
-import binnie.botany.api.IBlockSoil;
 import binnie.botany.api.IFlower;
-import binnie.botany.api.IFlowerRoot;
-import binnie.botany.api.IGardeningManager;
+import binnie.botany.api.gardening.IBlockSoil;
 import binnie.botany.ceramic.BlockCeramic;
+import binnie.botany.ceramic.BlockCeramicBrick;
 import binnie.botany.ceramic.BlockCeramicPatterned;
-import binnie.botany.ceramic.BlockStainedGlass;
-import binnie.botany.ceramic.brick.BlockCeramicBrick;
+import binnie.botany.ceramic.BlockStained;
 import binnie.botany.core.BotanyCore;
 import binnie.botany.core.BotanyGUI;
 import binnie.botany.core.ModuleCore;
 import binnie.botany.flower.BlockFlower;
-import binnie.botany.flower.ItemBotany;
+import binnie.botany.flower.ItemFlower;
 import binnie.botany.flower.ItemInsulatedTube;
 import binnie.botany.flower.TileEntityFlower;
 import binnie.botany.gardening.BlockPlant;
 import binnie.botany.gardening.BlockSoil;
+import binnie.botany.gardening.Gardening;
 import binnie.botany.gardening.ItemSoilMeter;
 import binnie.botany.gardening.ItemTrowel;
 import binnie.botany.gardening.ModuleGardening;
@@ -59,24 +34,44 @@ import binnie.core.item.ItemMisc;
 import binnie.core.network.BinniePacketHandler;
 import binnie.core.network.IPacketID;
 import binnie.core.proxy.IProxyCore;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.SidedProxy;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLInterModComms;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.eventhandler.Event;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import net.minecraft.block.Block;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.player.BonemealEvent;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.event.world.BlockEvent;
 
-@Mod(modid = Constants.BOTANY_MOD_ID, name = "Binnie's Botany", useMetadata = true, dependencies = "required-after:" + Constants.CORE_MOD_ID)
+@Mod(
+	modid = "Botany",
+	name = "Botany",
+	useMetadata = true,
+	dependencies = "after:BinnieCore"
+)
 public class Botany extends AbstractMod {
-	public static final float AGE_CHANCE = 0.2f;
-
-	@SuppressWarnings("NullableProblems")
-	@Mod.Instance(Constants.BOTANY_MOD_ID)
+	@Mod.Instance("Botany")
 	public static Botany instance;
-	@SuppressWarnings("NullableProblems")
-	@SidedProxy(clientSide = "binnie.botany.proxy.ProxyClient", serverSide = "binnie.botany.proxy.ProxyServer")
+
+	@SidedProxy(
+		clientSide = "binnie.botany.proxy.ProxyClient",
+		serverSide = "binnie.botany.proxy.ProxyServer"
+	)
 	public static Proxy proxy;
-	/* MODULE GENETIC */
+
 	public static BlockFlower flower;
-	public static ItemBotany flowerItem;
-	public static ItemBotany seed;
-	public static ItemBotany pollen;
+	public static Item seed;
+	public static Item pollen;
 	public static ItemDictionary database;
-	/* MODULE GARDENING */
 	public static BlockPlant plant;
 	public static ItemTrowel trowelWood;
 	public static ItemTrowel trowelStone;
@@ -92,37 +87,36 @@ public class Botany extends AbstractMod {
 	public static ItemInsulatedTube insulatedTube;
 	public static ItemSoilMeter soilMeter;
 	public static ItemMisc misc;
+	public static ItemFlower flowerItem;
 	public static ItemPigment pigment;
 	public static ItemClay clay;
 	public static BlockCeramic ceramic;
 	public static BlockCeramicPatterned ceramicTile;
-	public static BlockStainedGlass stained;
+	public static BlockStained stained;
 	public static BlockCeramicBrick ceramicBrick;
-	@Nullable
-	public static Item botanistBackpack;
+
+	public Botany() {
+		Botany.instance = this;
+	}
 
 	@Mod.EventHandler
-	public void preInit(FMLPreInitializationEvent evt) {
+	public void preInit(FMLPreInitializationEvent event) {
+		addModule(new ModuleCore());
+		addModule(new ModuleGenetics());
+		addModule(new ModuleGardening());
 		preInit();
 	}
 
 	@Mod.EventHandler
-	public void init(FMLInitializationEvent evt) {
+	public void init(FMLInitializationEvent event) {
 		init();
 	}
 
 	@Mod.EventHandler
-	public void postInit(FMLPostInitializationEvent evt) {
+	public void postInit(FMLPostInitializationEvent event) {
 		postInit();
 	}
 
-	@Override
-	protected void registerModules() {
-		addModule(new ModuleCore());
-		addModule(new ModuleGenetics());
-		addModule(new ModuleGardening());
-	}
-
 	@Override
 	public IBinnieGUID[] getGUIDs() {
 		return BotanyGUI.values();
@@ -150,7 +144,7 @@ public class Botany extends AbstractMod {
 
 	@Override
 	public String getModID() {
-		return Constants.BOTANY_MOD_ID;
+		return "botany";
 	}
 
 	@Override
@@ -158,171 +152,185 @@ public class Botany extends AbstractMod {
 		return PacketHandler.class;
 	}
 
-	@Override
-	public boolean isActive() {
-		return BinnieCore.isBotanyActive();
-	}
-
 	@SubscribeEvent
-	public void onShearFlower(PlayerInteractEvent.RightClickBlock event) {
-		EntityPlayer player = event.getEntityPlayer();
-		if (player == null) {
+	public void onShearFlower(PlayerInteractEvent event) {
+		if (event.action != PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK) {
 			return;
 		}
 
-		ItemStack heldItem = player.getHeldItemMainhand();
-		if (heldItem.isEmpty()) {
-			return;
+		if (event.entityPlayer != null && event.entityPlayer.getHeldItem() != null && event.entityPlayer.getHeldItem().getItem() == Items.shears) {
+			TileEntity tile = event.world.getTileEntity(event.x, event.y, event.z);
+			if (tile instanceof TileEntityFlower) {
+				TileEntityFlower flower = (TileEntityFlower) tile;
+				flower.onShear();
+				event.entityPlayer.getHeldItem().damageItem(1, event.entityPlayer);
+			}
 		}
 
-		TileEntity tile = event.getWorld().getTileEntity(event.getPos());
-		if (!(tile instanceof TileEntityFlower)) {
-			return;
-		}
-
-		TileEntityFlower flower = (TileEntityFlower) tile;
-		if (heldItem.getItem() == Items.SHEARS) {
-			flower.onShear();
-			heldItem.damageItem(1, player);
-		} else if (heldItem.getItem() == Botany.pollen) {
-			IFlower pollen = BotanyCore.getFlowerRoot().getMember(heldItem);
-			if (pollen != null && flower.canMateWith(pollen)) {
-				flower.mateWith(pollen);
-				if (!player.capabilities.isCreativeMode) {
-					heldItem.shrink(1);
+		if (event.entityPlayer != null && event.entityPlayer.getHeldItem() != null && event.entityPlayer.getHeldItem().getItem() == Botany.pollen) {
+			TileEntity tile = event.world.getTileEntity(event.x, event.y, event.z);
+			if (tile instanceof TileEntityFlower) {
+				TileEntityFlower flower = (TileEntityFlower) tile;
+				IFlower pollen = BotanyCore.getFlowerRoot().getMember(event.entityPlayer.getHeldItem());
+				if (pollen != null && flower.canMateWith(pollen)) {
+					flower.mateWith(pollen);
+					if (!event.entityPlayer.capabilities.isCreativeMode) {
+						ItemStack heldItem = event.entityPlayer.getHeldItem();
+						heldItem.stackSize--;
+					}
 				}
 			}
 		}
 	}
 
 	@SubscribeEvent
-	public void onFertiliseSoil(PlayerInteractEvent.RightClickBlock event) {
-		World world = event.getWorld();
-		if (world == null) {
+	public void onFertiliseSoil(PlayerInteractEvent event) {
+		if (event.action != PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK || event.world == null) {
 			return;
 		}
 
-		BlockPos pos = event.getPos();
-		EntityPlayer player = event.getEntityPlayer();
-		if (player == null) {
+		if (event.entityPlayer == null || event.entityPlayer.getHeldItem() == null) {
 			return;
 		}
 
-		ItemStack heldItem = player.getHeldItemMainhand();
-		if (heldItem.isEmpty()) {
-			return;
+		int y = event.y;
+		Block block = event.world.getBlock(event.x, y, event.z);
+		if (block == null || !Gardening.isSoil(block)) {
+			block = event.world.getBlock(event.x, --y, event.z);
 		}
-
-		IGardeningManager gardening = BotanyCore.getGardening();
-		Block block = world.getBlockState(event.getPos()).getBlock();
-		if (!gardening.isSoil(block)) {
-			pos = pos.down();
-			block = world.getBlockState(pos).getBlock();
-		}
-
-		if (!gardening.isSoil(block)) {
+		if (block == null || !Gardening.isSoil(block)) {
 			return;
 		}
 
 		IBlockSoil soil = (IBlockSoil) block;
-		int fertiliserStrength = gardening.getFertiliserStrength(heldItem);
-		if (gardening.isNutrientFertiliser(heldItem) && soil.getType(world, pos) != EnumSoilType.FLOWERBED) {
-			EnumSoilType type = soil.getType(world, pos);
-			int next = Math.min(type.ordinal() + fertiliserStrength, 2);
-			if (soil.fertilise(world, pos, EnumSoilType.values()[next]) && !player.capabilities.isCreativeMode) {
-				heldItem.shrink(1);
+		if (Gardening.isNutrientFertiliser(event.entityPlayer.getHeldItem()) && soil.getType(event.world, event.x, y, event.z) != EnumSoilType.FLOWERBED) {
+			EnumSoilType type = soil.getType(event.world, event.x, y, event.z);
+			int next = Math.min(type.ordinal() + Gardening.getFertiliserStrength(event.entityPlayer.getHeldItem()), 2);
+			if (soil.fertilise(event.world, event.x, y, event.z, EnumSoilType.values()[next]) && !event.entityPlayer.capabilities.isCreativeMode) {
+				ItemStack heldItem = event.entityPlayer.getHeldItem();
+				heldItem.stackSize--;
 				return;
 			}
 		}
 
-		if (gardening.isAcidFertiliser(heldItem) && soil.getPH(world, pos) != EnumAcidity.ACID) {
-			EnumAcidity pH = soil.getPH(world, pos);
-			int next = Math.max(pH.ordinal() - fertiliserStrength, 0);
-			if (soil.setPH(world, pos, EnumAcidity.values()[next]) && !player.capabilities.isCreativeMode) {
-				heldItem.shrink(1);
+		if (Gardening.isAcidFertiliser(event.entityPlayer.getHeldItem()) && soil.getPH(event.world, event.x, y, event.z) != EnumAcidity.ACID) {
+			EnumAcidity pH = soil.getPH(event.world, event.x, y, event.z);
+			int next = Math.max(pH.ordinal() - Gardening.getFertiliserStrength(event.entityPlayer.getHeldItem()), 0);
+			if (soil.setPH(event.world, event.x, y, event.z, EnumAcidity.values()[next]) && !event.entityPlayer.capabilities.isCreativeMode) {
+				ItemStack heldItem2 = event.entityPlayer.getHeldItem();
+				heldItem2.stackSize--;
 				return;
 			}
 		}
 
-		if (gardening.isAlkalineFertiliser(heldItem) && soil.getPH(world, pos) != EnumAcidity.ALKALINE) {
-			EnumAcidity pH = soil.getPH(world, pos);
-			int next = Math.min(pH.ordinal() + fertiliserStrength, 2);
-			if (soil.setPH(world, pos, EnumAcidity.values()[next]) && !player.capabilities.isCreativeMode) {
-				heldItem.shrink(1);
+		if (Gardening.isAlkalineFertiliser(event.entityPlayer.getHeldItem()) && soil.getPH(event.world, event.x, y, event.z) != EnumAcidity.ALKALINE) {
+			EnumAcidity pH = soil.getPH(event.world, event.x, y, event.z);
+			int next = Math.min(pH.ordinal() + Gardening.getFertiliserStrength(event.entityPlayer.getHeldItem()), 2);
+			if (soil.setPH(event.world, event.x, y, event.z, EnumAcidity.values()[next]) && !event.entityPlayer.capabilities.isCreativeMode) {
+				ItemStack heldItem3 = event.entityPlayer.getHeldItem();
+				heldItem3.stackSize--;
 				return;
 			}
 		}
 
-		if (gardening.isWeedkiller(heldItem) && gardening.addWeedKiller(world, pos) && !player.capabilities.isCreativeMode) {
-			heldItem.shrink(1);
+		if (Gardening.isWeedkiller(event.entityPlayer.getHeldItem()) && Gardening.addWeedKiller(event.world, event.x, y, event.z) && !event.entityPlayer.capabilities.isCreativeMode) {
+			ItemStack heldItem4 = event.entityPlayer.getHeldItem();
+			heldItem4.stackSize--;
 		}
 	}
 
 	@SubscribeEvent
 	public void plantVanilla(BlockEvent.PlaceEvent event) {
-		World world = event.getWorld();
-		BlockPos pos = event.getPos();
-		Block block = world.getBlockState(pos.down()).getBlock();
-		if (!BotanyCore.getGardening().isSoil(block)) {
+		World world = event.world;
+		int x = event.x;
+		int y = event.y;
+		int z = event.z;
+		Block block = world.getBlock(x, y - 1, z);
+		if (!(block instanceof IBlockSoil)) {
 			return;
 		}
 
-		EntityPlayer player = event.getPlayer();
-		ItemStack heldItem = player.getHeldItem(event.getHand());
-		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
-		IFlower flower = flowerRoot.getConversion(heldItem);
+		IFlower flower = BotanyCore.getFlowerRoot().getConversion(event.itemInHand);
 		if (flower != null) {
-			flowerRoot.plant(world, pos, flower, player.getGameProfile());
+			Gardening.plant(world, x, y, z, flower, event.player.getGameProfile());
 		}
 	}
 
 	@Deprecated
-	public void onPlantVanilla(PlayerInteractEvent.RightClickBlock event) {
-		BlockPos pos = event.getPos();
-		World world = event.getWorld();
-		EntityPlayer player = event.getEntityPlayer();
-		ItemStack heldItem = player.getHeldItemMainhand();
-		if (!BinnieCore.getBinnieProxy().isSimulating(event.getWorld())) {
+	public void onPlantVanilla(PlayerInteractEvent event) {
+		if (!BinnieCore.proxy.isSimulating(event.world) || event.action != PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK) {
+			return;
+		}
+		if (event.entityPlayer == null || event.entityPlayer.getHeldItem() == null) {
 			return;
 		}
 
-		if (heldItem.isEmpty()) {
-			return;
-		}
-
-		Block block = world.getBlockState(pos).getBlock();
+		World world = event.world;
+		int x = event.x;
+		int y = event.y;
+		int z = event.z;
+		Block block = world.getBlock(x, y, z);
 		int py = -1;
-		if (block instanceof IBlockSoil && (world.isAirBlock(pos.up()) || block.isReplaceable(world, pos))) {
+		if (block instanceof IBlockSoil && (world.isAirBlock(x, y + 1, z) || world.getBlock(x, y, z).isReplaceable(world, x, y, z))) {
 			py = 1;
 		}
+
 		if (py < 0) {
 			return;
 		}
 
-		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
-		IFlower flower = flowerRoot.getConversion(heldItem);
-		if (flower != null && flowerRoot.plant(world, pos.add(0, py, 0), flower, player.getGameProfile()) && !player.capabilities.isCreativeMode) {
-			heldItem.shrink(1);
+		IFlower flower = BotanyCore.getFlowerRoot().getConversion(event.entityPlayer.getHeldItem());
+		if (flower != null && Gardening.plant(world, x, y + py, z, flower, event.entityPlayer.getGameProfile()) && !event.entityPlayer.capabilities.isCreativeMode) {
+			ItemStack heldItem = event.entityPlayer.getHeldItem();
+			heldItem.stackSize--;
 		}
 	}
 
 	@SubscribeEvent
 	public void onBonemeal(BonemealEvent event) {
-		BlockPos pos = event.getPos();
-		Block block = event.getBlock().getBlock();
-		if (BotanyCore.getGardening().isSoil(block)) {
+		Block block = event.world.getBlock(event.x, event.y, event.z);
+		if (Gardening.isSoil(block)) {
 			IBlockSoil soil = (IBlockSoil) block;
-			if (soil.fertilise(event.getWorld(), pos, EnumSoilType.LOAM)) {
+			if (soil.fertilise(event.world, event.x, event.y, event.z, EnumSoilType.LOAM)) {
 				event.setResult(Event.Result.ALLOW);
 			}
 		}
 
-		TileEntity tile = event.getWorld().getTileEntity(pos);
+		TileEntity tile = event.world.getTileEntity(event.x, event.y, event.z);
 		if (tile instanceof TileEntityFlower && ((TileEntityFlower) tile).onBonemeal()) {
 			event.setResult(Event.Result.ALLOW);
 		}
 	}
 
+	@Override
+	public boolean isActive() {
+		return BinnieCore.isBotanyActive();
+	}
+
+	@Mod.EventHandler
+	public void onIMC(FMLInterModComms.IMCEvent event) {
+		for (FMLInterModComms.IMCMessage message : event.getMessages()) {
+			if (message.key.equals("add-nutrient-fertiliser-1")) {
+				ModuleGardening.queuedNutrientFertilisers.put(message.getItemStackValue(), 1);
+			}
+			if (message.key.equals("add-nutrient-fertiliser-2")) {
+				ModuleGardening.queuedNutrientFertilisers.put(message.getItemStackValue(), 2);
+			}
+			if (message.key.equals("add-acid-fertiliser-1")) {
+				ModuleGardening.queuedAcidFertilisers.put(message.getItemStackValue(), 1);
+			}
+			if (message.key.equals("add-acid-fertiliser-2")) {
+				ModuleGardening.queuedAcidFertilisers.put(message.getItemStackValue(), 2);
+			}
+			if (message.key.equals("add-alkaline-fertiliser-1")) {
+				ModuleGardening.queuedAlkalineFertilisers.put(message.getItemStackValue(), 1);
+			}
+			if (message.key.equals("add-alkaline-fertiliser-2")) {
+				ModuleGardening.queuedAlkalineFertilisers.put(message.getItemStackValue(), 1);
+			}
+		}
+	}
+
 	public static class PacketHandler extends BinniePacketHandler {
 		public PacketHandler() {
 			super(Botany.instance);

src/main/java/binnie/botany/CreativeTabBotany.java

@@ -1,14 +1,13 @@
 package binnie.botany;
 
+import binnie.core.util.I18N;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import binnie.core.util.I18N;
-
 public class CreativeTabBotany extends CreativeTabs {
 	public static CreativeTabs instance = new CreativeTabBotany();
 
@@ -18,11 +17,10 @@ public class CreativeTabBotany extends CreativeTabs {
 
 	@Override
 	public ItemStack getIconItemStack() {
-		return new ItemStack(Blocks.RED_FLOWER, 1, 5);
+		return new ItemStack(Blocks.red_flower, 1, 5);
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
 	public String getTranslatedTabLabel() {
 		return getTabLabel();
 	}
@@ -35,7 +33,7 @@ public class CreativeTabBotany extends CreativeTabs {
 
 	@Override
 	@SideOnly(Side.CLIENT)
-	public ItemStack getTabIconItem() {
-		return new ItemStack(Blocks.YELLOW_FLOWER);
+	public Item getTabIconItem() {
+		return Item.getItemFromBlock(Blocks.yellow_flower);
 	}
 }

src/main/java/binnie/botany/api/EnumAcidity.java

@@ -1,34 +1,11 @@
 package binnie.botany.api;
 
-import javax.annotation.Nullable;
+public enum EnumAcidity {
+	ACID,
+	NEUTRAL,
+	ALKALINE;
 
-import net.minecraft.util.IStringSerializable;
-import net.minecraft.util.text.TextFormatting;
-
-import binnie.core.util.I18N;
-
-public enum EnumAcidity implements IStringSerializable {
-	ACID(TextFormatting.RED),
-	NEUTRAL(null),
-	ALKALINE(TextFormatting.AQUA);
-
-	@Nullable
-	TextFormatting color;
-
-	EnumAcidity(@Nullable TextFormatting color) {
-		this.color = color;
-	}
-
-	@Override
-	public String getName() {
+	public String getID() {
 		return name().toLowerCase();
 	}
-
-	public String getLocalisedName(boolean withColor) {
-		String localisedName = I18N.localise("botany.ph." + getName());
-		if (withColor && color != null) {
-			localisedName += color;
-		}
-		return localisedName;
-	}
 }

src/main/java/binnie/botany/api/EnumFlowerChromosome.java

@@ -1,7 +1,5 @@
 package binnie.botany.api;
 
-import java.util.Locale;
-
 import forestry.api.genetics.AlleleManager;
 import forestry.api.genetics.IAllele;
 import forestry.api.genetics.IAlleleArea;
@@ -38,7 +36,7 @@ public enum EnumFlowerChromosome implements IChromosomeType {
 
 	@Override
 	public String getName() {
-		return toString().toLowerCase(Locale.ENGLISH);
+		return toString().toLowerCase();
 	}
 
 	@Override

src/main/java/binnie/botany/api/EnumFlowerStage.java

@@ -1,31 +1,18 @@
 package binnie.botany.api;
 
-import forestry.api.genetics.ISpeciesType;
-
-public enum EnumFlowerStage implements ISpeciesType {
+public enum EnumFlowerStage {
 	FLOWER("Flower"),
 	SEED("Seed"),
-	POLLEN("Pollen");
+	POLLEN("Pollen"),
+	NONE("NONE");
 
-	public static final EnumFlowerStage[] VALUES = values();
-	String name;
+	protected String name;
 
 	EnumFlowerStage(String name) {
 		this.name = name;
 	}
 
-	public static EnumFlowerStage getStage(IFlower flower) {
-		return getStage(flower.getAge());
-	}
-
-	public static EnumFlowerStage getStage(int age) {
-		return age == 0
-				? EnumFlowerStage.SEED
-				: EnumFlowerStage.FLOWER;
-	}
-
 	public String getName() {
 		return name;
 	}
-
 }

src/main/java/binnie/botany/api/EnumMoisture.java

@@ -1,34 +1,11 @@
 package binnie.botany.api;
 
-import javax.annotation.Nullable;
+public enum EnumMoisture {
+	DRY,
+	NORMAL,
+	DAMP;
 
-import net.minecraft.util.IStringSerializable;
-import net.minecraft.util.text.TextFormatting;
-
-import binnie.core.util.I18N;
-
-public enum EnumMoisture implements IStringSerializable {
-	DRY(TextFormatting.YELLOW),
-	NORMAL(null),
-	DAMP(TextFormatting.DARK_BLUE);
-
-	@Nullable
-	final TextFormatting color;
-
-	EnumMoisture(@Nullable TextFormatting color) {
-		this.color = color;
-	}
-
-	@Override
-	public String getName() {
+	public String getID() {
 		return name().toLowerCase();
 	}
-
-	public String getLocalisedName(boolean withColor) {
-		String localisedName = I18N.localise("botany.moisture." + getName());
-		if (withColor && color != null) {
-			localisedName += color;
-		}
-		return localisedName;
-	}
 }

src/main/java/binnie/botany/api/EnumSoilType.java

@@ -1,29 +1,11 @@
 package binnie.botany.api;
 
-import java.util.Locale;
+public enum EnumSoilType {
+	SOIL,
+	LOAM,
+	FLOWERBED;
 
-import net.minecraft.util.IStringSerializable;
-import net.minecraft.util.text.TextFormatting;
-
-import binnie.core.util.I18N;
-
-public enum EnumSoilType implements IStringSerializable {
-	SOIL(TextFormatting.DARK_GRAY),
-	LOAM(TextFormatting.GOLD),
-	FLOWERBED(TextFormatting.LIGHT_PURPLE);
-
-	private final TextFormatting color;
-
-	EnumSoilType(TextFormatting color) {
-		this.color = color;
-	}
-
-	@Override
-	public String getName() {
-		return name().toLowerCase(Locale.ENGLISH);
-	}
-
-	public String getTranslated() {
-		return color + I18N.localise("botany.soil." + getName());
+	public String getID() {
+		return name().toLowerCase();
 	}
 }

src/main/java/binnie/botany/api/FlowerManager.java

@@ -1,18 +0,0 @@
-package binnie.botany.api;
-
-public class FlowerManager {
-	/**
-	 * Convenient access to AlleleManager.alleleRegistry.getSpeciesRoot("rootFlowers")
-	 */
-	public static IFlowerRoot flowerRoot;
-
-	/**
-	 * Used to create new flowers.
-	 */
-	public static IFlowerFactory flowerFactory;
-
-	/**
-	 * Used to manager soil.
-	 */
-	public static IGardeningManager gardening;
-}

src/main/java/binnie/botany/api/IAlleleFlowerEffect.java

@@ -1,10 +1,9 @@
 package binnie.botany.api;
 
-import net.minecraft.world.World;
-
 import forestry.api.genetics.IAlleleEffect;
 import forestry.api.genetics.IEffectData;
+import net.minecraft.world.World;
 
 public interface IAlleleFlowerEffect extends IAlleleEffect {
-	IEffectData doEffect(IFlowerGenome genome, IEffectData effect, World world, int x, int y, int z);
+	IEffectData doEffect(IFlowerGenome genome, IEffectData storedData, World world, int x, int y, int z);
 }

src/main/java/binnie/botany/api/IAlleleFlowerSpecies.java

@@ -1,28 +1,11 @@
 package binnie.botany.api;
 
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.item.Item;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.api.core.IModelManager;
-import forestry.api.genetics.IAlleleProperty;
 import forestry.api.genetics.IAlleleSpecies;
 
-public interface IAlleleFlowerSpecies extends IAlleleSpecies, IAlleleProperty<IAlleleFlowerSpecies> {
+public interface IAlleleFlowerSpecies extends IAlleleSpecies {
 	IFlowerType getType();
 
 	EnumAcidity getPH();
 
 	EnumMoisture getMoisture();
-
-	@SideOnly(Side.CLIENT)
-	int getFlowerColor(EnumFlowerStage type, int renderPass);
-
-	@SideOnly(Side.CLIENT)
-	ModelResourceLocation getFlowerModel(EnumFlowerStage type, boolean flowered);
-
-	@SideOnly(Side.CLIENT)
-	void registerModels(Item item, IModelManager manager, EnumFlowerStage type);
 }

src/main/java/binnie/botany/api/IAlleleFlowerSpeciesBuilder.java

@@ -1,12 +0,0 @@
-package binnie.botany.api;
-
-import forestry.api.genetics.IAlleleSpeciesBuilder;
-
-public interface IAlleleFlowerSpeciesBuilder extends IAlleleSpeciesBuilder {
-	@Override
-	IAlleleFlowerSpecies build();
-
-	IAlleleFlowerSpeciesBuilder setPH(EnumAcidity acidity);
-
-	IAlleleFlowerSpeciesBuilder setMoisture(EnumMoisture moisture);
-}

src/main/java/binnie/botany/api/IBlockSoil.java

@@ -1,22 +0,0 @@
-package binnie.botany.api;
-
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
-public interface IBlockSoil {
-	EnumAcidity getPH(World world, BlockPos pos);
-
-	EnumMoisture getMoisture(World world, BlockPos pos);
-
-	EnumSoilType getType(World world, BlockPos pos);
-
-	boolean fertilise(World world, BlockPos pos, EnumSoilType soilType);
-
-	boolean degrade(World world, BlockPos pos, EnumSoilType soilType);
-
-	boolean setPH(World world, BlockPos pos, EnumAcidity acidity);
-
-	boolean setMoisture(World world, BlockPos pos, EnumMoisture moisture);
-
-	boolean resistsWeeds(World world, BlockPos pos);
-}

src/main/java/binnie/botany/api/IColorMix.java

@@ -1,13 +0,0 @@
-package binnie.botany.api;
-
-public interface IColorMix {
-	IFlowerColor getColorFirst();
-
-	IFlowerColor getColorSecond();
-
-	boolean isMutation(IFlowerColor colorFirst, IFlowerColor colorSecond);
-
-	int getChance();
-
-	IFlowerColor getResult();
-}

src/main/java/binnie/botany/api/IColourMix.java

@@ -0,0 +1,13 @@
+package binnie.botany.api;
+
+public interface IColourMix {
+	IFlowerColor getColor1();
+
+	IFlowerColor getColor2();
+
+	boolean isMutation(IFlowerColor color1, IFlowerColor color2);
+
+	int getChance();
+
+	IFlowerColor getResult();
+}

src/main/java/binnie/botany/api/IFlower.java

@@ -1,20 +1,15 @@
 package binnie.botany.api;
 
-import javax.annotation.Nullable;
-
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
 import forestry.api.genetics.IIndividual;
+import net.minecraft.world.World;
 
 public interface IFlower extends IIndividual {
 	@Override
 	IFlowerGenome getGenome();
 
-	@Nullable
 	IFlowerGenome getMate();
 
-	void mate(IFlower flower);
+	void mate(IFlower other);
 
 	int getAge();
 
@@ -22,17 +17,17 @@ public interface IFlower extends IIndividual {
 
 	void age();
 
-	IFlower getOffspring(World world, BlockPos pos);
+	IFlower getOffspring(World world);
 
 	int getMaxAge();
 
 	boolean isWilted();
 
-	void setWilted(boolean p0);
+	void setWilted(boolean value);
 
 	boolean hasFlowered();
 
-	void setFlowered(boolean p0);
+	void setFlowered(boolean value);
 
 	void removeMate();
 }

src/main/java/binnie/botany/api/IFlowerColor.java

@@ -9,5 +9,5 @@ public interface IFlowerColor {
 
 	int getID();
 
-	String getColorName();
+	String getName();
 }

src/main/java/binnie/botany/api/IFlowerDefinition.java

@@ -1,15 +0,0 @@
-package binnie.botany.api;
-
-import net.minecraft.item.ItemStack;
-
-import forestry.core.genetics.IGeneticDefinition;
-
-public interface IFlowerDefinition extends IGeneticDefinition {
-	@Override
-	IFlowerGenome getGenome();
-
-	@Override
-	IFlower getIndividual();
-
-	ItemStack getMemberStack(EnumFlowerStage flowerStage);
-}

src/main/java/binnie/botany/api/IFlowerFactory.java

@@ -1,10 +0,0 @@
-package binnie.botany.api;
-
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IClassification;
-
-public interface IFlowerFactory {
-	IAlleleFlowerSpeciesBuilder createSpecies(String uid, String unlocalizedName, String authority, String unlocalizedDescription, boolean isDominant, IClassification branch, String binomial, IFlowerType flowerType);
-
-	IFlowerMutationBuilder createMutation(IAlleleFlowerSpecies allele0, IAlleleFlowerSpecies allele1, IAllele[] result, int chance);
-}

src/main/java/binnie/botany/api/IFlowerGenome.java

@@ -33,9 +33,9 @@ public interface IFlowerGenome extends IGenome {
 
 	float getSappiness();
 
-	boolean canTolerate(EnumAcidity acidity);
+	boolean canTolerate(EnumAcidity pH);
 
 	boolean canTolerate(EnumMoisture moisture);
 
-	boolean canTolerate(EnumTemperature temperature);
+	boolean canTolerate(EnumTemperature temp);
 }

src/main/java/binnie/botany/api/IFlowerMutation.java

@@ -1,13 +1,9 @@
 package binnie.botany.api;
 
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IGenome;
 import forestry.api.genetics.IMutation;
 
 public interface IFlowerMutation extends IMutation {
-	@Override
-	IFlowerRoot getRoot();
-
-	float getChance(World world, BlockPos pos, IAlleleFlowerSpecies allele0, IAlleleFlowerSpecies allele1, IFlowerGenome genome0, IFlowerGenome genome1);
+	float getChance(IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1);
 }

src/main/java/binnie/botany/api/IFlowerMutationBuilder.java

@@ -1,6 +0,0 @@
-package binnie.botany.api;
-
-import forestry.api.genetics.IMutationBuilder;
-
-public interface IFlowerMutationBuilder extends IMutationBuilder {
-}

src/main/java/binnie/botany/api/IFlowerRoot.java

@@ -1,28 +1,22 @@
 package binnie.botany.api;
 
-import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.List;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
 import com.mojang.authlib.GameProfile;
-
 import forestry.api.genetics.IAllele;
 import forestry.api.genetics.ISpeciesRoot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+import java.util.Collection;
 
 public interface IFlowerRoot extends ISpeciesRoot {
 	@Override
-	@Nullable
-	IFlower getMember(ItemStack memberStack);
+	IFlower getMember(ItemStack stack);
 
 	@Override
 	IFlower templateAsIndividual(IAllele[] template);
 
 	@Override
-	IFlower templateAsIndividual(IAllele[] templateFirst, IAllele[] templateSecond);
+	IFlower templateAsIndividual(IAllele[] templateActive, IAllele[] templateInactive);
 
 	@Override
 	IFlowerGenome templateAsGenome(IAllele[] template);
@@ -31,29 +25,20 @@ public interface IFlowerRoot extends ISpeciesRoot {
 	IFlowerGenome templateAsGenome(IAllele[] templateActive, IAllele[] templateInactive);
 
 	@Override
-	IBotanistTracker getBreedingTracker(World world, @Nullable GameProfile profile);
+	IBotanistTracker getBreedingTracker(World world, GameProfile player);
 
 	@Override
-	List<? extends IFlowerMutation> getMutations(boolean shuffle);
+	Collection<IFlowerMutation> getMutations(boolean shuffle);
 
-	@Override
-	@Nullable
-	EnumFlowerStage getType(ItemStack itemStack);
+	EnumFlowerStage getStageType(ItemStack stack);
 
-	IFlower getFlower(IFlowerGenome genome);
+	IFlower getFlower(World world, IFlowerGenome genome);
 
-	void addConversion(ItemStack memberStack, IAllele[] template);
+	void addConversion(ItemStack stack, IAllele[] template);
 
-	@Nullable
-	IFlower getConversion(ItemStack memberStack);
+	IFlower getConversion(ItemStack stack);
 
-	Collection<IColorMix> getColorMixes(boolean shuffle);
+	Collection<IColourMix> getColourMixes(boolean shuffle);
 
-	void registerColourMix(IColorMix colorMix);
-
-	boolean plant(World world, BlockPos pos, IFlower flower, GameProfile owner);
-
-	void tryGrowSection(World world, BlockPos pos);
-
-	void onGrowFromSeed(World world, BlockPos pos);
+	void registerColourMix(IColourMix colorMix);
 }

src/main/java/binnie/botany/api/IFlowerType.java

@@ -1,21 +1,13 @@
 package binnie.botany.api;
 
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.item.Item;
+import net.minecraft.util.IIcon;
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+public interface IFlowerType {
+	IIcon getStem(EnumFlowerStage stage, boolean flowered, int section);
 
-import forestry.api.core.IModelManager;
+	IIcon getPetalIcon(EnumFlowerStage stage, boolean flowered, int section);
 
-public interface IFlowerType<I extends IFlowerType<I>> extends Comparable<I> {
-	@SideOnly(Side.CLIENT)
-	void registerModels(Item item, IModelManager manager, EnumFlowerStage type);
-
-	@SideOnly(Side.CLIENT)
-	ModelResourceLocation getModel(EnumFlowerStage type, boolean flowered);
-
-	String getName();
+	IIcon getVariantIcon(EnumFlowerStage stage, boolean flowered, int section);
 
 	int getID();
 

src/main/java/binnie/botany/api/IGardeningManager.java

@@ -1,68 +0,0 @@
-package binnie.botany.api;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-
-import net.minecraft.block.Block;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
-import forestry.api.core.EnumTemperature;
-
-public interface IGardeningManager {
-	default boolean isSoil(Block block) {
-		return block instanceof IBlockSoil;
-	}
-
-	boolean isSoil(Item item);
-
-	boolean isSoil(ItemStack item);
-
-	EnumMoisture getNaturalMoisture(World world, BlockPos pos);
-
-	EnumAcidity getNaturalPH(World world, BlockPos pos);
-
-	float getBiomeMoisture(World world, BlockPos pos);
-
-	float getBiomePH(World world, BlockPos pos);
-
-	void plantSoil(World world, BlockPos pos, EnumSoilType soil, EnumMoisture moisture, EnumAcidity acidity);
-
-	Collection<ItemStack> getAcidFertilisers();
-
-	Collection<ItemStack> getAlkalineFertilisers();
-
-	Collection<ItemStack> getNutrientFertilisers();
-
-	void registerAcidFertiliser(ItemStack stack, int strength);
-
-	void registerAlkalineFertiliser(ItemStack stack, int strength);
-
-	void registerNutrientFertiliser(ItemStack stack, int strength);
-
-	boolean isAcidFertiliser(ItemStack stack);
-
-	boolean isAlkalineFertiliser(ItemStack stack);
-
-	boolean isNutrientFertiliser(ItemStack stack);
-
-	int getFertiliserStrength(ItemStack stack);
-
-	boolean canTolerate(@Nullable IFlower flower, World world, BlockPos pos);
-
-	EnumSoilType getSoilType(World world, BlockPos pos);
-
-	default Block getSoilBlock(EnumSoilType type) {
-		return getSoilBlock(type, false);
-	}
-
-	Block getSoilBlock(EnumSoilType type, boolean weedKill);
-
-	boolean canTolerate(IFlower flower, EnumAcidity acidity, EnumMoisture moisture, EnumTemperature temperature);
-
-	boolean isWeedkiller(ItemStack heldItem);
-
-	boolean addWeedKiller(World world, BlockPos pos);
-}

src/main/java/binnie/botany/api/gardening/IBlockSoil.java

@@ -0,0 +1,24 @@
+package binnie.botany.api.gardening;
+
+import binnie.botany.api.EnumAcidity;
+import binnie.botany.api.EnumMoisture;
+import binnie.botany.api.EnumSoilType;
+import net.minecraft.world.World;
+
+public interface IBlockSoil {
+	EnumAcidity getPH(World world, int x, int y, int z);
+
+	EnumMoisture getMoisture(World world, int x, int y, int z);
+
+	EnumSoilType getType(World world, int x, int y, int z);
+
+	boolean fertilise(World world, int x, int y, int z, EnumSoilType maxLevel);
+
+	boolean degrade(World world, int x, int y, int z, EnumSoilType minLevel);
+
+	boolean setPH(World world, int x, int y, int z, EnumAcidity pH);
+
+	boolean setMoisture(World world, int x, int y, int z, EnumMoisture p4);
+
+	boolean resistsWeeds(World world, int x, int y, int z);
+}

src/main/java/binnie/botany/api/package-info.java

@@ -1,7 +0,0 @@
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-package binnie.botany.api;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-import mcp.MethodsReturnNonnullByDefault;

src/main/java/binnie/botany/ceramic/BlockCeramic.java

@@ -1,119 +1,146 @@
 package binnie.botany.ceramic;
 
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
+import binnie.botany.Botany;
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.genetics.EnumFlowerColor;
+import binnie.core.block.BlockMetadata;
+import binnie.core.block.IBlockMetadata;
+import binnie.core.block.TileEntityMetadata;
+import binnie.core.util.I18N;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
-import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import java.util.ArrayList;
+import java.util.List;
 
-import forestry.api.core.IItemModelRegister;
-import forestry.api.core.IModelManager;
-import forestry.core.blocks.IColoredBlock;
-
-import binnie.botany.CreativeTabBotany;
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.core.BinnieCore;
-import binnie.core.util.TileUtil;
-
-public class BlockCeramic extends Block implements IColoredBlock, IItemModelRegister {
+public class BlockCeramic extends Block implements IBlockMetadata {
 	public BlockCeramic() {
-		super(Material.ROCK);
+		super(Material.rock);
 		setHardness(1.0f);
 		setResistance(5.0f);
-		setRegistryName("ceramic");
+		setBlockName("ceramic");
 		setCreativeTab(CreativeTabBotany.instance);
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerModel(Item item, IModelManager manager) {
-		for (EnumFlowerColor c : EnumFlowerColor.values()) {
-			manager.registerItemModel(item, c.ordinal());
-		}
+	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int blockMeta, int fortune) {
+		return BlockMetadata.getBlockDropped(this, world, x, y, z, blockMeta);
 	}
 
 	@Override
-	public List<ItemStack> getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
-		return Collections.emptyList();
+	public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z, boolean willHarvest) {
+		return BlockMetadata.breakBlock(this, player, world, x, y, z);
 	}
 
 	@Override
-	public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, @Nullable EntityPlayer player, boolean willHarvest) {
-		List<ItemStack> drops = new ArrayList<>();
-		TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
-		if (ceramic != null) {
-			drops = Collections.singletonList(ceramic.getStack());
-		}
-		boolean hasBeenBroken = world.setBlockToAir(pos);
-		if (hasBeenBroken && BinnieCore.getBinnieProxy().isSimulating(world) && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
-			for (ItemStack drop : drops) {
-				spawnAsEntity(world, pos, drop);
-			}
-		}
-		return hasBeenBroken;
+	public TileEntity createNewTileEntity(World var1, int i) {
+		return new TileEntityMetadata();
 	}
 
 	@Override
-	public TileEntity createTileEntity(World world, IBlockState state) {
-		return new TileCeramic();
-	}
-
-	@Override
-	public boolean hasTileEntity(IBlockState state) {
+	public boolean hasTileEntity(int meta) {
 		return true;
 	}
 
 	@Override
-	public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
-		TileCeramic ceramic = TileUtil.getTile(worldIn, pos, TileCeramic.class);
-		if (ceramic != null) {
-			ceramic.setColor(EnumFlowerColor.VALUES[stack.getItemDamage()]);
-		}
+	public boolean onBlockEventReceived(World world, int x, int y, int z, int eventId, int eventType) {
+		super.onBlockEventReceived(world, x, y, z, eventId, eventType);
+		TileEntity tileentity = world.getTileEntity(x, y, z);
+		return tileentity != null && tileentity.receiveClientEvent(eventId, eventType);
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
-	public void getSubBlocks(Item item, CreativeTabs tab, NonNullList<ItemStack> itemList) {
+	public int getPlacedMeta(ItemStack itemStack, World world, int x, int y, int z, ForgeDirection direction) {
+		return TileEntityMetadata.getItemDamage(itemStack);
+	}
+
+	@Override
+	public int getDroppedMeta(int blockMeta, int tileMeta) {
+		return tileMeta;
+	}
+
+	@Override
+	public String getBlockName(ItemStack itemStack) {
+		return I18N.localise("botany.ceramicBlock");
+	}
+
+	@Override
+	public void addBlockTooltip(ItemStack stack, List tooltip) {
+		int meta = TileEntityMetadata.getItemDamage(stack);
+		tooltip.add(EnumChatFormatting.GRAY + EnumFlowerColor.get(meta).getName());
+	}
+
+	@Override
+	public void dropAsStack(World world, int x, int y, int z, ItemStack itemStack) {
+		dropBlockAsItem(world, x, y, z, itemStack);
+	}
+
+	@Override
+	public void getSubBlocks(Item item, CreativeTabs tabs, List itemList) {
 		for (EnumFlowerColor c : EnumFlowerColor.values()) {
-			itemList.add(new ItemStack(item, 1, c.getFlowerColorAllele().getID()));
+			itemList.add(TileEntityMetadata.getItemStack(this, c.ordinal()));
 		}
 	}
 
 	@Override
-	public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
-		TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
-		if (ceramic != null) {
-			return ceramic.getStack();
-		}
-		return super.getPickBlock(state, target, world, pos, player);
-	}
-
 	@SideOnly(Side.CLIENT)
-	@Override
-	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess world, @Nullable BlockPos pos, int tintIndex) {
-		if (world != null && pos != null) {
-			TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
-			if (ceramic != null) {
-				return ceramic.getColor().getFlowerColorAllele().getColor(false);
-			}
+	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
+		if (tile != null) {
+			return getIcon(side, tile.getTileMetadata());
 		}
-		return EnumFlowerColor.get(0).getFlowerColorAllele().getColor(false);
+		return super.getIcon(world, x, y, z, side);
+	}
+
+	@Override
+	public IIcon getIcon(int side, int meta) {
+		return blockIcon;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerBlockIcons(IIconRegister register) {
+		blockIcon = Botany.proxy.getIcon(register, "ceramic");
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int colorMultiplier(IBlockAccess world, int x, int y, int z) {
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
+		if (tile != null) {
+			return getRenderColor(tile.getTileMetadata());
+		}
+		return 0xffffff;
+	}
+
+	@Override
+	public void breakBlock(World world, int x, int y, int z, Block block, int side) {
+		super.breakBlock(world, x, y, z, block, side);
+		world.removeTileEntity(x, y, z);
+	}
+
+	@Override
+	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer player) {
+		return BlockMetadata.getPickBlock(world, x, y, z);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getRenderColor(int meta) {
+		return EnumFlowerColor.get(meta).getColor(false);
 	}
 }

src/main/java/binnie/botany/ceramic/BlockCeramicBrick.java

@@ -0,0 +1,553 @@
+package binnie.botany.ceramic;
+
+import binnie.botany.Botany;
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.genetics.EnumFlowerColor;
+import binnie.botany.items.BotanyItems;
+import binnie.core.BinnieCore;
+import binnie.core.block.BlockMetadata;
+import binnie.core.block.IBlockMetadata;
+import binnie.core.block.IMultipassBlock;
+import binnie.core.block.MultipassBlockRenderer;
+import binnie.core.block.TileEntityMetadata;
+import binnie.core.util.I18N;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipassBlock {
+	public BlockCeramicBrick() {
+		super(Material.rock);
+		setHardness(1.0f);
+		setResistance(5.0f);
+		setBlockName("ceramicBrick");
+		setCreativeTab(CreativeTabBotany.instance);
+	}
+
+	private static BlockType getType(int meta) {
+		return new BlockType(meta);
+	}
+
+	@Override
+	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int blockMeta, int fortune) {
+		return BlockMetadata.getBlockDropped(this, world, x, y, z, blockMeta);
+	}
+
+	@Override
+	public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z) {
+		return BlockMetadata.breakBlock(this, player, world, x, y, z);
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World var1, int i) {
+		return new TileEntityMetadata();
+	}
+
+	@Override
+	public boolean hasTileEntity(int meta) {
+		return true;
+	}
+
+	@Override
+	public boolean onBlockEventReceived(World world, int x, int y, int z, int eventId, int eventType) {
+		super.onBlockEventReceived(world, x, y, z, eventId, eventType);
+		TileEntity tileentity = world.getTileEntity(x, y, z);
+		return tileentity != null && tileentity.receiveClientEvent(eventId, eventType);
+	}
+
+	@Override
+	public int getPlacedMeta(ItemStack itemStack, World world, int x, int y, int z, ForgeDirection direction) {
+		return TileEntityMetadata.getItemDamage(itemStack);
+	}
+
+	@Override
+	public int getDroppedMeta(int blockMeta, int tileMeta) {
+		return tileMeta;
+	}
+
+	@Override
+	public String getBlockName(ItemStack itemStack) {
+		int meta = TileEntityMetadata.getItemDamage(itemStack);
+		return getType(meta).getName();
+	}
+
+	@Override
+	public void addBlockTooltip(ItemStack itemStack, List tooltip) {
+		int meta = TileEntityMetadata.getItemDamage(itemStack);
+		getType(meta).addTooltip(tooltip);
+	}
+
+	@Override
+	public void dropAsStack(World world, int x, int y, int z, ItemStack itemStack) {
+		dropBlockAsItem(world, x, y, z, itemStack);
+	}
+
+	@Override
+	public void getSubBlocks(Item item, CreativeTabs tab, List itemList) {
+		for (EnumFlowerColor c : EnumFlowerColor.values()) {
+			BlockType type = new BlockType(c, c, TileType.Tile);
+			itemList.add(TileEntityMetadata.getItemStack(this, type.ordinal()));
+		}
+
+		for (TileType type2 : TileType.values()) {
+			if (type2.canDouble()) {
+				itemList.add(new BlockType(EnumFlowerColor.BROWN, EnumFlowerColor.GOLD, type2).getStack(1));
+			}
+		}
+
+		itemList.add(new BlockType(EnumFlowerColor.GOLD, EnumFlowerColor.GOLD, TileType.Split).getStack(1));
+		itemList.add(new BlockType(EnumFlowerColor.BROWN, EnumFlowerColor.BROWN, TileType.Chequered).getStack(1));
+		itemList.add(new BlockType(EnumFlowerColor.GOLD, EnumFlowerColor.BROWN, TileType.LargeBrick).getStack(1));
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
+		if (tile != null) {
+			return getIcon(side, tile.getTileMetadata());
+		}
+		return super.getIcon(world, x, y, z, side);
+	}
+
+	@Override
+	public IIcon getIcon(int side, int meta) {
+		return getType(meta).getIcon(MultipassBlockRenderer.getLayer());
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerBlockIcons(IIconRegister register) {
+		for (TileType type : TileType.values()) {
+			for (int i = 0; i < 3; ++i) {
+				type.icons[i] = Botany.proxy.getIcon(register, "ceramic." + type.id + "." + i);
+			}
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int colorMultiplier(IBlockAccess world, int x, int y, int z) {
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
+		if (tile != null) {
+			return getRenderColor(tile.getTileMetadata());
+		}
+		return 0xffffff;
+	}
+
+	@Override
+	public void breakBlock(World world, int x, int y, int z, Block block, int side) {
+		super.breakBlock(world, x, y, z, block, side);
+		world.removeTileEntity(x, y, z);
+	}
+
+	@Override
+	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
+		return BlockMetadata.getPickBlock(world, x, y, z);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getRenderColor(int meta) {
+		return colorMultiplier(meta);
+	}
+
+	@Override
+	public int getNumberOfPasses() {
+		return 3;
+	}
+
+	@Override
+	public int colorMultiplier(int meta) {
+		BlockType type = getType(meta);
+		if (MultipassBlockRenderer.getLayer() == 0) {
+			return 0xffffff;
+		}
+		if (MultipassBlockRenderer.getLayer() == 1) {
+			return type.color1.getColor(false);
+		}
+		return type.color2.getColor(false);
+	}
+
+	@Override
+	public int getRenderType() {
+		return BinnieCore.multipassRenderID;
+	}
+
+	public enum TileType {
+		Tile("tile", "ceramicTile"),
+		Brick("brick", "ceramicBricks"),
+		StripeBrick("brickstripe", "strippedCeramicBricks"),
+		LargeBrick("bricklarge", "largeCeramicBricks"),
+		Split("split", "splitCeramicTile"),
+		Chequered("cheque", "chequeredCeramicTile"),
+		Mixed("mixed", "mixedCeramicTile"),
+		VerticalBrick("verticalbrick", "verticalCeramicBricks"),
+		VerticalStripeBrick("verticalbrickstripe", "verticalStripedCeramicBricks"),
+		VerticalLargeBrick("verticalbricklarge", "largeVerticalCeramicBricks");
+
+		protected String id;
+		protected String name;
+		protected IIcon[] icons;
+
+		TileType(String id, String name) {
+			icons = new IIcon[3];
+			this.id = id;
+			this.name = name;
+		}
+
+		public static TileType get(int id) {
+			return values()[id % values().length];
+		}
+
+		public boolean canDouble() {
+			return this != TileType.Tile;
+		}
+
+		public ItemStack getRecipe(List<ItemStack> stacks) {
+			switch (this) {
+				case Tile:
+					return getTileRecipe(stacks);
+
+				case Split:
+					return getSplitRecipe(stacks);
+
+				case Chequered:
+					return getChequeredRecipe(stacks);
+
+				case Mixed:
+					return getMixedRecipe(stacks);
+
+				case LargeBrick:
+					return getLargeBrickRecipe(stacks);
+
+				case Brick:
+				case StripeBrick:
+					return getBrickRecipe(stacks);
+
+				case VerticalLargeBrick:
+				case VerticalBrick:
+				case VerticalStripeBrick:
+					return getVerticalBrickRecipe(stacks);
+			}
+			return null;
+		}
+
+		private ItemStack getTileRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return null;
+			}
+
+			int mortars = 0;
+			int blockColor = -1;
+			for (ItemStack stack : stacks) {
+				if (isMortar(stack)) {
+					mortars++;
+				} else {
+					if (stack.getItem() != Item.getItemFromBlock(Botany.ceramic)) {
+						return null;
+					}
+
+					int color = TileEntityMetadata.getItemDamage(stack);
+					if (blockColor == -1) {
+						blockColor = color;
+					} else if (blockColor != color) {
+						return null;
+					}
+				}
+			}
+
+			if (mortars != 1) {
+				return null;
+			}
+			EnumFlowerColor c = EnumFlowerColor.get(blockColor);
+			return new BlockType(c, c, TileType.Tile).getStack(3);
+		}
+
+		private ItemStack getSplitRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return null;
+			}
+
+			int[] colors = {-1, -1};
+			int altCounter = 0;
+			for (ItemStack stack : stacks) {
+				int alt = (altCounter != 0 && altCounter != 3) ? 1 : 0;
+				if (stack.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
+					return null;
+				}
+
+				BlockType type = new BlockType(stack);
+				if (type.type != TileType.Tile) {
+					return null;
+				}
+
+				int color2 = type.color1.ordinal();
+				if (colors[alt] == -1) {
+					colors[alt] = color2;
+				} else if (colors[alt] != color2) {
+					return null;
+				}
+				altCounter++;
+			}
+			return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Split).getStack(4);
+		}
+
+		private ItemStack getChequeredRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return null;
+			}
+
+			int[] colors = {-1, -1};
+			for (ItemStack stack : stacks) {
+				if (stack.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
+					return null;
+				}
+
+				BlockType type2 = new BlockType(stack);
+				if (type2.type != TileType.Split) {
+					return null;
+				}
+
+				int color1 = type2.color1.ordinal();
+				int color2 = type2.color2.ordinal();
+				if (colors[0] == -1) {
+					colors[0] = color1;
+					colors[1] = color2;
+				} else if (colors[0] != color1 || colors[1] != color2) {
+					return null;
+				}
+			}
+			return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Chequered).getStack(4);
+		}
+
+		private ItemStack getMixedRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 4) {
+				return null;
+			}
+
+			int[] colors = {-1, -1};
+			for (ItemStack stack : stacks) {
+				if (stack.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
+					return null;
+				}
+
+				BlockType type2 = new BlockType(stack);
+				if (type2.isTwoColors()) {
+					return null;
+				}
+
+				int color3 = type2.color1.ordinal();
+				if (type2.type == TileType.Split) {
+					if (colors[1] != -1) {
+						return null;
+					}
+					colors[1] = color3;
+				} else {
+					if (type2.type != TileType.Chequered) {
+						return null;
+					}
+
+					if (colors[0] == -1) {
+						colors[0] = color3;
+					} else if (colors[0] != color3) {
+						return null;
+					}
+				}
+			}
+
+			if (colors[0] == -1 || colors[1] == -1) {
+				return null;
+			}
+			return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Mixed).getStack(4);
+		}
+
+		private ItemStack getLargeBrickRecipe(List<ItemStack> stacks) {
+			if (stacks.size() == 1) {
+				ItemStack stack3 = stacks.get(0);
+				BlockType type3 = new BlockType(stack3);
+				if (type3.type == TileType.VerticalLargeBrick) {
+					type3.type = this;
+					return type3.getStack(1);
+				}
+				return null;
+			}
+
+			if (stacks.size() != 3) {
+				return null;
+			}
+
+			int[] colors = {-1, -1};
+			for (ItemStack stack4 : stacks) {
+				if (stack4.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
+					return null;
+				}
+
+				BlockType type4 = new BlockType(stack4);
+				if (type4.type != TileType.Tile) {
+					return null;
+				}
+
+				int color5 = type4.color1.ordinal();
+				if (colors[0] == -1) {
+					colors[0] = color5;
+				} else if (colors[1] == -1) {
+					colors[1] = color5;
+				} else if (colors[1] != color5) {
+					return null;
+				}
+			}
+
+			if (colors[1] == -1) {
+				colors[1] = colors[0];
+			}
+			return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.LargeBrick).getStack(3);
+		}
+
+		private ItemStack getBrickRecipe(List<ItemStack> stacks) {
+			if (stacks.size() == 1) {
+				ItemStack stack = stacks.get(0);
+				BlockType type = new BlockType(stack);
+				if (type.type == TileType.VerticalBrick) {
+					type.type = this;
+					return type.getStack(1);
+				}
+
+				if (type.type == TileType.StripeBrick) {
+					type.type = this;
+					return type.getStack(1);
+				}
+				return null;
+			}
+
+			if (stacks.size() != 4) {
+				return null;
+			}
+
+			int[] colors = {-1, -1};
+			for (int index2 = 0; index2 < stacks.size(); ++index2) {
+				ItemStack stack = stacks.get(index2);
+				if (stack.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
+					return null;
+				}
+
+				BlockType type = new BlockType(stack);
+				if (type.type != TileType.LargeBrick) {
+					return null;
+				}
+
+				int color5 = type.color1.ordinal();
+				int color6 = type.color2.ordinal();
+				int alt2 = (index2 != 0 && index2 != 3) ? 1 : 0;
+				if (this == TileType.StripeBrick) {
+					alt2 = 0;
+				}
+
+				if (colors[alt2] == -1) {
+					colors[alt2] = color5;
+					colors[1 - alt2] = color6;
+				} else if (colors[alt2] != color5 || colors[1 - alt2] != color6) {
+					return null;
+				}
+			}
+			return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), this).getStack(4);
+		}
+
+		private ItemStack getVerticalBrickRecipe(List<ItemStack> stacks) {
+			if (stacks.size() != 1) {
+				return null;
+			}
+
+			ItemStack stack5 = stacks.get(0);
+			BlockType type = new BlockType(stack5);
+			if (type.type == TileType.LargeBrick) {
+				type.type = TileType.VerticalLargeBrick;
+				return type.getStack(1);
+			}
+
+			if (type.type == TileType.Brick) {
+				type.type = TileType.VerticalBrick;
+				return type.getStack(1);
+			}
+
+			if (type.type == TileType.StripeBrick) {
+				type.type = TileType.VerticalStripeBrick;
+				return type.getStack(1);
+			}
+			return null;
+		}
+
+		private boolean isMortar(ItemStack stack) {
+			return stack.getItem() == Botany.misc
+				&& stack.getItemDamage() == BotanyItems.Mortar.ordinal();
+		}
+	}
+
+	public static class BlockType {
+		protected EnumFlowerColor color1;
+		protected EnumFlowerColor color2;
+		protected TileType type;
+
+		private BlockType(EnumFlowerColor color1, EnumFlowerColor color2, TileType type) {
+			this.color1 = color1;
+			this.color2 = color2;
+			this.type = type;
+		}
+
+		public boolean isTwoColors() {
+			return type.canDouble() && color2 != color1;
+		}
+
+		public BlockType(ItemStack stack) {
+			this(TileEntityMetadata.getItemDamage(stack));
+		}
+
+		public ItemStack getStack(int stackSize) {
+			ItemStack stack = TileEntityMetadata.getItemStack(Botany.ceramicBrick, ordinal());
+			stack.stackSize = stackSize;
+			return stack;
+		}
+
+		public BlockType(int id) {
+			color1 = EnumFlowerColor.get(id & 0xFF);
+			color2 = EnumFlowerColor.get(id >> 8 & 0xFF);
+			type = TileType.get(id >> 16 & 0xFF);
+		}
+
+		public String getName() {
+			return I18N.localise("botany." + type.name);
+		}
+
+		public void addTooltip(List tooltip) {
+			String name = color1.getName();
+			if (type.canDouble() && color2 != color1) {
+				name = I18N.localise("botany.colour.double", name, color2.getName());
+			}
+			tooltip.add(EnumChatFormatting.GRAY + name);
+		}
+
+		public int ordinal() {
+			return color1.ordinal() + color2.ordinal() * 256 + type.ordinal() * 65536;
+		}
+
+		public IIcon getIcon(int layer) {
+			return type.icons[layer];
+		}
+	}
+}

src/main/java/binnie/botany/ceramic/BlockCeramicPatterned.java

@@ -1,32 +1,42 @@
 package binnie.botany.ceramic;
 
-import net.minecraft.block.material.Material;
-import net.minecraft.item.ItemStack;
-
 import binnie.botany.CreativeTabBotany;
 import binnie.botany.genetics.EnumFlowerColor;
+import binnie.core.block.TileEntityMetadata;
 import binnie.core.util.I18N;
 import binnie.extratrees.api.IDesign;
 import binnie.extratrees.carpentry.BlockDesign;
 import binnie.extratrees.carpentry.DesignBlock;
 import binnie.extratrees.carpentry.ModuleCarpentry;
+import net.minecraft.block.material.Material;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+
+import java.util.List;
 
 public class BlockCeramicPatterned extends BlockDesign {
 	public BlockCeramicPatterned() {
-		super(CeramicDesignSystem.instance, Material.ROCK);
+		super(CeramicDesignSystem.instance, Material.rock);
 		setHardness(1.0f);
 		setResistance(5.0f);
 		setCreativeTab(CreativeTabBotany.instance);
-		setRegistryName("ceramicPattern");
+		setBlockName("ceramicPattern");
 	}
 
 	@Override
 	public ItemStack getCreativeStack(IDesign design) {
-		return ModuleCarpentry.getItemStack(this, CeramicColor.get(EnumFlowerColor.White), CeramicColor.get(EnumFlowerColor.Black), design);
+		return ModuleCarpentry.getItemStack(this, CeramicColor.get(EnumFlowerColor.WHITE), CeramicColor.get(EnumFlowerColor.BLACK), design);
 	}
 
 	@Override
 	public String getBlockName(DesignBlock design) {
-		return I18N.localise("botany.ceramic.block.name", design.getDesign().getName());
+		return I18N.localise("botany.ceramicBlock");
+	}
+
+	@Override
+	public void addBlockTooltip(ItemStack stack, List tooltip) {
+		super.addBlockTooltip(stack, tooltip);
+		DesignBlock block = ModuleCarpentry.getDesignBlock(getDesignSystem(), TileEntityMetadata.getItemDamage(stack));
+		tooltip.add(EnumChatFormatting.GRAY + block.getDesign().getName());
 	}
 }

src/main/java/binnie/botany/ceramic/BlockStained.java

@@ -0,0 +1,197 @@
+package binnie.botany.ceramic;
+
+import binnie.botany.Botany;
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.genetics.EnumFlowerColor;
+import binnie.core.block.BlockMetadata;
+import binnie.core.block.IBlockMetadata;
+import binnie.core.block.TileEntityMetadata;
+import binnie.core.util.I18N;
+import binnie.extratrees.ExtraTrees;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class BlockStained extends Block implements IBlockMetadata {
+	public BlockStained() {
+		super(Material.glass);
+		setCreativeTab(CreativeTabBotany.instance);
+		setBlockName("stained");
+	}
+
+	@Override
+	public int quantityDropped(Random rand) {
+		return 0;
+	}
+
+	@Override
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	@Override
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getRenderBlockPass() {
+		return 1;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) {
+//		Block block2 = world.getBlock(x - Facing.offsetsXForSide[side], y - Facing.offsetsYForSide[side], z - Facing.offsetsZForSide[side]);
+		Block block = world.getBlock(x, y, z);
+		return block != this
+			&& block != ExtraTrees.blockStained
+			&& super.shouldSideBeRendered(world, x, y, z, side);
+	}
+
+	@Override
+	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int blockMeta, int fortune) {
+		return BlockMetadata.getBlockDropped(this, world, x, y, z, blockMeta);
+	}
+
+	@Override
+	public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z, boolean willHarvest) {
+		return BlockMetadata.breakBlock(this, player, world, x, y, z);
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World var1, int i) {
+		return new TileEntityMetadata();
+	}
+
+	@Override
+	public boolean hasTileEntity(int meta) {
+		return true;
+	}
+
+	@Override
+	public boolean onBlockEventReceived(World world, int x, int y, int z, int eventId, int eventType) {
+		super.onBlockEventReceived(world, x, y, z, eventId, eventType);
+		TileEntity tileentity = world.getTileEntity(x, y, z);
+		return tileentity != null && tileentity.receiveClientEvent(eventId, eventType);
+	}
+
+	@Override
+	public int getPlacedMeta(ItemStack itemStack, World world, int x, int y, int z, ForgeDirection direction) {
+		return TileEntityMetadata.getItemDamage(itemStack);
+	}
+
+	@Override
+	public int getDroppedMeta(int blockMeta, int tileMeta) {
+		return tileMeta;
+	}
+
+	@Override
+	public String getBlockName(ItemStack itemStack) {
+		return I18N.localise("botany.pigmentedGlass");
+	}
+
+	@Override
+	public void addBlockTooltip(ItemStack itemStack, List tooltip) {
+		int meta = TileEntityMetadata.getItemDamage(itemStack);
+		tooltip.add(EnumChatFormatting.GRAY + EnumFlowerColor.get(meta).getName());
+	}
+
+	@Override
+	public void dropAsStack(World world, int x, int y, int z, ItemStack stack) {
+		dropBlockAsItem(world, x, y, z, stack);
+	}
+
+	@Override
+	public void getSubBlocks(Item item, CreativeTabs tab, List itemList) {
+		for (EnumFlowerColor c : EnumFlowerColor.values()) {
+			itemList.add(TileEntityMetadata.getItemStack(this, c.ordinal()));
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
+		if (tile != null) {
+			return getIcon(side, tile.getTileMetadata());
+		}
+		return super.getIcon(world, x, y, z, side);
+	}
+
+	@Override
+	public IIcon getIcon(int side, int meta) {
+		return blockIcon;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerBlockIcons(IIconRegister register) {
+		blockIcon = Botany.proxy.getIcon(register, "stained");
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int colorMultiplier(IBlockAccess world, int x, int y, int z) {
+		TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
+		if (tile != null) {
+			return getRenderColor(tile.getTileMetadata());
+		}
+		return 0xffffff;
+	}
+
+	@Override
+	public void breakBlock(World world, int x, int y, int z, Block block, int side) {
+		super.breakBlock(world, x, y, z, block, side);
+		world.removeTileEntity(x, y, z);
+	}
+
+	@Override
+	public boolean isWood(IBlockAccess world, int x, int y, int z) {
+		return true;
+	}
+
+	@Override
+	public int getFlammability(IBlockAccess world, int x, int y, int z, ForgeDirection face) {
+		return 20;
+	}
+
+	@Override
+	public boolean isFlammable(IBlockAccess world, int x, int y, int z, ForgeDirection face) {
+		return true;
+	}
+
+	@Override
+	public int getFireSpreadSpeed(IBlockAccess world, int x, int y, int z, ForgeDirection face) {
+		return 5;
+	}
+
+	@Override
+	public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer player) {
+		return BlockMetadata.getPickBlock(world, x, y, z);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getRenderColor(int meta) {
+		return EnumFlowerColor.get(meta).getColor(false);
+	}
+}

src/main/java/binnie/botany/ceramic/BlockStainedGlass.java

@@ -1,185 +0,0 @@
-package binnie.botany.ceramic;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Random;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.SoundType;
-import net.minecraft.block.material.Material;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.enchantment.EnchantmentHelper;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.Enchantments;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.stats.StatList;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.BlockRenderLayer;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.RayTraceResult;
-import net.minecraft.world.IBlockAccess;
-import net.minecraft.world.World;
-
-import net.minecraftforge.event.ForgeEventFactory;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.api.core.IItemModelRegister;
-import forestry.api.core.IModelManager;
-import forestry.core.blocks.IColoredBlock;
-
-import binnie.botany.CreativeTabBotany;
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.core.block.BlockMetadata;
-import binnie.core.block.IBlockMetadata;
-import binnie.core.block.TileEntityMetadata;
-import binnie.core.util.I18N;
-
-public class BlockStainedGlass extends Block implements IBlockMetadata, IColoredBlock, IItemModelRegister {
-	public BlockStainedGlass() {
-		super(Material.GLASS);
-		setCreativeTab(CreativeTabBotany.instance);
-		setRegistryName("stained");
-		setSoundType(SoundType.GLASS);
-		setHardness(0.3F);
-	}
-
-	@Override
-	public int quantityDropped(Random rand) {
-		return 0;
-	}
-
-	@Override
-	public boolean isOpaqueCube(IBlockState state) {
-		return false;
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public BlockRenderLayer getBlockLayer() {
-		return BlockRenderLayer.TRANSLUCENT;
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void registerModel(Item item, IModelManager manager) {
-		for (EnumFlowerColor color : EnumFlowerColor.values()) {
-			manager.registerItemModel(item, color.getFlowerColorAllele().getID());
-		}
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public boolean shouldSideBeRendered(IBlockState blockState, IBlockAccess blockAccess, BlockPos pos, EnumFacing side) {
-		IBlockState iblockstate = blockAccess.getBlockState(pos.offset(side));
-		Block block = iblockstate.getBlock();
-		return block != this;
-	}
-
-	@Override
-	public void harvestBlock(World worldIn, EntityPlayer player, BlockPos pos, IBlockState state, @Nullable TileEntity te, ItemStack stack) {
-		player.addStat(StatList.getBlockStats(this));
-		player.addExhaustion(0.005F);
-
-		if (EnchantmentHelper.getEnchantmentLevel(Enchantments.SILK_TOUCH, stack) > 0 && te instanceof TileEntityMetadata) {
-			List<ItemStack> items = new ArrayList<>();
-			TileEntityMetadata tile = (TileEntityMetadata) te;
-			int damage = getDroppedMeta(state, tile.getTileMetadata());
-			ItemStack itemstack = TileEntityMetadata.getItemStack(this, damage);
-
-			if (!itemstack.isEmpty()) {
-				items.add(itemstack);
-			}
-
-			ForgeEventFactory.fireBlockHarvesting(items, worldIn, pos, state, 0, 1.0f, true, player);
-			for (ItemStack item : items) {
-				spawnAsEntity(worldIn, pos, item);
-			}
-		}
-	}
-
-	@Override
-	public List<ItemStack> getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
-		return Collections.emptyList();
-	}
-
-	@Override
-	public TileEntity createNewTileEntity(World var1, int i) {
-		return new TileEntityMetadata();
-	}
-
-	@Override
-	public boolean hasTileEntity(IBlockState state) {
-		return true;
-	}
-
-	@Override
-	public boolean eventReceived(IBlockState state, World worldIn, BlockPos pos, int id, int param) {
-		TileEntity tileentity = worldIn.getTileEntity(pos);
-		return tileentity != null && tileentity.receiveClientEvent(id, param);
-	}
-
-	@Override
-	public int getPlacedMeta(ItemStack stack, World world, BlockPos pos, EnumFacing clickedBlock) {
-		return TileEntityMetadata.getItemDamage(stack);
-	}
-
-	@Override
-	public int getDroppedMeta(IBlockState state, int tileMetadata) {
-		return tileMetadata;
-	}
-
-	@Override
-	public String getDisplayName(ItemStack itemStack) {
-		EnumFlowerColor color = EnumFlowerColor.get(TileEntityMetadata.getItemDamage(itemStack));
-		return I18N.localise("botany.pigmented.glass.name", color.getDisplayName());
-	}
-
-	@Override
-	public void getSubBlocks(Item itemIn, CreativeTabs tab, NonNullList<ItemStack> itemList) {
-		for (EnumFlowerColor color : EnumFlowerColor.values()) {
-			itemList.add(TileEntityMetadata.getItemStack(this, color.ordinal()));
-		}
-	}
-
-	@Override
-	public boolean isWood(IBlockAccess world, BlockPos pos) {
-		return true;
-	}
-
-	@Override
-	public int getFlammability(IBlockAccess world, BlockPos pos, EnumFacing face) {
-		return 20;
-	}
-
-	@Override
-	public boolean isFlammable(IBlockAccess world, BlockPos pos, EnumFacing face) {
-		return true;
-	}
-
-	@Override
-	public int getFireSpreadSpeed(IBlockAccess world, BlockPos pos, EnumFacing face) {
-		return 5;
-	}
-
-	@Override
-	public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
-		return BlockMetadata.getPickBlock(world, pos);
-	}
-
-	@Override
-	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess worldIn, @Nullable BlockPos pos, int tintIndex) {
-		if (worldIn == null || pos == null) {
-			return 0;
-		}
-		EnumFlowerColor color = EnumFlowerColor.get(TileEntityMetadata.getTileMetadata(worldIn, pos));
-		return color.getFlowerColorAllele().getColor(false);
-	}
-}

src/main/java/binnie/botany/ceramic/CeramicColor.java

@@ -1,25 +1,25 @@
 package binnie.botany.ceramic;
 
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import net.minecraft.item.ItemStack;
-
 import binnie.botany.Botany;
 import binnie.botany.genetics.EnumFlowerColor;
 import binnie.core.block.TileEntityMetadata;
 import binnie.extratrees.api.IDesignMaterial;
+import net.minecraft.item.ItemStack;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
 
 public class CeramicColor implements IDesignMaterial {
-	private final static Map<EnumFlowerColor, CeramicColor> map = new LinkedHashMap<>();
+	private static Map<EnumFlowerColor, CeramicColor> map;
 
 	static {
+		CeramicColor.map = new LinkedHashMap<>();
 		for (EnumFlowerColor c : EnumFlowerColor.values()) {
 			CeramicColor.map.put(c, new CeramicColor(c));
 		}
 	}
 
-	EnumFlowerColor color;
+	protected EnumFlowerColor color;
 
 	CeramicColor(EnumFlowerColor color) {
 		this.color = color;
@@ -35,17 +35,12 @@ public class CeramicColor implements IDesignMaterial {
 	}
 
 	@Override
-	public ItemStack getStack(boolean fireproof) {
-		return getStack();
-	}
-
-	@Override
-	public String getDesignMaterialName() {
+	public String getName() {
 		return color.getName();
 	}
 
 	@Override
-	public int getColour() {
-		return color.getFlowerColorAllele().getColor(false);
+	public int getColor() {
+		return color.getColor(false);
 	}
 }

src/main/java/binnie/botany/ceramic/CeramicDesignSystem.java

@@ -1,33 +1,28 @@
 package binnie.botany.ceramic;
 
-import javax.annotation.Nullable;
-import java.util.HashMap;
-import java.util.Map;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.ResourceLocation;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import binnie.botany.Botany;
 import binnie.botany.genetics.EnumFlowerColor;
 import binnie.botany.items.BotanyItems;
 import binnie.core.AbstractMod;
+import binnie.core.BinnieCore;
 import binnie.extratrees.api.IDesignMaterial;
 import binnie.extratrees.api.IDesignSystem;
 import binnie.extratrees.api.IPattern;
 import binnie.extratrees.carpentry.DesignerManager;
 import binnie.extratrees.carpentry.EnumPattern;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+
+import java.util.HashMap;
+import java.util.Map;
 
 public class CeramicDesignSystem implements IDesignSystem {
 	public static CeramicDesignSystem instance = new CeramicDesignSystem();
-	Map<Integer, TextureAtlasSprite> primary;
-	Map<Integer, TextureAtlasSprite> secondary;
+
+	protected Map<Integer, IIcon> primary;
+	protected Map<Integer, IIcon> secondary;
 
 	CeramicDesignSystem() {
 		primary = new HashMap<>();
@@ -37,12 +32,12 @@ public class CeramicDesignSystem implements IDesignSystem {
 
 	@Override
 	public IDesignMaterial getDefaultMaterial() {
-		return CeramicColor.get(EnumFlowerColor.White);
+		return CeramicColor.get(EnumFlowerColor.WHITE);
 	}
 
 	@Override
 	public IDesignMaterial getDefaultMaterial2() {
-		return CeramicColor.get(EnumFlowerColor.Black);
+		return CeramicColor.get(EnumFlowerColor.BLACK);
 	}
 
 	@Override
@@ -56,13 +51,11 @@ public class CeramicDesignSystem implements IDesignSystem {
 	}
 
 	public String getTexturePath() {
-		return "blocks/ceramic";
+		return "ceramic";
 	}
 
 	@Override
-	@Nullable
-	@SideOnly(Side.CLIENT)
-	public TextureAtlasSprite getPrimarySprite(IPattern pattern) {
+	public IIcon getPrimaryIcon(IPattern pattern) {
 		if (pattern instanceof EnumPattern) {
 			return primary.get(((EnumPattern) pattern).ordinal());
 		}
@@ -70,9 +63,7 @@ public class CeramicDesignSystem implements IDesignSystem {
 	}
 
 	@Override
-	@Nullable
-	@SideOnly(Side.CLIENT)
-	public TextureAtlasSprite getSecondarySprite(IPattern pattern) {
+	public IIcon getSecondaryIcon(IPattern pattern) {
 		if (pattern instanceof EnumPattern) {
 			return secondary.get(((EnumPattern) pattern).ordinal());
 		}
@@ -80,14 +71,10 @@ public class CeramicDesignSystem implements IDesignSystem {
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerSprites() {
-		TextureMap textureMap = Minecraft.getMinecraft().getTextureMapBlocks();
+	public void registerIcons(IIconRegister register) {
 		for (EnumPattern pattern : EnumPattern.values()) {
-			ResourceLocation primaryLocation = new ResourceLocation(getMod().getModID(), getTexturePath() + "/" + pattern.toString().toLowerCase() + ".0");
-			ResourceLocation secondaryLocation = new ResourceLocation(getMod().getModID(), getTexturePath() + "/" + pattern.toString().toLowerCase() + ".1");
-			primary.put(pattern.ordinal(), textureMap.registerSprite(primaryLocation));
-			secondary.put(pattern.ordinal(), textureMap.registerSprite(secondaryLocation));
+			primary.put(pattern.ordinal(), BinnieCore.proxy.getIcon(register, getMod().getModID(), getTexturePath() + "/" + pattern.toString().toLowerCase() + ".0"));
+			secondary.put(pattern.ordinal(), BinnieCore.proxy.getIcon(register, getMod().getModID(), getTexturePath() + "/" + pattern.toString().toLowerCase() + ".1"));
 		}
 	}
 
@@ -97,14 +84,11 @@ public class CeramicDesignSystem implements IDesignSystem {
 
 	@Override
 	public ItemStack getAdhesive() {
-		return BotanyItems.MORTAR.get(1);
+		return BotanyItems.Mortar.get(1);
 	}
 
 	@Override
-	@Nullable
-	public IDesignMaterial getMaterial(ItemStack itemStack) {
-		return (itemStack.getItem() == Item.getItemFromBlock(Botany.ceramic))
-				? getMaterial(itemStack.getItemDamage())
-				: null;
+	public IDesignMaterial getMaterial(ItemStack stack) {
+		return (stack.getItem() == Item.getItemFromBlock(Botany.ceramic)) ? getMaterial(stack.getItemDamage()) : null;
 	}
 }

src/main/java/binnie/botany/ceramic/CeramicTileRecipe.java

@@ -1,27 +1,22 @@
 package binnie.botany.ceramic;
 
-import java.util.ArrayList;
-import java.util.List;
-
+import binnie.botany.Botany;
 import net.minecraft.inventory.InventoryCrafting;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.IRecipe;
-import net.minecraft.util.NonNullList;
 import net.minecraft.world.World;
 
-import net.minecraftforge.common.ForgeHooks;
-
-import binnie.botany.Botany;
-import binnie.botany.ceramic.brick.CeramicBrickType;
+import java.util.ArrayList;
+import java.util.List;
 
 public class CeramicTileRecipe implements IRecipe {
-	private ItemStack cached = ItemStack.EMPTY;
+	protected ItemStack cached;
 
 	@Override
-	public boolean matches(InventoryCrafting inv, World world) {
-		cached = getCraftingResult(inv);
-		return !cached.isEmpty();
+	public boolean matches(InventoryCrafting crafting, World world) {
+		cached = getCraftingResult(crafting);
+		return cached != null;
 	}
 
 	@Override
@@ -33,9 +28,10 @@ public class CeramicTileRecipe implements IRecipe {
 		List<ItemStack> stacks = new ArrayList<>();
 		int ix = -1;
 		int iy = -1;
+
 		for (int i = 0; i < inv.getSizeInventory(); ++i) {
 			ItemStack stack = inv.getStackInSlot(i);
-			if (!stack.isEmpty()) {
+			if (stack != null) {
 				int x = i / 3;
 				int y = i % 3;
 				if (ix == -1) {
@@ -43,21 +39,24 @@ public class CeramicTileRecipe implements IRecipe {
 					iy = y;
 				}
 				if (x - ix >= 2 || y - iy >= 2 || y < iy || x < ix) {
-					return ItemStack.EMPTY;
+					return null;
 				}
-				if (stack.getItem() != ceramicBlock && stack.getItem() != ceramicTile && stack.getItem() != ceramicBrick && stack.getItem() != mortar) {
-					return ItemStack.EMPTY;
+				
+				Item item = stack.getItem();
+				if (item != ceramicBlock && item != ceramicTile && item != ceramicBrick && item != mortar) {
+					return null;
 				}
 				stacks.add(stack);
 			}
 		}
-		for (CeramicBrickType type : CeramicBrickType.VALUES) {
-			ItemStack result = type.getRecipe(stacks);
-			if (!result.isEmpty()) {
-				return result;
+
+		for (BlockCeramicBrick.TileType type : BlockCeramicBrick.TileType.values()) {
+			ItemStack stack2 = type.getRecipe(stacks);
+			if (stack2 != null) {
+				return stack2;
 			}
 		}
-		return ItemStack.EMPTY;
+		return null;
 	}
 
 	@Override
@@ -69,9 +68,4 @@ public class CeramicTileRecipe implements IRecipe {
 	public ItemStack getRecipeOutput() {
 		return cached;
 	}
-
-	@Override
-	public NonNullList<ItemStack> getRemainingItems(InventoryCrafting inv) {
-		return ForgeHooks.defaultRecipeGetRemainingItems(inv);
-	}
 }

src/main/java/binnie/botany/ceramic/ItemCeramic.java

@@ -1,37 +0,0 @@
-package binnie.botany.ceramic;
-
-import net.minecraft.item.ItemBlock;
-import net.minecraft.item.ItemStack;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.core.items.IColoredItem;
-
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.core.util.I18N;
-
-public class ItemCeramic extends ItemBlock implements IColoredItem {
-	public ItemCeramic(BlockCeramic block) {
-		super(block);
-	}
-
-	@Override
-	public int getMetadata(int metadata) {
-		return metadata;
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public int getColorFromItemstack(ItemStack stack, int tintIndex) {
-		EnumFlowerColor color = EnumFlowerColor.get(stack.getItemDamage());
-		return color.getFlowerColorAllele().getColor(false);
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public String getItemStackDisplayName(ItemStack itemStack) {
-		EnumFlowerColor color = EnumFlowerColor.get(itemStack.getItemDamage());
-		return I18N.localise("botany.ceramic.name", color.getDisplayName());
-	}
-}

src/main/java/binnie/botany/ceramic/ItemStainedGlass.java

@@ -1,26 +0,0 @@
-package binnie.botany.ceramic;
-
-import net.minecraft.block.Block;
-import net.minecraft.item.ItemStack;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.core.items.IColoredItem;
-
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.core.block.ItemMetadata;
-import binnie.core.block.TileEntityMetadata;
-
-public class ItemStainedGlass extends ItemMetadata implements IColoredItem {
-	public ItemStainedGlass(Block block) {
-		super(block);
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public int getColorFromItemstack(ItemStack stack, int tintIndex) {
-		EnumFlowerColor color = EnumFlowerColor.get(TileEntityMetadata.getItemDamage(stack));
-		return color.getFlowerColorAllele().getColor(false);
-	}
-}

src/main/java/binnie/botany/ceramic/PigmentRecipe.java

@@ -1,43 +1,51 @@
 package binnie.botany.ceramic;
 
-import net.minecraft.inventory.InventoryCrafting;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.crafting.IRecipe;
-import net.minecraft.util.NonNullList;
-import net.minecraft.world.World;
-
-import net.minecraftforge.common.ForgeHooks;
-
 import binnie.Binnie;
 import binnie.botany.Botany;
 import binnie.botany.api.IFlower;
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.world.World;
 
 public class PigmentRecipe implements IRecipe {
+	protected ItemStack cached;
+
+	private ItemStack unknown;
+
+	public PigmentRecipe() {
+		unknown = null;
+	}
+
 	@Override
 	public boolean matches(InventoryCrafting crafting, World world) {
-		return !getCraftingResult(crafting).isEmpty();
+		return getCraftingResult(crafting) != null;
 	}
 
 	@Override
 	public ItemStack getRecipeOutput() {
-		return ItemStack.EMPTY;
+		if (cached != null) {
+			return cached;
+		}
+		return unknown;
 	}
 
 	@Override
 	public ItemStack getCraftingResult(InventoryCrafting crafting) {
 		int n = 0;
-		ItemStack stack = ItemStack.EMPTY;
+		ItemStack stack = null;
 		for (int i = 0; i < crafting.getSizeInventory(); ++i) {
-			ItemStack stackInSlot = crafting.getStackInSlot(i);
-			if (!stackInSlot.isEmpty()) {
+			if (crafting.getStackInSlot(i) != null) {
 				if (++n > 1) {
-					return ItemStack.EMPTY;
+					return null;
 				}
-				if (Binnie.GENETICS.getFlowerRoot().isMember(stackInSlot)) {
-					IFlower flower = Binnie.GENETICS.getFlowerRoot().getMember(stackInSlot);
-					if (flower != null && flower.getAge() >= 1) {
-						stack = new ItemStack(Botany.pigment, 1, flower.getGenome().getPrimaryColor().getID());
-					}
+				if (!Binnie.Genetics.getFlowerRoot().isMember(crafting.getStackInSlot(i))) {
+					continue;
+				}
+
+				IFlower flower = Binnie.Genetics.getFlowerRoot().getMember(crafting.getStackInSlot(i));
+				if (flower.getAge() >= 1) {
+					stack = new ItemStack(Botany.pigment, 1, flower.getGenome().getPrimaryColor().getID());
 				}
 			}
 		}
@@ -48,9 +56,4 @@ public class PigmentRecipe implements IRecipe {
 	public int getRecipeSize() {
 		return 1;
 	}
-
-	@Override
-	public NonNullList<ItemStack> getRemainingItems(InventoryCrafting inv) {
-		return ForgeHooks.defaultRecipeGetRemainingItems(inv);
-	}
 }

src/main/java/binnie/botany/ceramic/TileCeramic.java

@@ -1,44 +0,0 @@
-package binnie.botany.ceramic;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-
-import binnie.botany.Botany;
-import binnie.botany.genetics.EnumFlowerColor;
-
-public class TileCeramic extends TileEntity {
-	protected EnumFlowerColor color = EnumFlowerColor.Black;
-
-	public EnumFlowerColor getColor() {
-		return color;
-	}
-
-	public void setColor(EnumFlowerColor color) {
-		this.color = color;
-	}
-
-	@Override
-	public NBTTagCompound writeToNBT(NBTTagCompound compound) {
-		compound.setInteger("Color", color.getFlowerColorAllele().getID());
-		return super.writeToNBT(compound);
-	}
-
-	@Override
-	public void readFromNBT(NBTTagCompound compound) {
-		super.readFromNBT(compound);
-		color = EnumFlowerColor.VALUES[compound.getInteger("Color")];
-	}
-
-	public ItemStack getStack() {
-		return getStack(1);
-	}
-
-	public ItemStack getStack(int amount) {
-		int ID = 0;
-		if (color != null) {
-			ID = color.getFlowerColorAllele().getID();
-		}
-		return new ItemStack(Botany.ceramic, amount, ID);
-	}
-}

src/main/java/binnie/botany/ceramic/brick/BlockCeramicBrick.java

@@ -1,262 +0,0 @@
-package binnie.botany.ceramic.brick;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.material.Material;
-import net.minecraft.block.properties.IProperty;
-import net.minecraft.block.properties.PropertyEnum;
-import net.minecraft.block.state.BlockStateContainer;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.ItemMeshDefinition;
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.BlockRenderLayer;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.EnumHand;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.RayTraceResult;
-import net.minecraft.world.IBlockAccess;
-import net.minecraft.world.World;
-
-import net.minecraftforge.client.model.ModelLoader;
-import net.minecraftforge.common.property.ExtendedBlockState;
-import net.minecraftforge.common.property.IExtendedBlockState;
-import net.minecraftforge.common.property.IUnlistedProperty;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.api.core.IItemModelRegister;
-import forestry.api.core.IModelManager;
-import forestry.api.core.ISpriteRegister;
-import forestry.api.core.IStateMapperRegister;
-import forestry.api.core.ITextureManager;
-import forestry.core.blocks.IColoredBlock;
-import forestry.core.blocks.properties.UnlistedBlockAccess;
-import forestry.core.blocks.properties.UnlistedBlockPos;
-import forestry.core.models.BlockModelEntry;
-
-import binnie.Constants;
-import binnie.botany.CreativeTabBotany;
-import binnie.botany.ceramic.TileCeramic;
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.core.BinnieCore;
-import binnie.core.block.IMultipassBlock;
-import binnie.core.models.DefaultStateMapper;
-import binnie.core.models.ModelManager;
-import binnie.core.models.ModelMutlipass;
-import binnie.core.util.TileUtil;
-
-public class BlockCeramicBrick extends Block implements IMultipassBlock<CeramicBrickPair>, IColoredBlock, ISpriteRegister, IStateMapperRegister, IItemModelRegister {
-	private static final PropertyEnum<CeramicBrickType> TYPE = PropertyEnum.create("type", CeramicBrickType.class);
-
-	public BlockCeramicBrick() {
-		super(Material.ROCK);
-		setHardness(1.0f);
-		setResistance(5.0f);
-		setRegistryName("ceramicBrick");
-		setCreativeTab(CreativeTabBotany.instance);
-	}
-
-	@Override
-	public List<ItemStack> getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
-		return Collections.emptyList();
-	}
-
-	@Override
-	public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, @Nullable EntityPlayer player, boolean willHarvest) {
-		List<ItemStack> drops = new ArrayList<>();
-		TileCeramic ceramic = TileUtil.getTile(world, pos, TileCeramic.class);
-		if (ceramic != null) {
-			drops = Collections.singletonList(ceramic.getStack());
-		}
-		boolean hasBeenBroken = world.setBlockToAir(pos);
-		if (hasBeenBroken && BinnieCore.getBinnieProxy().isSimulating(world) && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
-			for (ItemStack drop : drops) {
-				spawnAsEntity(world, pos, drop);
-			}
-		}
-		return hasBeenBroken;
-	}
-
-	@Override
-	public TileEntity createTileEntity(World world, IBlockState state) {
-		return new TileCeramicBrick();
-	}
-
-	@Override
-	public boolean hasTileEntity(IBlockState state) {
-		return true;
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void getSubBlocks(Item item, CreativeTabs tab, NonNullList<ItemStack> itemList) {
-		for (EnumFlowerColor color : EnumFlowerColor.values()) {
-			itemList.add(new CeramicBrickPair(color, color, CeramicBrickType.TILE).getStack(1));
-		}
-		for (CeramicBrickType type : CeramicBrickType.VALUES) {
-			if (type.canDouble()) {
-				itemList.add(new CeramicBrickPair(EnumFlowerColor.Brown, EnumFlowerColor.Gold, type).getStack(1));
-			}
-		}
-		itemList.add(new CeramicBrickPair(EnumFlowerColor.Gold, EnumFlowerColor.Gold, CeramicBrickType.SPLIT).getStack(1));
-		itemList.add(new CeramicBrickPair(EnumFlowerColor.Brown, EnumFlowerColor.Brown, CeramicBrickType.CHEQUERED).getStack(1));
-		itemList.add(new CeramicBrickPair(EnumFlowerColor.Gold, EnumFlowerColor.Brown, CeramicBrickType.LARGE_BRICK).getStack(1));
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void registerStateMapper() {
-		ResourceLocation resourceLocation = new ResourceLocation(Constants.BOTANY_MOD_ID, "ceramicBrick");
-		ModelLoader.setCustomStateMapper(this, new DefaultStateMapper(resourceLocation));
-		ModelManager.registerCustomBlockModel(new BlockModelEntry(
-				new ModelResourceLocation(resourceLocation, "normal"),
-				new ModelResourceLocation(resourceLocation, "inventory"),
-				new ModelMutlipass<>(BlockCeramicBrick.class),
-				this
-		));
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void registerModel(Item item, IModelManager manager) {
-		manager.registerItemModel(item, new CeramicBrickMeshDefinition());
-	}
-
-	@Override
-	protected BlockStateContainer createBlockState() {
-		return new ExtendedBlockState(
-				this,
-				new IProperty[]{TYPE},
-				new IUnlistedProperty[]{
-						UnlistedBlockPos.POS,
-						UnlistedBlockAccess.BLOCKACCESS
-				}
-		);
-	}
-
-	@Override
-	public IBlockState getStateFromMeta(int meta) {
-		return getDefaultState().withProperty(TYPE, CeramicBrickType.VALUES[meta]);
-	}
-
-	@Override
-	public int getMetaFromState(IBlockState state) {
-		return state.getValue(TYPE).ordinal();
-	}
-
-	@Override
-	public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-		return ((IExtendedBlockState) super.getExtendedState(state, world, pos)).withProperty(UnlistedBlockPos.POS, pos).withProperty(UnlistedBlockAccess.BLOCKACCESS, world);
-	}
-
-	@Override
-	public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) {
-		return getDefaultState().withProperty(TYPE, CeramicBrickType.get(meta >> 16 & 0xFF));
-	}
-
-	@Override
-	public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
-		TileCeramicBrick ceramic = TileUtil.getTile(worldIn, pos, TileCeramicBrick.class);
-		if (ceramic != null) {
-			int damage = stack.getItemDamage();
-			ceramic.setColors(EnumFlowerColor.get(damage & 0xFF), EnumFlowerColor.get(damage >> 8 & 0xFF));
-		}
-	}
-
-	@Override
-	public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) {
-		TileCeramicBrick ceramic = TileUtil.getTile(world, pos, TileCeramicBrick.class);
-		if (ceramic != null) {
-			return ceramic.pair().getStack(0);
-		}
-		return super.getPickBlock(state, target, world, pos, player);
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess world, @Nullable BlockPos pos, int tintIndex) {
-		if (world != null && pos != null) {
-			TileCeramicBrick ceramic = TileUtil.getTile(world, pos, TileCeramicBrick.class);
-			if (ceramic != null) {
-				if (tintIndex == 1) {
-					return ceramic.getColorFirst().getFlowerColorAllele().getColor(false);
-				} else if (tintIndex == 2) {
-					return ceramic.getColorSecond().getFlowerColorAllele().getColor(false);
-				}
-			}
-		}
-		return 0xffffff;
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public BlockRenderLayer getBlockLayer() {
-		return BlockRenderLayer.CUTOUT;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public int getRenderPasses() {
-		return 3;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public CeramicBrickPair getInventoryKey(ItemStack stack) {
-		return new CeramicBrickPair(stack);
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public CeramicBrickPair getWorldKey(IBlockState state) {
-		IExtendedBlockState extendedState = (IExtendedBlockState) state;
-		IBlockAccess world = extendedState.getValue(UnlistedBlockAccess.BLOCKACCESS);
-		BlockPos pos = extendedState.getValue(UnlistedBlockPos.POS);
-		TileCeramicBrick ceramic = TileUtil.getTile(world, pos, TileCeramicBrick.class);
-		if (ceramic != null) {
-			return ceramic.pair();
-		}
-		return null;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public TextureAtlasSprite getSprite(CeramicBrickPair type, @Nullable EnumFacing facing, int pass) {
-		return type.getSprite(pass);
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerSprites(ITextureManager manager) {
-		TextureMap textureMap = Minecraft.getMinecraft().getTextureMapBlocks();
-		for (CeramicBrickType type : CeramicBrickType.VALUES) {
-			type.sprites = new TextureAtlasSprite[3];
-			for (int i = 0; i < 3; ++i) {
-				type.sprites[i] = textureMap.registerSprite(new ResourceLocation(Constants.BOTANY_MOD_ID + ":blocks/ceramic." + type.id + "." + i));
-			}
-		}
-	}
-
-	private class CeramicBrickMeshDefinition implements ItemMeshDefinition {
-		@Override
-		public ModelResourceLocation getModelLocation(ItemStack stack) {
-			return new ModelResourceLocation(Constants.BOTANY_MOD_ID + ":ceramicBrick", "inventory");
-		}
-	}
-}

src/main/java/binnie/botany/ceramic/brick/CeramicBrickPair.java

@@ -1,77 +0,0 @@
-package binnie.botany.ceramic.brick;
-
-import com.google.common.base.Preconditions;
-
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.item.ItemStack;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import binnie.botany.Botany;
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.core.block.TileEntityMetadata;
-import binnie.core.util.I18N;
-
-public class CeramicBrickPair {
-	public final EnumFlowerColor colorFirst;
-	public final EnumFlowerColor colorSecond;
-
-	public CeramicBrickType type;
-	public int ordinal;
-
-	CeramicBrickPair(EnumFlowerColor colorFirst, EnumFlowerColor colorSecond, CeramicBrickType type) {
-		this.colorFirst = colorFirst;
-		this.colorSecond = colorSecond;
-		this.type = type;
-		ordinal = colorFirst.ordinal() + colorSecond.ordinal() * 256 + type.ordinal() * 256 * 256;
-	}
-
-	public CeramicBrickPair(ItemStack stack) {
-		this(TileEntityMetadata.getItemDamage(stack));
-	}
-
-	public CeramicBrickPair(int id) {
-		colorFirst = EnumFlowerColor.get(id & 0xFF);
-		colorSecond = EnumFlowerColor.get(id >> 8 & 0xFF);
-		type = CeramicBrickType.get(id >> 16 & 0xFF);
-	}
-
-	public boolean isTwoColors() {
-		return type.canDouble() && colorSecond != colorFirst;
-	}
-
-	public ItemStack getStack(int i) {
-		return new ItemStack(Botany.ceramicBrick, i, ordinal());
-	}
-
-	public String getName() {
-		String name = colorFirst.getFlowerColorAllele().getColorName();
-		if (type.canDouble() && colorSecond != colorFirst) {
-			name = name + " & " + colorSecond.getFlowerColorAllele().getColorName();
-		}
-		return I18N.localise("botany.ceramic.type." + type.id + ".name", name);
-	}
-
-	public int ordinal() {
-		return ordinal;
-	}
-
-	@SideOnly(Side.CLIENT)
-	public TextureAtlasSprite getSprite(int pass) {
-		TextureAtlasSprite[] sprites = type.sprites;
-		Preconditions.checkState(sprites != null, "Sprites have not been registered.");
-		return sprites[pass];
-	}
-
-	@Override
-	public int hashCode() {
-		return Integer.hashCode(ordinal());
-	}
-
-	@Override
-	public boolean equals(Object obj) {
-		return obj instanceof CeramicBrickPair
-				&& ((CeramicBrickPair) obj).ordinal() == ordinal();
-	}
-}

src/main/java/binnie/botany/ceramic/brick/CeramicBrickType.java

@@ -1,329 +0,0 @@
-package binnie.botany.ceramic.brick;
-
-import javax.annotation.Nullable;
-import java.util.List;
-
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.IStringSerializable;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import binnie.botany.Botany;
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.botany.items.BotanyItems;
-import binnie.core.block.TileEntityMetadata;
-
-public enum CeramicBrickType implements IStringSerializable {
-	TILE("tile") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			if (stacks.size() != 4) {
-				return ItemStack.EMPTY;
-			}
-			int mortars = 0;
-			int blocks = 0;
-			int blockColor = -1;
-			for (ItemStack stack : stacks) {
-				if (isMortar(stack)) {
-					++mortars;
-				} else {
-					if (stack.getItem() != Item.getItemFromBlock(Botany.ceramic)) {
-						return ItemStack.EMPTY;
-					}
-					++blocks;
-					int color = TileEntityMetadata.getItemDamage(stack);
-					if (blockColor == -1) {
-						blockColor = color;
-					} else {
-						if (blockColor != color) {
-							return ItemStack.EMPTY;
-						}
-					}
-				}
-			}
-			if (mortars != 1) {
-				return ItemStack.EMPTY;
-			}
-			EnumFlowerColor c = EnumFlowerColor.get(blockColor);
-			return new CeramicBrickPair(c, c, CeramicBrickType.TILE).getStack(3);
-		}
-	},
-	BRICK("brick") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			return getBrickRecipe(this, stacks);
-		}
-	},
-	STRIPE_BRICK("brickstripe") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			return getBrickRecipe(this, stacks);
-		}
-	},
-	LARGE_BRICK("bricklarge") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			if (stacks.size() == 1) {
-				ItemStack stack3 = stacks.get(0);
-				CeramicBrickPair type3 = new CeramicBrickPair(stack3);
-				if (type3.type == CeramicBrickType.VERTICAL_LARGE_BRICK) {
-					type3.type = this;
-					return type3.getStack(1);
-				}
-				return ItemStack.EMPTY;
-			} else {
-				if (stacks.size() != 3) {
-					return ItemStack.EMPTY;
-				}
-				int[] colors = {-1, -1};
-				int a = 0;
-				int b = 0;
-				for (ItemStack stack4 : stacks) {
-					if (stack4.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
-						return ItemStack.EMPTY;
-					}
-					CeramicBrickPair type4 = new CeramicBrickPair(stack4);
-					if (type4.type != CeramicBrickType.TILE) {
-						return ItemStack.EMPTY;
-					}
-					int color5 = type4.colorFirst.ordinal();
-					if (colors[0] == -1) {
-						colors[0] = color5;
-						a++;
-					} else if (colors[0] == color5) {
-						a++;
-					} else if (colors[1] == -1) {
-						colors[1] = color5;
-						b++;
-					} else {
-						if (colors[1] != color5) {
-							return ItemStack.EMPTY;
-						}
-						b++;
-					}
-				}
-				if (colors[1] == -1) {
-					colors[1] = colors[0];
-				}
-				return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.LARGE_BRICK).getStack(3);
-			}
-		}
-	},
-	SPLIT("split") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			if (stacks.size() != 4) {
-				return ItemStack.EMPTY;
-			}
-			int[] colors = {-1, -1};
-			int altCounter = 0;
-			for (ItemStack stack2 : stacks) {
-				int alt = (altCounter != 0 && altCounter != 3) ? 1 : 0;
-				if (stack2.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
-					return ItemStack.EMPTY;
-				}
-				CeramicBrickPair type = new CeramicBrickPair(stack2);
-				if (type.type != CeramicBrickType.TILE) {
-					return ItemStack.EMPTY;
-				}
-				int color2 = type.colorFirst.ordinal();
-				if (colors[alt] == -1) {
-					colors[alt] = color2;
-				} else if (colors[alt] != color2) {
-					return ItemStack.EMPTY;
-				}
-				++altCounter;
-			}
-			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.SPLIT).getStack(4);
-		}
-	},
-	CHEQUERED("cheque") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			if (stacks.size() != 4) {
-				return ItemStack.EMPTY;
-			}
-			int[] colors = {-1, -1};
-			for (ItemStack stack2 : stacks) {
-				if (stack2.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
-					return ItemStack.EMPTY;
-				}
-				CeramicBrickPair type2 = new CeramicBrickPair(stack2);
-				if (type2.type != CeramicBrickType.SPLIT) {
-					return ItemStack.EMPTY;
-				}
-				int color3 = type2.colorFirst.ordinal();
-				int color4 = type2.colorSecond.ordinal();
-				if (colors[0] == -1) {
-					colors[0] = color3;
-					colors[1] = color4;
-				} else {
-					if (colors[0] != color3 || colors[1] != color4) {
-						return ItemStack.EMPTY;
-					}
-				}
-			}
-			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.CHEQUERED).getStack(4);
-		}
-	},
-	MIXED("mixed") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			if (stacks.size() != 4) {
-				return ItemStack.EMPTY;
-			}
-			int[] colors = {-1, -1};
-			for (ItemStack stack2 : stacks) {
-				if (stack2.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
-					return ItemStack.EMPTY;
-				}
-				CeramicBrickPair type2 = new CeramicBrickPair(stack2);
-				if (type2.isTwoColors()) {
-					return ItemStack.EMPTY;
-				}
-				int color3 = type2.colorFirst.ordinal();
-				if (type2.type == CeramicBrickType.SPLIT) {
-					if (colors[1] != -1) {
-						return ItemStack.EMPTY;
-					}
-					colors[1] = color3;
-				} else {
-					if (type2.type != CeramicBrickType.CHEQUERED) {
-						return ItemStack.EMPTY;
-					}
-					if (colors[0] == -1) {
-						colors[0] = color3;
-					} else if (colors[0] != color3) {
-						return ItemStack.EMPTY;
-					}
-				}
-				int color4 = type2.colorSecond.ordinal();
-			}
-			if (colors[0] == -1 || colors[1] == -1) {
-				return ItemStack.EMPTY;
-			}
-			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), CeramicBrickType.MIXED).getStack(4);
-		}
-	},
-	VERTICAL_BRICK("verticalbrick") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			return getVerticalBrickRecipe(stacks);
-		}
-	},
-	VERTICAL_STRIPE_BRICK("verticalbrickstripe") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			return getVerticalBrickRecipe(stacks);
-		}
-	},
-	VERTICAL_LARGE_BRICK("verticalbricklarge") {
-		@Override
-		public ItemStack getRecipe(List<ItemStack> stacks) {
-			return getVerticalBrickRecipe(stacks);
-		}
-	};
-
-	public static final CeramicBrickType[] VALUES = values();
-
-	public String id;
-
-	@SideOnly(Side.CLIENT)
-	@Nullable
-	TextureAtlasSprite[] sprites;
-
-	CeramicBrickType(String id) {
-		this.id = id;
-	}
-
-	public static CeramicBrickType get(int id) {
-		return VALUES[id % VALUES.length];
-	}
-
-	public boolean canDouble() {
-		return this != CeramicBrickType.TILE;
-	}
-
-	public abstract ItemStack getRecipe(List<ItemStack> stacks);
-
-	protected ItemStack getVerticalBrickRecipe(List<ItemStack> stacks) {
-		if (stacks.size() != 1) {
-			return ItemStack.EMPTY;
-		}
-		ItemStack stack5 = stacks.get(0);
-		CeramicBrickPair type = new CeramicBrickPair(stack5);
-		if (type.type == CeramicBrickType.LARGE_BRICK) {
-			type.type = CeramicBrickType.VERTICAL_LARGE_BRICK;
-			return type.getStack(1);
-		}
-
-		if (type.type == CeramicBrickType.BRICK) {
-			type.type = CeramicBrickType.VERTICAL_BRICK;
-			return type.getStack(1);
-		}
-
-		if (type.type == CeramicBrickType.STRIPE_BRICK) {
-			type.type = CeramicBrickType.VERTICAL_STRIPE_BRICK;
-			return type.getStack(1);
-		}
-		return ItemStack.EMPTY;
-	}
-
-	protected ItemStack getBrickRecipe(CeramicBrickType ceramicType, List<ItemStack> stacks) {
-		if (stacks.size() == 1) {
-			ItemStack stack5 = stacks.get(0);
-			CeramicBrickPair type = new CeramicBrickPair(stack5);
-			if (type.type == CeramicBrickType.VERTICAL_BRICK) {
-				type.type = ceramicType;
-				return type.getStack(1);
-			}
-
-			if (type.type == CeramicBrickType.STRIPE_BRICK) {
-				type.type = ceramicType;
-				return type.getStack(1);
-			}
-			return ItemStack.EMPTY;
-		} else if (stacks.size() == 4) {
-			int[] colors = {-1, -1};
-			for (int index2 = 0; index2 < stacks.size(); ++index2) {
-				ItemStack stack4 = stacks.get(index2);
-				if (stack4.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
-					return ItemStack.EMPTY;
-				}
-
-				CeramicBrickPair type4 = new CeramicBrickPair(stack4);
-				if (type4.type != CeramicBrickType.LARGE_BRICK) {
-					return ItemStack.EMPTY;
-				}
-
-				int color5 = type4.colorFirst.ordinal();
-				int color6 = type4.colorSecond.ordinal();
-				int alt2 = (index2 != 0 && index2 != 3) ? 1 : 0;
-				if (ceramicType == CeramicBrickType.STRIPE_BRICK) {
-					alt2 = 0;
-				}
-
-				if (colors[alt2] == -1) {
-					colors[alt2] = color5;
-					colors[1 - alt2] = color6;
-				} else if (colors[alt2] != color5 || colors[1 - alt2] != color6) {
-					return ItemStack.EMPTY;
-				}
-			}
-			return new CeramicBrickPair(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), ceramicType).getStack(4);
-		}
-		return ItemStack.EMPTY;
-	}
-
-	protected boolean isMortar(ItemStack stack) {
-		return stack.getItem() == Botany.misc && stack.getItemDamage() == BotanyItems.MORTAR.ordinal();
-	}
-
-	@Override
-	public String getName() {
-		return id;
-	}
-}

src/main/java/binnie/botany/ceramic/brick/ItemCeramicBrick.java

@@ -1,38 +0,0 @@
-package binnie.botany.ceramic.brick;
-
-import net.minecraft.item.ItemBlock;
-import net.minecraft.item.ItemStack;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.core.items.IColoredItem;
-
-public class ItemCeramicBrick extends ItemBlock implements IColoredItem {
-	public ItemCeramicBrick(BlockCeramicBrick block) {
-		super(block);
-	}
-
-	@Override
-	public int getMetadata(int metadata) {
-		return metadata;
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public int getColorFromItemstack(ItemStack stack, int tintIndex) {
-		CeramicBrickPair ceramic = new CeramicBrickPair(stack.getItemDamage());
-		if (tintIndex == 1) {
-			return ceramic.colorFirst.getFlowerColorAllele().getColor(false);
-		} else if (tintIndex == 2) {
-			return ceramic.colorSecond.getFlowerColorAllele().getColor(false);
-		}
-		return 0xffffff;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public String getItemStackDisplayName(ItemStack itemStack) {
-		return new CeramicBrickPair(itemStack.getItemDamage()).getName();
-	}
-}

src/main/java/binnie/botany/ceramic/brick/TileCeramicBrick.java

@@ -1,69 +0,0 @@
-package binnie.botany.ceramic.brick;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-
-import binnie.botany.Botany;
-import binnie.botany.genetics.EnumFlowerColor;
-import binnie.core.block.TileEntityMetadata;
-
-public class TileCeramicBrick extends TileEntity {
-	private EnumFlowerColor colorFirst = EnumFlowerColor.Black;
-	private EnumFlowerColor colorSecond = EnumFlowerColor.White;
-
-	public void setColors(EnumFlowerColor colorFirst, EnumFlowerColor colorSecond) {
-		this.colorFirst = colorFirst;
-		this.colorSecond = colorSecond;
-	}
-
-	public boolean hasTwoColors() {
-		return CeramicBrickType.VALUES[getBlockMetadata()].canDouble() && colorSecond != colorFirst;
-	}
-
-	public ItemStack getStack(int i) {
-		ItemStack s = TileEntityMetadata.getItemStack(Botany.ceramicBrick, ordinal());
-		s.setCount(i);
-		return s;
-	}
-
-	public int ordinal() {
-		return colorFirst.ordinal() + colorSecond.ordinal() * 256 + getBlockMetadata() * 256 * 256;
-	}
-
-	public CeramicBrickPair pair() {
-		return new CeramicBrickPair(colorFirst, colorSecond, CeramicBrickType.VALUES[getBlockMetadata()]);
-	}
-
-	public EnumFlowerColor getColorFirst() {
-		return colorFirst;
-	}
-
-	public EnumFlowerColor getColorSecond() {
-		return colorSecond;
-	}
-
-	@Override
-	public NBTTagCompound writeToNBT(NBTTagCompound compound) {
-		compound.setInteger("First", colorFirst.ordinal());
-		compound.setInteger("Second", colorSecond.ordinal());
-		return super.writeToNBT(compound);
-	}
-
-	@Override
-	public NBTTagCompound getUpdateTag() {
-		return writeToNBT(new NBTTagCompound());
-	}
-
-	@Override
-	public void readFromNBT(NBTTagCompound compound) {
-		super.readFromNBT(compound);
-		if (compound.hasKey("First")) {
-			colorFirst = EnumFlowerColor.VALUES[compound.getInteger("First")];
-		}
-
-		if (compound.hasKey("Second")) {
-			colorSecond = EnumFlowerColor.VALUES[compound.getInteger("Second")];
-		}
-	}
-}

src/main/java/binnie/botany/ceramic/brick/package-info.java

@@ -1,9 +0,0 @@
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-@FieldsAreNonnullByDefault
-package binnie.botany.ceramic.brick;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-import binnie.core.util.FieldsAreNonnullByDefault;
-import mcp.MethodsReturnNonnullByDefault;

src/main/java/binnie/botany/ceramic/package-info.java

@@ -1,9 +0,0 @@
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-@FieldsAreNonnullByDefault
-package binnie.botany.ceramic;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-import binnie.core.util.FieldsAreNonnullByDefault;
-import mcp.MethodsReturnNonnullByDefault;

src/main/java/binnie/botany/core/BotanyCore.java

@@ -1,25 +1,12 @@
 package binnie.botany.core;
 
-import binnie.botany.api.FlowerManager;
 import binnie.botany.api.IFlowerRoot;
-import binnie.botany.api.IGardeningManager;
-import binnie.botany.gardening.Gardening;
-import binnie.botany.genetics.FlowerRoot;
+import binnie.botany.genetics.FlowerHelper;
 
 public class BotanyCore {
-	public static final int CHANCE_INTERPOLLINATION = 20;
+	public static IFlowerRoot speciesRoot = new FlowerHelper();
 
 	public static IFlowerRoot getFlowerRoot() {
-		if (FlowerManager.flowerRoot == null) {
-			FlowerManager.flowerRoot = new FlowerRoot();
-		}
-		return FlowerManager.flowerRoot;
-	}
-
-	public static IGardeningManager getGardening() {
-		if (FlowerManager.gardening == null) {
-			FlowerManager.gardening = new Gardening();
-		}
-		return FlowerManager.gardening;
+		return BotanyCore.speciesRoot;
 	}
 }

src/main/java/binnie/botany/core/BotanyGUI.java

@@ -1,33 +1,23 @@
 package binnie.botany.core;
 
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
-import net.minecraftforge.fml.relauncher.Side;
-
 import binnie.botany.craftgui.WindowBotanistDatabase;
 import binnie.core.craftgui.minecraft.Window;
 import binnie.core.gui.IBinnieGUID;
+import cpw.mods.fml.relauncher.Side;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
 
 public enum BotanyGUI implements IBinnieGUID {
-	DATABASE,
-	DATABASE_NEI;
+	Database,
+	DatabaseNEI;
 
 	@Override
 	public Window getWindow(EntityPlayer player, World world, int x, int y, int z, Side side) {
 		Window window = null;
-		TileEntity tileEntity = world.getTileEntity(new BlockPos(x, y, z));
-		IInventory object = null;
-		if (tileEntity instanceof IInventory) {
-			object = (IInventory) tileEntity;
-		}
 		switch (this) {
-			case DATABASE:
-			case DATABASE_NEI: {
-				window = WindowBotanistDatabase.create(player, side, this != BotanyGUI.DATABASE);
+			case Database:
+			case DatabaseNEI: {
+				window = WindowBotanistDatabase.create(player, side, this != BotanyGUI.Database);
 				break;
 			}
 		}

src/main/java/binnie/botany/core/BotanyTexture.java

@@ -1,37 +0,0 @@
-package binnie.botany.core;
-
-import javax.annotation.Nullable;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import binnie.Binnie;
-import binnie.botany.Botany;
-import binnie.core.resource.BinnieResource;
-import binnie.core.resource.IBinnieTexture;
-import binnie.core.resource.ResourceType;
-
-// TODO unused enum?
-public enum BotanyTexture implements IBinnieTexture {
-	;
-	String texture;
-	ResourceType type;
-
-	@SideOnly(Side.CLIENT)
-	@Nullable
-	private BinnieResource resource;
-
-	BotanyTexture(ResourceType base, String texture) {
-		this.texture = texture;
-		type = base;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public BinnieResource getTexture() {
-		if (resource == null) {
-			resource = Binnie.RESOURCE.getPNG(Botany.instance, type, texture);
-		}
-		return resource;
-	}
-}

src/main/java/binnie/botany/core/package-info.java

@@ -1,9 +0,0 @@
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-@FieldsAreNonnullByDefault
-package binnie.botany.core;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-import binnie.core.util.FieldsAreNonnullByDefault;
-import mcp.MethodsReturnNonnullByDefault;

src/main/java/binnie/botany/craftgui/ControlColorDisplay.java

@@ -1,24 +1,21 @@
 package binnie.botany.craftgui;
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import binnie.botany.api.IFlowerColor;
-import binnie.core.craftgui.Attribute;
+import binnie.core.craftgui.CraftGUI;
 import binnie.core.craftgui.ITooltip;
 import binnie.core.craftgui.IWidget;
 import binnie.core.craftgui.Tooltip;
+import binnie.core.craftgui.WidgetAttribute;
 import binnie.core.craftgui.controls.core.Control;
 import binnie.core.craftgui.controls.core.IControlValue;
-import binnie.core.craftgui.renderer.RenderUtil;
+import binnie.core.craftgui.geometry.IArea;
 
 public class ControlColorDisplay extends Control implements IControlValue<IFlowerColor>, ITooltip {
 	private IFlowerColor value;
 
-	public ControlColorDisplay(IWidget parent, int x, int y, IFlowerColor value) {
-		super(parent, x, y, 16, 16);
-		this.value = value;
-		addAttribute(Attribute.MouseOver);
+	public ControlColorDisplay(IWidget parent, float x, float y) {
+		super(parent, x, y, 16.0f, 16.0f);
+		addAttribute(WidgetAttribute.MOUSE_OVER);
 	}
 
 	@Override
@@ -32,15 +29,15 @@ public class ControlColorDisplay extends Control implements IControlValue<IFlowe
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
-	public void onRenderBackground(int guiWidth, int guiHeight) {
-		RenderUtil.drawSolidRect(getArea(), -1);
-		RenderUtil.drawSolidRect(getArea().inset(1), 0xff000000 + getValue().getColor(false));
+	public void onRenderBackground() {
+		IArea area = getArea();
+		CraftGUI.render.solid(area, -1);
+		CraftGUI.render.solid(area.inset(1), 0xff000000 + getValue().getColor(false));
 	}
 
 	@Override
 	public void getTooltip(Tooltip tooltip) {
 		super.getTooltip(tooltip);
-		tooltip.add(value.getColorName());
+		tooltip.add(value.getName());
 	}
 }

src/main/java/binnie/botany/craftgui/ControlColorMixBox.java

@@ -1,25 +1,24 @@
 package binnie.botany.craftgui;
 
-import binnie.botany.api.IColorMix;
+import binnie.botany.api.IColourMix;
 import binnie.core.craftgui.IWidget;
 import binnie.core.craftgui.controls.listbox.ControlListBox;
 
-public class ControlColorMixBox extends ControlListBox<IColorMix> {
-	private int index;
+public class ControlColorMixBox extends ControlListBox<IColourMix> {
 	private Type type;
 
 	public ControlColorMixBox(IWidget parent, int x, int y, int width, int height, Type type) {
-		super(parent, x, y, width, height, 12);
+		super(parent, x, y, width, height, 12.0f);
 		this.type = type;
 	}
 
 	@Override
-	public IWidget createOption(IColorMix value, int y) {
+	public IWidget createOption(IColourMix value, int y) {
 		return new ControlColorMixItem(getContent(), value, y);
 	}
 
 	enum Type {
-		RESULTANT,
-		FURTHER,
+		Resultant,
+		Further
 	}
 }

src/main/java/binnie/botany/craftgui/ControlColorMixItem.java

@@ -1,23 +1,30 @@
 package binnie.botany.craftgui;
 
-import binnie.botany.api.IColorMix;
+import binnie.botany.api.IColourMix;
 import binnie.core.craftgui.controls.listbox.ControlList;
 import binnie.core.craftgui.controls.listbox.ControlOption;
 
-public class ControlColorMixItem extends ControlOption<IColorMix> {
-	private final ControlColorDisplay itemWidget1;
-	private final ControlColorDisplay itemWidget2;
-	private final ControlColorDisplay itemWidget3;
-	private final ControlColorMixSymbol addSymbol;
-	private final ControlColorMixSymbol arrowSymbol;
+public class ControlColorMixItem extends ControlOption<IColourMix> {
+	protected ControlColorDisplay itemWidget1;
+	protected ControlColorDisplay itemWidget2;
+	protected ControlColorDisplay itemWidget3;
+	protected ControlColourMixSymbol addSymbol;
+	protected ControlColourMixSymbol arrowSymbol;
 
-	public ControlColorMixItem(ControlList<IColorMix> controlList, IColorMix option, int y) {
+	public ControlColorMixItem(ControlList<IColourMix> controlList, IColourMix option, int y) {
 		super(controlList, option, y);
-		IColorMix value = getValue();
-		itemWidget1 = new ControlColorDisplay(this, 4, 4, value.getColorFirst());
-		itemWidget2 = new ControlColorDisplay(this, 44, 4, value.getColorSecond());
-		itemWidget3 = new ControlColorDisplay(this, 104, 4, value.getResult());
-		addSymbol = new ControlColorMixSymbol(this, 24, 4, 0, value);
-		arrowSymbol = new ControlColorMixSymbol(this, 64, 4, 1, value);
+		itemWidget1 = new ControlColorDisplay(this, 4.0f, 4.0f);
+		itemWidget2 = new ControlColorDisplay(this, 44.0f, 4.0f);
+		itemWidget3 = new ControlColorDisplay(this, 104.0f, 4.0f);
+		addSymbol = new ControlColourMixSymbol(this, 24, 4, 0);
+		arrowSymbol = new ControlColourMixSymbol(this, 64, 4, 1);
+
+		if (getValue() != null) {
+			itemWidget1.setValue(getValue().getColor1());
+			itemWidget2.setValue(getValue().getColor2());
+			itemWidget3.setValue(getValue().getResult());
+			addSymbol.setValue(getValue());
+			arrowSymbol.setValue(getValue());
+		}
 	}
 }

src/main/java/binnie/botany/craftgui/ControlColorMixSymbol.java

@@ -1,55 +0,0 @@
-package binnie.botany.craftgui;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import binnie.botany.api.IColorMix;
-import binnie.core.craftgui.Attribute;
-import binnie.core.craftgui.CraftGUI;
-import binnie.core.craftgui.ITooltip;
-import binnie.core.craftgui.IWidget;
-import binnie.core.craftgui.Tooltip;
-import binnie.core.craftgui.controls.core.Control;
-import binnie.core.craftgui.geometry.Point;
-import binnie.core.craftgui.resource.Texture;
-import binnie.core.craftgui.resource.minecraft.CraftGUITextureSheet;
-import binnie.core.craftgui.resource.minecraft.StandardTexture;
-import binnie.core.util.I18N;
-
-public class ControlColorMixSymbol extends Control implements ITooltip {
-	static Texture MutationPlus = new StandardTexture(2, 94, 16, 16, CraftGUITextureSheet.Controls2);
-	static Texture MutationArrow = new StandardTexture(20, 94, 32, 16, CraftGUITextureSheet.Controls2);
-	IColorMix value;
-	int type;
-
-	protected ControlColorMixSymbol(IWidget parent, int x, int y, int type, IColorMix value) {
-		super(parent, x, y, 16 + type * 16, 16);
-		this.value = value;
-		this.type = type;
-		addAttribute(Attribute.MouseOver);
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void onRenderBackground(int guiWidth, int guiHeight) {
-		super.onRenderBackground(guiWidth, guiHeight);
-		if (type == 0) {
-			CraftGUI.render.texture(ControlColorMixSymbol.MutationPlus, Point.ZERO);
-		} else {
-			CraftGUI.render.texture(ControlColorMixSymbol.MutationArrow, Point.ZERO);
-		}
-	}
-
-	public void setValue(IColorMix value) {
-		this.value = value;
-		setColor(0xffffff);
-	}
-
-	@Override
-	public void getTooltip(Tooltip tooltip) {
-		if (type == 1) {
-			float chance = value.getChance();
-			tooltip.add(I18N.localise("botany.gui.controls.color_mix_symbol.chance", chance));
-		}
-	}
-}

src/main/java/binnie/botany/craftgui/ControlColorOption.java

@@ -1,32 +1,28 @@
 package binnie.botany.craftgui;
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import binnie.botany.api.IFlowerColor;
-import binnie.core.craftgui.Attribute;
 import binnie.core.craftgui.CraftGUI;
+import binnie.core.craftgui.WidgetAttribute;
 import binnie.core.craftgui.controls.listbox.ControlList;
 import binnie.core.craftgui.controls.listbox.ControlTextOption;
 import binnie.core.craftgui.geometry.CraftGUIUtil;
-import binnie.core.craftgui.geometry.Point;
+import binnie.core.craftgui.geometry.IPoint;
 
-@SideOnly(Side.CLIENT)
 public class ControlColorOption extends ControlTextOption<IFlowerColor> {
-	private ControlColorDisplay controlBee;
-	private Point boxPosition;
+	protected ControlColorDisplay controlBee;
+	protected IPoint boxPosition;
 
 	public ControlColorOption(ControlList<IFlowerColor> controlList, IFlowerColor option, int y) {
-		super(controlList, option, option.getColorName(), y);
-		setSize(new Point(getSize().x(), 20));
-		controlBee = new ControlColorDisplay(this, 2, 2, option);
-		addAttribute(Attribute.MouseOver);
-		CraftGUIUtil.moveWidget(textWidget, new Point(22, 0));
-		textWidget.setSize(textWidget.getSize().sub(new Point(24, 0)));
-		int th = CraftGUI.render.textHeight(textWidget.getValue(), textWidget.getSize().x());
+		super(controlList, option, option.getName(), y);
+		setSize(new IPoint(getSize().x(), 20.0f));
+		(controlBee = new ControlColorDisplay(this, 2.0f, 2.0f)).setValue(option);
+		addAttribute(WidgetAttribute.MOUSE_OVER);
+		CraftGUIUtil.moveWidget(textWidget, new IPoint(22.0f, 0.0f));
+		textWidget.setSize(textWidget.getSize().sub(new IPoint(24.0f, 0.0f)));
+		int th = (int) CraftGUI.render.textHeight(textWidget.getValue(), textWidget.getSize().x());
 		int height = Math.max(20, th + 6);
-		setSize(new Point(size().x(), height));
-		textWidget.setSize(new Point(textWidget.getSize().x(), height));
-		boxPosition = new Point(2, (height - 18) / 2);
+		setSize(new IPoint(size().x(), height));
+		textWidget.setSize(new IPoint(textWidget.getSize().x(), height));
+		boxPosition = new IPoint(2.0f, (height - 18) / 2);
 	}
 }

src/main/java/binnie/botany/craftgui/ControlColourMixSymbol.java

@@ -0,0 +1,52 @@
+package binnie.botany.craftgui;
+
+import binnie.botany.api.IColourMix;
+import binnie.core.craftgui.CraftGUI;
+import binnie.core.craftgui.ITooltip;
+import binnie.core.craftgui.IWidget;
+import binnie.core.craftgui.Tooltip;
+import binnie.core.craftgui.WidgetAttribute;
+import binnie.core.craftgui.controls.core.Control;
+import binnie.core.craftgui.geometry.IPoint;
+import binnie.core.craftgui.resource.Texture;
+import binnie.core.craftgui.resource.minecraft.CraftGUITextureSheet;
+import binnie.core.craftgui.resource.minecraft.StandardTexture;
+import binnie.core.util.I18N;
+
+public class ControlColourMixSymbol extends Control implements ITooltip {
+	protected static Texture MutationPlus = new StandardTexture(2, 94, 16, 16, CraftGUITextureSheet.Controls2);
+	protected static Texture MutationArrow = new StandardTexture(20, 94, 32, 16, CraftGUITextureSheet.Controls2);
+
+	protected IColourMix value;
+	protected int type;
+
+	protected ControlColourMixSymbol(IWidget parent, int x, int y, int type) {
+		super(parent, x, y, 16 + type * 16, 16.0f);
+		this.type = type;
+		value = null;
+		addAttribute(WidgetAttribute.MOUSE_OVER);
+	}
+
+	@Override
+	public void onRenderBackground() {
+		super.onRenderBackground();
+		if (type == 0) {
+			CraftGUI.render.texture(ControlColourMixSymbol.MutationPlus, IPoint.ZERO);
+		} else {
+			CraftGUI.render.texture(ControlColourMixSymbol.MutationArrow, IPoint.ZERO);
+		}
+	}
+
+	public void setValue(IColourMix value) {
+		this.value = value;
+		setColor(0xffffff);
+	}
+
+	@Override
+	public void getTooltip(Tooltip tooltip) {
+		if (type == 1) {
+			float chance = value.getChance();
+			tooltip.add(I18N.localise("botany.gui.controls.colorMixSymbol.chance", chance));
+		}
+	}
+}

src/main/java/binnie/botany/craftgui/PageColorMix.java

@@ -1,9 +1,6 @@
 package binnie.botany.craftgui;
 
-import java.util.ArrayList;
-import java.util.List;
-
-import binnie.botany.api.IColorMix;
+import binnie.botany.api.IColourMix;
 import binnie.botany.api.IFlowerColor;
 import binnie.botany.core.BotanyCore;
 import binnie.core.craftgui.IWidget;
@@ -13,24 +10,27 @@ import binnie.core.craftgui.database.DatabaseTab;
 import binnie.core.craftgui.database.PageAbstract;
 import binnie.core.util.I18N;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class PageColorMix extends PageAbstract<IFlowerColor> {
-	ControlText pageSpeciesFurther_Title;
-	ControlColorMixBox pageSpeciesFurther_List;
+	ControlText title;
+	ControlColorMixBox list;
 
 	public PageColorMix(IWidget parent, DatabaseTab tab) {
 		super(parent, tab);
-		pageSpeciesFurther_Title = new ControlTextCentered(this, 8, I18N.localise("botany.gui.controls.page.color_further.title"));
-		pageSpeciesFurther_List = new ControlColorMixBox(this, 4, 20, 136, 152, ControlColorMixBox.Type.FURTHER);
+		title = new ControlTextCentered(this, 8.0f, I18N.localise("botany.gui.controls.pageColorFurtherTitle"));
+		list = new ControlColorMixBox(this, 4, 20, 136, 152, ControlColorMixBox.Type.Further);
 	}
 
 	@Override
 	public void onValueChanged(IFlowerColor colour) {
-		List<IColorMix> mixes = new ArrayList<>();
-		for (IColorMix mix : BotanyCore.getFlowerRoot().getColorMixes(false)) {
-			if (mix.getColorFirst() == colour || mix.getColorSecond() == colour) {
+		List<IColourMix> mixes = new ArrayList<>();
+		for (IColourMix mix : BotanyCore.getFlowerRoot().getColourMixes(false)) {
+			if (mix.getColor1() == colour || mix.getColor2() == colour) {
 				mixes.add(mix);
 			}
 		}
-		pageSpeciesFurther_List.setOptions(mixes);
+		list.setOptions(mixes);
 	}
 }

src/main/java/binnie/botany/craftgui/PageColorMixResultant.java

@@ -1,9 +1,6 @@
 package binnie.botany.craftgui;
 
-import java.util.ArrayList;
-import java.util.List;
-
-import binnie.botany.api.IColorMix;
+import binnie.botany.api.IColourMix;
 import binnie.botany.api.IFlowerColor;
 import binnie.botany.core.BotanyCore;
 import binnie.core.craftgui.IWidget;
@@ -13,24 +10,27 @@ import binnie.core.craftgui.database.DatabaseTab;
 import binnie.core.craftgui.database.PageAbstract;
 import binnie.core.util.I18N;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class PageColorMixResultant extends PageAbstract<IFlowerColor> {
-	ControlText pageSpeciesFurther_Title;
-	ControlColorMixBox pageSpeciesFurther_List;
+	protected ControlText title;
+	protected ControlColorMixBox list;
 
 	public PageColorMixResultant(IWidget parent, DatabaseTab tab) {
 		super(parent, tab);
-		pageSpeciesFurther_Title = new ControlTextCentered(this, 8, I18N.localise("botany.gui.controls.page.species_further.title"));
-		pageSpeciesFurther_List = new ControlColorMixBox(this, 4, 20, 136, 152, ControlColorMixBox.Type.RESULTANT);
+		title = new ControlTextCentered(this, 8.0f, I18N.localise("botany.gui.controls.pageSpeciesFurtherTitle"));
+		list = new ControlColorMixBox(this, 4, 20, 136, 152, ControlColorMixBox.Type.Resultant);
 	}
 
 	@Override
-	public void onValueChanged(IFlowerColor colour) {
-		List<IColorMix> mixes = new ArrayList<>();
-		for (IColorMix mix : BotanyCore.getFlowerRoot().getColorMixes(false)) {
-			if (mix.getResult() == colour) {
+	public void onValueChanged(IFlowerColor color) {
+		List<IColourMix> mixes = new ArrayList<>();
+		for (IColourMix mix : BotanyCore.getFlowerRoot().getColourMixes(false)) {
+			if (mix.getResult() == color) {
 				mixes.add(mix);
 			}
 		}
-		pageSpeciesFurther_List.setOptions(mixes);
+		list.setOptions(mixes);
 	}
 }

src/main/java/binnie/botany/craftgui/PageSpeciesFlowerGenome.java

@@ -1,11 +1,5 @@
 package binnie.botany.craftgui;
 
-import net.minecraft.item.ItemStack;
-
-import forestry.api.genetics.IAllele;
-import forestry.api.genetics.IAlleleSpecies;
-import forestry.api.genetics.IIndividual;
-
 import binnie.Binnie;
 import binnie.botany.api.EnumFlowerChromosome;
 import binnie.botany.api.EnumFlowerStage;
@@ -19,72 +13,76 @@ import binnie.core.craftgui.controls.core.Control;
 import binnie.core.craftgui.controls.scroll.ControlScrollableContent;
 import binnie.core.craftgui.database.DatabaseTab;
 import binnie.core.craftgui.database.PageSpecies;
-import binnie.core.craftgui.geometry.Area;
-import binnie.core.craftgui.geometry.Point;
+import binnie.core.craftgui.geometry.IArea;
+import binnie.core.craftgui.geometry.IPoint;
 import binnie.core.craftgui.geometry.TextJustification;
 import binnie.core.craftgui.minecraft.control.ControlItemDisplay;
 import binnie.core.util.I18N;
+import binnie.genetics.genetics.AlleleHelper;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IAlleleSpecies;
+import forestry.api.genetics.IIndividual;
+import net.minecraft.item.ItemStack;
 
 public class PageSpeciesFlowerGenome extends PageSpecies {
 	public PageSpeciesFlowerGenome(IWidget parent, DatabaseTab tab) {
 		super(parent, tab);
 	}
 
-	public static String tolerated(boolean t) {
-		if (t) {
-			return "Tolerated";
-		}
-		return "Not Tolerated";
-	}
-
 	@Override
 	public void onValueChanged(IAlleleSpecies species) {
 		deleteAllChildren();
-		IAllele[] template = Binnie.GENETICS.getFlowerRoot().getTemplate(species.getUID());
+		IAllele[] template = Binnie.Genetics.getFlowerRoot().getTemplate(species.getUID());
 		if (template == null) {
 			return;
 		}
 
-		IFlower tree = Binnie.GENETICS.getFlowerRoot().templateAsIndividual(template);
+		IFlower tree = Binnie.Genetics.getFlowerRoot().templateAsIndividual(template);
+		if (tree == null) {
+			return;
+		}
+
 		IFlowerGenome genome = tree.getGenome();
 		IAlleleFlowerSpecies treeSpecies = genome.getPrimary();
 		int w = 144;
 		int h = 176;
-		new ControlText(this, new Area(0, 4, w, 16), I18N.localise("botany.gui.database.tab.genome"), TextJustification.MIDDLE_CENTER);
-		ControlScrollableContent scrollable = new ControlScrollableContent(this, 4, 20, w - 8, h - 8 - 16, 12);
-		Control contents = new Control(scrollable, 0, 0, w - 8 - 12, h - 8 - 16);
+
+		new ControlText(this, new IArea(0.0f, 4.0f, w, 16.0f), I18N.localise("botany.gui.database.tab.genome"), TextJustification.MIDDLE_CENTER);
+		ControlScrollableContent scrollable = new ControlScrollableContent(this, 4.0f, 20.0f, w - 8, h - 8 - 16, 12.0f);
+		Control contents = new Control(scrollable, 0.0f, 0.0f, w - 8 - 12, h - 8 - 16);
+
 		int tw = w - 8 - 12;
 		int w2 = 55;
 		int w3 = tw - 50;
 		int y = 0;
 		int th = 14;
-		int th2 = 18;
-		new ControlText(contents, new Area(0, y, w2, th), I18N.localise("botany.gui.database.tab.genome.temp"), TextJustification.MIDDLE_RIGHT);
-		new ControlText(contents, new Area(w2, y, w3, th), treeSpecies.getTemperature().getName(), TextJustification.MIDDLE_LEFT);
-
+		int valueX = w2 + 4;
+		new ControlText(contents, new IArea(0.0f, y, w2, th),  I18N.localise("botany.gui.database.tab.genome.temp"), TextJustification.MIDDLE_RIGHT);
+		new ControlText(contents, new IArea(valueX, y, w3, th), AlleleHelper.toDisplay(treeSpecies.getTemperature()), TextJustification.MIDDLE_LEFT);
 		y += th;
-		new ControlText(contents, new Area(0, y, w2, th), I18N.localise("botany.gui.database.tab.genome.moist"), TextJustification.MIDDLE_RIGHT);
-		new ControlText(contents, new Area(w2, y, w3, th), treeSpecies.getMoisture().getLocalisedName(false), TextJustification.MIDDLE_LEFT);
 
+		new ControlText(contents, new IArea(0.0f, y, w2, th), I18N.localise("botany.gui.database.tab.genome.moist"), TextJustification.MIDDLE_RIGHT);
+		new ControlText(contents, new IArea(valueX, y, w3, th), AlleleHelper.toDisplay(treeSpecies.getMoisture()), TextJustification.MIDDLE_LEFT);
 		y += th;
-		new ControlText(contents, new Area(0, y, w2, th), I18N.localise("botany.gui.database.tab.genome.ph"), TextJustification.MIDDLE_RIGHT);
-		new ControlText(contents, new Area(w2, y, w3, th), treeSpecies.getPH().getLocalisedName(false), TextJustification.MIDDLE_LEFT);
 
+		new ControlText(contents, new IArea(0.0f, y, w2, th), I18N.localise("botany.gui.database.tab.genome.ph"), TextJustification.MIDDLE_RIGHT);
+		new ControlText(contents, new IArea(valueX, y, w3, th), AlleleHelper.toDisplay(treeSpecies.getPH()), TextJustification.MIDDLE_LEFT);
 		y += th;
-		new ControlText(contents, new Area(0, y, w2, th), I18N.localise("botany.gui.database.tab.genome.fertility"), TextJustification.MIDDLE_RIGHT);
-		new ControlText(contents, new Area(w2, y, w3, th), genome.getFertility() + "x", TextJustification.MIDDLE_LEFT);
 
+		new ControlText(contents, new IArea(0.0f, y, w2, th), I18N.localise("botany.gui.database.tab.genome.fertility"), TextJustification.MIDDLE_RIGHT);
+		new ControlText(contents, new IArea(valueX, y, w3, th), genome.getFertility() + "x", TextJustification.MIDDLE_LEFT);
 		y += th;
+
 		float lifespan = genome.getLifespan() * 68.27f / genome.getAgeChance() / 24000.0f;
 		String lifespanValue = String.format("%.2f", lifespan);
-		new ControlText(contents, new Area(0, y, w2, th), I18N.localise("botany.gui.database.tab.genome.lifespan"), TextJustification.MIDDLE_RIGHT);
-		new ControlText(contents, new Area(w2, y, w3, th), I18N.localise("botany.gui.database.tab.genome.lifespan.value", lifespanValue), TextJustification.MIDDLE_LEFT);
-
+		new ControlText(contents, new IArea(0.0f, y, w2, th), I18N.localise("botany.gui.database.tab.genome.lifespan"), TextJustification.MIDDLE_RIGHT);
+		new ControlText(contents, new IArea(valueX, y, w3, th), I18N.localise("botany.gui.database.tab.genome.lifespan.value", lifespanValue), TextJustification.MIDDLE_LEFT);
 		y += th;
-		new ControlText(contents, new Area(0, y, w2, th), I18N.localise("botany.gui.database.tab.genome.nectar"), TextJustification.MIDDLE_RIGHT);
-		new ControlText(contents, new Area(w2, y, w3, th), genome.getActiveAllele(EnumFlowerChromosome.SAPPINESS).getName(), TextJustification.MIDDLE_LEFT);
 
+		new ControlText(contents, new IArea(0.0f, y, w2, th), I18N.localise("botany.gui.database.tab.genome.nectar"), TextJustification.MIDDLE_RIGHT);
+		new ControlText(contents, new IArea(valueX, y, w3, th), genome.getActiveAllele(EnumFlowerChromosome.SAPPINESS).getName(), TextJustification.MIDDLE_LEFT);
 		y += th;
+
 		int x = w2;
 		int tot = 0;
 		for (IIndividual vid : BotanyCore.getFlowerRoot().getIndividualTemplates()) {
@@ -93,18 +91,18 @@ public class PageSpeciesFlowerGenome extends PageSpecies {
 					x -= 54;
 					y += 18;
 				}
-				ItemStack stack = BotanyCore.getFlowerRoot().getMemberStack(vid, EnumFlowerStage.FLOWER);
+				ItemStack stack = BotanyCore.getFlowerRoot().getMemberStack(vid, EnumFlowerStage.FLOWER.ordinal());
 				ControlItemDisplay display = new ControlItemDisplay(contents, x, y);
 				display.setItemStack(stack);
-				++tot;
+				tot++;
 				x += 18;
 			}
 		}
 
 		int numOfLines = 1 + (tot - 1) / 3;
-		new ControlText(contents, new Area(0, y - (numOfLines - 1) * 18, w2, 4 + 18 * numOfLines), I18N.localise("botany.gui.database.tab.genome.varieties"), TextJustification.MIDDLE_RIGHT);
+		new ControlText(contents, new IArea(0.0f, y - (numOfLines - 1) * 18, w2, 4 + 18 * numOfLines), I18N.localise("botany.gui.database.tab.genome.varieties"), TextJustification.MIDDLE_RIGHT);
 		y += th;
-		contents.setSize(new Point(contents.size().x(), y));
+		contents.setSize(new IPoint(contents.size().x(), y));
 		scrollable.setScrollableContent(contents);
 	}
 }

src/main/java/binnie/botany/craftgui/WindowBotanistDatabase.java

@@ -1,14 +1,5 @@
 package binnie.botany.craftgui;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import net.minecraft.entity.player.EntityPlayer;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import binnie.Binnie;
 import binnie.botany.Botany;
 import binnie.botany.api.IFlowerColor;
@@ -26,15 +17,19 @@ import binnie.core.craftgui.database.PageSpeciesMutations;
 import binnie.core.craftgui.database.PageSpeciesOverview;
 import binnie.core.craftgui.database.PageSpeciesResultant;
 import binnie.core.craftgui.database.WindowAbstractDatabase;
-import binnie.core.craftgui.geometry.Area;
+import binnie.core.craftgui.geometry.IArea;
 import binnie.core.craftgui.minecraft.Window;
 import binnie.core.util.I18N;
+import cpw.mods.fml.relauncher.Side;
+import net.minecraft.entity.player.EntityPlayer;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 public class WindowBotanistDatabase extends WindowAbstractDatabase {
-	private ControlListBox<EnumFlowerColor> selectionBoxColors;
-
 	public WindowBotanistDatabase(EntityPlayer player, Side side, boolean nei) {
-		super(player, side, nei, Binnie.GENETICS.flowerBreedingSystem, 130);
+		super(player, side, nei, Binnie.Genetics.flowerBreedingSystem, 130.0f);
 	}
 
 	public static Window create(EntityPlayer player, Side side, boolean nei) {
@@ -42,19 +37,18 @@ public class WindowBotanistDatabase extends WindowAbstractDatabase {
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
 	protected void addTabs() {
-		new PageSpeciesOverview(getInfoPages(Mode.SPECIES), new DatabaseTab(Botany.instance, "species.overview", 0));
-		new PageSpeciesFlowerGenome(getInfoPages(Mode.SPECIES), new DatabaseTab(Botany.instance, "genome", 0));
-		new PageSpeciesClassification(getInfoPages(Mode.SPECIES), new DatabaseTab(Botany.instance, "species.classification", 0));
-		new PageSpeciesResultant(getInfoPages(Mode.SPECIES), new DatabaseTab(Botany.instance, "species.resultant", 0));
-		new PageSpeciesMutations(getInfoPages(Mode.SPECIES), new DatabaseTab(Botany.instance, "species.further", 0));
-		new PageBranchOverview(getInfoPages(Mode.BRANCHES), new DatabaseTab(Botany.instance, "branches.overview", 0));
-		new PageBranchSpecies(getInfoPages(Mode.BRANCHES), new DatabaseTab(Botany.instance, "branches.species", 0));
-		createMode(FlowerMode.Color, new FlowerColorModeWidgets());
-		new PageColorMixResultant(getInfoPages(FlowerMode.Color), new DatabaseTab(Botany.instance, "color.resultant", 0));
-		new PageColorMix(getInfoPages(FlowerMode.Color), new DatabaseTab(Botany.instance, "color.further", 0));
-		new PageBreeder(getInfoPages(Mode.BREEDER), getUsername(), new DatabaseTab(Botany.instance, "breeder", 0));
+		new PageSpeciesOverview(getInfoPages(Mode.Species), new DatabaseTab(Botany.instance, "species.overview"));
+		new PageSpeciesFlowerGenome(getInfoPages(Mode.Species), new DatabaseTab(Botany.instance, "genome"));
+		new PageSpeciesClassification(getInfoPages(Mode.Species), new DatabaseTab(Botany.instance, "species.classification"));
+		new PageSpeciesResultant(getInfoPages(Mode.Species), new DatabaseTab(Botany.instance, "species.resultant"));
+		new PageSpeciesMutations(getInfoPages(Mode.Species), new DatabaseTab(Botany.instance, "species.further"));
+		new PageBranchOverview(getInfoPages(Mode.Branches), new DatabaseTab(Botany.instance, "branches.overview"));
+		new PageBranchSpecies(getInfoPages(Mode.Branches), new DatabaseTab(Botany.instance, "branches.species"));
+		createMode(FlowerMode.COLOR, new ColorModeWidget());
+		new PageColorMixResultant(getInfoPages(FlowerMode.COLOR), new DatabaseTab(Botany.instance, "colour.resultant"));
+		new PageColorMix(getInfoPages(FlowerMode.COLOR), new DatabaseTab(Botany.instance, "colour.further"));
+		new PageBreeder(getInfoPages(Mode.Breeder), getUsername(), new DatabaseTab(Botany.instance, "breeder"));
 	}
 
 	@Override
@@ -63,12 +57,12 @@ public class WindowBotanistDatabase extends WindowAbstractDatabase {
 	}
 
 	@Override
-	protected String getBackgroundTextureName() {
-		return "FlowerDatabase";
+	protected String getName() {
+		return I18N.localise("botany.gui.database.name");
 	}
 
 	enum FlowerMode implements IDatabaseMode {
-		Color;
+		COLOR;
 
 		@Override
 		public String getName() {
@@ -76,22 +70,21 @@ public class WindowBotanistDatabase extends WindowAbstractDatabase {
 		}
 	}
 
-	@SideOnly(Side.CLIENT)
-	private class FlowerColorModeWidgets extends ModeWidgets {
-		public FlowerColorModeWidgets() {
-			super(FlowerMode.Color, WindowBotanistDatabase.this);
+	private class ColorModeWidget extends ModeWidgets {
+		public ColorModeWidget() {
+			super(FlowerMode.COLOR, WindowBotanistDatabase.this);
 		}
 
 		@Override
-		public void createListBox(Area area) {
-			listBox = new ControlListBox<IFlowerColor>(modePage, area.xPos(), area.yPos(), area.width(), area.height(), 12) {
+		public void createListBox(IArea area) {
+			listBox = new ControlListBox<IFlowerColor>(modePage, area.x(), area.y(), area.w(), area.h(), 12.0f) {
 				@Override
 				public IWidget createOption(IFlowerColor value, int y) {
 					return new ControlColorOption(getContent(), value, y);
 				}
 			};
-
-			List<IFlowerColor> colors = Arrays.stream(EnumFlowerColor.values()).map(c -> c.getFlowerColorAllele()).collect(Collectors.toList());
+			List<IFlowerColor> colors = new ArrayList<>();
+			Collections.addAll(colors, EnumFlowerColor.values());
 			listBox.setOptions(colors);
 		}
 	}

src/main/java/binnie/botany/craftgui/package-info.java

@@ -1,9 +0,0 @@
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-@FieldsAreNonnullByDefault
-package binnie.botany.craftgui;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-import binnie.core.util.FieldsAreNonnullByDefault;
-import mcp.MethodsReturnNonnullByDefault;

src/main/java/binnie/botany/farm/CircuitGarden.java

@@ -1,63 +1,74 @@
 package binnie.botany.farm;
 
-import com.google.common.base.Preconditions;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.text.TextFormatting;
-
-import forestry.api.circuits.ChipsetManager;
-import forestry.api.circuits.ICircuitLayout;
-import forestry.api.farming.FarmDirection;
-import forestry.api.farming.IFarmHousing;
-
 import binnie.botany.api.EnumAcidity;
 import binnie.botany.api.EnumMoisture;
 import binnie.core.circuits.BinnieCircuit;
 import binnie.core.util.I18N;
+import forestry.api.circuits.ChipsetManager;
+import forestry.api.farming.FarmDirection;
+import forestry.api.farming.IFarmHousing;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
 
 public class CircuitGarden extends BinnieCircuit {
 	private boolean isManual;
-	private GardenLogic logic;
+	private boolean isFertilised;
+	private ItemStack icon;
+	private EnumMoisture moisture;
+	private EnumAcidity acidity;
 
-	public CircuitGarden(EnumMoisture moisture, @Nullable EnumAcidity ph, boolean manual, boolean fertilised, ItemStack recipe, ItemStack icon) {
-		super(getName(moisture, ph, manual, fertilised), 4, getLayout(manual), recipe);
+	public CircuitGarden(EnumMoisture moisture, EnumAcidity ph, boolean manual, boolean fertilised, ItemStack recipe, ItemStack icon) {
+		super("garden." + moisture.getID() + ((ph != null) ? ("." + ph.getID()) : "") + (manual ? ".manual" : "") + (fertilised ? ".fert" : ""), 4, manual ? ChipsetManager.circuitRegistry.getLayout("forestry.farms.manual") : ChipsetManager.circuitRegistry.getLayout("forestry.farms.managed"), recipe);
+		this.moisture = moisture;
+		this.icon = icon;
 		isManual = manual;
-		logic = new GardenLogic(moisture, ph, isManual, fertilised, icon, I18N.localise(getUnlocalizedName()));
-		String info = I18N.localise("botany.moisture") + ": " + moisture.getLocalisedName(true);
-		if (ph != null) {
-			info += TextFormatting.GRAY + ", " + I18N.localise("botany.ph") + ": " + moisture.getLocalisedName(true);
-		}
-		String fertilizedKey = fertilised ? "for.binnie.circuit.garden.fertilized" : "for.binnie.circuit.garden.unfertilized";
-		info += TextFormatting.GRAY + " " + I18N.localise(fertilizedKey);
-		addTooltipString(I18N.localise("for.binnie.circuit.garden.info", info));
-	}
+		isFertilised = fertilised;
+		acidity = ph;
+		String info = "";
 
-	private static ICircuitLayout getLayout(boolean manual) {
-		String layoutUid = manual ? "forestry.farms.manual" : "forestry.farms.managed";
-		ICircuitLayout layout = ChipsetManager.circuitRegistry.getLayout(layoutUid);
-		Preconditions.checkState(layout != null, "Couldn't find Forestry circuit layout %s.", layoutUid);
-		return layout;
-	}
+		if (moisture == EnumMoisture.DRY) {
+			info += EnumChatFormatting.YELLOW
+				+ I18N.localise("botany.moisture.dry")
+				+ EnumChatFormatting.RESET;
+		}
 
-	private static String getName(EnumMoisture moisture, @Nullable EnumAcidity ph, boolean manual, boolean fertilised) {
-		String name = "garden." + moisture.getName();
-		if (ph != null) {
-			name += "." + ph.getName();
+		if (moisture == EnumMoisture.DAMP) {
+			info += EnumChatFormatting.YELLOW
+				+ I18N.localise("botany.moisture.damp")
+				+ EnumChatFormatting.RESET;
 		}
-		if (manual) {
-			name += ".manual";
-		}
-		if (fertilised) {
-			name += ".fert";
-		}
-		return name;
-	}
 
-	public CircuitGarden setManual() {
-		isManual = true;
-		return this;
+		if (acidity == EnumAcidity.ACID) {
+			if (info.length() > 0) {
+				info += ", ";
+			}
+			info += EnumChatFormatting.RED
+				+ I18N.localise("botany.ph.acid")
+				+ EnumChatFormatting.RESET;
+		}
+
+		if (acidity == EnumAcidity.NEUTRAL) {
+			if (info.length() > 0) {
+				info += ", ";
+			}
+			info += EnumChatFormatting.GREEN
+				+ I18N.localise("botany.ph.neutral")
+				+ EnumChatFormatting.RESET;
+		}
+
+		if (acidity == EnumAcidity.ALKALINE) {
+			if (info.length() > 0) {
+				info += ", ";
+			}
+			info += EnumChatFormatting.AQUA
+				+ I18N.localise("botany.ph.alkaline")
+				+ EnumChatFormatting.RESET;
+		}
+
+		if (info.length() > 0) {
+			info = " (" + info + EnumChatFormatting.RESET + ")";
+		}
+		addTooltipString(I18N.localise("botany.circuit.flowers") + info);
 	}
 
 	@Override
@@ -65,24 +76,15 @@ public class CircuitGarden extends BinnieCircuit {
 		return tile instanceof IFarmHousing;
 	}
 
-	@Nullable
-	private IFarmHousing getCircuitable(Object tile) {
-		if (!isCircuitable(tile)) {
-			return null;
-		}
-		return (IFarmHousing) tile;
-	}
-
 	@Override
 	public void onInsertion(int slot, Object tile) {
-		IFarmHousing housing = getCircuitable(tile);
-		if (housing == null) {
+		if (!isCircuitable(tile)) {
 			return;
 		}
 
-		logic.setManual(isManual);
-
-		housing.setFarmLogic(FarmDirection.values()[slot], logic);
+		GardenLogic logic = new GardenLogic((IFarmHousing) tile);
+		logic.setData(moisture, acidity, isManual, isFertilised, icon, I18N.localise(getName()));
+		((IFarmHousing) tile).setFarmLogic(FarmDirection.values()[slot], logic);
 	}
 
 	@Override
@@ -92,16 +94,14 @@ public class CircuitGarden extends BinnieCircuit {
 
 	@Override
 	public void onRemoval(int slot, Object tile) {
-		IFarmHousing farmHousing = getCircuitable(tile);
-		if (farmHousing == null) {
+		if (!isCircuitable(tile)) {
 			return;
 		}
-
-		farmHousing.resetFarmLogic(FarmDirection.values()[slot]);
+		((IFarmHousing) tile).resetFarmLogic(FarmDirection.values()[slot]);
 	}
 
 	@Override
-	public void onTick(int slot, Object tile) {
+	public void onTick(int arg0, Object arg1) {
 		// ignored
 	}
 }

src/main/java/binnie/botany/farm/FarmLogic.java

@@ -1,16 +1,22 @@
 package binnie.botany.farm;
 
+import forestry.api.farming.FarmDirection;
+import forestry.api.farming.IFarmHousing;
+import forestry.api.farming.IFarmLogic;
+import forestry.core.utils.vect.Vect;
 import net.minecraft.block.Block;
-import net.minecraft.block.state.IBlockState;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import forestry.api.farming.IFarmLogic;
-
 public abstract class FarmLogic implements IFarmLogic {
-	boolean isManual;
+	protected World world;
+	protected IFarmHousing housing;
+	protected boolean isManual;
+
+	public FarmLogic(IFarmHousing housing) {
+		this.housing = housing;
+	}
 
 	@Override
 	public IFarmLogic setManual(boolean flag) {
@@ -18,32 +24,35 @@ public abstract class FarmLogic implements IFarmLogic {
 		return this;
 	}
 
-	protected final boolean isAirBlock(World world, BlockPos pos) {
-		return world.isAirBlock(pos);
+	protected boolean isAirBlock(Vect position) {
+		return world.isAirBlock(position.x, position.y, position.z);
 	}
 
-	protected final IBlockState getBlockState(World world, BlockPos pos) {
-		return world.getBlockState(pos);
+	protected boolean isWaterBlock(Vect position) {
+		return world.getBlock(position.x, position.y, position.z) == Blocks.water;
 	}
 
-	protected final Block getBlock(World world, BlockPos pos) {
-		return getBlockState(world, pos).getBlock();
+	protected Block getBlock(Vect position) {
+		return world.getBlock(position.x, position.y, position.z);
 	}
 
-	protected final int getBlockMeta(World world, BlockPos pos) {
-		IBlockState blockState = world.getBlockState(pos);
-		return blockState.getBlock().getMetaFromState(blockState);
+	protected int getBlockMeta(Vect position) {
+		return world.getBlockMetadata(position.x, position.y, position.z);
 	}
 
-	protected final ItemStack getAsItemStack(World world, BlockPos position) {
-		return new ItemStack(getBlock(world, position), 1, getBlockMeta(world, position));
+	protected ItemStack getAsItemStack(Vect position) {
+		return new ItemStack(getBlock(position), 1, getBlockMeta(position));
 	}
 
-	protected final boolean isWaterBlock(World world, BlockPos pos) {
-		return getBlock(world, pos) == Blocks.WATER;
+	protected Vect translateWithOffset(int x, int y, int z, FarmDirection direction, int step) {
+		return new Vect(
+			x + direction.getForgeDirection().offsetX * step,
+			y + direction.getForgeDirection().offsetY * step,
+			z + direction.getForgeDirection().offsetZ * step
+		);
 	}
 
-	protected final void setBlock(World world, BlockPos pos, Block block, int meta) {
-		world.setBlockState(pos, block.getStateFromMeta(meta), 2);
+	protected void setBlock(Vect position, Block block, int meta) {
+		world.setBlock(position.x, position.y, position.z, block, meta, 2);
 	}
 }

src/main/java/binnie/botany/farm/FarmableFlower.java

@@ -1,54 +1,30 @@
 package binnie.botany.farm;
 
-import javax.annotation.Nullable;
-
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.Blocks;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
-import forestry.api.farming.ICrop;
-import forestry.api.farming.IFarmable;
-
 import binnie.botany.Botany;
 import binnie.botany.api.EnumFlowerStage;
 import binnie.botany.api.IFlower;
-import binnie.botany.api.IFlowerRoot;
 import binnie.botany.core.BotanyCore;
-import binnie.botany.flower.TileEntityFlower;
+import binnie.botany.gardening.Gardening;
+import forestry.api.farming.ICrop;
+import forestry.api.farming.IFarmable;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
 
 public class FarmableFlower implements IFarmable {
 	@Override
-	public boolean isSaplingAt(World world, BlockPos pos) {
-		return world.getBlockState(pos) == Botany.flower;
+	public boolean isSaplingAt(World world, int x, int y, int z) {
+		return world.getBlock(x, y, z) == Botany.flower;
 	}
 
-	@Nullable
 	@Override
-	public ICrop getCropAt(World world, BlockPos pos, IBlockState blockState) {
-		IFlower flower = null;
-		if (world.getTileEntity(pos) instanceof TileEntityFlower) {
-			flower = ((TileEntityFlower) world.getTileEntity(pos)).getFlower();
-		}
-
-		// TODO Look at TileEntityFlower::onShear logic
-		if (flower != null && flower.getAge() > 1) {
-			IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
-			ItemStack mature = flowerRoot.getMemberStack(flower, EnumFlowerStage.FLOWER);
-			ItemStack seed = flowerRoot.getMemberStack(flower, EnumFlowerStage.SEED);
-			if (mature != null && seed != null) {
-				world.setBlockState(pos, Blocks.AIR.getDefaultState(), 2);
-				return new FlowerCrop(pos, mature, seed);
-			}
-		}
+	public ICrop getCropAt(World world, int x, int y, int z) {
 		return null;
 	}
 
 	@Override
 	public boolean isGermling(ItemStack itemstack) {
-		EnumFlowerStage stage = BotanyCore.getFlowerRoot().getType(itemstack);
+		EnumFlowerStage stage = BotanyCore.speciesRoot.getStageType(itemstack);
 		return stage == EnumFlowerStage.FLOWER || stage == EnumFlowerStage.SEED;
 	}
 
@@ -58,10 +34,9 @@ public class FarmableFlower implements IFarmable {
 	}
 
 	@Override
-	public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, BlockPos pos) {
-		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
-		IFlower flower = flowerRoot.getMember(germling);
-		flowerRoot.plant(world, pos, flower, player.getGameProfile());
+	public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, int x, int y, int z) {
+		IFlower flower = BotanyCore.getFlowerRoot().getMember(germling);
+		Gardening.plant(world, x, y, z, flower, player.getGameProfile());
 		return true;
 	}
 }

src/main/java/binnie/botany/farm/FarmableVanillaFlower.java

@@ -1,14 +1,12 @@
 package binnie.botany.farm;
 
+import binnie.botany.api.IFlower;
+import binnie.botany.core.BotanyCore;
+import binnie.botany.gardening.Gardening;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import binnie.botany.api.IFlower;
-import binnie.botany.api.IFlowerRoot;
-import binnie.botany.core.BotanyCore;
-
 public class FarmableVanillaFlower extends FarmableFlower {
 	@Override
 	public boolean isGermling(ItemStack itemstack) {
@@ -16,9 +14,8 @@ public class FarmableVanillaFlower extends FarmableFlower {
 	}
 
 	@Override
-	public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, BlockPos pos) {
-		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
-		IFlower flower = flowerRoot.getConversion(germling);
-		return flowerRoot.plant(world, pos, flower, player.getGameProfile());
+	public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, int x, int y, int z) {
+		IFlower flower = BotanyCore.getFlowerRoot().getConversion(germling);
+		return Gardening.plant(world, x, y, z, flower, player.getGameProfile());
 	}
 }

src/main/java/binnie/botany/farm/FlowerCrop.java

@@ -1,31 +0,0 @@
-package binnie.botany.farm;
-
-import javax.annotation.Nullable;
-import java.util.Collections;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.math.BlockPos;
-
-import forestry.api.farming.ICrop;
-
-public class FlowerCrop implements ICrop {
-	NonNullList<ItemStack> drops = NonNullList.create();
-	BlockPos position;
-
-	public FlowerCrop(BlockPos pos, ItemStack... drops) {
-		Collections.addAll(this.drops, drops);
-		position = pos;
-	}
-
-	@Nullable
-	@Override
-	public NonNullList<ItemStack> harvest() {
-		return drops;
-	}
-
-	@Override
-	public BlockPos getPosition() {
-		return position;
-	}
-}

src/main/java/binnie/botany/farm/GardenLogic.java

@@ -1,13 +1,22 @@
 package binnie.botany.farm;
 
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Objects;
-import java.util.stream.Collectors;
-
+import binnie.Binnie;
+import binnie.botany.Botany;
+import binnie.botany.api.EnumAcidity;
+import binnie.botany.api.EnumMoisture;
+import binnie.botany.api.EnumSoilType;
+import binnie.botany.api.gardening.IBlockSoil;
+import binnie.botany.flower.TileEntityFlower;
+import binnie.botany.gardening.Gardening;
+import com.mojang.authlib.GameProfile;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import forestry.api.farming.FarmDirection;
+import forestry.api.farming.ICrop;
+import forestry.api.farming.IFarmHousing;
+import forestry.api.farming.IFarmable;
+import forestry.core.access.IOwnable;
+import forestry.core.utils.vect.Vect;
 import net.minecraft.block.Block;
 import net.minecraft.client.renderer.texture.TextureMap;
 import net.minecraft.init.Blocks;
@@ -15,53 +24,30 @@ import net.minecraft.item.Item;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.NonNullList;
+import net.minecraft.util.IIcon;
 import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-
 import net.minecraftforge.fluids.FluidStack;
 
-import forestry.api.farming.FarmDirection;
-import forestry.api.farming.ICrop;
-import forestry.api.farming.IFarmHousing;
-import forestry.api.farming.IFarmable;
-import forestry.core.owner.IOwnedTile;
-import forestry.core.utils.BlockUtil;
-
-import binnie.Binnie;
-import binnie.botany.Botany;
-import binnie.botany.api.EnumAcidity;
-import binnie.botany.api.EnumMoisture;
-import binnie.botany.api.EnumSoilType;
-import binnie.botany.api.IBlockSoil;
-import binnie.botany.api.IGardeningManager;
-import binnie.botany.core.BotanyCore;
-import binnie.botany.flower.TileEntityFlower;
-import binnie.core.liquid.ManagerLiquid;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 
 public class GardenLogic extends FarmLogic {
-	List<IFarmable> farmables;
-	private EnumMoisture moisture;
-	@Nullable
-	private EnumAcidity acidity;
-	private boolean fertilised;
-	private String name;
-	private NonNullList<ItemStack> produce;
+	protected EnumMoisture moisture;
+	protected EnumAcidity acidity;
+	protected boolean fertilised;
+	protected String name;
+	protected ArrayList<ItemStack> produce;
+	protected List<IFarmable> farmables;
+
 	private ItemStack icon;
 
-	public GardenLogic(EnumMoisture moisture2, @Nullable EnumAcidity acidity2, boolean isManual, boolean isFertilised, ItemStack icon2, String name2) {
-		this.isManual = isManual;
-		produce = NonNullList.create();
+	public GardenLogic(IFarmHousing housing) {
+		super(housing);
+		produce = new ArrayList<>();
 		farmables = new ArrayList<>();
 		farmables.add(new FarmableFlower());
 		farmables.add(new FarmableVanillaFlower());
-
-		moisture = moisture2;
-		acidity = acidity2;
-		fertilised = isFertilised;
-		icon = icon2;
-		name = name2;
 	}
 
 	@Override
@@ -75,96 +61,114 @@ public class GardenLogic extends FarmLogic {
 	}
 
 	@Override
-	public boolean isAcceptedResource(ItemStack itemstack) {
-		IGardeningManager gardening = BotanyCore.getGardening();
-		return gardening.isSoil(itemstack.getItem()) ||
-				itemstack.getItem() == Item.getItemFromBlock(Blocks.SAND) ||
-				itemstack.getItem() == Item.getItemFromBlock(Blocks.DIRT) ||
-				gardening.isAcidFertiliser(itemstack) ||
-				gardening.isAlkalineFertiliser(itemstack);
+	public boolean isAcceptedResource(ItemStack stack) {
+		Item item = stack.getItem();
+		return Gardening.isSoil(item)
+			|| item == Item.getItemFromBlock(Blocks.sand)
+			|| item == Item.getItemFromBlock(Blocks.dirt)
+			|| Gardening.isAcidFertiliser(stack)
+			|| Gardening.isAlkalineFertiliser(stack);
 	}
 
 	@Override
-	public NonNullList<ItemStack> collect(World world, IFarmHousing farmHousing) {
-		NonNullList<ItemStack> products = produce;
-		produce = NonNullList.create();
+	public Collection<ItemStack> collect() {
+		Collection<ItemStack> products = produce;
+		produce = new ArrayList<>();
 		return products;
 	}
 
 	@Override
-	public boolean cultivate(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) {
-		return maintainSoil(world, pos, direction, extent, farmHousing) ||
-				(!isManual && maintainWater(world, pos, direction, extent, farmHousing)) ||
-				maintainCrops(world, pos.up(), direction, extent, farmHousing);
+	public boolean cultivate(int x, int y, int z, FarmDirection direction, int extent) {
+		world = housing.getWorld();
+		return maintainSoil(x, y, z, direction, extent)
+			|| !isManual && maintainWater(x, y, z, direction, extent)
+			|| maintainCrops(x, y + 1, z, direction, extent);
 	}
 
 	private boolean isWaste(ItemStack stack) {
-		return stack.getItem() == Item.getItemFromBlock(Blocks.DIRT);
+		return stack.getItem() == Item.getItemFromBlock(Blocks.dirt);
 	}
 
-	private boolean maintainSoil(World world, BlockPos pos, FarmDirection direction, int extent, IFarmHousing housing) {
-		IGardeningManager gardening = BotanyCore.getGardening();
+	private boolean maintainSoil(int x, int y, int z, FarmDirection direction, int extent) {
 		for (int i = 0; i < extent; ++i) {
-			BlockPos position = pos.offset(direction.getFacing(), i);
-			if (fertilised && gardening.isSoil(getBlock(world, position))) {
-				IBlockSoil soil = (IBlockSoil) getBlock(world, position);
-				if (soil.fertilise(world, position, EnumSoilType.FLOWERBED)) {
+			Vect position = translateWithOffset(x, y, z, direction, i);
+			boolean isSoil = Gardening.isSoil(world.getBlock(position.x, position.y, position.z));
+			
+			// remove unnecessary blocks
+			if (!isManual && !isSoil && !isAirBlock(position)) {
+				Block block = world.getBlock(position.x, position.y, position.z);
+				if (moisture == EnumMoisture.DAMP) {
+					if (block != Blocks.water) {
+						dropBlockAsProduction(position);
+					}
+				} else if (moisture == EnumMoisture.DRY) {
+					if (block != Blocks.sand) {
+						dropBlockAsProduction(position);
+					}
+				} else {
+					dropBlockAsProduction(position);
+				}
+			}
+
+			if (fertilised && isSoil) {
+				IBlockSoil soil = (IBlockSoil) world.getBlock(position.x, position.y, position.z);
+				if (soil.fertilise(world, position.x, position.y, position.z, EnumSoilType.FLOWERBED)) {
 					continue;
 				}
 			}
 
-			if (getBlock(world, position.up()) == Botany.plant) {
-				world.setBlockToAir(position.up());
-			} else {
-				if (acidity != null && gardening.isSoil(getBlock(world, position))) {
-					IBlockSoil soil = (IBlockSoil) getBlock(world, position);
-					EnumAcidity pH = soil.getPH(world, position);
-					if (pH.ordinal() < acidity.ordinal()) {
-						ItemStack stack = getAvailableAlkaline(housing);
-						if (!stack.isEmpty() && soil.setPH(world, position, EnumAcidity.values()[pH.ordinal() + 1])) {
-							NonNullList<ItemStack> resources = NonNullList.create();
-							resources.add(stack);
-							housing.getFarmInventory().removeResources(resources);
-							continue;
-						}
-					}
-					if (pH.ordinal() > acidity.ordinal()) {
-						ItemStack stack = getAvailableAcid(housing);
-						if (!stack.isEmpty() && soil.setPH(world, position, EnumAcidity.values()[pH.ordinal() - 1])) {
-							NonNullList<ItemStack> resources = NonNullList.create();
-							resources.add(stack);
-							housing.getFarmInventory().removeResources(resources);
-							continue;
-						}
+			if (world.getBlock(position.x, position.y + 1, position.z) == Botany.plant) {
+				world.setBlockToAir(position.x, position.y + 1, position.z);
+				continue;
+			}
+
+			if (acidity != null && isSoil) {
+				IBlockSoil soil = (IBlockSoil) world.getBlock(position.x, position.y, position.z);
+				EnumAcidity pH = soil.getPH(world, position.x, position.y, position.z);
+				if (pH.ordinal() < acidity.ordinal()) {
+					ItemStack stack = getAvailableAlkaline();
+					if (stack != null && soil.setPH(world, position.x, position.y, position.z, EnumAcidity.values()[pH.ordinal() + 1])) {
+						housing.getFarmInventory().removeResources(new ItemStack[]{stack});
+						continue;
 					}
 				}
 
-				if (!isAirBlock(world, position) && !BlockUtil.isReplaceableBlock(getBlockState(world, position), world, position)) {
-					ItemStack block = getAsItemStack(world, position);
-					ItemStack loam = getAvailableLoam(housing);
-					if (isWaste(block) && !loam.isEmpty()) {
-						produce.addAll(Blocks.DIRT.getDrops(world, position, Block.getBlockFromItem(block.getItem()).getStateFromMeta(block.getItemDamage()), 0));
-						setBlock(world, position, Blocks.AIR, 0);
-						return trySetSoil(world, position, loam, housing);
+				if (pH.ordinal() > acidity.ordinal()) {
+					ItemStack stack = getAvailableAcid();
+					if (stack != null && soil.setPH(world, position.x, position.y, position.z, EnumAcidity.values()[pH.ordinal() - 1])) {
+						housing.getFarmInventory().removeResources(new ItemStack[]{stack});
+						continue;
 					}
-				} else if (!isManual) {
-					if (!isWaterBlock(world, position)) {
-						if (i % 2 == 0) {
-							return trySetSoil(world, position, housing);
-						}
-						FarmDirection cclock = FarmDirection.EAST;
-						if (direction == FarmDirection.EAST) {
-							cclock = FarmDirection.SOUTH;
-						} else if (direction == FarmDirection.SOUTH) {
-							cclock = FarmDirection.EAST;
-						} else if (direction == FarmDirection.WEST) {
-							cclock = FarmDirection.SOUTH;
-						}
-						BlockPos previous = position.offset(cclock.getFacing());
-						ItemStack soil2 = getAsItemStack(world, previous);
-						if (!gardening.isSoil(soil2.getItem())) {
-							trySetSoil(world, position, housing);
-						}
+				}
+			}
+
+			if (!isAirBlock(position) && !world.getBlock(position.x, position.y, position.z).isReplaceable(world, position.x, position.y, position.z)) {
+				ItemStack block = getAsItemStack(position);
+				ItemStack loam = getAvailableLoam();
+				if (isWaste(block) && loam != null) {
+					produce.addAll(Blocks.dirt.getDrops(world, position.x, position.y, position.z, block.getItemDamage(), 0));
+					setBlock(position, Blocks.air, 0);
+					return trySetSoil(position, loam);
+				}
+			} else if (!isManual) {
+				if (!isWaterBlock(position)) {
+					if (i % 2 == 0) {
+						return trySetSoil(position);
+					}
+
+					FarmDirection cclock = FarmDirection.EAST;
+					if (direction == FarmDirection.EAST) {
+						cclock = FarmDirection.SOUTH;
+					} else if (direction == FarmDirection.SOUTH) {
+						cclock = FarmDirection.EAST;
+					} else if (direction == FarmDirection.WEST) {
+						cclock = FarmDirection.SOUTH;
+					}
+
+					Vect previous = translateWithOffset(position.x, position.y, position.z, cclock, 1);
+					ItemStack soil2 = getAsItemStack(previous);
+					if (!Gardening.isSoil(soil2.getItem())) {
+						trySetSoil(position);
 					}
 				}
 			}
@@ -172,140 +176,140 @@ public class GardenLogic extends FarmLogic {
 		return false;
 	}
 
-	private boolean maintainWater(World world, BlockPos pos, FarmDirection direction, int extent, IFarmHousing housing) {
+	private boolean maintainWater(int x, int y, int z, FarmDirection direction, int extent) {
 		for (int i = 0; i < extent; ++i) {
-			BlockPos position = pos.offset(direction.getFacing(), i);
-			if (!isAirBlock(world, position) && !BlockUtil.isReplaceableBlock(getBlockState(world, position), world, position)) {
+			Vect position = translateWithOffset(x, y, z, direction, i);
+			if (!isAirBlock(position) && !world.getBlock(x, y, z).isReplaceable(world, position.x, position.y, position.z)) {
 				continue;
 			}
-			if (isWaterBlock(world, position)) {
+
+			if (isWaterBlock(position)) {
 				continue;
 			}
 
 			boolean isEnclosed = true;
-			if (world.isAirBlock(position.east())) {
+			if (world.isAirBlock(position.x + 1, position.y, position.z)) {
 				isEnclosed = false;
-			} else if (world.isAirBlock(position.west())) {
+			} else if (world.isAirBlock(position.x - 1, position.y, position.z)) {
 				isEnclosed = false;
-			} else if (world.isAirBlock(position.south())) {
+			} else if (world.isAirBlock(position.x, position.y, position.z + 1)) {
 				isEnclosed = false;
-			} else if (world.isAirBlock(position.north())) {
+			} else if (world.isAirBlock(position.x, position.y, position.z - 1)) {
 				isEnclosed = false;
 			}
 
 			isEnclosed = (isEnclosed || moisture != EnumMoisture.DAMP);
 			if (isEnclosed) {
-				return trySetWater(world, position, housing);
+				return trySetWater(position);
 			}
 		}
 		return false;
 	}
 
-	private ItemStack getAvailableLoam(IFarmHousing housing) {
+	private ItemStack getAvailableLoam() {
 		EnumMoisture[] moistures;
 		if (moisture == EnumMoisture.DAMP) {
 			moistures = new EnumMoisture[]{
-					EnumMoisture.DAMP,
-					EnumMoisture.NORMAL,
-					EnumMoisture.DRY
+				EnumMoisture.DAMP,
+				EnumMoisture.NORMAL,
+				EnumMoisture.DRY
 			};
 		} else if (moisture == EnumMoisture.DRY) {
 			moistures = new EnumMoisture[]{
-					EnumMoisture.DRY,
-					EnumMoisture.DAMP,
-					EnumMoisture.DRY
+				EnumMoisture.DRY,
+				EnumMoisture.DAMP,
+				EnumMoisture.DRY
 			};
 		} else {
 			moistures = new EnumMoisture[]{
-					EnumMoisture.DRY,
-					EnumMoisture.NORMAL,
-					EnumMoisture.DAMP
+				EnumMoisture.DRY,
+				EnumMoisture.NORMAL,
+				EnumMoisture.DAMP
 			};
 		}
 
 		EnumAcidity[] acidities = {
-				EnumAcidity.NEUTRAL,
-				EnumAcidity.ACID,
-				EnumAcidity.ALKALINE
+			EnumAcidity.NEUTRAL,
+			EnumAcidity.ACID,
+			EnumAcidity.ALKALINE
 		};
 
 		for (EnumMoisture moist : moistures) {
 			for (EnumAcidity acid : acidities) {
 				for (Block type : new Block[]{Botany.flowerbed, Botany.loam, Botany.soil}) {
 					int meta = acid.ordinal() * 3 + moist.ordinal();
-					NonNullList<ItemStack> resources = NonNullList.create();
-					ItemStack resourceStack = new ItemStack(type, 1, meta);
-					resources.add(resourceStack);
-					if (housing.getFarmInventory().hasResources(resources)) {
-						return resourceStack;
+					ItemStack[] resource = {new ItemStack(type, 1, meta)};
+					if (housing.getFarmInventory().hasResources(resource)) {
+						return resource[0];
 					}
 				}
 			}
 		}
 
-		NonNullList<ItemStack> resources = NonNullList.create();
-		ItemStack resourceStack = new ItemStack(Blocks.DIRT);
-		resources.add(resourceStack);
-		if (housing.getFarmInventory().hasResources(resources)) {
-			return new ItemStack(Blocks.DIRT);
+		if (housing.getFarmInventory().hasResources(new ItemStack[]{new ItemStack(Blocks.dirt)})) {
+			return new ItemStack(Blocks.dirt);
 		}
-		return ItemStack.EMPTY;
+		return null;
 	}
 
-	private boolean trySetSoil(World world, BlockPos position, IFarmHousing housing) {
-		return trySetSoil(world, position, getAvailableLoam(housing), housing);
+	private boolean trySetSoil(Vect position) {
+		return trySetSoil(position, getAvailableLoam());
 	}
 
-	private boolean trySetSoil(World world, BlockPos position, ItemStack loam, IFarmHousing housing) {
+	private boolean trySetSoil(Vect position, ItemStack loam) {
 		ItemStack copy = loam;
-		if (loam.isEmpty()) {
+		if (loam == null) {
 			return false;
 		}
 
-		if (loam.getItem() == Item.getItemFromBlock(Blocks.DIRT)) {
-			loam = new ItemStack(Botany.soil, 1, 4);
+		if (loam.getItem() == Item.getItemFromBlock(Blocks.dirt)) {
+			loam = new ItemStack(Botany.soil, 0, 4);
 		}
 
-		setBlock(world, position, ((ItemBlock) loam.getItem()).getBlock(), loam.getItemDamage());
-		NonNullList<ItemStack> resources = NonNullList.create();
-		resources.add(copy);
-		housing.getFarmInventory().removeResources(resources);
+		setBlock(position, ((ItemBlock) loam.getItem()).field_150939_a, loam.getItemDamage());
+		housing.getFarmInventory().removeResources(new ItemStack[]{copy});
 		return true;
 	}
 
-	private boolean trySetWater(World world, BlockPos position, IFarmHousing housing) {
-		FluidStack water = Binnie.LIQUID.getFluidStack(ManagerLiquid.WATER, 1000);
+	private boolean trySetWater(Vect position) {
+		FluidStack water = Binnie.Liquid.getLiquidStack("water", 1000);
 		if (moisture == EnumMoisture.DAMP) {
-			if (water == null || !housing.hasLiquid(water)) {
+			if (!housing.hasLiquid(water)) {
 				return false;
 			}
-			setBlock(world, position, Blocks.WATER, 0);
+
+			setBlock(position, Blocks.water, 0);
 			housing.removeLiquid(water);
 			return true;
 		}
 
 		if (moisture != EnumMoisture.DRY) {
-			return trySetSoil(world, position, housing);
+			return trySetSoil(position);
 		}
-		ItemStack sand = new ItemStack(Blocks.SAND, 1);
-		NonNullList<ItemStack> resources = NonNullList.create();
-		resources.add(sand);
-		if (!housing.getFarmInventory().hasResources(resources)) {
+
+		ItemStack[] sand = {new ItemStack(Blocks.sand, 1)};
+		if (!housing.getFarmInventory().hasResources(sand)) {
 			return false;
 		}
-		setBlock(world, position, Blocks.SAND, 0);
-		housing.getFarmInventory().removeResources(resources);
+
+		setBlock(position, Blocks.sand, 0);
+		housing.getFarmInventory().removeResources(sand);
 		return true;
 	}
 
-	public void setIcon(ItemStack icon) {
-		this.icon = icon;
+	private void dropBlockAsProduction(Vect position) {
+		ItemStack stack = new ItemStack(world.getBlock(position.x, position.y, position.z));
+		if (stack.getItem() == null) {
+			return;
+		}
+		produce.add(stack);
+		world.setBlockToAir(position.x, position.y, position.z);
 	}
 
 	@Override
-	public boolean isAcceptedGermling(ItemStack itemstack) {
+	public boolean isAcceptedGermling(ItemStack stack) {
 		for (IFarmable farmable : farmables) {
-			if (farmable.isGermling(itemstack)) {
+			if (farmable.isGermling(stack)) {
 				return true;
 			}
 		}
@@ -313,17 +317,23 @@ public class GardenLogic extends FarmLogic {
 	}
 
 	@Override
-	public Collection<ICrop> harvest(World world, BlockPos pos, FarmDirection direction, int extent) {
-		if (isManual) {
-			return Collections.emptyList();
-		}
-		return farmables.stream().map(farmable -> farmable.getCropAt(world, pos.up(), world.getBlockState(pos.up())))
-				.filter(Objects::nonNull).collect(Collectors.toList());
+	public Collection<ICrop> harvest(int x, int y, int z, FarmDirection direction, int extent) {
+		return null;
 	}
 
 	@Override
-	public ResourceLocation getTextureMap() {
-		return TextureMap.LOCATION_BLOCKS_TEXTURE;
+	@SideOnly(Side.CLIENT)
+	public IIcon getIcon() {
+		return icon.getIconIndex();
+	}
+
+	public void setIcon(ItemStack icon) {
+		this.icon = icon;
+	}
+
+	@Override
+	public ResourceLocation getSpriteSheet() {
+		return TextureMap.locationBlocksTexture;
 	}
 
 	@Override
@@ -331,68 +341,67 @@ public class GardenLogic extends FarmLogic {
 		return name;
 	}
 
-	@Override
-	public ItemStack getIconItemStack() {
-		return icon;
-	}
-
-	protected boolean maintainCrops(World world, BlockPos pos, FarmDirection direction, int extent, IFarmHousing housing) {
-		IGardeningManager gardening = BotanyCore.getGardening();
+	protected boolean maintainCrops(int x, int y, int z, FarmDirection direction, int extent) {
 		for (int i = 0; i < extent; ++i) {
-			BlockPos position = pos.offset(direction.getFacing(), i);
-			if (isAirBlock(world, position) || BlockUtil.isReplaceableBlock(getBlockState(world, position), world, position)) {
-				ItemStack below = getAsItemStack(world, position.down());
-				if (gardening.isSoil(below.getItem())) {
-					return trySetCrop(world, position, housing);
+			Vect position = translateWithOffset(x, y, z, direction, i);
+			if (isAirBlock(position) || world.getBlock(x, y, z).isReplaceable(world, position.x, position.y, position.z)) {
+				ItemStack below = getAsItemStack(position.add(new Vect(0, -1, 0)));
+				if (Gardening.isSoil(below.getItem())) {
+					return trySetCrop(position);
 				}
 			}
 		}
 		return false;
 	}
 
-	private boolean trySetCrop(World world, BlockPos position, IFarmHousing housing) {
+	private boolean trySetCrop(Vect position) {
 		for (IFarmable farmable : farmables) {
-			if (!housing.plantGermling(farmable, world, position)) {
+			boolean success = housing.plantGermling(farmable, world, position.x, position.y, position.z);
+			if (!success || !(housing instanceof IOwnable)) {
 				continue;
 			}
 
-			if (housing instanceof IOwnedTile) {
-				TileEntity tile = world.getTileEntity(position);
-				if (tile instanceof TileEntityFlower) {
-					TileEntityFlower flower = (TileEntityFlower) tile;
-					IOwnedTile owned = (IOwnedTile) housing;
+			TileEntity tile = housing.getWorld().getTileEntity(position.x, position.y, position.z);
+			if (!(tile instanceof TileEntityFlower)) {
+				return true;
+			}
 
-					flower.setOwner(owned.getOwnerHandler().getOwner());
-				}
+			try {
+				IOwnable housing2 = (IOwnable) housing;
+				GameProfile prof = (GameProfile) IOwnable.class.getMethod("getOwnerProfile", new Class[0]).invoke(housing2);
+				((TileEntityFlower) tile).setOwner(prof);
+			} catch (Exception ex) {
+				// ignored
 			}
 			return true;
 		}
 		return false;
 	}
 
-	public ItemStack getAvailableAcid(IFarmHousing housing) {
-		for (ItemStack stack : BotanyCore.getGardening().getAcidFertilisers()) {
-			if (!stack.isEmpty()) {
-				NonNullList<ItemStack> resources = NonNullList.create();
-				resources.add(stack);
-				if (housing.getFarmInventory().hasResources(resources)) {
-					return stack;
-				}
+	public ItemStack getAvailableAcid() {
+		for (ItemStack stack : Gardening.getAcidFertilisers()) {
+			if (stack != null && stack.getItem() != null && housing.getFarmInventory().hasResources(new ItemStack[]{stack})) {
+				return stack;
 			}
 		}
-		return ItemStack.EMPTY;
+		return null;
 	}
 
-	public ItemStack getAvailableAlkaline(IFarmHousing housing) {
-		for (ItemStack stack : BotanyCore.getGardening().getAlkalineFertilisers()) {
-			if (!stack.isEmpty()) {
-				NonNullList<ItemStack> resources = NonNullList.create();
-				resources.add(stack);
-				if (housing.getFarmInventory().hasResources(resources)) {
-					return stack;
-				}
+	public ItemStack getAvailableAlkaline() {
+		for (ItemStack stack : Gardening.getAlkalineFertilisers()) {
+			if (stack != null && stack.getItem() != null && housing.getFarmInventory().hasResources(new ItemStack[]{stack})) {
+				return stack;
 			}
 		}
-		return ItemStack.EMPTY;
+		return null;
+	}
+
+	public void setData(EnumMoisture moisture, EnumAcidity acidity, boolean isManual, boolean fertilised, ItemStack icon, String name) {
+		this.moisture = moisture;
+		this.acidity = acidity;
+		this.isManual = isManual;
+		this.fertilised = fertilised;
+		this.icon = icon;
+		this.name = name;
 	}
 }

src/main/java/binnie/botany/farm/package-info.java

@@ -1,9 +0,0 @@
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-@FieldsAreNonnullByDefault
-package binnie.botany.farm;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-import binnie.core.util.FieldsAreNonnullByDefault;
-import mcp.MethodsReturnNonnullByDefault;

src/main/java/binnie/botany/flower/BlockFlower.java

@@ -1,320 +1,232 @@
-package binnie.botany.flower;
-
-import javax.annotation.Nullable;
-import java.util.List;
-import java.util.Random;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockContainer;
-import net.minecraft.block.SoundType;
-import net.minecraft.block.material.Material;
-import net.minecraft.block.properties.PropertyBool;
-import net.minecraft.block.properties.PropertyInteger;
-import net.minecraft.block.state.BlockStateContainer;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.entity.EntityLivingBase;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.Blocks;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.BlockRenderLayer;
-import net.minecraft.util.EnumBlockRenderType;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.EnumHand;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.math.AxisAlignedBB;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.IBlockAccess;
-import net.minecraft.world.World;
-
-import com.mojang.authlib.GameProfile;
-
-import net.minecraftforge.client.model.ModelLoader;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.api.core.IStateMapperRegister;
-import forestry.core.blocks.IColoredBlock;
-
-import binnie.botany.Botany;
-import binnie.botany.api.IFlower;
-import binnie.botany.api.IFlowerGenome;
-import binnie.botany.api.IFlowerRoot;
-import binnie.botany.api.IFlowerType;
-import binnie.botany.core.BotanyCore;
-import binnie.botany.genetics.EnumFlowerType;
-import binnie.botany.genetics.FlowerDefinition;
-import binnie.botany.network.PacketID;
-import binnie.core.BinnieCore;
-import binnie.core.network.packet.MessageNBT;
-import binnie.core.util.TileUtil;
-
-public class BlockFlower extends BlockContainer implements IColoredBlock, IStateMapperRegister {
-	public static final AxisAlignedBB FLOWER_BLOCK_AABB = new AxisAlignedBB(0.3D, 0.0D, 0.3D, 0.7D, 0.6D, 0.7D);
-	/* PROPERTIES */
-	public static final PropertyFlower FLOWER = new PropertyFlower("flower", IFlowerType.class);
-	public static final PropertyInteger SECTION = PropertyInteger.create("section", 0, EnumFlowerType.highestSection - 1);
-	public static final PropertyBool FLOWERED = PropertyBool.create("flowered");
-	public static final PropertyBool SEED = PropertyBool.create("seed");
-
-	public BlockFlower() {
-		super(Material.PLANTS);
-		setTickRandomly(true);
-		setRegistryName("flower");
-		setSoundType(SoundType.PLANT);
-	}
-
-	@Override
-	public TileEntity createNewTileEntity(World world, int meta) {
-		return new TileEntityFlower();
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerStateMapper() {
-		ModelLoader.setCustomStateMapper(this, new StateMapperFlower());
-	}
-
-	@Override
-	public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
-		ItemStack heldItem = player.getHeldItemMainhand();
-		if (heldItem.isEmpty() || heldItem.getItem() != BinnieCore.getFieldKit() || !player.isSneaking()) {
-			return false;
-		}
-		if (world.isRemote) {
-			return true;
-		}
-
-		TileEntity tile = world.getTileEntity(pos);
-		if (!(tile instanceof TileEntityFlower)) {
-			return true;
-		}
-
-		TileEntityFlower tileFlower = (TileEntityFlower) tile;
-		IFlower flower = tileFlower.getFlower();
-		if (flower == null) {
-			return true;
-		}
-
-		IFlowerGenome flowerGenome = flower.getGenome();
-		NBTTagCompound info = new NBTTagCompound();
-		info.setString("Species", flowerGenome.getPrimary().getUID());
-		info.setString("Species2", flowerGenome.getSecondary().getUID());
-		info.setFloat("Age", flower.getAge() / flowerGenome.getLifespan());
-		info.setShort("Colour", (short) flowerGenome.getPrimaryColor().getID());
-		info.setShort("Colour2", (short) flowerGenome.getSecondaryColor().getID());
-		info.setBoolean("Wilting", flower.isWilted());
-		info.setBoolean("Flowered", flower.hasFlowered());
-		Botany.proxy.sendToPlayer(new MessageNBT(PacketID.FIELDKIT.ordinal(), info), player);
-		heldItem.damageItem(1, player);
-		return true;
-	}
-
-	@Override
-	@Nullable
-	public AxisAlignedBB getCollisionBoundingBox(IBlockState blockState, IBlockAccess worldIn, BlockPos pos) {
-		return null;
-	}
-
-	@Override
-	public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
-		TileEntity tile = source.getTileEntity(pos);
-		if (tile instanceof TileEntityFlower) {
-			TileEntityFlower flower = (TileEntityFlower) tile;
-			if (flower.getType().getSections() > 1) {
-				return FULL_BLOCK_AABB;
-			}
-		}
-		return FLOWER_BLOCK_AABB;
-	}
-
-	@Override
-	public AxisAlignedBB getSelectedBoundingBox(IBlockState state, World world, BlockPos pos) {
-		TileEntity tile = world.getTileEntity(pos);
-		if (tile instanceof TileEntityFlower) {
-			TileEntityFlower flower = (TileEntityFlower) tile;
-			if (flower.getType().getSections() > 1) {
-				return FULL_BLOCK_AABB.offset(pos);
-			}
-		}
-		return FLOWER_BLOCK_AABB.offset(pos);
-	}
-
-	@Override
-	public boolean isOpaqueCube(IBlockState state) {
-		return false;
-	}
-
-	@Override
-	public boolean isFullCube(IBlockState state) {
-		return false;
-	}
-
-	@Override
-	public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) {
-		super.onBlockPlacedBy(world, pos, state, placer, stack);
-		IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
-		TileEntity flower = world.getTileEntity(pos);
-		if (!BinnieCore.getBinnieProxy().isSimulating(world)) {
-			if (flower != null && flower instanceof TileEntityFlower) {
-				IFlower f = flowerRoot.getMember(stack);
-				if (f != null) {
-					((TileEntityFlower) flower).setRender(new TileEntityFlower.RenderInfo(f, (TileEntityFlower) flower));
-				}
-			}
-			return;
-		}
-
-		TileEntity below = world.getTileEntity(pos.down());
-		if (flower != null && flower instanceof TileEntityFlower) {
-			if (below instanceof TileEntityFlower) {
-				((TileEntityFlower) flower).setSection(((TileEntityFlower) below).getSection());
-			} else {
-				GameProfile owner = (placer instanceof EntityPlayer) ? ((EntityPlayer) placer).getGameProfile() : null;
-				((TileEntityFlower) flower).create(stack, owner);
-			}
-		}
-		flowerRoot.tryGrowSection(world, pos);
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public int colorMultiplier(IBlockState state, @Nullable IBlockAccess world, @Nullable BlockPos pos, int tintIndex) {
-		if (world != null && pos != null) {
-			TileEntity tile = world.getTileEntity(pos);
-			if (tile instanceof TileEntityFlower) {
-				TileEntityFlower flower = (TileEntityFlower) tile;
-				if (tintIndex == 0) {
-					return flower.getStemColour();
-				} else if (tintIndex == 1) {
-					return flower.getPrimaryColour();
-				}
-				return flower.getSecondaryColour();
-			}
-		}
-		return 0xffffff;
-	}
-
-	@Override
-	public boolean canPlaceBlockAt(World world, BlockPos pos) {
-		return super.canPlaceBlockAt(world, pos) && canBlockStay(world, pos);
-	}
-
-	public boolean canBlockStay(World world, BlockPos pos) {
-		TileEntity tile = world.getTileEntity(pos);
-		IBlockState downState = world.getBlockState(pos.down());
-		if (tile instanceof TileEntityFlower && ((TileEntityFlower) tile).getSection() > 0) {
-			return downState.getBlock() == Botany.flower;
-		}
-		return canPlaceBlockOn(downState.getBlock());
-	}
-
-	protected boolean canPlaceBlockOn(Block block) {
-		return block == Blocks.GRASS
-				|| block == Blocks.DIRT
-				|| block == Blocks.FARMLAND
-				|| BotanyCore.getGardening().isSoil(block);
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public EnumBlockRenderType getRenderType(IBlockState state) {
-		return EnumBlockRenderType.MODEL;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public EnumOffsetType getOffsetType() {
-		return EnumOffsetType.XZ;
-	}
-
-	@Override
-	@SideOnly(Side.CLIENT)
-	public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
-		TileEntityFlower flower = TileUtil.getTile(world, pos, TileEntityFlower.class);
-		if (flower != null && flower.getType() != null) {
-			state = state.withProperty(FLOWER, flower.getType());
-			state = state.withProperty(FLOWERED, flower.isFlowered());
-			state = state.withProperty(SECTION, flower.getRenderSection());
-			state = state.withProperty(SEED, flower.getAge() == 0);
-		} else {
-			state = state.withProperty(FLOWER, FlowerDefinition.Dandelion.getSpecies().getType());
-			state = state.withProperty(FLOWERED, false);
-			state = state.withProperty(SEED, false);
-		}
-		return state;
-	}
-
-	@Override
-	protected BlockStateContainer createBlockState() {
-		return new BlockStateContainer(this, FLOWER, FLOWERED, SECTION, SEED);
-	}
-
-	@Override
-	public int getMetaFromState(IBlockState state) {
-		return 0;
-	}
-
-	@Override
-	public BlockRenderLayer getBlockLayer() {
-		return BlockRenderLayer.CUTOUT;
-	}
-
-	@Override
-	public void neighborChanged(IBlockState state, World worldIn, BlockPos pos, Block blockIn, BlockPos fromPos) {
-		checkAndDropBlock(worldIn, pos);
-		TileEntity tile = worldIn.getTileEntity(pos);
-		if (tile instanceof TileEntityFlower) {
-			TileEntityFlower flower = (TileEntityFlower) tile;
-			if (flower.getSection() == 0 && flower.getFlower() != null && flower.getFlower().getAge() > 0 && flower.getFlower().getGenome().getPrimary().getType().getSections() > 1 && worldIn.getBlockState(pos.up()).getBlock() != Botany.flower) {
-				dropBlockAsItem(worldIn, pos, worldIn.getBlockState(pos), 0);
-				worldIn.setBlockToAir(pos);
-			}
-		}
-	}
-
-	@Override
-	public void updateTick(World world, BlockPos pos, IBlockState state, Random rand) {
-		TileEntity tile = world.getTileEntity(pos);
-		if (tile instanceof TileEntityFlower) {
-			((TileEntityFlower) tile).randomUpdate(rand);
-			checkAndDropBlock(world, pos);
-			return;
-		}
-		world.setBlockToAir(pos);
-	}
-
-	protected void checkAndDropBlock(World world, BlockPos pos) {
-		if (!canBlockStay(world, pos)) {
-			dropBlockAsItem(world, pos, world.getBlockState(pos), 0);
-			world.setBlockToAir(pos);
-		}
-	}
-
-	@Override
-	public NonNullList<ItemStack> getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
-		NonNullList<ItemStack> drops = NonNullList.create();
-		TileEntity tile = world.getTileEntity(pos);
-		if (tile instanceof TileEntityFlower && ((TileEntityFlower) tile).getSection() == 0) {
-			ItemStack flower = ((TileEntityFlower) tile).getItemStack();
-			if (!flower.isEmpty()) {
-				drops.add(flower);
-			}
-		}
-		return drops;
-	}
-
-	@Override
-	public boolean removedByPlayer(IBlockState state, World world, BlockPos pos, EntityPlayer player, boolean willHarvest) {
-		List<ItemStack> drops = getDrops(world, pos, world.getBlockState(pos), 0);
-		boolean hasBeenBroken = world.setBlockToAir(pos);
-		if (hasBeenBroken && BinnieCore.getBinnieProxy().isSimulating(world) && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
-			for (ItemStack drop : drops) {
-				spawnAsEntity(world, pos, drop);
-			}
-		}
-		return hasBeenBroken;
-	}
-}
+package binnie.botany.flower;
+
+import binnie.botany.Botany;
+import binnie.botany.api.EnumFlowerStage;
+import binnie.botany.api.IFlower;
+import binnie.botany.api.IFlowerType;
+import binnie.botany.core.BotanyCore;
+import binnie.botany.gardening.Gardening;
+import binnie.botany.genetics.EnumFlowerType;
+import binnie.core.BinnieCore;
+import com.mojang.authlib.GameProfile;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class BlockFlower extends BlockContainer {
+	public BlockFlower() {
+		super(Material.plants);
+		float f = 0.2f;
+		setBlockBounds(0.5f - f, 0.0f, 0.5f - f, 0.5f + f, f * 3.0f, 0.5f + f);
+		setTickRandomly(true);
+		setBlockName("flower");
+		setStepSound(Block.soundTypeGrass);
+	}
+
+	@Override
+	public String getUnlocalizedName() {
+		return "botany.flower";
+	}
+
+	@Override
+	public int getRenderType() {
+		return RendererBotany.renderID;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerBlockIcons(IIconRegister register) {
+		for (EnumFlowerType type : EnumFlowerType.values()) {
+			type.registerIcons(register);
+		}
+	}
+
+	@Override
+	public TileEntity createNewTileEntity(World world, int meta) {
+		return new TileEntityFlower();
+	}
+
+	@Override
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z) {
+		return null;
+	}
+
+	@Override
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	@Override
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	@Override
+	public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entity, ItemStack stack) {
+		super.onBlockPlacedBy(world, x, y, z, entity, stack);
+		TileEntity flower = world.getTileEntity(x, y, z);
+		if (!BinnieCore.proxy.isSimulating(world)) {
+			if (flower != null && flower instanceof TileEntityFlower) {
+				IFlower f = BotanyCore.getFlowerRoot().getMember(stack);
+				((TileEntityFlower) flower).setRender(new TileEntityFlower.RenderInfo(f, (TileEntityFlower) flower));
+			}
+			return;
+		}
+
+		TileEntity below = world.getTileEntity(x, y - 1, z);
+		if (flower != null && flower instanceof TileEntityFlower) {
+			if (below instanceof TileEntityFlower) {
+				((TileEntityFlower) flower).setSection(((TileEntityFlower) below).getSection());
+			} else {
+				GameProfile owner = (entity instanceof EntityPlayer) ? ((EntityPlayer) entity).getGameProfile() : null;
+				((TileEntityFlower) flower).create(stack, owner);
+			}
+		}
+		Gardening.tryGrowSection(world, x, y, z);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+		TileEntity tile = world.getTileEntity(x, y, z);
+		if (!(tile instanceof TileEntityFlower)) {
+			return super.getIcon(world, x, y, z, side);
+		}
+
+		TileEntityFlower f = (TileEntityFlower) tile;
+		EnumFlowerStage stage = (f.getAge() == 0) ? EnumFlowerStage.SEED : EnumFlowerStage.FLOWER;
+		IFlowerType flower = f.getType();
+		int section = f.getRenderSection();
+		boolean flowered = f.isFlowered();
+		if (RendererBotany.pass == 0) {
+			return flower.getStem(stage, flowered, section);
+		}
+
+		return (RendererBotany.pass == 1) ?
+			flower.getPetalIcon(stage, flowered, section) :
+			flower.getVariantIcon(stage, flowered, section);
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int colorMultiplier(IBlockAccess world, int x, int y, int z) {
+		TileEntity tile = world.getTileEntity(x, y, z);
+		if (tile instanceof TileEntityFlower) {
+			TileEntityFlower f = (TileEntityFlower) tile;
+			if (RendererBotany.pass == 0) {
+				return f.getStemColour();
+			}
+			return (RendererBotany.pass == 1) ?
+				f.getPrimaryColor() :
+				f.getSecondaryColor();
+		}
+		return 0xffffff;
+	}
+
+	@Override
+	public boolean canPlaceBlockAt(World world, int x, int y, int z) {
+		return super.canPlaceBlockAt(world, x, y, z)
+			&& canBlockStay(world, x, y, z);
+	}
+
+	protected boolean canPlaceBlockOn(Block block) {
+		return block == Blocks.grass
+			|| block == Blocks.dirt
+			|| block == Blocks.farmland
+			|| Gardening.isSoil(block);
+	}
+
+	@Override
+	public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
+		super.onNeighborBlockChange(world, x, y, z, block);
+		checkAndDropBlock(world, x, y, z);
+		TileEntity tile = world.getTileEntity(x, y, z);
+		if (!(tile instanceof TileEntityFlower)) {
+			return;
+		}
+
+		TileEntityFlower flower = (TileEntityFlower) tile;
+		if (flower.getSection() == 0
+			&& flower.getFlower() != null
+			&& flower.getFlower().getAge() > 0
+			&& flower.getFlower().getGenome().getPrimary().getType().getSections() > 1
+			&& world.getBlock(x, y + 1, z) != Botany.flower) {
+			dropBlockAsItem(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
+			world.setBlockToAir(x, y, z);
+		}
+	}
+
+	@Override
+	public void updateTick(World world, int x, int y, int z, Random rand) {
+		TileEntity tile = world.getTileEntity(x, y, z);
+		if (tile instanceof TileEntityFlower) {
+			((TileEntityFlower) tile).randomUpdate(rand);
+			checkAndDropBlock(world, x, y, z);
+			return;
+		}
+		world.setBlockToAir(x, y, z);
+	}
+
+	protected void checkAndDropBlock(World world, int x, int y, int z) {
+		if (!canBlockStay(world, x, y, z)) {
+			dropBlockAsItem(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
+			world.setBlockToAir(x, y, z);
+		}
+	}
+
+	@Override
+	public boolean canBlockStay(World world, int x, int y, int z) {
+		TileEntity tile = world.getTileEntity(x, y, z);
+		if (tile instanceof TileEntityFlower && ((TileEntityFlower) tile).getSection() > 0) {
+			return world.getBlock(x, y - 1, z) == Botany.flower;
+		}
+		return canPlaceBlockOn(world.getBlock(x, y - 1, z));
+	}
+
+	@Override
+	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int blockMeta, int fortune) {
+		ArrayList<ItemStack> drops = new ArrayList<>();
+		TileEntity tile = world.getTileEntity(x, y, z);
+		if (tile instanceof TileEntityFlower && ((TileEntityFlower) tile).getSection() == 0) {
+			ItemStack flower = ((TileEntityFlower) tile).getItemStack();
+			if (flower != null) {
+				drops.add(flower);
+			}
+		}
+		return drops;
+	}
+
+	@Override
+	public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z, boolean willHarvest) {
+		List<ItemStack> drops = getDrops(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
+		boolean hasBeenBroken = world.setBlockToAir(x, y, z);
+		if (hasBeenBroken && BinnieCore.proxy.isSimulating(world) && drops.size() > 0 && (player == null || !player.capabilities.isCreativeMode)) {
+			for (ItemStack drop : drops) {
+				dropBlockAsItem(world, x, y, z, drop);
+			}
+		}
+		return hasBeenBroken;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IIcon getIcon(int meta, int side) {
+		return Blocks.yellow_flower.getIcon(0, 0);
+	}
+}

src/main/java/binnie/botany/flower/EnumTubeInsulate.java

@@ -1,60 +0,0 @@
-package binnie.botany.flower;
-
-import net.minecraft.init.Blocks;
-import net.minecraft.item.ItemStack;
-
-import binnie.core.util.I18N;
-
-enum EnumTubeInsulate {
-	CLAY(0xa1aacc, "clay"),
-	COBBLE(0x7b7b7b, "cobblestone"),
-	SAND(0xefeab5, "sandstone"),
-	HARDENED_CLAY(0x935c43, "hardened_clay"),
-	STONE(0x6d6d6d, "stone"),
-	SANDSTONE(0xc1b989, "sandstone");
-
-	public static final EnumTubeInsulate[] VALUES = values();
-
-	int color;
-	String name;
-
-	EnumTubeInsulate(int color, String name) {
-		this.color = color;
-		this.name = name;
-	}
-
-	public static EnumTubeInsulate get(int meta) {
-		return VALUES[meta / 128 % VALUES.length];
-	}
-
-	public int getColor() {
-		return color;
-	}
-
-	public String getDisplayName() {
-		return I18N.localise("botany.tube.insulate." + name + ".name");
-	}
-
-	public ItemStack getStack() {
-		switch (this) {
-			case CLAY:
-				return new ItemStack(Blocks.CLAY);
-
-			case COBBLE:
-				return new ItemStack(Blocks.COBBLESTONE);
-
-			case HARDENED_CLAY:
-				return new ItemStack(Blocks.HARDENED_CLAY);
-
-			case SAND:
-				return new ItemStack(Blocks.SAND);
-
-			case SANDSTONE:
-				return new ItemStack(Blocks.SANDSTONE);
-
-			case STONE:
-				return new ItemStack(Blocks.STONE);
-		}
-		throw new IllegalStateException("Unknown insulated tube type: " + this);
-	}
-}

src/main/java/binnie/botany/flower/EnumTubeMaterial.java

@@ -1,32 +0,0 @@
-package binnie.botany.flower;
-
-import binnie.core.util.I18N;
-
-enum EnumTubeMaterial {
-	COPPER(0xe3b78e, "copper"),
-	TIN(0xe1eef4, "tin"),
-	BRONZE(0xddc276, "bronze"),
-	IRON(0xd8d8d8, "iron");
-
-	public static final EnumTubeMaterial[] VALUES = values();
-
-	int color;
-	String name;
-
-	EnumTubeMaterial(int color, String name) {
-		this.color = color;
-		this.name = name;
-	}
-
-	public static EnumTubeMaterial get(int meta) {
-		return VALUES[meta % VALUES.length];
-	}
-
-	public int getColor() {
-		return color;
-	}
-
-	public String getDisplayName() {
-		return I18N.localise("botany.tube.material." + name + ".name");
-	}
-}

src/main/java/binnie/botany/flower/FlowerSpriteManager.java

@@ -1,96 +0,0 @@
-package binnie.botany.flower;
-
-import javax.annotation.Nullable;
-import java.util.HashMap;
-import java.util.Map;
-
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import binnie.Binnie;
-import binnie.botany.Botany;
-import binnie.botany.api.IFlowerType;
-import binnie.core.resource.BinnieSprite;
-
-public class FlowerSpriteManager {
-	private static final Map<IFlowerType, FlowerSprites> flowerSprites = new HashMap<>();
-
-	public static void initSprites(IFlowerType type) {
-		if (flowerSprites.containsKey(type)) {
-			return;
-		}
-		flowerSprites.put(type, new FlowerSprites(type));
-	}
-
-	@Nullable
-	@SideOnly(Side.CLIENT)
-	public static TextureAtlasSprite getStem(IFlowerType type, int section, boolean flowered) {
-		FlowerSprites flower = flowerSprites.get(type);
-		if (flower == null) {
-			return null;
-		}
-		return flower.getStem(type, section, flowered);
-	}
-
-	@Nullable
-	@SideOnly(Side.CLIENT)
-	public static TextureAtlasSprite getPetal(IFlowerType type, int section, boolean flowered) {
-		FlowerSprites flower = flowerSprites.get(type);
-		if (flower == null) {
-			return null;
-		}
-		return flower.getPetal(type, section, flowered);
-	}
-
-	@Nullable
-	@SideOnly(Side.CLIENT)
-	public static TextureAtlasSprite getVariant(IFlowerType type, int section, boolean flowered) {
-		FlowerSprites flower = flowerSprites.get(type);
-		if (flower == null) {
-			return null;
-		}
-		return flower.getVariant(type, section, flowered);
-	}
-
-	private static class FlowerSprites {
-		private BinnieSprite[] stem;
-		private BinnieSprite[] variant;
-		private BinnieSprite[] petal;
-		private BinnieSprite[] unflowered;
-		private int sections;
-
-		public FlowerSprites(IFlowerType type) {
-			sections = type.getSections();
-			stem = new BinnieSprite[sections];
-			petal = new BinnieSprite[sections];
-			variant = new BinnieSprite[sections];
-			unflowered = new BinnieSprite[sections];
-			for (int section = 0; section < sections; ++section) {
-				String suf = (section == 0) ? "" : ("" + (section + 1));
-				String pre = (sections == 1) ? "" : "double/";
-				stem[section] = Binnie.RESOURCE.getBlockSprite(Botany.instance, "flowers/" + pre + type.toString().toLowerCase() + suf + ".0");
-				petal[section] = Binnie.RESOURCE.getBlockSprite(Botany.instance, "flowers/" + pre + type.toString().toLowerCase() + suf + ".1");
-				variant[section] = Binnie.RESOURCE.getBlockSprite(Botany.instance, "flowers/" + pre + type.toString().toLowerCase() + suf + ".2");
-				unflowered[section] = Binnie.RESOURCE.getBlockSprite(Botany.instance, "flowers/" + pre + type.toString().toLowerCase() + suf + ".3");
-			}
-		}
-
-		@SideOnly(Side.CLIENT)
-		public TextureAtlasSprite getStem(IFlowerType type, int section, boolean flowered) {
-			return stem[section % sections].getSprite();
-		}
-
-		@SideOnly(Side.CLIENT)
-		public TextureAtlasSprite getPetal(IFlowerType type, int section, boolean flowered) {
-			return (flowered ? petal[section % sections] : unflowered[section % sections]).getSprite();
-		}
-
-		@Nullable
-		@SideOnly(Side.CLIENT)
-		public TextureAtlasSprite getVariant(IFlowerType type, int section, boolean flowered) {
-			return flowered ? variant[section % sections].getSprite() : null;
-		}
-	}
-}

src/main/java/binnie/botany/flower/ItemBotany.java

@@ -1,68 +1,50 @@
 package binnie.botany.flower;
 
-import com.google.common.base.Preconditions;
-
-import javax.annotation.Nullable;
-import java.util.List;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.SoundType;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.renderer.ItemMeshDefinition;
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemBlock;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.EnumActionResult;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.EnumHand;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.SoundCategory;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.text.TextFormatting;
-import net.minecraft.world.World;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.api.core.IItemModelRegister;
-import forestry.api.core.IModelManager;
-import forestry.api.genetics.IIndividual;
-import forestry.api.genetics.IPollinatable;
-import forestry.core.config.Config;
-import forestry.core.items.IColoredItem;
-
 import binnie.Binnie;
 import binnie.botany.Botany;
 import binnie.botany.CreativeTabBotany;
-import binnie.botany.api.EnumFlowerChromosome;
 import binnie.botany.api.EnumFlowerStage;
-import binnie.botany.api.IAlleleFlowerSpecies;
 import binnie.botany.api.IFlower;
+import binnie.botany.api.IFlowerColor;
 import binnie.botany.api.IFlowerGenome;
 import binnie.botany.api.IFlowerType;
 import binnie.botany.core.BotanyCore;
+import binnie.botany.genetics.EnumFlowerType;
 import binnie.botany.genetics.Flower;
+import binnie.core.BinnieCore;
 import binnie.core.util.I18N;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.core.config.Config;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
 
-public class ItemBotany extends Item implements IColoredItem, IItemModelRegister {
-	private EnumFlowerStage type;
-	private String tag;
+import java.util.List;
 
-	public ItemBotany(String name, EnumFlowerStage type, String tag) {
-		this.type = type;
-		this.tag = tag;
+public abstract class ItemBotany extends Item {
+	public ItemBotany(String name) {
 		setCreativeTab(CreativeTabBotany.instance);
 		setUnlocalizedName(name);
-		setRegistryName(name);
 		hasSubtypes = true;
 	}
 
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getSpriteNumber() {
+		return 0;
+	}
+
 	@Override
 	public boolean isDamageable() {
 		return false;
@@ -79,178 +61,229 @@ public class ItemBotany extends Item implements IColoredItem, IItemModelRegister
 	}
 
 	@Override
-	public boolean hasEffect(ItemStack itemstack) {
-		if (!itemstack.hasTagCompound()) {
+	public boolean hasEffect(ItemStack stack, int pass) {
+		if (!stack.hasTagCompound()) {
 			return false;
 		}
-		IIndividual individual = getIndividual(itemstack);
-		return individual != null && individual.hasEffect();
+
+		IIndividual individual = getIndividual(stack);
+		return individual != null
+			&& individual.getGenome() != null
+			&& individual.hasEffect();
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
-	public void addInformation(ItemStack itemStack, EntityPlayer player, List<String> list, boolean flag) {
-		IFlower individual = (IFlower) getIndividual(itemStack);
+	public void addInformation(ItemStack itemstack, EntityPlayer player, List tooltip, boolean flag) {
+		if (!itemstack.hasTagCompound()) {
+			return;
+		}
+		IFlower individual = (IFlower) getIndividual(itemstack);
 		if (individual == null) {
-			list.add(TextFormatting.DARK_RED + I18N.localise("item.botany.flower.destroy"));
+			tooltip.add(I18N.localise("botany.item.tooltip.bugged"));
 			return;
 		}
 
 		IFlowerGenome genome = individual.getGenome();
-		//Colors
-		String primaryColor = genome.getPrimaryColor().getColorName();
-		String secondaryColor = genome.getSecondaryColor().getColorName();
-		String stemColor = genome.getStemColor().getColorName();
-		String colorInfo;
-		if (!primaryColor.equals(secondaryColor)) {
-			colorInfo = I18N.localise("item.botany.grammar.flower.secondary");
+		IFlowerColor primaryColor = genome.getPrimaryColor();
+		IFlowerColor secondColor = genome.getSecondaryColor();
+		IFlowerColor stemColor = genome.getStemColor();
+
+		if (primaryColor == secondColor) {
+			tooltip.add(EnumChatFormatting.YELLOW + I18N.localise("botany.item.tooltip.flowerColor1", primaryColor.getName(), stemColor.getName()));
 		} else {
-			colorInfo = I18N.localise("item.botany.grammar.flower");
+			tooltip.add(EnumChatFormatting.YELLOW + I18N.localise("botany.item.tooltip.flowerColor2", primaryColor.getName(), secondColor.getName(), stemColor.getName()));
 		}
-		list.add(TextFormatting.YELLOW + colorInfo.replaceAll("%PRIMARY", primaryColor).replaceAll("%SECONDARY", secondaryColor).replaceAll("%STEM", stemColor));
 
 		if (individual.isAnalyzed()) {
-			if (GuiScreen.isShiftKeyDown()) {
-				individual.addTooltip(list);
+			if (BinnieCore.proxy.isShiftDown()) {
+				individual.addTooltip(tooltip);
 			} else {
-				list.add(TextFormatting.ITALIC + "<" + I18N.localise("for.gui.tooltip.tmi") + ">");
+				tooltip.add(EnumChatFormatting.GRAY + I18N.localise("botany.item.tooltip.holdMore"));
 			}
 		} else {
-			list.add("<" + I18N.localise("for.gui.unknown") + ">");
+			tooltip.add(I18N.localise("botany.item.tooltip.unknownGenome"));
 		}
 	}
 
-	@Nullable
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void registerIcons(IIconRegister par1IconRegister) {
+	}
+
 	protected IIndividual getIndividual(ItemStack itemstack) {
-		NBTTagCompound tagCompound = itemstack.getTagCompound();
-		if (tagCompound == null) {
-			return null;
-		}
-		return new Flower(tagCompound);
-	}
-
-	private IAlleleFlowerSpecies getPrimarySpecies(ItemStack itemstack) {
-		IFlower tree = BotanyCore.getFlowerRoot().getMember(itemstack);
-		if (tree == null) {
-			return (IAlleleFlowerSpecies) BotanyCore.getFlowerRoot().getDefaultTemplate()[EnumFlowerChromosome.SPECIES.ordinal()];
-		}
-		return tree.getGenome().getPrimary();
+		return new Flower(itemstack.getTagCompound());
 	}
 
 	@Override
 	public String getItemStackDisplayName(ItemStack itemstack) {
 		if (!itemstack.hasTagCompound()) {
-			return I18N.localise("item.botany.flower.corrupted.name");
+			return I18N.localise("botany.item.tooltip.unknown");
 		}
+
 		IIndividual individual = getIndividual(itemstack);
-		if (individual != null) {
-			return individual.getDisplayName() + (!tag.isEmpty() ? " " + I18N.localise("item.botany." + tag + ".name") : "");
+		if (individual != null && individual.getGenome() != null) {
+			String tag = getTag();
+			if (tag == null || tag.isEmpty()) {
+				return individual.getDisplayName();
+			}
+			return I18N.localise("botany.item.botany.name", individual.getDisplayName(), tag);
 		}
-		return I18N.localise("item.botany.flower.corrupted.name");
+		return I18N.localise("botany.item.flowerCorrupted.name");
 	}
 
 	@Override
-	public void getSubItems(Item item, CreativeTabs tab, NonNullList<ItemStack> itemList) {
+	public void getSubItems(Item item, CreativeTabs par2CreativeTabs, List itemList) {
 		addCreativeItems(itemList, true);
 	}
 
-	public void addCreativeItems(NonNullList<ItemStack> itemList, boolean hideSecrets) {
-		for (IIndividual individual : BotanyCore.getFlowerRoot().getIndividualTemplates()) {
+	public void addCreativeItems(List itemList, boolean hideSecrets) {
+		for (IIndividual individual : BotanyCore.speciesRoot.getIndividualTemplates()) {
 			if (hideSecrets && individual.isSecret() && !Config.isDebug) {
 				continue;
 			}
-			itemList.add(BotanyCore.getFlowerRoot().getMemberStack(individual.copy(), type));
+			itemList.add(BotanyCore.speciesRoot.getMemberStack(individual.copy(), getStage().ordinal()));
 		}
 	}
 
 	@Override
-	public int getColorFromItemstack(ItemStack stack, int tintIndex) {
-		IFlower flower = BotanyCore.getFlowerRoot().getMember(stack);
-		if (flower == null) {
+	public int getColorFromItemStack(ItemStack itemstack, int renderPass) {
+		IFlower flower = BotanyCore.speciesRoot.getMember(itemstack);
+		if (flower == null || flower.getGenome() == null) {
 			return 0xffffff;
 		}
-		if (tintIndex == 0) {
+
+		if (renderPass == 0) {
 			return flower.getGenome().getStemColor().getColor(flower.isWilted());
 		}
-		return (tintIndex == 1)
-				? flower.getGenome().getPrimaryColor().getColor(flower.isWilted())
-				: flower.getGenome().getSecondaryColor().getColor(flower.isWilted());
+		return (renderPass == 1) ?
+			flower.getGenome().getPrimaryColor().getColor(flower.isWilted()) :
+			flower.getGenome().getSecondaryColor().getColor(flower.isWilted());
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerModel(Item item, IModelManager manager) {
-		for (IFlowerType flowerType : (List<IFlowerType>) BlockFlower.FLOWER.getAllowedValues()) {
-			flowerType.registerModels(item, manager, type);
-		}
-		manager.registerItemModel(item, new BotanyMeshDefinition());
-	}
-
-	@Override
-	public EnumActionResult onItemUse(EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
-		ItemStack stack = player.getHeldItem(hand);
-		if (type == EnumFlowerStage.POLLEN) {
-			IFlower flower = Binnie.GENETICS.getFlowerRoot().getMember(stack);
-			TileEntity target = world.getTileEntity(pos);
-			if (!(target instanceof IPollinatable)) {
-				return EnumActionResult.PASS;
-			}
-			IPollinatable pollinatable = (IPollinatable) target;
-			if (!pollinatable.canMateWith(flower)) {
-				return EnumActionResult.FAIL;
-			}
-			pollinatable.mateWith(flower);
-			if (!player.capabilities.isCreativeMode) {
-				stack.shrink(1);
-			}
-			return EnumActionResult.SUCCESS;
-		}
-
-		IBlockState iblockstate = world.getBlockState(pos);
-		Block block = iblockstate.getBlock();
-
-		if (!block.isReplaceable(world, pos)) {
-			pos = pos.offset(facing);
-		}
-
-		if (stack.getCount() != 0 && player.canPlayerEdit(pos, facing, stack) && world.mayPlace(Botany.flower, pos, false, facing, null)) {
-			int i = getMetadata(stack.getMetadata());
-			IBlockState iblockstate1 = Botany.flower.getStateForPlacement(world, pos, facing, hitX, hitY, hitZ, i, player, hand);
-
-			if (placeBlockAt(stack, player, world, pos, facing, hitX, hitY, hitZ, iblockstate1)) {
-				SoundType soundtype = world.getBlockState(pos).getBlock().getSoundType(world.getBlockState(pos), world, pos, player);
-				world.playSound(player, pos, soundtype.getPlaceSound(), SoundCategory.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
-				stack.shrink(1);
-			}
-
-			return EnumActionResult.SUCCESS;
-		}
-		return EnumActionResult.FAIL;
-	}
-
-	public boolean placeBlockAt(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, IBlockState newState) {
-		if (!world.setBlockState(pos, newState, 3)) {
-			return false;
-		}
-
-		IBlockState state = world.getBlockState(pos);
-		if (state.getBlock() == Botany.flower) {
-			ItemBlock.setTileEntityNBT(world, player, pos, stack);
-			Botany.flower.onBlockPlacedBy(world, pos, state, player, stack);
-		}
-
+	public boolean requiresMultipleRenderPasses() {
 		return true;
 	}
 
-	@SideOnly(Side.CLIENT)
-	private class BotanyMeshDefinition implements ItemMeshDefinition {
-		@Override
-		public ModelResourceLocation getModelLocation(ItemStack stack) {
-			IFlower flower = BotanyCore.getFlowerRoot().getMember(stack);
-			Preconditions.checkNotNull(flower);
-			IAlleleFlowerSpecies flowerSpecies = flower.getGenome().getPrimary();
-			IFlowerType flowerType = flowerSpecies.getType();
-			return flowerSpecies.getFlowerModel(type, flower.hasFlowered());
-		}
+	@Override
+	public int getRenderPasses(int metadata) {
+		return 3;
 	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public IIcon getIcon(ItemStack itemstack, int renderPass) {
+		IFlower flower = BotanyCore.speciesRoot.getMember(itemstack);
+		if (flower == null || flower.getGenome() == null || flower.getGenome().getPrimary() == null) {
+			return EnumFlowerType.ALLIUM.getBlank();
+		}
+
+		IFlowerType type = flower.getGenome().getPrimary().getType();
+		if (renderPass == 0) {
+			return type.getStem(getStage(), flower.hasFlowered(), type.getSections() - 1);
+		}
+		if (renderPass == 1) {
+			return type.getPetalIcon(getStage(), flower.hasFlowered(), type.getSections() - 1);
+		}
+		return type.getVariantIcon(getStage(), flower.hasFlowered(), type.getSections() - 1);
+	}
+
+	@Override
+	public boolean onItemUse(ItemStack itemstack, EntityPlayer player, World world, int x, int y, int z, int side, float px, float py, float pz) {
+		if (getStage() == EnumFlowerStage.POLLEN) {
+			IFlower flower = Binnie.Genetics.getFlowerRoot().getMember(itemstack);
+			TileEntity target = world.getTileEntity(x, y, z);
+			if (!(target instanceof IPollinatable)) {
+				return false;
+			}
+			IPollinatable pollinatable = (IPollinatable) target;
+			if (!pollinatable.canMateWith(flower)) {
+				return false;
+			}
+			pollinatable.mateWith(flower);
+			if (!player.capabilities.isCreativeMode) {
+				itemstack.stackSize--;
+			}
+			return true;
+		}
+
+		Block blockFlower = Botany.flower;
+		Block blockAlreadyThere = world.getBlock(x, y, z);
+		if (blockAlreadyThere == Blocks.snow_layer && (world.getBlockMetadata(x, y, z) & 0x7) < 1) {
+			side = 1;
+		} else if (blockAlreadyThere != Blocks.vine && blockAlreadyThere != Blocks.tallgrass && blockAlreadyThere != Blocks.deadbush && !blockAlreadyThere.isReplaceable(world, x, y, z)) {
+			if (side == 0) {
+				y--;
+			} else if (side == 1) {
+				y++;
+			} else if (side == 2) {
+				z--;
+			} else if (side == 3) {
+				z++;
+			} else if (side == 4) {
+				x--;
+			} else if (side == 5) {
+				x++;
+			}
+		}
+
+		if (itemstack.stackSize == 0 || !player.canPlayerEdit(x, y, z, side, itemstack)) {
+			return false;
+		}
+		if (y == 255 && blockFlower.getMaterial().isSolid()) {
+			return false;
+		}
+
+		if (world.canPlaceEntityOnSide(blockFlower, x, y, z, false, side, player, itemstack)) {
+			int i1 = getMetadata(itemstack.getItemDamage());
+			int j1 = blockFlower.onBlockPlaced(world, x, y, z, side, px, py, pz, i1);
+			if (placeBlockAt(itemstack, player, world, x, y, z, side, px, py, pz, j1)) {
+				world.playSoundEffect(x + 0.5f, y + 0.5f, z + 0.5f, blockFlower.stepSound.func_150496_b(), (blockFlower.stepSound.getVolume() + 1.0f) / 2.0f, blockFlower.stepSound.getPitch() * 0.8f);
+				itemstack.stackSize--;
+			}
+			return true;
+		}
+		return false;
+	}
+
+	@SideOnly(Side.CLIENT)
+	public boolean func_150936_a(World world, int x, int y, int z, int side, EntityPlayer player, ItemStack stack) {
+		Block field_150939_a = Botany.flower;
+		Block block = world.getBlock(x, y, z);
+		if (block == Blocks.snow_layer) {
+			side = 1;
+		} else if (block != Blocks.vine && block != Blocks.tallgrass && block != Blocks.deadbush && !block.isReplaceable(world, x, y, z)) {
+			if (side == 0) {
+				y--;
+			} else if (side == 1) {
+				y++;
+			} else if (side == 2) {
+				z--;
+			} else if (side == 3) {
+				z++;
+			} else if (side == 4) {
+				x--;
+			} else if (side == 5) {
+				x++;
+			}
+		}
+		return world.canPlaceEntityOnSide(field_150939_a, x, y, z, false, side, null, stack);
+	}
+
+	public boolean placeBlockAt(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ, int metadata) {
+		Block block = Botany.flower;
+		if (!world.setBlock(x, y, z, block, metadata, 3)) {
+			return false;
+		}
+
+		if (world.getBlock(x, y, z) == block) {
+			block.onBlockPlacedBy(world, x, y, z, player, stack);
+			block.onPostBlockPlaced(world, x, y, z, metadata);
+		}
+		return true;
+	}
+
+	public abstract EnumFlowerStage getStage();
+
+	public abstract String getTag();
 }

src/main/java/binnie/botany/flower/ItemFlower.java

@@ -0,0 +1,19 @@
+package binnie.botany.flower;
+
+import binnie.botany.api.EnumFlowerStage;
+
+public class ItemFlower extends ItemBotany {
+	public ItemFlower() {
+		super("itemFlower");
+	}
+
+	@Override
+	public EnumFlowerStage getStage() {
+		return EnumFlowerStage.FLOWER;
+	}
+
+	@Override
+	public String getTag() {
+		return "";
+	}
+}

src/main/java/binnie/botany/flower/ItemInsulatedTube.java

@@ -1,121 +1,167 @@
 package binnie.botany.flower;
 
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.Multimap;
-
-import java.util.Collection;
-import java.util.List;
-
-import net.minecraft.client.gui.GuiScreen;
+import binnie.botany.Botany;
+import binnie.botany.CreativeTabBotany;
+import binnie.core.util.I18N;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.client.renderer.texture.IIconRegister;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.IIcon;
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
+import java.util.List;
 
-import forestry.api.circuits.ChipsetManager;
-import forestry.api.circuits.ICircuit;
-import forestry.api.circuits.ICircuitLayout;
-import forestry.api.core.IModelManager;
-import forestry.core.circuits.SolderManager;
-import forestry.core.items.IColoredItem;
-import forestry.core.utils.Translator;
+public class ItemInsulatedTube extends Item {
+	IIcon[] icons;
 
-import binnie.botany.CreativeTabBotany;
-import binnie.core.item.ItemCore;
-import binnie.core.util.I18N;
-
-public class ItemInsulatedTube extends ItemCore implements IColoredItem {
 	public ItemInsulatedTube() {
-		super("insulated_tube");
-		setUnlocalizedName("botany.insulated_tube");
+		icons = new IIcon[3];
+		setUnlocalizedName("insulatedTube");
 		setCreativeTab(CreativeTabBotany.instance);
 		setHasSubtypes(true);
 	}
 
-	private static Multimap<ICircuitLayout, ICircuit> getCircuits(ItemStack itemStack) {
-		Multimap<ICircuitLayout, ICircuit> circuits = ArrayListMultimap.create();
-		Collection<ICircuitLayout> allLayouts = ChipsetManager.circuitRegistry.getRegisteredLayouts().values();
-		for (ICircuitLayout circuitLayout : allLayouts) {
-			ICircuit circuit = SolderManager.getCircuit(circuitLayout, itemStack);
-			if (circuit != null) {
-				circuits.put(circuitLayout, circuit);
-			}
-		}
-		return circuits;
-	}
-
-	public static String getInsulate(ItemStack stack) {
-		return EnumTubeInsulate.get(stack.getItemDamage()).getDisplayName();
-	}
-
 	public static ItemStack getInsulateStack(ItemStack stack) {
-		return EnumTubeInsulate.get(stack.getItemDamage()).getStack();
+		return Insulate.get(stack.getItemDamage()).getStack();
 	}
 
 	@Override
 	@SideOnly(Side.CLIENT)
-	public void getSubItems(Item item, CreativeTabs tab, NonNullList<ItemStack> subItems) {
-		for (EnumTubeMaterial mat : EnumTubeMaterial.values()) {
-			for (EnumTubeInsulate ins : EnumTubeInsulate.values()) {
-				subItems.add(new ItemStack(this, 1, mat.ordinal() + ins.ordinal() * 128));
-			}
-		}
-	}
-
-	@SideOnly(Side.CLIENT)
-	@Override
-	public void registerModel(Item item, IModelManager manager) {
-		for (EnumTubeMaterial mat : EnumTubeMaterial.values()) {
-			for (EnumTubeInsulate ins : EnumTubeInsulate.values()) {
-				manager.registerItemModel(item, mat.ordinal() + ins.ordinal() * 128);
+	public void getSubItems(Item item, CreativeTabs tab, List list) {
+		for (Material mat : Material.values()) {
+			for (Insulate ins : Insulate.values()) {
+				list.add(new ItemStack(this, 1, mat.ordinal() + ins.ordinal() * 128));
 			}
 		}
 	}
 
 	@Override
-	public int getColorFromItemstack(ItemStack stack, int tintIndex) {
-		if (tintIndex == 0) {
+	@SideOnly(Side.CLIENT)
+	public void registerIcons(IIconRegister register) {
+		for (int i = 0; i < 3; ++i) {
+			icons[i] = Botany.proxy.getIcon(register, "insulatedTube." + i);
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getColorFromItemStack(ItemStack stack, int pass) {
+		if (pass == 0) {
 			return 0xffffff;
-		} else if (tintIndex == 1) {
-			return EnumTubeMaterial.get(stack.getItemDamage()).getColor();
 		}
-		return EnumTubeInsulate.get(stack.getItemDamage()).getColor();
+		return (pass == 1)
+			? Material.get(stack.getItemDamage()).getColor()
+			: Insulate.get(stack.getItemDamage()).getColor();
 	}
 
 	@Override
 	@SideOnly(Side.CLIENT)
-	public void addInformation(ItemStack itemstack, EntityPlayer player, List<String> list, boolean flag) {
-		super.addInformation(itemstack, player, list, flag);
-		Multimap<ICircuitLayout, ICircuit> circuits = getCircuits(itemstack);
-		if (!circuits.isEmpty()) {
-			if (GuiScreen.isShiftKeyDown()) {
-				for (ICircuitLayout circuitLayout : circuits.keys()) {
-					String circuitLayoutName = circuitLayout.getUsage();
-					list.add(TextFormatting.WHITE.toString() + TextFormatting.UNDERLINE + circuitLayoutName);
-					for (ICircuit circuit : circuits.get(circuitLayout)) {
-						circuit.addTooltip(list);
-					}
-				}
-			} else {
-				list.add(TextFormatting.ITALIC + "<" + Translator.translateToLocal("for.gui.tooltip.tmi") + ">");
-			}
-		} else {
-			list.add("<" + Translator.translateToLocal("for.gui.noeffect") + ">");
-		}
+	public void addInformation(ItemStack stack, EntityPlayer player, List tooltip, boolean advanced) {
+		super.addInformation(stack, player, tooltip, advanced);
+		tooltip.add(Insulate.get(stack.getItemDamage()).getName());
 	}
 
 	@Override
-	public String getItemStackDisplayName(ItemStack itemStack) {
-		int meta = itemStack.getMetadata();
-		return I18N.localise(
-				"item.botany.insulated_tube.name",
-				EnumTubeMaterial.get(meta).getDisplayName(),
-				EnumTubeInsulate.get(meta).getDisplayName()
-		);
+	public String getItemStackDisplayName(ItemStack stack) {
+		return Material.get(stack.getItemDamage()).getName() + " "
+			+ I18N.localise("botany.tube.name");
+	}
+
+	@Override
+	public int getRenderPasses(int metadata) {
+		return 3;
+	}
+
+	@Override
+	public IIcon getIcon(ItemStack stack, int pass) {
+		return icons[pass % 3];
+	}
+
+	@Override
+	public boolean requiresMultipleRenderPasses() {
+		return true;
+	}
+
+	enum Material {
+		Copper(0xe3b78e, "cooper"),
+		Tin(0xe1eef4, "tin"),
+		Bronze(0xddc276, "bronze"),
+		Iron(0xd8d8d8, "iron");
+
+		protected int color;
+		protected String name;
+
+		Material(int color, String name) {
+			this.color = color;
+			this.name = name;
+		}
+
+		public static Material get(int i) {
+			return values()[i % values().length];
+		}
+
+		public int getColor() {
+			return color;
+		}
+
+		public String getName() {
+			return I18N.localise("botany.tube." + name);
+		}
+	}
+
+	enum Insulate {
+		Clay(0xa1aacc, "clay"),
+		Cobble(0x7b7b7b, "cobblestone"),
+		Sand(0xefeab5, "sand"),
+		HardenedClay(0x935c43, "hardenedClay"),
+		Stone(0x6d6d6d, "smoothStone"),
+		Sandstone(0xc1b989, "sandstone");
+
+		protected int color;
+		protected String name;
+
+		Insulate(int color, String name) {
+			this.color = color;
+			this.name = name;
+		}
+
+		public static Insulate get(int i) {
+			return values()[i / 128 % values().length];
+		}
+
+		public int getColor() {
+			return color;
+		}
+
+		public String getName() {
+			return I18N.localise("botany.tube.insulate." + name);
+		}
+
+		public ItemStack getStack() {
+			switch (this) {
+				case Clay:
+					return new ItemStack(Blocks.clay);
+
+				case Cobble:
+					return new ItemStack(Blocks.cobblestone);
+
+				case HardenedClay:
+					return new ItemStack(Blocks.hardened_clay);
+
+				case Sand:
+					return new ItemStack(Blocks.sand);
+
+				case Sandstone:
+					return new ItemStack(Blocks.sandstone);
+
+				case Stone:
+					return new ItemStack(Blocks.stone);
+			}
+			return null;
+		}
 	}
 }

src/main/java/binnie/botany/flower/ItemPollen.java

@@ -0,0 +1,20 @@
+package binnie.botany.flower;
+
+import binnie.botany.api.EnumFlowerStage;
+import binnie.core.util.I18N;
+
+public class ItemPollen extends ItemBotany {
+	public ItemPollen() {
+		super("pollen");
+	}
+
+	@Override
+	public EnumFlowerStage getStage() {
+		return EnumFlowerStage.POLLEN;
+	}
+
+	@Override
+	public String getTag() {
+		return I18N.localise("botany.item.pollen.tag.name");
+	}
+}

src/main/java/binnie/botany/flower/ItemSeed.java

@@ -0,0 +1,20 @@
+package binnie.botany.flower;
+
+import binnie.botany.api.EnumFlowerStage;
+import binnie.core.util.I18N;
+
+public class ItemSeed extends ItemBotany {
+	public ItemSeed() {
+		super("seed");
+	}
+
+	@Override
+	public EnumFlowerStage getStage() {
+		return EnumFlowerStage.SEED;
+	}
+
+	@Override
+	public String getTag() {
+		return I18N.localise("botany.item.germling.tag.name");
+	}
+}

src/main/java/binnie/botany/flower/PropertyFlower.java

@@ -1,53 +0,0 @@
-package binnie.botany.flower;
-
-import com.google.common.base.Optional;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-
-import net.minecraft.block.properties.PropertyHelper;
-
-import forestry.api.genetics.AlleleManager;
-import forestry.api.genetics.IAllele;
-
-import binnie.botany.api.IAlleleFlowerSpecies;
-import binnie.botany.api.IFlowerType;
-
-public class PropertyFlower<I extends IFlowerType<I>> extends PropertyHelper<I> {
-	public PropertyFlower(String name, Class<I> flowerTypeClass) {
-		super(name, flowerTypeClass);
-	}
-
-	@Override
-	public List<I> getAllowedValues() {
-		List<I> flowerTypes = new ArrayList<>();
-		for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) {
-			if (allele instanceof IAlleleFlowerSpecies) {
-				IFlowerType flowerType = ((IAlleleFlowerSpecies) allele).getType();
-				if (!flowerTypes.contains(flowerType)) {
-					flowerTypes.add((I) flowerType);
-				}
-			}
-		}
-		return flowerTypes;
-	}
-
-	/**
-	 * Get the name for the given value.
-	 */
-	@Override
-	public String getName(IFlowerType value) {
-		return value.getName().toLowerCase(Locale.ENGLISH);
-	}
-
-	@Override
-	public Optional<I> parseValue(String value) {
-		IAllele allele = AlleleManager.alleleRegistry.getAllele(value);
-		if (IAlleleFlowerSpecies.class.isInstance(allele)) {
-			IAlleleFlowerSpecies alleleValue = IAlleleFlowerSpecies.class.cast(allele);
-			return Optional.of((I) alleleValue.getType());
-		}
-		return Optional.absent();
-	}
-}

src/main/java/binnie/botany/flower/RendererBotany.java

@@ -0,0 +1,60 @@
+package binnie.botany.flower;
+
+import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.EntityRenderer;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+
+public class RendererBotany implements ISimpleBlockRenderingHandler {
+	public static int renderID;
+	public static int pass;
+
+	@Override
+	public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer) {
+		// ignored
+	}
+
+	@Override
+	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
+		Tessellator tessellator = Tessellator.instance;
+		tessellator.setBrightness(block.getMixedBrightnessForBlock(renderer.blockAccess, x, y, z));
+		double d1 = x;
+		double d2 = y;
+		double d3 = z;
+		long i1 = x * 3129871 ^ z * 116129781L;
+		i1 = i1 * i1 * 42317861L + i1 * 11L;
+		d1 += ((i1 >> 16 & 0xFL) / 15.0f - 0.5) * 0.3;
+		d3 += ((i1 >> 24 & 0xFL) / 15.0f - 0.5) * 0.3;
+
+		for (int j = 0; j < 3; ++j) {
+			RendererBotany.pass = j;
+			int l = block.colorMultiplier(renderer.blockAccess, x, y, z);
+			float f = (l >> 16 & 0xFF) / 255.0f;
+			float f2 = (l >> 8 & 0xFF) / 255.0f;
+			float f3 = (l & 0xFF) / 255.0f;
+
+			if (EntityRenderer.anaglyphEnable) {
+				f = (f * 30.0f + f2 * 59.0f + f3 * 11.0f) / 100.0f;
+				f2 = (f * 30.0f + f2 * 70.0f) / 100.0f;
+				f3 = (f * 30.0f + f3 * 70.0f) / 100.0f;
+			}
+			tessellator.setColorOpaque_F(f, f2, f3);
+			IIcon iicon = block.getIcon(world, x, y, z, 0);
+			renderer.drawCrossedSquares(iicon, d1, d2, d3, 1.0f);
+		}
+		return false;
+	}
+
+	@Override
+	public boolean shouldRender3DInInventory(int i) {
+		return false;
+	}
+
+	@Override
+	public int getRenderId() {
+		return RendererBotany.renderID;
+	}
+}

src/main/java/binnie/botany/flower/StateMapperFlower.java

@@ -1,39 +0,0 @@
-package binnie.botany.flower;
-
-import com.google.common.collect.Maps;
-
-import java.util.Map;
-
-import net.minecraft.block.properties.IProperty;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.client.renderer.block.statemap.StateMapperBase;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import binnie.Constants;
-import binnie.botany.api.IFlowerType;
-
-@SideOnly(Side.CLIENT)
-public class StateMapperFlower extends StateMapperBase {
-	@Override
-	protected ModelResourceLocation getModelResourceLocation(IBlockState state) {
-		Map<IProperty<?>, Comparable<?>> properties = Maps.newLinkedHashMap(state.getProperties());
-		IFlowerType flowerType = (IFlowerType) state.getValue(BlockFlower.FLOWER);
-		if (flowerType.getSections() < 2) {
-			properties.remove(BlockFlower.SECTION);
-		} else if (flowerType.getSections() <= state.getValue(BlockFlower.SECTION)) {
-			properties.put(BlockFlower.SECTION, flowerType.getSections() - 1);
-		}
-
-		if (state.getValue(BlockFlower.SEED)) {
-			properties.remove(BlockFlower.SECTION);
-			properties.remove(BlockFlower.FLOWER);
-			properties.remove(BlockFlower.FLOWERED);
-		} else {
-			properties.remove(BlockFlower.SEED);
-		}
-		return new ModelResourceLocation(Constants.BOTANY_MOD_ID + ":flower", getPropertyString(properties));
-	}
-}

src/main/java/binnie/botany/flower/TileEntityFlower.java

@@ -1,35 +1,5 @@
 package binnie.botany.flower;
 
-import javax.annotation.Nullable;
-import java.util.HashSet;
-import java.util.Random;
-import java.util.Set;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.entity.item.EntityItem;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTUtil;
-import net.minecraft.network.NetworkManager;
-import net.minecraft.network.play.server.SPacketUpdateTileEntity;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import net.minecraft.world.biome.Biome;
-
-import com.mojang.authlib.GameProfile;
-
-import net.minecraftforge.common.EnumPlantType;
-
-import forestry.api.core.EnumHumidity;
-import forestry.api.core.EnumTemperature;
-import forestry.api.core.IErrorState;
-import forestry.api.genetics.IIndividual;
-import forestry.api.genetics.IPollinatable;
-import forestry.api.lepidopterology.IButterfly;
-import forestry.api.lepidopterology.IButterflyNursery;
-
 import binnie.Binnie;
 import binnie.botany.Botany;
 import binnie.botany.api.EnumFlowerStage;
@@ -38,27 +8,46 @@ import binnie.botany.api.IAlleleFlowerSpecies;
 import binnie.botany.api.IFlower;
 import binnie.botany.api.IFlowerColor;
 import binnie.botany.api.IFlowerGenome;
-import binnie.botany.api.IFlowerRoot;
 import binnie.botany.api.IFlowerType;
-import binnie.botany.api.IGardeningManager;
 import binnie.botany.core.BotanyCore;
-import binnie.botany.gardening.PlantType;
+import binnie.botany.gardening.BlockPlant;
+import binnie.botany.gardening.Gardening;
 import binnie.botany.genetics.EnumFlowerColor;
 import binnie.botany.genetics.EnumFlowerType;
 import binnie.botany.genetics.Flower;
+import binnie.botany.network.MessageFlowerUpdate;
 import binnie.core.BinnieCore;
+import com.mojang.authlib.GameProfile;
+import forestry.api.core.EnumHumidity;
+import forestry.api.core.EnumTemperature;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IPollinatable;
+import forestry.api.lepidopterology.IButterfly;
+import forestry.api.lepidopterology.IButterflyNursery;
+import forestry.lepidopterology.entities.EntityButterfly;
+import net.minecraft.block.Block;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.network.Packet;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.common.EnumPlantType;
+
+import java.util.EnumSet;
+import java.util.Random;
 
 public class TileEntityFlower extends TileEntity implements IPollinatable, IButterflyNursery {
-	@Nullable
-	IFlower flower;
-	@Nullable
-	GameProfile owner;
-	int section;
-	@Nullable
-	RenderInfo renderInfo;
-	@Nullable
-	IButterfly caterpillar;
-	int matureTime;
+	protected IFlower flower;
+	protected GameProfile owner;
+	protected int section;
+	protected RenderInfo renderInfo;
+	protected IButterfly caterpillar;
+	protected int matureTime;
 
 	public TileEntityFlower() {
 		flower = null;
@@ -68,61 +57,49 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 	}
 
 	@Override
-	public void readFromNBT(NBTTagCompound nbtCompound) {
-		if (nbtCompound.hasKey("Flower")) {
-			flower = new Flower(nbtCompound.getCompoundTag("Flower"));
-			if (flower.getAge() == 0) {
-				flower.setFlowered(false);
-			}
+	public void readFromNBT(NBTTagCompound nbttagcompound) {
+		flower = new Flower(nbttagcompound);
+		section = nbttagcompound.getByte("section");
+		if (flower.getAge() == 0) {
+			flower.setFlowered(false);
 		}
 
-		if (nbtCompound.hasKey("section")) {
-			section = nbtCompound.getByte("section");
+		owner = NBTUtil.func_152459_a(nbttagcompound.getCompoundTag("owner"));
+		if (nbttagcompound.hasKey("CATER") && BinnieCore.isLepidopteryActive()) {
+			matureTime = nbttagcompound.getInteger("caterTime");
+			caterpillar = Binnie.Genetics.getButterflyRoot().getMember(nbttagcompound.getCompoundTag("cater"));
 		}
-
-		if (nbtCompound.hasKey("owner")) {
-			owner = NBTUtil.readGameProfileFromNBT(nbtCompound.getCompoundTag("owner"));
-		}
-
-		if (nbtCompound.hasKey("CATER") && BinnieCore.isLepidopteryActive()) {
-			matureTime = nbtCompound.getInteger("caterTime");
-			caterpillar = Binnie.GENETICS.getButterflyRoot().getMember(nbtCompound.getCompoundTag("cater"));
-		}
-
-		readRenderInfo(nbtCompound);
-		super.readFromNBT(nbtCompound);
+		super.readFromNBT(nbttagcompound);
 	}
 
 	@Override
-	public NBTTagCompound writeToNBT(NBTTagCompound nbtCompound) {
+	public void writeToNBT(NBTTagCompound nbttagcompound) {
 		if (flower != null) {
-			nbtCompound.setTag("Flower", flower.writeToNBT(new NBTTagCompound()));
+			flower.writeToNBT(nbttagcompound);
 		}
 
 		if (owner != null) {
 			NBTTagCompound nbt = new NBTTagCompound();
-			NBTUtil.writeGameProfile(nbt, owner);
-			nbtCompound.setTag("owner", nbt);
+			NBTUtil.func_152460_a(nbt, owner);
+			nbttagcompound.setTag("owner", nbt);
 		}
 
 		if (caterpillar != null) {
-			nbtCompound.setInteger("caterTime", matureTime);
+			nbttagcompound.setInteger("caterTime", matureTime);
 			NBTTagCompound subcompound = new NBTTagCompound();
 			caterpillar.writeToNBT(subcompound);
-			nbtCompound.setTag("cater", subcompound);
+			nbttagcompound.setTag("cater", subcompound);
 		}
-
-		nbtCompound.setByte("section", (byte) getSection());
-		return super.writeToNBT(nbtCompound);
+		nbttagcompound.setByte("section", (byte) getSection());
+		super.writeToNBT(nbttagcompound);
 	}
 
-	public void create(ItemStack stack, @Nullable GameProfile owner) {
-		IFlower flower = BotanyCore.getFlowerRoot().getMember(stack);
-		create(flower, owner);
+	public void create(ItemStack stack, GameProfile owner) {
+		create(BotanyCore.getFlowerRoot().getMember(stack), owner);
 	}
 
-	public void create(IFlower flower, @Nullable GameProfile owner) {
-		this.flower = flower;
+	public void create(IFlower stack, GameProfile owner) {
+		flower = stack;
 		if (flower.getAge() == 0) {
 			flower.setFlowered(false);
 		}
@@ -132,12 +109,11 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 	}
 
 	@Override
-	public EnumPlantType getPlantType() {
-		return EnumPlantType.Plains;
+	public EnumSet<EnumPlantType> getPlantType() {
+		return EnumSet.of(EnumPlantType.Plains);
 	}
 
 	@Override
-	@Nullable
 	public IIndividual getPollen() {
 		return getFlower();
 	}
@@ -145,11 +121,11 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 	@Override
 	public boolean canMateWith(IIndividual individual) {
 		return isBreeding()
-				&& individual instanceof IFlower
-				&& getFlower() != null
-				&& getFlower().getMate() == null
-				&& getFlower().hasFlowered()
-				&& !getFlower().isGeneticEqual(individual);
+			&& individual instanceof IFlower
+			&& getFlower() != null
+			&& getFlower().getMate() == null
+			&& getFlower().hasFlowered()
+			&& !getFlower().isGeneticEqual(individual);
 	}
 
 	@Override
@@ -160,19 +136,18 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 
 		IAlleleFlowerSpecies primary = (IAlleleFlowerSpecies) individual.getGenome().getPrimary();
 		IAlleleFlowerSpecies primary2 = getFlower().getGenome().getPrimary();
-		if (primary == primary2 || world.rand.nextInt(4) == 0) {
+		if (primary == primary2 || worldObj.rand.nextInt(4) == 0) {
 			getFlower().mate((IFlower) individual);
-			world.markBlockRangeForRenderUpdate(pos, pos);
+			worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
 		}
 	}
 
-	@Nullable
 	public IFlower getFlower() {
 		if (getSection() <= 0) {
 			return flower;
 		}
 
-		TileEntity tile = world.getTileEntity(pos.down(getSection()));
+		TileEntity tile = worldObj.getTileEntity(xCoord, yCoord - getSection(), zCoord);
 		if (tile instanceof TileEntityFlower) {
 			return ((TileEntityFlower) tile).getFlower();
 		}
@@ -180,23 +155,19 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 	}
 
 	public boolean isBreeding() {
-		Block roots = getWorld().getBlockState(getPos().down()).getBlock();
-		return BotanyCore.getGardening().isSoil(roots);
+		Block roots = getWorldObj().getBlock(xCoord, yCoord - 1, zCoord);
+		return Gardening.isSoil(roots);
 	}
 
 	public void randomUpdate(Random rand) {
-		if (world.getBlockState(pos).getBlock() != Botany.flower) {
+		if (worldObj.getBlock(xCoord, yCoord, zCoord) != Botany.flower) {
 			invalidate();
 			return;
 		}
-		if (getSection() > 0) {
-			return;
-		}
-		if (flower == null) {
+		if (getSection() > 0 || flower == null) {
 			return;
 		}
 
-		// TODO always false?
 		if (flower.getGenome() == null) {
 			invalidate();
 			return;
@@ -205,18 +176,17 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 			return;
 		}
 
-		float light = world.getLight(pos);
+		float light = worldObj.getBlockLightValue(xCoord, yCoord, zCoord);
 		if (light < 6.0f) {
 			for (int dx = -2; dx <= 2; ++dx) {
 				for (int dy = -2; dy <= 2; ++dy) {
-					light -= (world.canBlockSeeSky(pos) ? 0.0f : 0.5f);
+					light -= (worldObj.canBlockSeeTheSky(xCoord, yCoord, zCoord) ? 0.0f : 0.5f);
 				}
 			}
 		}
 
-		IGardeningManager gardening = BotanyCore.getGardening();
-		boolean canTolerate = gardening.canTolerate(getFlower(), world, pos);
-		EnumSoilType soil = gardening.getSoilType(world, pos.down());
+		boolean canTolerate = Gardening.canTolerate(getFlower(), worldObj, xCoord, yCoord, zCoord);
+		EnumSoilType soil = Gardening.getSoilType(worldObj, xCoord, yCoord, zCoord);
 		if (rand.nextFloat() < getFlower().getGenome().getAgeChance()) {
 			if (flower.getAge() < 1) {
 				if (canTolerate && light > 6.0f) {
@@ -230,7 +200,6 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 		if (canTolerate && flower.getAge() > 1 && !flower.isWilted() && light > 6.0f) {
 			flower.setFlowered(true);
 		}
-
 		if (!canTolerate && flower.isWilted() && rand.nextInt(2 + Math.max(flower.getAge(), 2)) == 0) {
 			kill();
 			return;
@@ -247,28 +216,32 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 			flower.setWilted(false);
 		}
 
-		float CHANCE_DISPERSAL = 0.8f;
-		CHANCE_DISPERSAL += 0.2f * flower.getGenome().getFertility();
-		CHANCE_DISPERSAL *= 1.0f + soil.ordinal() * 0.5f;
-		float CHANCE_POLLINATE = 1.0f;
-		CHANCE_POLLINATE += 0.25f * flower.getGenome().getFertility();
-		CHANCE_POLLINATE *= 1.0f + soil.ordinal() * 0.5f;
-		float CHANCE_SELFPOLLINATE = 0.2f * CHANCE_POLLINATE;
-		if (world.rand.nextFloat() < CHANCE_DISPERSAL && flower.hasFlowered() && !flower.isWilted()) {
+		float chanceDispersal = 0.8f;
+		chanceDispersal += 0.2f * flower.getGenome().getFertility();
+		chanceDispersal *= 1.0f + soil.ordinal() * 0.5f;
+		float chancePollinate = 1.0f;
+		chancePollinate += 0.25f * flower.getGenome().getFertility();
+		chancePollinate *= 1.0f + soil.ordinal() * 0.5f;
+		float chanceSelfPollinate = 0.2f * chancePollinate;
+
+		if (worldObj.rand.nextFloat() < chanceDispersal && flower.hasFlowered() && !flower.isWilted()) {
 			IFlowerGenome mate = flower.getMate();
 			if (mate != null) {
 				boolean dispersed = false;
 				for (int a = 0; a < 5 && !dispersed; ++a) {
-					int dx2;
-					int dz;
-					for (dx2 = 0, dz = 0; dx2 == 0 && dz == 0; dx2 = rand.nextInt(3) - 1, dz = rand.nextInt(3) - 1) {
+					int dx2 = 0;
+					int dz = 0;
+					while (dx2 == 0 && dz == 0) {
+						dx2 = rand.nextInt(3) - 1;
+						dz = rand.nextInt(3) - 1;
 					}
 
-					Block b2 = world.getBlockState(pos.add(dx2, -1, dz)).getBlock();
-					if (world.isAirBlock(pos.add(dx2, 0, dz)) && BotanyCore.getGardening().isSoil(b2)) {
-						IFlower offspring = flower.getOffspring(world, pos);
+					Block b = getWorldObj().getBlock(xCoord + dx2, yCoord, zCoord + dz);
+					Block b2 = getWorldObj().getBlock(xCoord + dx2, yCoord - 1, zCoord + dz);
+					if (b == Blocks.air && Gardening.isSoil(b2)) {
+						IFlower offspring = flower.getOffspring(getWorldObj());
 						if (offspring != null) {
-							BotanyCore.getFlowerRoot().plant(world, pos.add(dx2, 0, dz), offspring, getOwner());
+							Gardening.plant(getWorldObj(), xCoord + dx2, yCoord, zCoord + dz, offspring, getOwner());
 							flower.removeMate();
 							dispersed = true;
 						}
@@ -277,20 +250,23 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 			}
 		}
 
-		if (world.rand.nextFloat() < CHANCE_POLLINATE && flower.hasFlowered() && !flower.isWilted()) {
+		if (worldObj.rand.nextFloat() < chancePollinate && flower.hasFlowered() && !flower.isWilted()) {
 			for (int a2 = 0; a2 < 4; ++a2) {
-				int dx3;
-				int dz2;
-				for (dx3 = 0, dz2 = 0; dx3 == 0 && dz2 == 0; dx3 = rand.nextInt(5) - 2, dz2 = rand.nextInt(5) - 2) {
+				int dx3 = 0;
+				int dz2 = 0;
+				while (dx3 == 0 && dz2 == 0) {
+					dx3 = rand.nextInt(5) - 2;
+					dz2 = rand.nextInt(5) - 2;
 				}
-				TileEntity tile = world.getTileEntity(pos.add(dx3, 0, dz2));
+
+				TileEntity tile = getWorldObj().getTileEntity(xCoord + dx3, yCoord, zCoord + dz2);
 				if (tile instanceof IPollinatable && ((IPollinatable) tile).canMateWith(getFlower())) {
 					((IPollinatable) tile).mateWith(getFlower());
 				}
 			}
 		}
 
-		if (world.rand.nextFloat() < CHANCE_SELFPOLLINATE && flower.hasFlowered() && flower.getMate() == null) {
+		if (worldObj.rand.nextFloat() < chanceSelfPollinate && flower.hasFlowered() && flower.getMate() == null) {
 			mateWith(getFlower());
 		}
 		spawnButterflies();
@@ -301,67 +277,24 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 
 	private void doFlowerAge() {
 		getFlower().age();
-		if (getFlower().getAge() == 1) {
-			IFlowerRoot flowerRoot = BotanyCore.getFlowerRoot();
-			flowerRoot.onGrowFromSeed(world, pos);
-			if (getOwner() != null && getFlower() != null) {
-				flowerRoot.getBreedingTracker(world, getOwner()).registerBirth(getFlower());
-			}
+		if (getFlower().getAge() != 1) {
+			return;
 		}
-	}
 
-	private NBTTagCompound writeRenderInfo(NBTTagCompound tag) {
-		if (renderInfo != null) {
-			NBTTagCompound nbtRenderInfo = new NBTTagCompound();
-			nbtRenderInfo.setByte("primary", (byte) renderInfo.primary.getID());
-			nbtRenderInfo.setByte("secondary", (byte) renderInfo.secondary.getID());
-			nbtRenderInfo.setByte("stem", (byte) renderInfo.stem.getID());
-			nbtRenderInfo.setByte("type", (byte) renderInfo.type.ordinal());
-			nbtRenderInfo.setByte("age", renderInfo.age);
-			nbtRenderInfo.setByte("section", renderInfo.section);
-			nbtRenderInfo.setBoolean("wilted", renderInfo.wilted);
-			nbtRenderInfo.setBoolean("flowered", renderInfo.flowered);
-			tag.setTag("renderinfo", nbtRenderInfo);
-		}
-		return tag;
-	}
-
-	private void readRenderInfo(NBTTagCompound tag) {
-		if (tag.hasKey("renderinfo")) {
-			NBTTagCompound infotag = tag.getCompoundTag("renderinfo");
-			RenderInfo info = new RenderInfo();
-			info.primary = EnumFlowerColor.values()[infotag.getByte("primary")].getFlowerColorAllele();
-			info.secondary = EnumFlowerColor.values()[infotag.getByte("secondary")].getFlowerColorAllele();
-			info.stem = EnumFlowerColor.values()[infotag.getByte("stem")].getFlowerColorAllele();
-			info.type = EnumFlowerType.values()[infotag.getByte("type")];
-			info.age = infotag.getByte("age");
-			info.section = infotag.getByte("section");
-			info.wilted = infotag.getBoolean("wilted");
-			info.flowered = infotag.getBoolean("flowered");
-			setRender(info);
+		Gardening.onGrowFromSeed(worldObj, xCoord, yCoord, zCoord);
+		if (getOwner() != null && getFlower() != null) {
+			BotanyCore.getFlowerRoot().getBreedingTracker(getWorldObj(), getOwner()).registerBirth(getFlower());
 		}
 	}
 
 	@Override
-	public void onDataPacket(NetworkManager net, SPacketUpdateTileEntity pkt) {
-		super.onDataPacket(net, pkt);
-		// TODO client only call?
-		readRenderInfo(pkt.getNbtCompound());
-	}
-
-	@Override
-	public NBTTagCompound getUpdateTag() {
-		updateRender(true);
-		return writeRenderInfo(super.getUpdateTag());
-	}
-
-	@Override
-	public SPacketUpdateTileEntity getUpdatePacket() {
-		// TODO getFlower().getGenome() != null always true?
+	public Packet getDescriptionPacket() {
 		if (renderInfo == null && getFlower() != null && getFlower().getGenome() != null) {
 			renderInfo = new RenderInfo(getFlower(), this);
 		}
-		return (renderInfo != null) ? new SPacketUpdateTileEntity(pos, 0, getUpdateTag()) : null;
+		return (renderInfo != null) ?
+			Botany.instance.getNetworkWrapper().getPacketFrom(new MessageFlowerUpdate(xCoord, yCoord, zCoord, renderInfo).getMessage()) :
+			null;
 	}
 
 	public void updateRender(boolean update) {
@@ -372,7 +305,7 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 			}
 		}
 
-		TileEntity above = world.getTileEntity(pos.up());
+		TileEntity above = worldObj.getTileEntity(xCoord, yCoord + 1, zCoord);
 		if (above instanceof TileEntityFlower) {
 			((TileEntityFlower) above).updateRender(true);
 		}
@@ -384,25 +317,26 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 
 	public void setSection(int i) {
 		section = i;
-		if (BinnieCore.getBinnieProxy().isSimulating(world)) {
+		if (BinnieCore.proxy.isSimulating(worldObj)) {
 			updateRender(true);
 		}
 	}
 
 	public ItemStack getItemStack() {
-		IFlower flower = getFlower();
 		if (flower == null) {
-			return ItemStack.EMPTY;
+			return null;
 		}
-		return Binnie.GENETICS.getFlowerRoot().getMemberStack(flower, EnumFlowerStage.getStage(flower));
+		
+		int stage = (flower.getAge() == 0) ? EnumFlowerStage.SEED.ordinal() : EnumFlowerStage.FLOWER.ordinal();
+		return Binnie.Genetics.getFlowerRoot().getMemberStack(getFlower(), stage);
 	}
 
-	@Nullable
 	private TileEntityFlower getRoot() {
 		if (getSection() == 0) {
 			return null;
 		}
-		TileEntity tile = world.getTileEntity(pos.down(getSection()));
+
+		TileEntity tile = worldObj.getTileEntity(xCoord, yCoord - getSection(), zCoord);
 		return (tile instanceof TileEntityFlower) ? ((TileEntityFlower) tile) : null;
 	}
 
@@ -418,14 +352,15 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 		Random rand = new Random();
 		IFlower cutting = (IFlower) getFlower().copy();
 		cutting.setAge(0);
-		ItemStack cuttingStack = BotanyCore.getFlowerRoot().getMemberStack(cutting, EnumFlowerStage.SEED);
+		ItemStack cuttingStack = BotanyCore.getFlowerRoot().getMemberStack(cutting, EnumFlowerStage.SEED.ordinal());
 		float f = 0.7f;
 		double d = rand.nextFloat() * f + (1.0f - f) * 0.5;
 		double d2 = rand.nextFloat() * f + (1.0f - f) * 0.5;
 		double d3 = rand.nextFloat() * f + (1.0f - f) * 0.5;
-		EntityItem entityitem = new EntityItem(world, pos.getX() + d, pos.getY() + d2, pos.getZ() + d3, cuttingStack);
-		entityitem.setPickupDelay(10);
-		world.spawnEntity(entityitem);
+		EntityItem entityitem = new EntityItem(worldObj, xCoord + d, yCoord + d2, zCoord + d3, cuttingStack);
+		entityitem.delayBeforeCanPickup = 10;
+		worldObj.spawnEntityInWorld(entityitem);
+
 		for (int maxAge = getFlower().getMaxAge(), i = 0; i < maxAge; ++i) {
 			if (rand.nextBoolean()) {
 				getFlower().age();
@@ -441,58 +376,53 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 			return getRoot().checkIfDead(wasCut);
 		}
 
-		EnumSoilType soil = BotanyCore.getGardening().getSoilType(world, pos);
+		EnumSoilType soil = Gardening.getSoilType(worldObj, xCoord, yCoord, zCoord);
 		int maxAge = (int) (flower.getMaxAge() * (1.0f + soil.ordinal() * 0.25f));
-		if (flower.getAge() > maxAge) {
-			if (!wasCut && flower.getMate() != null) {
-				world.setBlockToAir(pos);
-				IFlower offspring = flower.getOffspring(world, pos.down());
-				TileEntity above = world.getTileEntity(pos.up());
-				if (above instanceof TileEntityFlower) {
-					world.setBlockToAir(pos.up());
-				}
-				BotanyCore.getFlowerRoot().plant(world, pos, offspring, getOwner());
-			} else {
-				kill();
-			}
-			return true;
+		if (flower.getAge() <= maxAge) {
+			return false;
 		}
-		return false;
+
+		if (!wasCut && flower.getMate() != null) {
+			worldObj.setBlockToAir(xCoord, yCoord, zCoord);
+			IFlower offspring = flower.getOffspring(getWorldObj());
+			TileEntity above = worldObj.getTileEntity(xCoord, yCoord + 1, zCoord);
+			if (above instanceof TileEntityFlower) {
+				worldObj.setBlockToAir(xCoord, yCoord + 1, zCoord);
+			}
+			Gardening.plant(worldObj, xCoord, yCoord, zCoord, offspring, getOwner());
+		} else {
+			kill();
+		}
+		return true;
 	}
 
 	public void kill() {
 		if (flower.getAge() > 0) {
-			world.setBlockState(pos, Botany.plant.getStateFromMeta(PlantType.DEAD_FLOWER.ordinal()), 2);
+			worldObj.setBlock(xCoord, yCoord, zCoord, Botany.plant, BlockPlant.Type.DeadFlower.ordinal(), 2);
 		} else {
-			world.setBlockToAir(pos);
+			worldObj.setBlockToAir(xCoord, yCoord, zCoord);
 		}
 
-		for (int i = 1; world.getTileEntity(pos.up(i)) instanceof TileEntityFlower; ++i) {
-			world.setBlockToAir(pos.up(i));
+		for (int i = 1; worldObj.getTileEntity(xCoord, yCoord + i, zCoord) instanceof TileEntityFlower; ++i) {
+			worldObj.setBlockToAir(xCoord, yCoord + i, zCoord);
 		}
 	}
 
 	public boolean onBonemeal() {
-		if (getFlower() == null) {
-			return false;
-		}
-		if (!isBreeding()) {
-			return false;
-		}
-		if (getFlower().isWilted()) {
+		if (getFlower() == null || !isBreeding() || getFlower().isWilted()) {
 			return false;
 		}
 
-		//this.doFlowerAge();
+		doFlowerAge();
 		if (getFlower().getAge() > 1 && !getFlower().hasFlowered()) {
 			getFlower().setFlowered(true);
 		}
+
 		checkIfDead(false);
 		updateRender(true);
 		return true;
 	}
 
-	@Nullable
 	public GameProfile getOwner() {
 		return owner;
 	}
@@ -502,88 +432,73 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 	}
 
 	public void spawnButterflies() {
-		/*if (!BinnieCore.isLepidopteryActive()) {
+		if (!BinnieCore.isLepidopteryActive()) {
 			return;
 		}
-		final int x = this.xCoord;
-		final int y = this.yCoord;
-		final int z = this.zCoord;
-		final World world = this.worldObj;
-		if (this.getCaterpillar() != null) {
+
+		int x = xCoord;
+		int y = yCoord;
+		int z = zCoord;
+		World world = worldObj;
+		if (getCaterpillar() != null) {
 			return;
 		}
-		if (world.rand.nextFloat() >= this.getFlower().getGenome().getSappiness()) {
+		if (world.rand.nextFloat() >= getFlower().getGenome().getSappiness()) {
 			return;
 		}
-		if (this.worldObj.rand.nextFloat() >= 0.2f) {
+		if (worldObj.rand.nextFloat() >= 0.2f) {
 			return;
 		}
-		final IButterfly spawn = Binnie.Genetics.getButterflyRoot().getIndividualTemplates().get(this.worldObj.rand.nextInt(Binnie.Genetics.getButterflyRoot().getIndividualTemplates().size()));
-		if (this.worldObj.rand.nextFloat() >= spawn.getGenome().getPrimary().getRarity() * 0.5f) {
+
+		IButterfly spawn = Binnie.Genetics.getButterflyRoot().getIndividualTemplates().get(worldObj.rand.nextInt(Binnie.Genetics.getButterflyRoot().getIndividualTemplates().size()));
+		if (worldObj.rand.nextFloat() >= spawn.getGenome().getPrimary().getRarity() * 0.5f) {
 			return;
 		}
-		if (this.worldObj.countEntities(EntityButterfly.class) > 100) {
+		if (worldObj.countEntities(EntityButterfly.class) > 100) {
 			return;
 		}
-		if (!spawn.canSpawn(this.worldObj, x, y, z)) {
+		if (!spawn.canSpawn(worldObj, x, y, z)) {
 			return;
 		}
+
 		if (world.isAirBlock(x, y + 1, z)) {
-			this.attemptButterflySpawn(world, spawn, x, y + 1, z);
+			attemptButterflySpawn(world, spawn, x, y + 1, z);
+		} else if (world.isAirBlock(x - 1, y, z)) {
+			attemptButterflySpawn(world, spawn, x - 1, y, z);
+		} else if (world.isAirBlock(x + 1, y, z)) {
+			attemptButterflySpawn(world, spawn, x + 1, y, z);
+		} else if (world.isAirBlock(x, y, z - 1)) {
+			attemptButterflySpawn(world, spawn, x, y, z - 1);
+		} else if (world.isAirBlock(x, y, z + 1)) {
+			attemptButterflySpawn(world, spawn, x, y, z + 1);
 		}
-		else if (world.isAirBlock(x - 1, y, z)) {
-			this.attemptButterflySpawn(world, spawn, x - 1, y, z);
-		}
-		else if (world.isAirBlock(x + 1, y, z)) {
-			this.attemptButterflySpawn(world, spawn, x + 1, y, z);
-		}
-		else if (world.isAirBlock(x, y, z - 1)) {
-			this.attemptButterflySpawn(world, spawn, x, y, z - 1);
-		}
-		else if (world.isAirBlock(x, y, z + 1)) {
-			this.attemptButterflySpawn(world, spawn, x, y, z + 1);
-		}*/
 	}
 
 	private void attemptButterflySpawn(World world, IButterfly butterfly, double x, double y, double z) {
 		if (BinnieCore.isLepidopteryActive()) {
-			Binnie.GENETICS.getButterflyRoot().spawnButterflyInWorld(world, butterfly.copy(), x, y + 0.10000000149011612, z);
+			Binnie.Genetics.getButterflyRoot().spawnButterflyInWorld(world, butterfly.copy(), x, y + 0.10000000149011612, z);
 		}
 	}
 
-	public GameProfile getOwnerName() {
-		return getOwner();
+	public World getWorld() {
+		return getWorldObj();
 	}
 
-	@Override
 	public EnumTemperature getTemperature() {
-		return EnumTemperature.getFromValue(world.getBiome(getPos()).getTemperature());
+		return EnumTemperature.getFromValue(worldObj.getBiomeGenForCoords(xCoord, zCoord).temperature);
 	}
 
-	@Override
 	public EnumHumidity getHumidity() {
-		return EnumHumidity.getFromValue(world.getBiome(getPos()).getRainfall());
-	}
-
-	public void setErrorState(int state) {
-	}
-
-	public int getErrorOrdinal() {
-		return 0;
-	}
-
-	public boolean addProduct(ItemStack product, boolean all) {
-		return false;
+		return EnumHumidity.getFromValue(worldObj.getBiomeGenForCoords(xCoord, zCoord).rainfall);
 	}
 
 	@Override
-	@Nullable
 	public IButterfly getCaterpillar() {
 		return caterpillar;
 	}
 
 	@Override
-	public void setCaterpillar(@Nullable IButterfly butterfly) {
+	public void setCaterpillar(IButterfly butterfly) {
 		caterpillar = butterfly;
 		matureTime = 0;
 	}
@@ -599,40 +514,31 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 	}
 
 	private void matureCaterpillar() {
-		//TODO Spawn the caterpillar in a cocon on the next Tree or other thing
-		/*if (this.getCaterpillar() == null) {
+		if (getCaterpillar() == null) {
 			return;
 		}
-        ++this.matureTime;
-		if (this.matureTime >= this.caterpillar.getGenome().getLifespan() / (this.caterpillar.getGenome().getFertility() * 2) && this.caterpillar.canTakeFlight(this.worldObj, this.xCoord, this.yCoord, this.zCoord)) {
-			if (this.worldObj.isAirBlock(this.xCoord, this.yCoord + 1, this.zCoord)) {
-				this.attemptButterflySpawn(this.worldObj, this.caterpillar, this.xCoord, this.yCoord + 1, this.zCoord);
+
+		matureTime++;
+		if (matureTime >= caterpillar.getGenome().getLifespan() / (caterpillar.getGenome().getFertility() * 2) && caterpillar.canTakeFlight(worldObj, xCoord, yCoord, zCoord)) {
+			if (worldObj.isAirBlock(xCoord, yCoord + 1, zCoord)) {
+				attemptButterflySpawn(worldObj, caterpillar, xCoord, yCoord + 1, zCoord);
+			} else if (worldObj.isAirBlock(xCoord - 1, yCoord, zCoord)) {
+				attemptButterflySpawn(worldObj, caterpillar, xCoord - 1, yCoord, zCoord);
+			} else if (worldObj.isAirBlock(xCoord + 1, yCoord, zCoord)) {
+				attemptButterflySpawn(worldObj, caterpillar, xCoord + 1, yCoord, zCoord);
+			} else if (worldObj.isAirBlock(xCoord, yCoord, zCoord - 1)) {
+				attemptButterflySpawn(worldObj, caterpillar, xCoord, yCoord, zCoord - 1);
+			} else if (worldObj.isAirBlock(xCoord, yCoord, zCoord + 1)) {
+				attemptButterflySpawn(worldObj, caterpillar, xCoord, yCoord, zCoord + 1);
 			}
-			else if (this.worldObj.isAirBlock(this.xCoord - 1, this.yCoord, this.zCoord)) {
-				this.attemptButterflySpawn(this.worldObj, this.caterpillar, this.xCoord - 1, this.yCoord, this.zCoord);
-			}
-			else if (this.worldObj.isAirBlock(this.xCoord + 1, this.yCoord, this.zCoord)) {
-				this.attemptButterflySpawn(this.worldObj, this.caterpillar, this.xCoord + 1, this.yCoord, this.zCoord);
-			}
-			else if (this.worldObj.isAirBlock(this.xCoord, this.yCoord, this.zCoord - 1)) {
-				this.attemptButterflySpawn(this.worldObj, this.caterpillar, this.xCoord, this.yCoord, this.zCoord - 1);
-			}
-			else if (this.worldObj.isAirBlock(this.xCoord, this.yCoord, this.zCoord + 1)) {
-				this.attemptButterflySpawn(this.worldObj, this.caterpillar, this.xCoord, this.yCoord, this.zCoord + 1);
-			}
-			this.setCaterpillar(null);
-		}*/
+			setCaterpillar(null);
+		}
 	}
 
 	public void setRender(RenderInfo render) {
 		renderInfo = render;
 		section = renderInfo.section;
-		if (!world.isRemote) {
-			IBlockState blockState = world.getBlockState(pos);
-			world.notifyBlockUpdate(pos, blockState, blockState, 0);
-		} else {
-			world.markBlockRangeForRenderUpdate(pos, pos);
-		}
+		worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
 	}
 
 	public int getAge() {
@@ -651,66 +557,45 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 		return renderInfo == null || renderInfo.flowered;
 	}
 
-	public int getPrimaryColour() {
-		return (renderInfo == null)
-				? EnumFlowerColor.Red.getFlowerColorAllele().getColor(false)
-				: renderInfo.primary.getColor(isWilted());
+	public int getPrimaryColor() {
+		return (renderInfo == null) ?
+			EnumFlowerColor.RED.getColor(false) :
+			renderInfo.primary.getColor(isWilted());
 	}
 
-	public int getSecondaryColour() {
-		return (renderInfo == null)
-				? EnumFlowerColor.Red.getFlowerColorAllele().getColor(false)
-				: renderInfo.secondary.getColor(isWilted());
+	public int getSecondaryColor() {
+		return (renderInfo == null) ?
+			EnumFlowerColor.RED.getColor(false) :
+			renderInfo.secondary.getColor(isWilted());
 	}
 
 	public int getStemColour() {
-		return (renderInfo == null)
-				? EnumFlowerColor.Green.getFlowerColorAllele().getColor(false)
-				: renderInfo.stem.getColor(isWilted());
+		return (renderInfo == null) ?
+			EnumFlowerColor.GREEN.getColor(false) :
+			renderInfo.stem.getColor(isWilted());
 	}
 
 	public IFlowerType getType() {
-		return (renderInfo == null)
-				? EnumFlowerType.Poppy
-				: renderInfo.type;
+		return (renderInfo == null) ?
+			EnumFlowerType.POPPY :
+			renderInfo.type;
+	}
+
+	public BiomeGenBase getBiome() {
+		return getWorld().getBiomeGenForCoords(xCoord, zCoord);
 	}
 
 	@Override
-	public Biome getBiome() {
-		return getWorld().getBiome(getPos());
-	}
-
-	@Nullable
-	public IErrorState getErrorState() {
-		return null;
-	}
-
-	public void setErrorState(IErrorState state) {
-	}
-
-	public boolean setErrorCondition(boolean condition, IErrorState errorState) {
-		return false;
-	}
-
-	public Set<IErrorState> getErrorStates() {
-		return new HashSet<>();
-	}
-
-	@Override
-	public BlockPos getCoordinates() {
-		return getPos();
+	public ChunkCoordinates getCoordinates() {
+		return new ChunkCoordinates(xCoord, yCoord, zCoord);
 	}
 
+	// TODO ??
 	@Override
 	public boolean isPollinated() {
 		return isBreeding();
 	}
 
-	@Override
-	public World getWorldObj() {
-		return world;
-	}
-
 	public static class RenderInfo {
 		public IFlowerColor primary;
 		public IFlowerColor secondary;
@@ -739,7 +624,13 @@ public class TileEntityFlower extends TileEntity implements IPollinatable, IButt
 		public boolean equals(Object obj) {
 			if (obj instanceof RenderInfo) {
 				RenderInfo o = (RenderInfo) obj;
-				return o.age == age && o.wilted == wilted && o.flowered == flowered && o.primary == primary && o.secondary == secondary && o.stem == stem && o.type == type;
+				return o.age == age
+					&& o.wilted == wilted
+					&& o.flowered == flowered
+					&& o.primary == primary
+					&& o.secondary == secondary
+					&& o.stem == stem
+					&& o.type == type;
 			}
 			return super.equals(obj);
 		}

src/main/java/binnie/botany/flower/package-info.java

@@ -1,9 +0,0 @@
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-@FieldsAreNonnullByDefault
-package binnie.botany.flower;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-import binnie.core.util.FieldsAreNonnullByDefault;
-import mcp.MethodsReturnNonnullByDefault;

src/main/java/binnie/botany/gardening/BlockPlant.java

@@ -1,154 +1,157 @@
 package binnie.botany.gardening;
 
+import binnie.botany.Botany;
+import binnie.botany.CreativeTabBotany;
+import binnie.botany.api.EnumSoilType;
+import binnie.botany.api.gardening.IBlockSoil;
+import binnie.core.util.I18N;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockBush;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockBush;
-import net.minecraft.block.SoundType;
-import net.minecraft.block.properties.PropertyEnum;
-import net.minecraft.block.state.BlockStateContainer;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.NonNullList;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.IBlockAccess;
-import net.minecraft.world.World;
-
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
-import forestry.api.core.IItemModelRegister;
-import forestry.api.core.IModelManager;
-
-import binnie.botany.CreativeTabBotany;
-import binnie.botany.api.EnumSoilType;
-import binnie.botany.api.IBlockSoil;
-import binnie.botany.core.BotanyCore;
-
-public class BlockPlant extends BlockBush implements IItemModelRegister {
-	public static final PropertyEnum<PlantType> PLANT_TYPE = PropertyEnum.create("plant_type", PlantType.class);
-
+public class BlockPlant extends BlockBush {
 	public BlockPlant() {
-		setRegistryName("plant");
+		setBlockName("plant");
 		setCreativeTab(CreativeTabBotany.instance);
 		setTickRandomly(true);
-		setSoundType(SoundType.PLANT);
+		setStepSound(Block.soundTypeGrass);
 	}
 
-	public static boolean isWeed(IBlockAccess world, BlockPos pos) {
-		IBlockState blockState = world.getBlockState(pos);
-		if (!(blockState.getBlock() instanceof BlockPlant)) {
+	public static boolean isWeed(IBlockAccess world, int x, int y, int z) {
+		if (!(world.getBlock(x, y, z) instanceof BlockPlant)) {
 			return false;
 		}
 
-		PlantType type = blockState.getValue(PLANT_TYPE);
-		return type.isWeed();
+		Type type = Type.get(world.getBlockMetadata(x, y, z));
+		return type == Type.Weeds
+			|| type == Type.WeedsLong
+			|| type == Type.WeedsVeryLong;
 	}
 
 	@Override
-	@SideOnly(Side.CLIENT)
-	public void registerModel(Item item, IModelManager manager) {
-		int index = 0;
-		for (PlantType type : PlantType.values()) {
-			manager.registerItemModel(item, index, type.getName());
-			index++;
-		}
-	}
-
-	@Override
-	protected BlockStateContainer createBlockState() {
-		return new BlockStateContainer(this, PLANT_TYPE);
-	}
-
-	@Override
-	public int getMetaFromState(IBlockState state) {
-		return state.getValue(PLANT_TYPE).ordinal();
-	}
-
-	@Override
-	public IBlockState getStateFromMeta(int meta) {
-		return getDefaultState().withProperty(PLANT_TYPE, PlantType.values()[meta]);
-	}
-
-	@Override
-	public List<ItemStack> getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
+	public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int metadata, int fortune) {
 		return new ArrayList<>();
 	}
 
 	@Override
-	public boolean canPlaceBlockAt(World worldIn, BlockPos pos) {
-		return super.canPlaceBlockAt(worldIn, pos) || BotanyCore.getGardening().isSoil(worldIn.getBlockState(pos).getBlock());
+	@SideOnly(Side.CLIENT)
+	public void registerBlockIcons(IIconRegister register) {
+		for (Type t : Type.values()) {
+			t.icon = Botany.proxy.getIcon(register, t.name().toLowerCase());
+		}
 	}
 
 	@Override
-	public int damageDropped(IBlockState state) {
-		return getMetaFromState(state);
+	protected boolean canPlaceBlockOn(Block block) {
+		return super.canPlaceBlockOn(block) || Gardening.isSoil(block);
 	}
 
 	@Override
 	@SideOnly(Side.CLIENT)
-	public void getSubBlocks(Item p_149666_1_, CreativeTabs p_149666_2_, NonNullList<ItemStack> subBlocks) {
-		for (PlantType type : PlantType.values()) {
-			subBlocks.add(type.get());
+	public IIcon getIcon(int side, int meta) {
+		return Type.values()[meta % Type.values().length].icon;
+	}
+
+	@Override
+	public int damageDropped(int damage) {
+		return damage;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void getSubBlocks(Item item, CreativeTabs tab, List list) {
+		for (Type type : Type.values()) {
+			list.add(type.get());
 		}
 	}
 
 	@Override
-	public void updateTick(World world, BlockPos pos, IBlockState state, Random rand) {
-		PlantType type = state.getValue(PLANT_TYPE);
-		if (rand.nextInt(4) == 0) {
-			if (type == PlantType.WEEDS) {
-				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS_LONG), 2);
-			} else if (type == PlantType.WEEDS_LONG) {
-				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS_VERY_LONG), 2);
-			} else if (type == PlantType.DEAD_FLOWER) {
-				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.DECAYING_FLOWER), 2);
-			} else if (type == PlantType.DECAYING_FLOWER) {
-				world.setBlockToAir(pos);
+	public void updateTick(World world, int x, int y, int z, Random random) {
+		Type type = Type.get(world.getBlockMetadata(x, y, z));
+		if (random.nextInt(4) == 0) {
+			if (type == Type.Weeds) {
+				world.setBlockMetadataWithNotify(x, y, z, Type.WeedsLong.ordinal(), 2);
+			} else if (type == Type.WeedsLong) {
+				world.setBlockMetadataWithNotify(x, y, z, Type.WeedsVeryLong.ordinal(), 2);
+			} else if (type == Type.DeadFlower) {
+				world.setBlockMetadataWithNotify(x, y, z, Type.DecayingFlower.ordinal(), 2);
+			} else if (type == Type.DecayingFlower) {
+				world.setBlockToAir(x, y, z);
 				return;
 			}
 		}
 
-		if (rand.nextInt(6) == 0) {
-			if (type == PlantType.WEEDS) {
-				world.setBlockToAir(pos);
-			} else if (type == PlantType.WEEDS_LONG) {
-				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS), 2);
-			} else if (type == PlantType.WEEDS_VERY_LONG) {
-				world.setBlockState(pos, state.withProperty(PLANT_TYPE, PlantType.WEEDS_LONG), 2);
+		if (random.nextInt(6) == 0) {
+			if (type == Type.Weeds) {
+				world.setBlockToAir(x, y, z);
+			} else if (type == Type.WeedsLong) {
+				world.setBlockMetadataWithNotify(x, y, z, Type.Weeds.ordinal(), 2);
+			} else if (type == Type.WeedsVeryLong) {
+				world.setBlockMetadataWithNotify(x, y, z, Type.WeedsLong.ordinal(), 2);
 			}
 		}
 
-		Block below = world.getBlockState(pos.down()).getBlock();
-		if (!BotanyCore.getGardening().isSoil(below)) {
+		Block below = world.getBlock(x, y - 1, z);
+		if (!Gardening.isSoil(below)) {
 			return;
 		}
 
 		IBlockSoil soil = (IBlockSoil) below;
-		if (rand.nextInt(3) != 0) {
+		if (random.nextInt(3) != 0) {
 			return;
 		}
 
-		if (type.isWeed()) {
-			if (!soil.degrade(world, pos.down(), EnumSoilType.LOAM)) {
-				soil.degrade(world, pos.down(), EnumSoilType.SOIL);
+		if (type == Type.Weeds || type == Type.WeedsLong || type == Type.WeedsVeryLong) {
+			if (!soil.degrade(world, x, y - 1, z, EnumSoilType.LOAM)) {
+				soil.degrade(world, x, y - 1, z, EnumSoilType.SOIL);
 			}
-		} else if (type == PlantType.DECAYING_FLOWER && !soil.fertilise(world, pos.down(), EnumSoilType.LOAM)) {
-			soil.fertilise(world, pos.down(), EnumSoilType.FLOWERBED);
+		} else if (type == Type.DecayingFlower && !soil.fertilise(world, x, y - 1, z, EnumSoilType.LOAM)) {
+			soil.fertilise(world, x, y - 1, z, EnumSoilType.FLOWERBED);
 		}
 	}
 
 	@Override
-	public boolean isReplaceable(IBlockAccess worldIn, BlockPos pos) {
+	public boolean isReplaceable(IBlockAccess world, int x, int y, int z) {
 		return true;
 	}
 
-	@Override
-	public EnumOffsetType getOffsetType() {
-		return EnumOffsetType.XZ;
+	public enum Type {
+		Weeds("weeds"),
+		WeedsLong("longWeeds"),
+		WeedsVeryLong("veryLongWeeds"),
+		DeadFlower("deadFlower"),
+		DecayingFlower("decayingFlower");
+
+		public IIcon icon;
+
+		protected String name;
+
+		Type(String name) {
+			this.name = name;
+		}
+
+		public static Type get(int id) {
+			return values()[id % values().length];
+		}
+
+		public ItemStack get() {
+			return new ItemStack(Botany.plant, 1, ordinal());
+		}
+
+		public String getName() {
+			return I18N.localise("botany.plant." + name);
+		}
 	}
 }