Fix mamapool NPE (#57)

Co-authored-by: Martin Robertz <dream-master@gmx.net>

.gitattributes

@@ -0,0 +1,44 @@
+* text eol=lf
+
+*.[jJ][aA][rR]          binary
+
+*.[pP][nN][gG]          binary
+*.[jJ][pP][gG]          binary
+*.[jJ][pP][eE][gG]      binary
+*.[gG][iI][fF]          binary
+*.[tT][iI][fF]          binary
+*.[tT][iI][fF][fF]      binary
+*.[iI][cC][oO]          binary
+*.[sS][vV][gG]          text
+*.[eE][pP][sS]          binary
+*.[xX][cC][fF]          binary
+
+*.[kK][aA][rR]          binary
+*.[mM]4[aA]             binary
+*.[mM][iI][dD]          binary
+*.[mM][iI][dD][iI]      binary
+*.[mM][pP]3             binary
+*.[oO][gG][gG]          binary
+*.[rR][aA]              binary
+
+*.7[zZ]                 binary
+*.[gG][zZ]              binary
+*.[tT][aA][rR]          binary
+*.[tT][gG][zZ]          binary
+*.[zZ][iI][pP]          binary
+
+*.[tT][cC][nN]          binary
+*.[sS][oO]              binary
+*.[dD][lL][lL]          binary
+*.[dD][yY][lL][iI][bB]  binary
+*.[pP][sS][dD]          binary
+*.[tT][tT][fF]          binary
+*.[oO][tT][fF]          binary
+
+*.[pP][aA][tT][cC][hH]  -text
+
+*.[bB][aA][tT]          text eol=crlf
+*.[cC][mM][dD]          text eol=crlf
+*.[pP][sS]1             text eol=crlf
+
+*[aA][uU][tT][oO][gG][eE][nN][eE][rR][aA][tT][eE][dD]* binary

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

@@ -1,5 +1,3 @@
-# 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
 
@@ -11,35 +9,5 @@ on:
 
 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.5 minutes
-      run: |
-        mkdir run
-        echo "eula=true" > run/eula.txt
-        timeout 90 ./gradlew runServer 2>&1 | tee -a server.log || true
-
-    - name: Test no errors reported during server run
-      run: |
-        chmod +x .github/scripts/test-no-error-reports.sh
-        .github/scripts/test-no-error-reports.sh
+    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/build-and-test.yml@master
+    secrets: inherit

.github/workflows/release-tags.yml

@@ -1,51 +1,14 @@
-# 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:
-      - '*'
+    tags: [ '*' ]
+
+permissions:
+  contents: write
 
 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
-
-      - name: Publish to Maven
-        run: ./gradlew publish
-        env:
-          MAVEN_USER: ${{ secrets.MAVEN_USER }}
-          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+  release-tags:
+    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@master
+    secrets: inherit

build.gradle

@@ -1,731 +1,5 @@
-//version: 1644612407
-/*
-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/GTNewHorizons/ExampleMod1.7.10/blob/main/build.gradle for updates.
-*/
-
-import org.gradle.internal.logging.text.StyledTextOutput
-import org.gradle.internal.logging.text.StyledTextOutputFactory
-import org.gradle.internal.logging.text.StyledTextOutput.Style
-
-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 {
-        maven {
-            name 'forge'
-            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 'com.github.GTNewHorizons:ForgeGradle:1.2.7'
-    }
-}
+//version: 1707058017
 
 plugins {
-    id 'java-library'
-    id 'idea'
-    id 'eclipse'
-    id 'scala'
-    id 'maven-publish'
-    id 'org.jetbrains.kotlin.jvm'        version '1.5.30' apply false
-    id 'org.jetbrains.kotlin.kapt'       version '1.5.30' apply false
-    id 'org.ajoberstar.grgit'            version '4.1.1'
-    id 'com.github.johnrengelman.shadow' version '4.0.4'
-    id 'com.palantir.git-version'        version '0.13.0' apply false
-    id 'de.undercouch.download'          version '5.0.1'
-    id 'com.github.gmazzo.buildconfig'   version '3.0.3' apply false
-}
-
-if (project.file('.git/HEAD').isFile()) {
-    apply plugin: 'com.palantir.git-version'
-}
-
-def out = services.get(StyledTextOutputFactory).create('an-output')
-
-apply plugin: 'forge'
-
-def projectJavaVersion = JavaLanguageVersion.of(8)
-
-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")
-
-boolean noPublishedSources = project.findProperty("noPublishedSources") ? project.noPublishedSources.toBoolean() : false
-
-String javaSourceDir = "src/main/java/"
-String scalaSourceDir = "src/main/scala/"
-String kotlinSourceDir = "src/main/kotlin/"
-
-String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/")
-String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/")
-String targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/")
-if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
-    throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
-}
-
-if(apiPackage) {
-    targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
-    targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
-    targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
-    if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
-        throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
-    }
-}
-
-if(accessTransformersFile) {
-    String targetFile = "src/main/resources/META-INF/" + accessTransformersFile
-    if(!getFile(targetFile).exists()) {
-        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("\\.", "/")
-    targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
-    if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
-        throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala  + " or " + targetPackageKotlin)
-    }
-
-    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"
-    String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".kt"
-    if(!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
-        throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
-    }
-}
-
-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"
-    String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".kt"
-    if(!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
-        throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
-    }
-}
-
-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
-try {
-    'git config core.fileMode false'.execute()
-}
-catch (Exception e) {
-    out.style(Style.Failure).println("git isn't installed at all")
-}
-
-// Pulls version first from the VERSION env and then git tag
-String identifiedVersion
-String versionOverride = System.getenv("VERSION") ?: null
-try {
-    identifiedVersion = versionOverride == null ? gitVersion() : versionOverride
-}
-catch (Exception e) {
-    out.style(Style.Failure).text(
-        'This mod must be version controlled by Git AND the repository must provide at least one tag,\n' +
-        'or the VERSION override must be set! ').style(Style.SuccessHeader).text('(Do NOT download from GitHub using the ZIP option, instead\n' +
-        'clone the repository, see ').style(Style.Info).text('https://gtnh.miraheze.org/wiki/Development').style(Style.SuccessHeader).println(' for details.)'
-    )
-    versionOverride = 'NO-GIT-TAG-SET'
-    identifiedVersion = versionOverride
-}
-version = minecraftVersion + '-' + identifiedVersion
-ext {
-    modVersion = identifiedVersion
-}
-
-if( identifiedVersion.equals(versionOverride) ) {
-    out.style(Style.Failure).text('Override version to ').style(Style.Identifier).text(modVersion).style(Style.Failure).println('!\7')
-}
-
-group = modGroup
-if(project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
-    archivesBaseName = customArchiveBaseName
-}
-else {
-    archivesBaseName = modId
-}
-
-def arguments = []
-def jvmArguments = []
-
-if(usesMixins.toBoolean()) {
-    arguments += [
-            "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
-    ]
-    jvmArguments += [
-            "-Dmixin.debug.countInjections=true", "-Dmixin.debug.verbose=true", "-Dmixin.debug.export=true"
-    ]
-}
-
-minecraft {
-    version = minecraftVersion + '-' + forgeVersion + '-' + minecraftVersion
-    runDir = 'run'
-
-    if (replaceGradleTokenInFile) {
-        replaceIn replaceGradleTokenInFile
-        if(gradleTokenModId) {
-            replace gradleTokenModId, modId
-        }
-        if(gradleTokenModName) {
-            replace gradleTokenModName, modName
-        }
-        if(gradleTokenVersion) {
-            replace gradleTokenVersion, modVersion
-        }
-        if(gradleTokenGroupName) {
-            replace gradleTokenGroupName, modGroup
-        }
-    }
-
-    clientIntellijRun {
-        args(arguments)
-        jvmArgs(jvmArguments)
-
-        if(developmentEnvironmentUserName) {
-            args("--username", developmentEnvironmentUserName)
-        }
-    }
-
-    serverIntellijRun {
-        args(arguments)
-        jvmArgs(jvmArguments)
-    }
-}
-
-if(file('addon.gradle').exists()) {
-    apply from: 'addon.gradle'
-}
-
-apply from: 'repositories.gradle'
-
-configurations {
-    implementation.extendsFrom(shadowImplementation)  // TODO: remove after all uses are refactored
-    implementation.extendsFrom(shadowCompile)
-    implementation.extendsFrom(shadeCompile)
-}
-
-repositories {
-    maven {
-        name 'Overmind forge repo mirror'
-        url 'https://gregtech.overminddl1.com/'
-    }
-    if(usesMixins.toBoolean()) {
-        maven {
-            name 'sponge'
-            url 'https://repo.spongepowered.org/repository/maven-public'
-        }
-        maven {
-            url 'https://jitpack.io'
-        }
-    }
-}
-
-dependencies {
-    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('com.github.GTNewHorizons:SpongePoweredMixin:0.7.12-GTNH') {
-            // 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.5.0')
-    }
-}
-
-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"
-}
-
-"""
-    }
-}
-
-task relocateShadowJar(type: ConfigureShadowRelocation) {
-    target = tasks.shadowJar
-    prefix = modGroup + ".shadow"
-}
-
-shadowJar {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    manifest {
-        attributes(getManifestAttributes())
-    }
-
-    minimize()  // This will only allow shading for actually used classes
-    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
-    dependsOn(relocateShadowJar)
-}
-
-jar {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    manifest {
-        attributes(getManifestAttributes())
-    }
-
-    if(usesShadowedDependencies.toBoolean()) {
-        dependsOn(shadowJar)
-        enabled = false
-    }
-}
-
-reobf {
-    if(usesMixins.toBoolean()) {
-        addExtraSrgFile mixinSrg
-    }
-}
-
-afterEvaluate {
-    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 {
-    if(developmentEnvironmentUserName) {
-        arguments += [
-                "--username",
-                developmentEnvironmentUserName
-        ]
-    }
-
-    args(arguments)
-    jvmArgs(jvmArguments)
-}
-
-runServer {
-    args(arguments)
-    jvmArgs(jvmArguments)
-}
-
-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 modVersion and minecraftVersion
-        expand "minecraftVersion": project.minecraft.version,
-            "modVersion": modVersion,
-            "modId": modId,
-            "modName": modName
-    }
-
-    if(usesMixins.toBoolean()) {
-        from refMap
-    }
-
-    // copy everything else that's 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) {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    from sourceSets.main.output
-    getArchiveClassifier().set("dev")
-
-    manifest {
-        attributes(getManifestAttributes())
-    }
-
-    minimize()  // This will only allow shading for actually used classes
-    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
-}
-
-task relocateShadowDevJar(type: ConfigureShadowRelocation) {
-    target = tasks.shadowDevJar
-    prefix = modGroup + ".shadow"
-}
-
-task circularResolverJar(type: Jar) {
-    dependsOn(relocateShadowDevJar)
-    dependsOn(shadowDevJar)
-    enabled = false
-}
-
-task devJar(type: Jar) {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    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 {
-    if(!noPublishedSources) {
-        archives sourcesJar
-    }
-    archives devJar
-    if(apiPackage) {
-        archives apiJar
-    }
-}
-
-// The gradle metadata includes all of the additional deps that we disabled from POM generation (including forgeBin with no groupID),
-// and isn't strictly needed with the POM so just disable it.
-tasks.withType(GenerateModuleMetadata) {
-    enabled = false
-}
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from components.java
-            if(usesShadowedDependencies.toBoolean()) {
-                artifact source: shadowJar, classifier: ""
-            }
-            if(!noPublishedSources) {
-                artifact source: sourcesJar, classifier: "src"
-            }
-            artifact source: usesShadowedDependencies.toBoolean() ? shadowDevJar : devJar, classifier: "dev"
-            if (apiPackage) {
-                artifact source: apiJar, classifier: "api"
-            }
-
-            groupId = System.getenv("ARTIFACT_GROUP_ID") ?: "com.github.GTNewHorizons"
-            artifactId = System.getenv("ARTIFACT_ID") ?: project.name
-            // Using the identified version, not project.version as it has the prepended 1.7.10
-            version = System.getenv("RELEASE_VERSION") ?: identifiedVersion
-
-            // remove extra garbage from who knows where
-            pom.withXml {
-                def badPomGroup = ['net.minecraft', 'com.google.code.findbugs', 'org.ow2.asm', 'com.typesafe.akka', 'com.typesafe', 'org.scala-lang',
-                                   'org.scala-lang.plugins', 'net.sf.jopt-simple', 'lzma', 'com.mojang', 'org.apache.commons', 'org.apache.httpcomponents',
-                                   'commons-logging', 'java3d', 'net.sf.trove4j', 'com.ibm.icu', 'com.paulscode', 'io.netty', 'com.google.guava',
-                                   'commons-io', 'commons-codec', 'net.java.jinput', 'net.java.jutils', 'com.google.code.gson', 'org.apache.logging.log4j',
-                                   'org.lwjgl.lwjgl', 'tv.twitch', 'org.jetbrains.kotlin', '']
-                Node pomNode = asNode()
-                pomNode.dependencies.'*'.findAll() {
-                    badPomGroup.contains(it.groupId.text())
-                }.each() {
-                    it.parent().remove(it)
-                }
-            }
-        }
-    }
-
-    repositories {
-        maven {
-            url = "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases"
-            credentials {
-                username = System.getenv("MAVEN_USER") ?: "NONE"
-                password = System.getenv("MAVEN_PASSWORD") ?: "NONE"
-            }
-        }
-    }
-}
-
-// 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 {
-        out.style(Style.SuccessHeader).println("Build script update available! Run 'gradle updateBuildScript'")
-    }
-}
-
-static URL availableBuildScriptUrl() {
-    new URL("https://raw.githubusercontent.com/GTNewHorizons/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 } }
-        out.style(Style.Success).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'
-}
-
-// Deobfuscation
-
-def deobf(String sourceURL) {
-    try {
-        URL url = new URL(sourceURL)
-        String fileName = url.getFile()
-
-        //get rid of directories:
-        int lastSlash = fileName.lastIndexOf("/")
-        if(lastSlash > 0) {
-            fileName = fileName.substring(lastSlash + 1)
-        }
-        //get rid of extension:
-        if(fileName.endsWith(".jar")) {
-            fileName = fileName.substring(0, fileName.lastIndexOf("."))
-        }
-
-        String hostName = url.getHost()
-        if(hostName.startsWith("www.")) {
-            hostName = hostName.substring(4)
-        }
-        List parts = Arrays.asList(hostName.split("\\."))
-        Collections.reverse(parts)
-        hostName = String.join(".", parts)
-
-        return deobf(sourceURL, hostName + "/" + fileName)
-    } catch(Exception e) {
-        return deobf(sourceURL, "deobf/" + String.valueOf(sourceURL.hashCode()))
-    }
-}
-
-// The method above is to be preferred. Use this method if the filename is not at the end of the URL.
-def deobf(String sourceURL, String fileName) {
-    String cacheDir = System.getProperty("user.home") + "/.gradle/caches/"
-    String bon2Dir = cacheDir + "forge_gradle/deobf"
-    String bon2File  = bon2Dir + "/BON2-2.5.0.jar"
-    String obfFile = cacheDir + "modules-2/files-2.1/" + fileName + ".jar"
-    String deobfFile = cacheDir + "modules-2/files-2.1/" + fileName + "-deobf.jar"
-
-    if(file(deobfFile).exists()) {
-        return files(deobfFile)
-    }
-
-    download.run {
-        src 'https://github.com/GTNewHorizons/BON2/releases/download/2.5.0/BON2-2.5.0.CUSTOM-all.jar'
-        dest bon2File
-        quiet true
-        overwrite false
-    }
-
-    download.run {
-        src sourceURL
-        dest obfFile
-        quiet true
-        overwrite false
-    }
-
-    exec {
-        commandLine 'java', '-jar', bon2File, '--inputJar', obfFile, '--outputJar', deobfFile, '--mcVer', '1.7.10', '--mappingsVer', 'stable_12', '--notch'
-        workingDir bon2Dir
-        standardOutput = new ByteArrayOutputStream()
-    }
-
-    return files(deobfFile)
-}
-
-// 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/GTNewHorizons/ExampleMod1.7.10/blob/main/gradle.properties")
-    }
-}
-
-def getFile(String relativePath) {
-    return new File(projectDir, relativePath)
+    id 'com.gtnewhorizons.gtnhconvention'
 }

dependencies.gradle

@@ -1,16 +1,19 @@
 // Add your dependencies here
 
 dependencies {
-    compile('com.github.GTNewHorizons:Baubles:1.0.1.14:dev')
+    compile('com.github.GTNewHorizons:Baubles:1.0.4:dev')
 
     compile('thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev')
 
-    compileOnly('com.github.GTNewHorizons:Railcraft:9.13.6:api') {transitive=false}
-    compileOnly('com.github.GTNewHorizons:StorageDrawers:1.11.13-GTNH:api') {transitive=false}
-    compileOnly('com.github.GTNewHorizons:ForgeMultipart:1.2.7:dev') {transitive=false}
-    compileOnly('com.github.GTNewHorizons:NotEnoughItems:2.2.7-GTNH:dev')
-    compileOnly('com.github.GTNewHorizons:BuildCraft:7.1.27:api') {transitive=false}
+    compileOnly('com.github.GTNewHorizons:Railcraft:9.15.11:api') {transitive=false}
+    compileOnly('com.github.GTNewHorizons:StorageDrawers:1.13.9-GTNH:api') {transitive=false}
+    compileOnly('com.github.GTNewHorizons:ForgeMultipart:1.5.0:dev') {transitive=false}
+    compileOnly('com.github.GTNewHorizons:NotEnoughItems:2.6.26-GTNH:dev')
+    compileOnly('com.github.GTNewHorizons:BuildCraft:7.1.39:api') {transitive=false}
+    compile('com.github.GTNewHorizons:GTNHLib:0.4.3:dev')
 
     compileOnly('curse.maven:cofh-lib-220333:2388748')
     compileOnly('curse.maven:minefactory-reloaded-66672:2366150')
+    devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.6.26-GTNH:dev')
 }
+

gradle.properties

@@ -1,64 +1,203 @@
+# ExampleMod tag to use as Blowdryer (Spotless, etc.) settings version, leave empty to disable.
+# LOCAL to test local config updates.
+gtnh.settings.blowdryerTag = 0.2.0
+
+# Human-readable mod name, available for mcmod.info population.
 modName = Botania
 
-# This is a case-sensitive string to identify your mod. Convention is to use lower case.
+# Case-sensitive identifier string, available for mcmod.info population and used for automatic mixin JSON generation.
+# Conventionally lowercase.
 modId = Botania
 
+# Root package of the mod, used to find various classes in other properties,
+# mcmod.info substitution, enabling assertions in run tasks, etc.
 modGroup = vazkii.botania
 
-# 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/
+# Whether to use modGroup as the maven publishing group.
+# Due to a history of using JitPack, the default is com.github.GTNewHorizons for all mods.
+useModGroupForPublishing = false
 
-# Will update your build.gradle automatically whenever an update is available
+# Updates your build.gradle and settings.gradle automatically whenever an update is available.
 autoUpdateBuildScript = false
 
+# Version of Minecraft to target
 minecraftVersion = 1.7.10
+
+# Version of Minecraft Forge to target
 forgeVersion = 10.13.4.1614
 
-# Select a username for testing your mod with breakpoints. You may leave this empty for a random username 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
+# Specify an MCP channel for dependency deobfuscation and the deobfParams task.
+channel = stable
+
+# Specify an MCP mappings version for dependency deobfuscation and the deobfParams task.
+mappingsVersion = 12
+
+# Defines other MCP mappings for dependency deobfuscation.
+remoteMappings = https\://raw.githubusercontent.com/MinecraftForge/FML/1.7.10/conf/
+
+# Select a default username for testing your mod. You can always override this per-run by running
+# `./gradlew runClient --username=AnotherPlayer`, or configuring this command in your IDE.
 developmentEnvironmentUserName = Developer
 
-# Define a source file of your project with:
+# Enables using modern Java syntax (up to version 17) via Jabel, while still targeting JVM 8.
+# See https://github.com/bsideup/jabel for details on how this works.
+enableModernJavaSyntax = false
+
+# Enables injecting missing generics into the decompiled source code for a better coding experience.
+# Turns most publicly visible List, Map, etc. into proper List<E>, Map<K, V> types.
+enableGenericInjection = false
+
+# Generate a class with a String field for the mod version named as defined below.
+# If generateGradleTokenClass is empty or not missing, no such class will be generated.
+# If gradleTokenVersion is empty or missing, the field will not be present in the class.
+generateGradleTokenClass =
+
+# Name of the token containing the project's current version to generate/replace.
+gradleTokenVersion = GRADLETOKEN_VERSION
+
+# [DEPRECATED] Mod ID replacement token.
+gradleTokenModId =
+
+# [DEPRECATED] Mod name replacement token.
+gradleTokenModName =
+
+# [DEPRECATED] Mod Group replacement token.
+gradleTokenGroupName =
+
+# [DEPRECATED]
+# Multiple source files can be defined here by providing a comma-separated list: Class1.java,Class2.java,Class3.java
 # public static final String VERSION = "GRADLETOKEN_VERSION";
 # The string's content will be replaced with your mod's 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
+# version in @Mod([...], version = VERSION, [...]).
+# Leave these properties empty to skip individual token replacements.
 replaceGradleTokenInFile = LibMisc.java
-gradleTokenModId =
-gradleTokenModName =
-gradleTokenVersion = GRADLETOKEN_VERSION
-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
+# Example value: (apiPackage = api) + (modGroup = com.myname.mymodid) -> com.myname.mymodid.api
 apiPackage = api
 
 # Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/META-INF/
-# Example value: mymodid_at.cfg
+# There can be multiple files in a space-separated list.
+# Example value: mymodid_at.cfg nei_at.cfg
 accessTransformersFile = botania_at.cfg
 
 # Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled!
 usesMixins = false
+
+# Set to a non-empty string to configure mixins in a separate source set under src/VALUE, instead of src/main.
+# This can speed up compile times thanks to not running the mixin annotation processor on all input sources.
+# Mixin classes will have access to "main" classes, but not the other way around.
+separateMixinSourceSet =
+
+# Adds some debug arguments like verbose output and class export.
+usesMixinDebug = 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 compatibility only
-# Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
+# 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.
+# Enables Mixins even if this mod doesn't use them, useful if one of the dependencies uses mixins.
+forceEnableMixins = false
+
+# If enabled, you may use 'shadowCompile' for dependencies. They will be integrated into your jar. It is your
+# responsibility to check the license 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
+# If disabled, won't remove unused classes from shadowed dependencies. Some libraries use reflection to access
+# their own classes, making the minimization unreliable.
+minimizeShadowedDependencies = true
+
+# If disabled, won't rename the shadowed classes.
+relocateShadowedDependencies = true
+
+# Adds CurseMaven, Modrinth, and some more well-known 1.7.10 repositories.
+includeWellKnownRepositories = true
+
+# A list of repositories to exclude from the includeWellKnownRepositories setting. Should be a space separated
+# list of strings, with the acceptable keys being(case does not matter):
+# cursemaven
+# modrinth
+excludeWellKnownRepositories =
+
+# Change these to your Maven coordinates if you want to publish to a custom Maven repository instead of the default GTNH Maven.
+# Authenticate with the MAVEN_USER and MAVEN_PASSWORD environment variables.
+# If you need a more complex setup disable maven publishing here and add a publishing repository to addon.gradle.
+usesMavenPublishing = true
+
+# Maven repository to publish the mod to.
+# mavenPublishUrl = https\://nexus.gtnewhorizons.com/repository/releases/
+
+# Publishing to Modrinth requires you to set the MODRINTH_TOKEN environment variable to your current Modrinth API token.
+#
+# The project's ID on Modrinth. Can be either the slug or the ID.
+# Leave this empty if you don't want to publish to Modrinth.
+modrinthProjectId =
+
+# The project's relations on Modrinth. You can use this to refer to other projects on Modrinth.
+# Syntax: scope1-type1:name1;scope2-type2:name2;...
+# Where scope can be one of [required, optional, incompatible, embedded],
+#       type can be one of [project, version],
+#       and the name is the Modrinth project or version slug/id of the other mod.
+# Example: required-project:fplib;optional-project:gasstation;incompatible-project:gregtech
+# Note: GTNH Mixins is automatically set as a required dependency if usesMixins = true
+modrinthRelations =
+
+# Publishing to CurseForge requires you to set the CURSEFORGE_TOKEN environment variable to one of your CurseForge API tokens.
+#
+# The project's numeric ID on CurseForge. You can find this in the About Project box.
+# Leave this empty if you don't want to publish on CurseForge.
+curseForgeProjectId =
+
+# The project's relations on CurseForge. You can use this to refer to other projects on CurseForge.
+# Syntax: type1:name1;type2:name2;...
+# Where type can be one of [requiredDependency, embeddedLibrary, optionalDependency, tool, incompatible],
+#       and the name is the CurseForge project slug of the other mod.
+# Example: requiredDependency:railcraft;embeddedLibrary:cofhlib;incompatible:buildcraft
+# Note: UniMixins is automatically set as a required dependency if usesMixins = true.
+curseForgeRelations =
+
+# Optional parameter to customize the produced artifacts. Use this to preserve artifact naming when migrating older
 # projects. New projects should not use this parameter.
-#customArchiveBaseName =
+# customArchiveBaseName =
+
+# Optional parameter to have the build automatically fail if an illegal version is used.
+# This can be useful if you e.g. only want to allow versions in the form of '1.1.xxx'.
+# The check is ONLY performed if the version is a git tag.
+# Note: the specified string must be escaped, so e.g. 1\\.1\\.\\d+ instead of 1\.1\.\d+
+# versionPattern =
+
+# Uncomment to prevent the source code from being published.
+# noPublishedSources = true
+
+# Uncomment this to disable Spotless checks.
+# This should only be uncommented to keep it easier to sync with upstream/other forks.
+# That is, if there is no other active fork/upstream, NEVER change this.
+disableSpotless = true
+
+# Uncomment this to disable Checkstyle checks (currently wildcard import check).
+# disableCheckstyle = true
+
+# Override the IDEA build type. Valid values are: "" (leave blank, do not override), "idea" (force use native IDEA build), "gradle"
+# (force use delegated build).
+# This is meant to be set in $HOME/.gradle/gradle.properties.
+# e.g. add "systemProp.org.gradle.project.ideaOverrideBuildType=idea" will override the build type to be native build.
+# WARNING: If you do use this option, it will overwrite whatever you have in your existing projects. This might not be what you want!
+# Usually there is no need to uncomment this here as other developers do not necessarily use the same build type as you.
+# ideaOverrideBuildType = idea
+
+# Whether IDEA should run spotless checks when pressing the Build button.
+# This is meant to be set in $HOME/.gradle/gradle.properties.
+# ideaCheckSpotlessOnBuild = true
+

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,7 @@
-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
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,80 +15,116 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -97,92 +133,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# 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"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# 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"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
-# 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")"
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
 fi
 
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -13,8 +13,10 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,10 +27,14 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @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"
 
@@ -37,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
-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.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -51,48 +57,36 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
-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.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 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%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 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
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

settings.gradle

@@ -0,0 +1,23 @@
+
+pluginManagement {
+    repositories {
+        maven {
+            // RetroFuturaGradle
+            name "GTNH Maven"
+            url "https://nexus.gtnewhorizons.com/repository/public/"
+            mavenContent {
+                includeGroup("com.gtnewhorizons")
+                includeGroupByRegex("com\\.gtnewhorizons\\..+")
+            }
+        }
+        gradlePluginPortal()
+        mavenCentral()
+        mavenLocal()
+    }
+}
+
+plugins {
+    id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.26'
+}
+
+

src/main/java/vazkii/botania/api/corporea/CorporeaRequest.java

@@ -1,26 +1,26 @@
-/**
- * This class was created by <Vindex>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- */
-package vazkii.botania.api.corporea;
-
-public class CorporeaRequest {
-	public Object matcher;
-	public boolean checkNBT;
-	public int count;
-	public int foundItems = 0;
-	public int extractedItems = 0;
-	
-	public CorporeaRequest(Object matcher, boolean checkNBT, int count) {
-		super();
-		this.matcher = matcher;
-		this.checkNBT = checkNBT;
-		this.count = count;
-	}
-
-}
+/**
+ * This class was created by <Vindex>. It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ * 
+ * Botania is Open Source and distributed under the
+ * Botania License: http://botaniamod.net/license.php
+ * 
+ */
+package vazkii.botania.api.corporea;
+
+public class CorporeaRequest {
+	public Object matcher;
+	public boolean checkNBT;
+	public int count;
+	public int foundItems = 0;
+	public int extractedItems = 0;
+	
+	public CorporeaRequest(Object matcher, boolean checkNBT, int count) {
+		super();
+		this.matcher = matcher;
+		this.checkNBT = checkNBT;
+		this.count = count;
+	}
+
+}

src/main/java/vazkii/botania/api/corporea/IWrappedInventory.java

@@ -1,57 +1,57 @@
-/**
- * This class was created by <Vindex>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- */
-package vazkii.botania.api.corporea;
-
-import java.util.List;
-
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.ItemStack;
-
-/**
- * This interface wraps IInventory corporea works with in order to provide
- * compatibility with different storage mods.
- *
- */
-public interface IWrappedInventory {
-
-	/**
-	 * Break encapsulation and exposes original inventory.
-	 */
-	IInventory getWrappedObject();
-
-	/**
-	 * Counts items in the inventory matching the request
-	 *
-	 * @param request
-	 *            - specifies what should be found
-	 * @return List of ItemStack, individual stacks may exceed maxStackSize for
-	 *         purposes of counting huge amounts. To get final count requestor
-	 *         should sum stackSize of all stacks.
-	 */
-	List<ItemStack> countItems(CorporeaRequest request);
-
-	/**
-	 * Convenience method for accessing spark over inventory
-	 */
-	ICorporeaSpark getSpark();
-
-	/**
-	 * Extracts items matching request from the inventory.<br/>
-	 * {@link CorporeaRequest#count} is updated to reflect how many items are
-	 * yet to be extracted.<br/>
-	 * {@link CorporeaRequest#foundItems} and
-	 * {@link CorporeaRequest#extractedItems} are updated to reflect how many
-	 * items were found and extracted.
-	 *
-	 * @param request
-	 * @return List of ItemStacks to be delivered to the destination.
-	 */
-	List<ItemStack> extractItems(CorporeaRequest request);
-}
+/**
+ * This class was created by <Vindex>. It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ * 
+ * Botania is Open Source and distributed under the
+ * Botania License: http://botaniamod.net/license.php
+ * 
+ */
+package vazkii.botania.api.corporea;
+
+import java.util.List;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+/**
+ * This interface wraps IInventory corporea works with in order to provide
+ * compatibility with different storage mods.
+ *
+ */
+public interface IWrappedInventory {
+
+	/**
+	 * Break encapsulation and exposes original inventory.
+	 */
+	IInventory getWrappedObject();
+
+	/**
+	 * Counts items in the inventory matching the request
+	 *
+	 * @param request
+	 *            - specifies what should be found
+	 * @return List of ItemStack, individual stacks may exceed maxStackSize for
+	 *         purposes of counting huge amounts. To get final count requestor
+	 *         should sum stackSize of all stacks.
+	 */
+	List<ItemStack> countItems(CorporeaRequest request);
+
+	/**
+	 * Convenience method for accessing spark over inventory
+	 */
+	ICorporeaSpark getSpark();
+
+	/**
+	 * Extracts items matching request from the inventory.<br/>
+	 * {@link CorporeaRequest#count} is updated to reflect how many items are
+	 * yet to be extracted.<br/>
+	 * {@link CorporeaRequest#foundItems} and
+	 * {@link CorporeaRequest#extractedItems} are updated to reflect how many
+	 * items were found and extracted.
+	 *
+	 * @param request
+	 * @return List of ItemStacks to be delivered to the destination.
+	 */
+	List<ItemStack> extractItems(CorporeaRequest request);
+}

src/main/java/vazkii/botania/api/item/IInWorldRenderable.java

@@ -0,0 +1,13 @@
+package vazkii.botania.api.item;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+/**
+ * An item that implements this will allow some custom render. This will be called while the item is in the inventory,
+ * armor slot or bauble slots.
+ */
+public interface IInWorldRenderable
+{
+    public void renderInWorld(EntityPlayer player, ItemStack stack);
+}

src/main/java/vazkii/botania/api/recipe/RecipeElvenTrade.java

@@ -43,11 +43,7 @@ public class RecipeElvenTrade {
 					List<ItemStack> validStacks = OreDictionary.getOres((String) input);
 					boolean found = false;
 					for(ItemStack ostack : validStacks) {
-						ItemStack cstack = ostack.copy();
-						if(cstack.getItemDamage() == Short.MAX_VALUE)
-							cstack.setItemDamage(stack.getItemDamage());
-
-						if(stack.isItemEqual(cstack)) {
+						if(OreDictionary.itemMatches(ostack, stack, false)) {
 							if(!stacksToRemove.contains(stack))
 								stacksToRemove.add(stack);
 							oredictIndex = j;

src/main/java/vazkii/botania/api/recipe/RecipePureDaisy.java

@@ -10,10 +10,6 @@
  */
 package vazkii.botania.api.recipe;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
@@ -22,8 +18,6 @@ import vazkii.botania.api.subtile.SubTileEntity;
 
 public class RecipePureDaisy {
 
-	private static final Map<String, List<ItemStack>> oreMap = new HashMap();
-
 	Object input;
 	Block output;
 	int outputMeta;
@@ -53,21 +47,10 @@ public class RecipePureDaisy {
 		if(stack == null || stack.getItem() == null)
 			return false;
 
-		List<ItemStack> ores;
-		if(oreMap.containsKey(entry))
-			ores = oreMap.get(entry);
-		else {
-			ores = OreDictionary.getOres(entry);
-			oreMap.put(entry, ores);
-		}
-
-		for(ItemStack ostack : ores) {
-			ItemStack cstack = ostack.copy();
-			if(cstack.getItemDamage() == Short.MAX_VALUE)
-				cstack.setItemDamage(stack.getItemDamage());
-
-			if(stack.isItemEqual(cstack))
+		for(ItemStack ostack : OreDictionary.getOres(entry, false)) {
+			if(OreDictionary.itemMatches(ostack, stack, false)) {
 				return true;
+			}
 		}
 
 		return false;

src/main/java/vazkii/botania/client/core/handler/BoundTileRenderer.java

@@ -29,6 +29,7 @@ import org.lwjgl.opengl.GL11;
 
 import vazkii.botania.api.BotaniaAPI;
 import vazkii.botania.api.item.IExtendedWireframeCoordinateListProvider;
+import vazkii.botania.api.item.IInWorldRenderable;
 import vazkii.botania.api.item.IWireframeCoordinateListProvider;
 import vazkii.botania.api.wand.ICoordBoundItem;
 import vazkii.botania.api.wand.IWireframeAABBProvider;
@@ -36,6 +37,10 @@ import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 
 public final class BoundTileRenderer {
 
+	public static int getWireframeColor(){
+		return Color.HSBtoRGB(ClientTickHandler.ticksInGame % 200 / 200F, 0.6F, 1F);
+	}
+
 	@SubscribeEvent
 	public void onWorldRenderLast(RenderWorldLastEvent event) {
 		GL11.glPushMatrix();
@@ -49,7 +54,7 @@ public final class BoundTileRenderer {
 
 		EntityPlayer player = Minecraft.getMinecraft().thePlayer;
 		ItemStack stack = player.getCurrentEquippedItem();
-		int color = Color.HSBtoRGB(ClientTickHandler.ticksInGame % 200 / 200F, 0.6F, 1F);
+		int color = getWireframeColor();
 		if(stack != null && stack.getItem() instanceof ICoordBoundItem) {
 			ChunkCoordinates coords = ((ICoordBoundItem) stack.getItem()).getBinding(stack);
 			if(coords != null)
@@ -82,6 +87,11 @@ public final class BoundTileRenderer {
 						renderBlockOutlineAt(coords, color, 5F);
 				}
 			}
+			if(stackInSlot != null && stackInSlot.getItem() instanceof IInWorldRenderable) {
+				IInWorldRenderable provider = (IInWorldRenderable) stackInSlot.getItem();
+				provider.renderInWorld(player,stackInSlot);
+			}
+
 		}
 
 		GL11.glEnable(GL11.GL_DEPTH_TEST);

src/main/java/vazkii/botania/client/core/handler/KeyHandler.java

@@ -0,0 +1,56 @@
+package vazkii.botania.client.core.handler;
+
+import net.minecraft.client.settings.KeyBinding;
+import vazkii.botania.common.network.PacketHandler;
+import vazkii.botania.common.network.PacketLokiClear;
+import vazkii.botania.common.network.PacketLokiMirror;
+import vazkii.botania.common.network.PacketLokiToggle;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import cpw.mods.fml.common.gameevent.InputEvent;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+
+public class KeyHandler {
+    private static final KeyBinding keyToggleRingOfLoki= new KeyBinding("botaniamisc.toggleLoki", 0, "botaniamisc.keyCategory");
+    private static final KeyBinding keyRingOfLokiClear= new KeyBinding("botaniamisc.ringOfLokiClear", 0, "botaniamisc.keyCategory");
+    private static final KeyBinding keyRingOfLokiMirror= new KeyBinding("botaniamisc.ringOfLokiMirror", 0, "botaniamisc.keyCategory");
+
+    public KeyHandler() {
+        FMLCommonHandler.instance().bus().register(this);
+        ClientRegistry.registerKeyBinding(keyToggleRingOfLoki);
+        ClientRegistry.registerKeyBinding(keyRingOfLokiClear);
+        ClientRegistry.registerKeyBinding(keyRingOfLokiMirror);
+
+    }
+    @SideOnly(Side.CLIENT)
+    @SubscribeEvent
+    public void key(InputEvent.KeyInputEvent event){
+        checkAndPerformKeyActions();
+    }
+
+    private void checkAndPerformKeyActions(){
+        if (keyToggleRingOfLoki.isPressed()){
+            toggleRingLoki();
+        }
+        if(keyRingOfLokiClear.isPressed()){
+            ringOfLokiClear();
+        }
+        if(keyRingOfLokiMirror.isPressed()){
+            toggleRingLokiMirroring();
+        }
+    }
+
+    private static void toggleRingLoki() {
+        PacketHandler.INSTANCE.sendToServer(new PacketLokiToggle());
+    }
+
+    private static void ringOfLokiClear() {
+        PacketHandler.INSTANCE.sendToServer(new PacketLokiClear());
+    }
+    private static void toggleRingLokiMirroring() {
+        PacketHandler.INSTANCE.sendToServer(new PacketLokiMirror());
+    }
+}

src/main/java/vazkii/botania/client/core/helper/RenderHelper.java

@@ -17,11 +17,11 @@ import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.settings.GameSettings;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.ResourceLocation;
 
-import org.lwjgl.input.Keyboard;
 import org.lwjgl.opengl.GL11;
 
 import vazkii.botania.client.core.handler.ClientTickHandler;
@@ -243,7 +243,7 @@ public final class RenderHelper {
 		KeyBinding[] keys = Minecraft.getMinecraft().gameSettings.keyBindings;
 		for(KeyBinding otherKey : keys)
 			if(otherKey.getKeyDescription().equals(keyName)) {
-				key = Keyboard.getKeyName(otherKey.getKeyCode());
+				key = GameSettings.getKeyDisplayString(otherKey.getKeyCode());
 				break;
 			}
 

src/main/java/vazkii/botania/client/core/helper/ShaderHelper.java

@@ -14,6 +14,8 @@ import java.io.BufferedReader;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 
+import it.unimi.dsi.fastutil.ints.Int2IntMap;
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import net.minecraft.client.renderer.OpenGlHelper;
 
 import org.apache.logging.log4j.Level;
@@ -33,6 +35,8 @@ public final class ShaderHelper {
 	private static final int VERT = ARBVertexShader.GL_VERTEX_SHADER_ARB;
 	private static final int FRAG = ARBFragmentShader.GL_FRAGMENT_SHADER_ARB;
 
+	private static final Int2IntMap TIME_UNIFORM_LOCATIONS = new Int2IntOpenHashMap();
+
 	public static int pylonGlow = 0;
 	public static int enchanterRune = 0;
 	public static int manaPool = 0;
@@ -67,8 +71,8 @@ public final class ShaderHelper {
 		ARBShaderObjects.glUseProgramObjectARB(shader);
 
 		if(shader != 0) {
-			int time = ARBShaderObjects.glGetUniformLocationARB(shader, "time");
-			ARBShaderObjects.glUniform1iARB(time, ClientTickHandler.ticksInGame);
+			int timeUniform = TIME_UNIFORM_LOCATIONS.computeIfAbsent(shader, s -> ARBShaderObjects.glGetUniformLocationARB(shader, "time"));
+			ARBShaderObjects.glUniform1iARB(timeUniform, ClientTickHandler.ticksInGame);
 
 			if(callback != null)
 				callback.call(shader);

src/main/java/vazkii/botania/client/core/proxy/ClientProxy.java

@@ -55,6 +55,7 @@ import vazkii.botania.client.core.handler.PersistentVariableHelper;
 import vazkii.botania.client.core.handler.SubTileRadiusRenderHandler;
 import vazkii.botania.client.core.handler.TooltipHandler;
 import vazkii.botania.client.core.helper.ShaderHelper;
+import vazkii.botania.client.core.handler.KeyHandler;
 import vazkii.botania.client.fx.FXSparkle;
 import vazkii.botania.client.fx.FXWisp;
 import vazkii.botania.client.gui.lexicon.GuiLexicon;
@@ -219,6 +220,7 @@ public class ClientProxy extends CommonProxy {
 		MinecraftForge.EVENT_BUS.register(new SubTileRadiusRenderHandler());
 		MinecraftForge.EVENT_BUS.register(new MultiblockRenderHandler());
 		MinecraftForge.EVENT_BUS.register(new SkyblockRenderEvents());
+		MinecraftForge.EVENT_BUS.register(new KeyHandler());
 		FMLCommonHandler.instance().bus().register(new CorporeaAutoCompleteHandler());
 
 		if(ConfigHandler.enableSeasonalFeatures) {

src/main/java/vazkii/botania/client/gui/bag/ContainerFlowerBag.java

@@ -1,99 +0,0 @@
-/**
- * This class was created by <Vazkii>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- * File Created @ [Mar 16, 2015, 6:42:40 PM (GMT)]
- */
-package vazkii.botania.client.gui.bag;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.Container;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import vazkii.botania.client.gui.SlotLocked;
-
-public class ContainerFlowerBag extends Container {
-
-	InventoryFlowerBag flowerBagInv;
-
-	public ContainerFlowerBag(EntityPlayer player) {
-		int i;
-		int j;
-
-		int slot = player.inventory.currentItem;
-		IInventory playerInv = player.inventory;
-		flowerBagInv = new InventoryFlowerBag(player, slot);
-
-		for(i = 0; i < 2; ++i)
-			for(j = 0; j < 8; ++j) {
-				int k = j + i * 8;
-				addSlotToContainer(new SlotFlower(flowerBagInv, k, 17 + j * 18, 26 + i * 18, k));
-			}
-
-		for(i = 0; i < 3; ++i)
-			for(j = 0; j < 9; ++j)
-				addSlotToContainer(new Slot(playerInv, j + i * 9 + 9, 8 + j * 18, 84 + i * 18));
-
-		for(i = 0; i < 9; ++i) {
-			if(player.inventory.currentItem == i)
-				addSlotToContainer(new SlotLocked(playerInv, i, 8 + i * 18, 142));
-			else addSlotToContainer(new Slot(playerInv, i, 8 + i * 18, 142));
-		}
-
-	}
-
-	@Override
-	public boolean canInteractWith(EntityPlayer player) {
-		boolean can = flowerBagInv.isUseableByPlayer(player);
-		if(!can)
-			onContainerClosed(player);
-
-		return can;
-	}
-
-	@Override
-	public void onContainerClosed(EntityPlayer player) {
-		super.onContainerClosed(player);
-		flowerBagInv.pushInventory();
-	}
-
-	@Override
-	public ItemStack transferStackInSlot(EntityPlayer p_82846_1_, int p_82846_2_) {
-		ItemStack itemstack = null;
-		Slot slot = (Slot)inventorySlots.get(p_82846_2_);
-
-		if(slot != null && slot.getHasStack()) {
-			ItemStack itemstack1 = slot.getStack();
-			itemstack = itemstack1.copy();
-
-			if(p_82846_2_ < 16) {
-				if(!mergeItemStack(itemstack1, 16, 52, true))
-					return null;
-			} else {
-				int i = itemstack.getItemDamage();
-				if(i < 16) {
-					Slot slot1 = (Slot)inventorySlots.get(i);
-					if(slot1.isItemValid(itemstack) && !mergeItemStack(itemstack1, i, i + 1, true))
-						return null;
-				}
-			}
-
-			if(itemstack1.stackSize == 0)
-				slot.putStack((ItemStack)null);
-			else slot.onSlotChanged();
-
-			if(itemstack1.stackSize == itemstack.stackSize)
-				return null;
-
-			slot.onPickupFromSlot(p_82846_1_, itemstack1);
-		}
-
-		return itemstack;
-	}
-
-}

src/main/java/vazkii/botania/client/gui/bag/GuiFlowerBag.java

@@ -1,74 +0,0 @@
-/**
- * This class was created by <Vazkii>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- * File Created @ [Mar 16, 2015, 6:42:43 PM (GMT)]
- */
-package vazkii.botania.client.gui.bag;
-
-import java.util.List;
-
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.client.renderer.RenderHelper;
-import net.minecraft.client.renderer.entity.RenderItem;
-import net.minecraft.client.resources.I18n;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.StatCollector;
-
-import org.lwjgl.opengl.GL11;
-
-import vazkii.botania.client.lib.LibResources;
-import vazkii.botania.common.block.ModBlocks;
-
-public class GuiFlowerBag extends GuiContainer {
-
-	private static final ResourceLocation texture = new ResourceLocation(LibResources.GUI_FLOWER_BAG);
-
-	public GuiFlowerBag(EntityPlayer player) {
-		super(new ContainerFlowerBag(player));
-	}
-
-	@Override
-	protected void drawGuiContainerForegroundLayer(int p_146979_1_, int p_146979_2_) {
-		String s = StatCollector.translateToLocal("item.botania:flowerBag.name");
-		fontRendererObj.drawString(s, xSize / 2 - fontRendererObj.getStringWidth(s) / 2, 6, 4210752);
-		fontRendererObj.drawString(I18n.format("container.inventory", new Object[0]), 8, ySize - 96 + 2, 4210752);
-	}
-
-	@Override
-	protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) {
-		GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
-		mc.getTextureManager().bindTexture(texture);
-		int k = (width - xSize) / 2;
-		int l = (height - ySize) / 2;
-		drawTexturedModalRect(k, l, 0, 0, xSize, ySize);
-
-		List<Slot> slotList = inventorySlots.inventorySlots;
-		for(Slot slot : slotList)
-			if(slot instanceof SlotFlower) {
-				SlotFlower slotf = (SlotFlower) slot;
-				if(!slotf.getHasStack()) {
-					ItemStack stack = new ItemStack(ModBlocks.flower, 0, slotf.color);
-					int x = guiLeft + slotf.xDisplayPosition;
-					int y = guiTop + slotf.yDisplayPosition;
-					RenderHelper.enableGUIStandardItemLighting();
-					RenderItem.getInstance().renderItemIntoGUI(mc.fontRenderer, mc.renderEngine, stack, x, y);
-					RenderHelper.disableStandardItemLighting();
-					mc.fontRenderer.drawStringWithShadow("0", x + 11, y + 9, 0xFF6666);
-				}
-			}
-	}
-
-	@Override
-	protected boolean checkHotbarKeys(int p_146983_1_) {
-		return false;
-	}
-
-}

src/main/java/vazkii/botania/client/gui/bag/InventoryFlowerBag.java

@@ -1,160 +0,0 @@
-/**
- * This class was created by <Vazkii>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- * File Created @ [Mar 16, 2015, 6:42:56 PM (GMT)]
- */
-package vazkii.botania.client.gui.bag;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.ItemStack;
-import vazkii.botania.common.item.ItemFlowerBag;
-import vazkii.botania.common.item.ModItems;
-import vazkii.botania.common.lib.LibItemNames;
-
-public class InventoryFlowerBag implements IInventory {
-
-	private static final ItemStack[] FALLBACK_INVENTORY = new ItemStack[16];
-
-	EntityPlayer player;
-	int slot;
-	ItemStack[] stacks = null;
-
-	boolean invPushed = false;
-	ItemStack storedInv = null;
-
-	public InventoryFlowerBag(EntityPlayer player, int slot) {
-		this.player = player;
-		this.slot = slot;
-	}
-
-	public static boolean isFlowerBag(ItemStack stack) {
-		return stack != null && stack.getItem() == ModItems.flowerBag;
-	}
-
-	ItemStack getStack() {
-		ItemStack stack = player.inventory.getStackInSlot(slot);
-		if(stack != null)
-			storedInv = stack;
-		return stack;
-	}
-
-	ItemStack[] getInventory() {
-		if(stacks != null)
-			return stacks;
-
-		ItemStack stack = getStack();
-		if(isFlowerBag(getStack())) {
-			stacks = ItemFlowerBag.loadStacks(stack);
-			return stacks;
-		}
-
-		return FALLBACK_INVENTORY;
-	}
-
-	public void pushInventory() {
-		if(invPushed)
-			return;
-
-		ItemStack stack = getStack();
-		if(stack == null)
-			stack = storedInv;
-
-		if(stack != null) {
-			ItemStack[] inv = getInventory();
-			ItemFlowerBag.setStacks(stack, inv);
-		}
-
-		invPushed = true;
-	}
-
-	@Override
-	public int getSizeInventory() {
-		return 16;
-	}
-
-	@Override
-	public ItemStack getStackInSlot(int i) {
-		return getInventory()[i];
-	}
-
-	@Override
-	public ItemStack decrStackSize(int i, int j) {
-		ItemStack[] inventorySlots = getInventory();
-		if (inventorySlots[i] != null) {
-			ItemStack stackAt;
-
-			if (inventorySlots[i].stackSize <= j) {
-				stackAt = inventorySlots[i];
-				inventorySlots[i] = null;
-				return stackAt;
-			} else {
-				stackAt = inventorySlots[i].splitStack(j);
-
-				if (inventorySlots[i].stackSize == 0)
-					inventorySlots[i] = null;
-
-				return stackAt;
-			}
-		}
-
-		return null;
-	}
-
-	@Override
-	public ItemStack getStackInSlotOnClosing(int i) {
-		return getStackInSlot(i);
-	}
-
-	@Override
-	public void setInventorySlotContents(int i, ItemStack itemstack) {
-		ItemStack[] inventorySlots = getInventory();
-		inventorySlots[i] = itemstack;
-	}
-
-	@Override
-	public int getInventoryStackLimit() {
-		return isFlowerBag(getStack()) ? 64 : 0;
-	}
-
-	@Override
-	public boolean isUseableByPlayer(EntityPlayer entityplayer) {
-		return isFlowerBag(getStack());
-	}
-
-	@Override
-	public boolean isItemValidForSlot(int i, ItemStack itemstack) {
-		return isFlowerBag(getStack());
-	}
-
-	@Override
-	public boolean hasCustomInventoryName() {
-		return false;
-	}
-
-	@Override
-	public void openInventory() {
-		// NO-OP
-	}
-
-	@Override
-	public void closeInventory() {
-		// NO-OP
-	}
-
-	@Override
-	public String getInventoryName() {
-		return LibItemNames.FLOWER_BAG;
-	}
-
-	@Override
-	public void markDirty() {
-		// NO-OP
-	}
-
-}

src/main/java/vazkii/botania/client/gui/bag/SlotFlower.java

@@ -1,39 +0,0 @@
-/**
- * This class was created by <Vazkii>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- * File Created @ [Mar 16, 2015, 7:20:05 PM (GMT)]
- */
-package vazkii.botania.client.gui.bag;
-
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import vazkii.botania.common.block.ModBlocks;
-
-public class SlotFlower extends Slot {
-
-	InventoryFlowerBag inv;
-	int color;
-
-	public SlotFlower(InventoryFlowerBag p_i1824_1_, int p_i1824_2_, int p_i1824_3_, int p_i1824_4_, int color) {
-		super(p_i1824_1_, p_i1824_2_, p_i1824_3_, p_i1824_4_);
-		this.color = color;
-		inv = p_i1824_1_;
-	}
-
-	@Override
-	public void onSlotChange(ItemStack oldStack, ItemStack newStack) {
-		inv.setInventorySlotContents(color, newStack);
-	}
-
-	@Override
-	public boolean isItemValid(ItemStack stack) {
-		return stack.getItem() == Item.getItemFromBlock(ModBlocks.flower) && stack.getItemDamage() == color;
-	}
-
-}

src/main/java/vazkii/botania/client/gui/bags/ContainerMagicPlantBag.java

@@ -0,0 +1,89 @@
+package vazkii.botania.client.gui.bags;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import vazkii.botania.client.gui.SlotLocked;
+
+public abstract class ContainerMagicPlantBag extends Container {
+
+    protected InventoryMagicPlantBag magicPlantInv;
+    public ContainerMagicPlantBag(EntityPlayer player) {
+        int i;
+        int j;
+
+        IInventory playerInv = player.inventory;
+
+        addMagicPlantSlots(player);
+
+        for(i = 0; i < 3; ++i) {
+            for(j = 0; j < 9; ++j) {
+                addSlotToContainer(new Slot(playerInv, j + i * 9 + 9, 8 + j * 18, 84 + i * 18));
+            }
+        }
+
+
+        for(i = 0; i < 9; ++i) {
+            if(player.inventory.currentItem == i) {
+                addSlotToContainer(new SlotLocked(playerInv, i, 8 + i * 18, 142));
+            }
+            else addSlotToContainer(new Slot(playerInv, i, 8 + i * 18, 142));
+        }
+    }
+
+    public abstract void  addMagicPlantSlots(EntityPlayer player);
+
+    @Override
+    public boolean canInteractWith(EntityPlayer player) {
+        boolean can = magicPlantInv.isUseableByPlayer(player);
+        if(!can)
+            onContainerClosed(player);
+
+        return can;
+    }
+
+    @Override
+    public void onContainerClosed(EntityPlayer player) {
+        super.onContainerClosed(player);
+        magicPlantInv.pushInventory();
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer p_82846_1_, int p_82846_2_) {
+        ItemStack itemstack = null;
+        Slot slot = (Slot)inventorySlots.get(p_82846_2_);
+
+        if(slot != null && slot.getHasStack()) {
+            ItemStack itemstack1 = slot.getStack();
+            itemstack = itemstack1.copy();
+
+            if(p_82846_2_ < 16) {
+                if(!mergeItemStack(itemstack1, 16, 52, true))
+                    return null;
+            } else {
+                int i = itemstack.getItemDamage();
+                if(i < 16) {
+                    Slot slot1 = (Slot)inventorySlots.get(i);
+                    if(slot1.isItemValid(itemstack) && !mergeItemStack(itemstack1, i, i + 1, true))
+                        return null;
+                }
+            }
+
+            if(itemstack1.stackSize == 0)
+                slot.putStack((ItemStack)null);
+            else slot.onSlotChanged();
+
+            if(itemstack1.stackSize == itemstack.stackSize)
+                return null;
+
+            slot.onPickupFromSlot(p_82846_1_, itemstack1);
+        }
+
+        return itemstack;
+    }
+
+}
+
+

src/main/java/vazkii/botania/client/gui/bags/GuiMagicPlantBag.java

@@ -0,0 +1,65 @@
+package vazkii.botania.client.gui.bags;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
+
+import org.lwjgl.opengl.GL11;
+
+public abstract class GuiMagicPlantBag extends GuiContainer {
+
+    private final ResourceLocation texture;
+    public GuiMagicPlantBag(ContainerMagicPlantBag container, ResourceLocation texture) {
+        super(container);
+        this.texture = texture;
+    }
+
+    @Override
+    protected void drawGuiContainerForegroundLayer(int p_146979_1_, int p_146979_2_) {
+        String s = StatCollector.translateToLocal(getLocalizedNameKey());
+        fontRendererObj.drawString(s, xSize / 2 - fontRendererObj.getStringWidth(s) / 2, 6, 4210752);
+        fontRendererObj.drawString(I18n.format("container.inventory", new Object[0]), 8, ySize - 96 + 2, 4210752);
+    }
+
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) {
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        mc.getTextureManager().bindTexture(texture);
+        int k = (width - xSize) / 2;
+        int l = (height - ySize) / 2;
+        drawTexturedModalRect(k, l, 0, 0, xSize, ySize);
+
+        List<Slot> slotList = inventorySlots.inventorySlots;
+        for(Slot slot : slotList)
+            if(slot instanceof SlotMagicPlant) {
+                SlotMagicPlant slotf = (SlotMagicPlant) slot;
+                if(!slotf.getHasStack()) {
+                    ItemStack stack = new ItemStack(itemTypeAllowed(), 0, slotf.color);
+                    int x = guiLeft + slotf.xDisplayPosition;
+                    int y = guiTop + slotf.yDisplayPosition;
+                    RenderHelper.enableGUIStandardItemLighting();
+                    RenderItem.getInstance().renderItemIntoGUI(mc.fontRenderer, mc.renderEngine, stack, x, y);
+                    RenderHelper.disableStandardItemLighting();
+                    mc.fontRenderer.drawStringWithShadow("0", x + 11, y + 9, 0xFF6666);
+                }
+            }
+    }
+
+    @Override
+    protected boolean checkHotbarKeys(int p_146983_1_) {
+        return false;
+    }
+
+    protected abstract Block itemTypeAllowed();
+
+    protected abstract String getLocalizedNameKey();
+}

src/main/java/vazkii/botania/client/gui/bags/InventoryMagicPlantBag.java

@@ -0,0 +1,148 @@
+package vazkii.botania.client.gui.bags;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import vazkii.botania.common.item.bag.ItemBagBase;
+
+public abstract class InventoryMagicPlantBag implements IInventory {
+
+    private static final ItemStack[] FALLBACK_INVENTORY = new ItemStack[16];
+
+    EntityPlayer player;
+    int slot;
+    ItemStack[] stacks = null;
+
+    boolean invPushed = false;
+    ItemStack storedInv = null;
+
+    public InventoryMagicPlantBag(EntityPlayer player, int slot) {
+        this.player = player;
+        this.slot = slot;
+    }
+
+    ItemStack getStack() {
+        ItemStack stack = player.inventory.getStackInSlot(slot);
+        if(stack != null)
+            storedInv = stack;
+        return stack;
+    }
+
+
+    public void pushInventory() {
+        if(invPushed)
+            return;
+
+        ItemStack stack = getStack();
+        if(stack == null)
+            stack = storedInv;
+
+        if(stack != null) {
+            ItemStack[] inv = getInventory();
+            ItemBagBase.setStacks(stack, inv);
+        }
+
+        invPushed = true;
+    }
+
+    ItemStack[] getInventory() {
+        if(stacks != null)
+            return stacks;
+
+        ItemStack stack = getStack();
+        if(isMagicPlantBag(getStack())) {
+            stacks = ItemBagBase.loadStacks(stack);
+            return stacks;
+        }
+
+        return FALLBACK_INVENTORY;
+    }
+
+    @Override
+    public int getSizeInventory() {
+        return 16;
+    }
+
+    @Override
+    public ItemStack getStackInSlot(int slotIn) {
+        return getInventory()[slotIn];
+    }
+
+    @Override
+    public ItemStack decrStackSize(int index, int count) {
+        ItemStack[] inventorySlots = getInventory();
+        if (inventorySlots[index] != null) {
+            ItemStack stackAt;
+
+            if (inventorySlots[index].stackSize <= count) {
+                stackAt = inventorySlots[index];
+                inventorySlots[index] = null;
+                return stackAt;
+            } else {
+                stackAt = inventorySlots[index].splitStack(count);
+
+                if (inventorySlots[index].stackSize == 0)
+                    inventorySlots[index] = null;
+
+                return stackAt;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public ItemStack getStackInSlotOnClosing(int index) {
+        return getStackInSlot(index);
+    }
+
+    @Override
+    public void setInventorySlotContents(int index, ItemStack stack) {
+        ItemStack[] inventorySlots = getInventory();
+        inventorySlots[index] = stack;
+    }
+
+    @Override
+    public String getInventoryName() {
+        return getBagName();
+    }
+
+    @Override
+    public boolean hasCustomInventoryName() {
+        return false;
+    }
+
+    @Override
+    public int getInventoryStackLimit() {
+        return isMagicPlantBag(getStack()) ? 64 : 0;
+    }
+
+    @Override
+    public void markDirty() {
+        // NO-OP
+    }
+
+    @Override
+    public boolean isUseableByPlayer(EntityPlayer player) {
+        return isMagicPlantBag(getStack());
+    }
+
+    @Override
+    public void openInventory() {
+        // NO-OP
+    }
+
+    @Override
+    public void closeInventory() {
+        // NO-OP
+    }
+
+    @Override
+    public boolean isItemValidForSlot(int index, ItemStack stack) {
+        return isMagicPlantBag(getStack());
+    }
+
+    protected abstract String getBagName();
+
+    public abstract boolean isMagicPlantBag(ItemStack stack);
+}

src/main/java/vazkii/botania/client/gui/bags/SlotMagicPlant.java

@@ -0,0 +1,32 @@
+
+package vazkii.botania.client.gui.bags;
+
+import net.minecraft.block.Block;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import vazkii.botania.common.block.ModBlocks;
+
+public abstract class SlotMagicPlant extends Slot {
+
+    InventoryMagicPlantBag inv;
+    int color;
+
+    public SlotMagicPlant(InventoryMagicPlantBag p_i1824_1_, int p_i1824_2_, int p_i1824_3_, int p_i1824_4_, int color) {
+        super(p_i1824_1_, p_i1824_2_, p_i1824_3_, p_i1824_4_);
+        this.color = color;
+        inv = p_i1824_1_;
+    }
+
+    @Override
+    public void onSlotChange(ItemStack oldStack, ItemStack newStack) {
+        inv.setInventorySlotContents(color, newStack);
+    }
+
+    @Override
+    public boolean isItemValid(ItemStack stack) {
+        return stack.getItem() == Item.getItemFromBlock(getValidBlock()) && stack.getItemDamage() == color;
+    }
+
+    protected abstract Block getValidBlock();
+}

src/main/java/vazkii/botania/client/gui/bags/flowerBag/ContainerFlowerBag.java

@@ -0,0 +1,23 @@
+package vazkii.botania.client.gui.bags.flowerBag;
+
+import net.minecraft.entity.player.EntityPlayer;
+import vazkii.botania.client.gui.bags.ContainerMagicPlantBag;
+
+public class ContainerFlowerBag extends ContainerMagicPlantBag {
+    public ContainerFlowerBag(EntityPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void addMagicPlantSlots(EntityPlayer player) {
+        int slot = player.inventory.currentItem;
+        magicPlantInv = new InventoryFlowerBag(player, slot);
+
+        for(int i = 0; i < 2; ++i) {
+            for (int j = 0; j < 8; ++j) {
+                int k = j + i * 8;
+                addSlotToContainer(new SlotFlower(magicPlantInv, k, 17 + j * 18, 26 + i * 18, k));
+            }
+        }
+    }
+}

src/main/java/vazkii/botania/client/gui/bags/flowerBag/GuiFlowerBag.java

@@ -0,0 +1,27 @@
+package vazkii.botania.client.gui.bags.flowerBag;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ResourceLocation;
+import vazkii.botania.client.gui.bags.GuiMagicPlantBag;
+import vazkii.botania.client.lib.LibResources;
+import vazkii.botania.common.block.ModBlocks;
+
+public class GuiFlowerBag extends GuiMagicPlantBag {
+
+    private static final ResourceLocation texture = new ResourceLocation(LibResources.GUI_FLOWER_BAG);
+
+    public GuiFlowerBag(EntityPlayer player) {
+        super(new ContainerFlowerBag(player), texture);
+    }
+
+    @Override
+    protected Block itemTypeAllowed() {
+        return ModBlocks.flower;
+    }
+
+    @Override
+    protected String getLocalizedNameKey() {
+        return "item.botania:flowerBag.name";
+    }
+}

src/main/java/vazkii/botania/client/gui/bags/flowerBag/InventoryFlowerBag.java

@@ -0,0 +1,23 @@
+package vazkii.botania.client.gui.bags.flowerBag;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import vazkii.botania.client.gui.bags.InventoryMagicPlantBag;
+import vazkii.botania.common.item.ModItems;
+import vazkii.botania.common.lib.LibItemNames;
+
+public class InventoryFlowerBag extends InventoryMagicPlantBag {
+    public InventoryFlowerBag(EntityPlayer player, int slot) {
+        super(player, slot);
+    }
+
+    @Override
+    public boolean isMagicPlantBag(ItemStack stack) {
+        return stack != null && stack.getItem() == ModItems.flowerBag;
+    }
+
+    @Override
+    protected String getBagName() {
+        return LibItemNames.FLOWER_BAG;
+    }
+}

src/main/java/vazkii/botania/client/gui/bags/flowerBag/SlotFlower.java

@@ -0,0 +1,18 @@
+package vazkii.botania.client.gui.bags.flowerBag;
+
+import net.minecraft.block.Block;
+import vazkii.botania.client.gui.bags.InventoryMagicPlantBag;
+import vazkii.botania.client.gui.bags.SlotMagicPlant;
+import vazkii.botania.common.block.ModBlocks;
+
+public class SlotFlower extends SlotMagicPlant {
+    public SlotFlower(InventoryMagicPlantBag p_i1824_1_, int p_i1824_2_, int p_i1824_3_, int p_i1824_4_, int color) {
+        super(p_i1824_1_, p_i1824_2_, p_i1824_3_, p_i1824_4_, color);
+    }
+
+    @Override
+    protected Block getValidBlock() {
+        return ModBlocks.flower;
+    }
+
+}

src/main/java/vazkii/botania/client/gui/bags/shroomBag/ContainerShroomBag.java

@@ -0,0 +1,23 @@
+package vazkii.botania.client.gui.bags.shroomBag;
+
+import net.minecraft.entity.player.EntityPlayer;
+import vazkii.botania.client.gui.bags.ContainerMagicPlantBag;
+
+public class ContainerShroomBag extends ContainerMagicPlantBag {
+    public ContainerShroomBag(EntityPlayer player) {
+        super(player);
+    }
+
+    @Override
+    public void addMagicPlantSlots(EntityPlayer player) {
+        int slot = player.inventory.currentItem;
+        magicPlantInv = new InventoryShroomBag(player, slot);
+
+        for(int i = 0; i < 2; ++i) {
+            for (int j = 0; j < 8; ++j) {
+                int k = j + i * 8;
+                addSlotToContainer(new SlotShroom(magicPlantInv, k, 17 + j * 18, 26 + i * 18, k));
+            }
+        }
+    }
+}

src/main/java/vazkii/botania/client/gui/bags/shroomBag/GuiShroomBag.java

@@ -0,0 +1,27 @@
+package vazkii.botania.client.gui.bags.shroomBag;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.ResourceLocation;
+import vazkii.botania.client.gui.bags.GuiMagicPlantBag;
+import vazkii.botania.client.lib.LibResources;
+import vazkii.botania.common.block.ModBlocks;
+
+public class GuiShroomBag extends GuiMagicPlantBag {
+
+    private static final ResourceLocation texture = new ResourceLocation(LibResources.GUI_SHROOM_BAG);
+
+    public GuiShroomBag(EntityPlayer player) {
+        super(new ContainerShroomBag(player), texture);
+    }
+
+    @Override
+    protected Block itemTypeAllowed() {
+        return ModBlocks.mushroom;
+    }
+
+    @Override
+    protected String getLocalizedNameKey() {
+        return "item.botania:shroomBag.name";
+    }
+}

src/main/java/vazkii/botania/client/gui/bags/shroomBag/InventoryShroomBag.java

@@ -0,0 +1,23 @@
+package vazkii.botania.client.gui.bags.shroomBag;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import vazkii.botania.client.gui.bags.InventoryMagicPlantBag;
+import vazkii.botania.common.item.ModItems;
+import vazkii.botania.common.lib.LibItemNames;
+
+public class InventoryShroomBag extends InventoryMagicPlantBag {
+    public InventoryShroomBag(EntityPlayer player, int slot) {
+        super(player, slot);
+    }
+
+    @Override
+    public boolean isMagicPlantBag(ItemStack stack) {
+        return stack != null && stack.getItem() == ModItems.shroomBag;
+    }
+
+    @Override
+    protected String getBagName() {
+        return LibItemNames.SHROOM_BAG;
+    }
+}

src/main/java/vazkii/botania/client/gui/bags/shroomBag/SlotShroom.java

@@ -0,0 +1,18 @@
+package vazkii.botania.client.gui.bags.shroomBag;
+
+import net.minecraft.block.Block;
+import vazkii.botania.client.gui.bags.InventoryMagicPlantBag;
+import vazkii.botania.client.gui.bags.SlotMagicPlant;
+import vazkii.botania.common.block.ModBlocks;
+
+public class SlotShroom extends SlotMagicPlant {
+    public SlotShroom(InventoryMagicPlantBag p_i1824_1_, int p_i1824_2_, int p_i1824_3_, int p_i1824_4_, int color) {
+        super(p_i1824_1_, p_i1824_2_, p_i1824_3_, p_i1824_4_, color);
+    }
+
+    @Override
+    protected Block getValidBlock() {
+        return ModBlocks.mushroom;
+    }
+
+}

src/main/java/vazkii/botania/client/integration/nei/recipe/RecipeHandlerElvenTrade.java

@@ -125,7 +125,7 @@ public class RecipeHandlerElvenTrade extends TemplateRecipeHandler {
 	public void loadCraftingRecipes(ItemStack result) {
 		if(hasElvenKnowledge()) {
 			for(RecipeElvenTrade recipe : filteredElvenTradeRecipes()) {
-				if(ItemNBTHelper.areStacksSameTypeCraftingWithNBT(recipe.getOutput(), result))
+				if(NEIServerUtils.areStacksSameTypeCrafting(recipe.getOutput(), result))
 					arecipes.add(new CachedElvenTradeRecipe(recipe));
 			}
 		}
@@ -136,7 +136,7 @@ public class RecipeHandlerElvenTrade extends TemplateRecipeHandler {
 		if(hasElvenKnowledge()) {
 			for(RecipeElvenTrade recipe : filteredElvenTradeRecipes()) {
 				CachedElvenTradeRecipe crecipe = new CachedElvenTradeRecipe(recipe);
-				if(ItemNBTHelper.cachedRecipeContainsWithNBT(crecipe.inputs, ingredient))
+				if(crecipe.contains(crecipe.inputs, ingredient))
 					arecipes.add(crecipe);
 			}
 		}

src/main/java/vazkii/botania/client/integration/nei/recipe/RecipeHandlerManaPool.java

@@ -5,6 +5,9 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.StatCollector;
@@ -49,6 +52,7 @@ public class RecipeHandlerManaPool extends TemplateRecipeHandler {
 				otherStacks.add(new PositionedStack(new ItemStack(ModBlocks.conjurationCatalyst), 10, 37));
 
 			output = new PositionedStack(recipe.getOutput(), 101, 37);
+			// This value is where the mana bar is stored initially
 			mana = recipe.getManaToConsume();
 		}
 
@@ -94,9 +98,16 @@ public class RecipeHandlerManaPool extends TemplateRecipeHandler {
 		super.drawBackground(recipe);
 		GL11.glEnable(GL11.GL_BLEND);
 		GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.5F);
+		// Mana infusion is the mana pool, super weird.
 		GuiDraw.changeTexture(LibResources.GUI_MANA_INFUSION_OVERLAY);
 		GuiDraw.drawTexturedModalRect(45, 20, 38, 35, 92, 50);
-		HUDHandler.renderManaBar(32, 80, 0x0000FF, 0.75F, ((CachedManaPoolRecipe) arecipes.get(recipe)).mana, TilePool.MAX_MANA / 10);
+		// Below is where the mana bar actually drawn.
+		int tempMana = ((CachedManaPoolRecipe) arecipes.get(recipe)).mana;
+		HUDHandler.renderManaBar(32, 80, 0x0000FF, 0.75F, GuiScreen.isShiftKeyDown() ? tempMana : tempMana * 10, TilePool.MAX_MANA / 10);
+		FontRenderer font = Minecraft.getMinecraft().fontRenderer;
+		String size = GuiScreen.isShiftKeyDown() ? "1x " : "10x ";
+		String localized = StatCollector.translateToLocal("botaniamisc.neiratio");
+		font.drawString(size + localized, 84 - font.getStringWidth(size + localized) / 2, 71, 0x000000);
 		RenderTilePool.forceMana = true;
 	}
 

src/main/java/vazkii/botania/client/lib/LibResources.java

@@ -44,6 +44,7 @@ public final class LibResources {
 	public static final String GUI_NEI_BLANK = PREFIX_GUI + "neiBlank.png";
 	public static final String GUI_NEI_BREWERY = PREFIX_GUI + "neiBrewery.png";
 	public static final String GUI_FLOWER_BAG = PREFIX_GUI + "flowerBag.png";
+	public static final String GUI_SHROOM_BAG = PREFIX_GUI + "shroomBag.png";
 	public static final String GUI_BAUBLE_BOX = PREFIX_GUI + "baubleBox.png";
 	public static final String GUI_HUD_ICONS = PREFIX_GUI + "hudIcons.png";
 	public static final String GUI_STENCIL = PREFIX_GUI + "stencil.png";

src/main/java/vazkii/botania/client/render/block/RenderSpecialFlower.java

@@ -40,11 +40,11 @@ public class RenderSpecialFlower implements ISimpleBlockRenderingHandler, IMulti
 	}
 
 	// Copied from RenderBlocks
-	public static boolean renderCrossedSquares(IBlockAccess blockAccess, Block par1Block, int par2, int par3, int par4, RenderBlocks render) {
+	public static boolean renderCrossedSquares(IBlockAccess blockAccess, Block block, int x, int y, int z, RenderBlocks render) {
 		Tessellator tessellator = Tessellator.instance;
-		tessellator.setBrightness(par1Block.getMixedBrightnessForBlock(blockAccess, par2, par3, par4));
+		tessellator.setBrightness(block.getMixedBrightnessForBlock(blockAccess, x, y, z));
 		float f = 1.0F;
-		int l = par1Block.colorMultiplier(blockAccess, par2, par3, par4);
+		int l = block.colorMultiplier(blockAccess, x, y, z);
 		float f1 = (l >> 16 & 255) / 255.0F;
 		float f2 = (l >> 8 & 255) / 255.0F;
 		float f3 = (l & 255) / 255.0F;
@@ -59,12 +59,12 @@ public class RenderSpecialFlower implements ISimpleBlockRenderingHandler, IMulti
 		}
 
 		tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);
-		double d1 = par2;
-		double d2 = par3;
-		double d0 = par4;
+		double d1 = x;
+		double d2 = y;
+		double d0 = z;
 		long sh;
 
-		sh = par2 * 3129871 ^ par4 * 116129781L ^ par3;
+		sh = x * 3129871 ^ z * 116129781L ^ y;
 		sh = sh * sh * 42317861L + sh * 11L;
 		d1 += ((sh >> 16 & 15L) / 15.0F - 0.5D) * 0.3D;
 		d2 += (sh >> 32 & 15L) / 15.0F * -0.15D;
@@ -72,8 +72,8 @@ public class RenderSpecialFlower implements ISimpleBlockRenderingHandler, IMulti
 
 
 		// Only change here, to use xyz rather than side/meta
-		IIcon icon = render.getBlockIcon(par1Block, blockAccess, par2, par3, par4, 0);
-		drawCrossedSquares(blockAccess, par1Block, icon, par2, par3, par4, d1, d2, d0, 1.0F, render);
+		IIcon icon = render.getBlockIcon(block, blockAccess, x, y, z, 0);
+		drawCrossedSquares(blockAccess, block, icon, x, y, z, d1, d2, d0, 1.0F, render);
 
 		return true;
 	}

src/main/java/vazkii/botania/client/render/tile/RenderTileFloatingFlower.java

@@ -10,7 +10,8 @@
  */
 package vazkii.botania.client.render.tile;
 
-import java.awt.*;
+
+import java.awt.Color;
 import java.util.Random;
 
 import net.minecraft.client.Minecraft;

src/main/java/vazkii/botania/client/render/world/SkyblockRenderEvents.java

@@ -16,13 +16,21 @@ import net.minecraftforge.client.event.RenderWorldLastEvent;
 import vazkii.botania.common.core.handler.ConfigHandler;
 import vazkii.botania.common.world.WorldTypeSkyblock;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import java.util.stream.IntStream;
 
 public final class SkyblockRenderEvents {
 
 	@SubscribeEvent
 	public void onRender(RenderWorldLastEvent event) {
 		World world = Minecraft.getMinecraft().theWorld;
-		if(ConfigHandler.enableFancySkybox && world.provider.dimensionId == 0 && (ConfigHandler.enableFancySkyboxInNormalWorlds || WorldTypeSkyblock.isWorldSkyblock(Minecraft.getMinecraft().theWorld))) {
+
+		boolean renderFancySkybox = ConfigHandler.enableFancySkybox && (
+				(ConfigHandler.enableFancySkyboxInNormalWorlds && (world.provider.dimensionId == 0) ) ||
+				(ConfigHandler.enableFancySkyboxInDimension && ConfigHandler.fancySkyboxDimensions.contains(world.provider.dimensionId)) ||
+				(WorldTypeSkyblock.isWorldSkyblock(Minecraft.getMinecraft().theWorld))
+		);
+
+		if(renderFancySkybox) {
 			if(!(world.provider.getSkyRenderer() instanceof SkyblockSkyRenderer))
 				world.provider.setSkyRenderer(new SkyblockSkyRenderer());
 		}

src/main/java/vazkii/botania/common/Botania.java

@@ -63,7 +63,6 @@ public class Botania {
 		storageDrawersLoaded = Loader.isModLoaded("StorageDrawers");
 		
 		lightHelper = coloredLightsLoaded ? new LightHelperColored() : new LightHelperVanilla();
-
 		proxy.preInit(event);
 	}
 	@EventHandler

src/main/java/vazkii/botania/common/block/BlockAltGrass.java

@@ -32,7 +32,7 @@ import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.Botania;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -57,7 +57,7 @@ public class BlockAltGrass extends BlockMod implements ILexiconable {
 	
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/BlockLivingrock.java

@@ -25,7 +25,7 @@ import net.minecraft.world.World;
 import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -55,7 +55,7 @@ public class BlockLivingrock extends BlockMod implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/BlockLivingwood.java

@@ -26,7 +26,7 @@ import net.minecraft.world.World;
 import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -64,7 +64,7 @@ public class BlockLivingwood extends BlockMod implements ILexiconable {
 	}
 
 	void register(String name) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, name);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, name);
 	}
 
 	@Override

src/main/java/vazkii/botania/common/block/BlockMod.java

@@ -13,11 +13,14 @@ package vazkii.botania.common.block;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.world.IBlockAccess;
 import vazkii.botania.api.recipe.IElvenItem;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.core.BotaniaCreativeTab;
+import vazkii.botania.common.core.handler.ConfigHandler;
 import vazkii.botania.common.item.block.ItemBlockElven;
-import vazkii.botania.common.item.block.ItemBlockMod;
+import vazkii.botania.common.item.block.ItemCubeMod;
 import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
@@ -35,7 +38,7 @@ public class BlockMod extends Block {
 	@Override
 	public Block setBlockName(String par1Str) {
 		if(shouldRegisterInNameSet())
-			GameRegistry.registerBlock(this, this instanceof IElvenItem ? ItemBlockElven.class : ItemBlockMod.class, par1Str);
+			GameRegistry.registerBlock(this, this instanceof IElvenItem ? ItemBlockElven.class : ItemCubeMod.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 
@@ -59,5 +62,9 @@ public class BlockMod extends Block {
 		return true;
 	}
 
+	@Override
+	public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+		return !ConfigHandler.noMobSpawnOnBlocks;
+	}
 
 }

src/main/java/vazkii/botania/common/block/BlockModContainer.java

@@ -14,10 +14,13 @@ 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.EnumCreatureType;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.core.BotaniaCreativeTab;
+import vazkii.botania.common.core.handler.ConfigHandler;
 import vazkii.botania.common.item.block.ItemBlockMod;
 import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.relauncher.Side;
@@ -63,4 +66,8 @@ public abstract class BlockModContainer<T extends TileEntity> extends BlockConta
 	@Override
 	public abstract T createNewTileEntity(World world, int meta);
 
+	@Override
+	public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+		return !ConfigHandler.noMobSpawnOnBlocks;
+	}
 }

src/main/java/vazkii/botania/common/block/BlockOpenCrate.java

@@ -42,7 +42,7 @@ import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.block.tile.TileCraftCrate;
 import vazkii.botania.common.block.tile.TileOpenCrate;
 import vazkii.botania.common.block.tile.TileSimpleInventory;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -76,7 +76,7 @@ public class BlockOpenCrate extends BlockModContainer implements ILexiconable, I
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/BlockPlatform.java

@@ -29,7 +29,7 @@ import vazkii.botania.api.wand.IWandable;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.block.tile.TileCamo;
 import vazkii.botania.common.block.tile.TilePlatform;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -59,7 +59,7 @@ public class BlockPlatform extends BlockCamo implements ILexiconable, IWandable
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/BlockSpecialFlower.java

@@ -176,12 +176,13 @@ public class BlockSpecialFlower extends BlockFlower implements ITileEntityProvid
 	}
 
 	@Override
-	public IIcon getIcon(IBlockAccess par1iBlockAccess, int par2, int par3, int par4, int par5) {
-		return ((TileSpecialFlower) par1iBlockAccess.getTileEntity(par2, par3, par4)).getIcon();
+	public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
+		final TileSpecialFlower flower = (TileSpecialFlower) world.getTileEntity(x, y, z);
+		return flower != null ? flower.getIcon() : BlockModFlower.icons[16];
 	}
 
 	@Override
-	public IIcon getIcon(int par1, int par2) {
+	public IIcon getIcon(int side, int meta) {
 		return BlockModFlower.icons[16];
 	}
 

src/main/java/vazkii/botania/common/block/decor/Block18Stone.java

@@ -26,7 +26,7 @@ import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.block.BlockMod;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -72,7 +72,7 @@ public class Block18Stone extends BlockMod implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/BlockCustomBrick.java

@@ -26,7 +26,7 @@ import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.block.BlockMod;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -56,7 +56,7 @@ public class BlockCustomBrick extends BlockMod implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/BlockEndStoneBrick.java

@@ -26,7 +26,7 @@ import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.block.BlockMod;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -73,7 +73,7 @@ public class BlockEndStoneBrick extends BlockMod implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/BlockPavement.java

@@ -23,7 +23,7 @@ import net.minecraft.util.MovingObjectPosition;
 import net.minecraft.world.World;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.block.BlockMod;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.relauncher.Side;
@@ -54,7 +54,7 @@ public class BlockPavement extends BlockMod {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/BlockPetalBlock.java

@@ -25,7 +25,7 @@ import net.minecraft.world.World;
 import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.common.block.BlockMod;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -52,7 +52,7 @@ public class BlockPetalBlock extends BlockMod implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/BlockPrismarine.java

@@ -30,7 +30,7 @@ import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.client.render.block.InterpolatedIcon;
 import vazkii.botania.common.block.BlockMod;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
@@ -64,7 +64,7 @@ public class BlockPrismarine extends BlockMod implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/BlockReeds.java

@@ -22,7 +22,7 @@ import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.core.BotaniaCreativeTab;
-import vazkii.botania.common.item.block.ItemBlockMod;
+import vazkii.botania.common.item.block.ItemCubeMod;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.lib.LibBlockNames;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -44,7 +44,7 @@ public class BlockReeds extends BlockRotatedPillar implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockMod.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeMod.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/biomestone/BlockBiomeStone.java

@@ -26,7 +26,7 @@ import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.client.core.helper.IconHelper;
 import vazkii.botania.common.block.BlockMod;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import vazkii.botania.common.lexicon.LexiconData;
 import cpw.mods.fml.common.registry.GameRegistry;
 
@@ -75,7 +75,7 @@ public class BlockBiomeStone extends BlockMod implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/slabs/BlockModSlab.java

@@ -5,14 +5,17 @@ import java.util.Random;
 import net.minecraft.block.BlockSlab;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.entity.EnumCreatureType;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.common.core.BotaniaCreativeTab;
+import vazkii.botania.common.core.handler.ConfigHandler;
 import vazkii.botania.common.item.block.ItemBlockModSlab;
 import vazkii.botania.common.lexicon.LexiconData;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -76,5 +79,8 @@ public abstract class BlockModSlab extends BlockSlab implements ILexiconable {
 	public LexiconEntry getEntry(World world, int x, int y, int z, EntityPlayer player, ItemStack lexicon) {
 		return LexiconData.decorativeBlocks;
 	}
-
+	@Override
+	public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
+		return !ConfigHandler.noMobSpawnOnBlocks;
+	}
 }

src/main/java/vazkii/botania/common/block/decor/stairs/BlockModStairs.java

@@ -8,7 +8,7 @@ import net.minecraft.world.World;
 import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
 import vazkii.botania.common.core.BotaniaCreativeTab;
-import vazkii.botania.common.item.block.ItemBlockMod;
+import vazkii.botania.common.item.block.ItemCubeMod;
 import vazkii.botania.common.lexicon.LexiconData;
 import cpw.mods.fml.common.registry.GameRegistry;
 
@@ -23,7 +23,7 @@ public class BlockModStairs extends BlockStairs implements ILexiconable {
 
 	@Override
 	public Block setBlockName(String par1Str) {
-		GameRegistry.registerBlock(this, ItemBlockMod.class, par1Str);
+		GameRegistry.registerBlock(this, ItemCubeMod.class, par1Str);
 		return super.setBlockName(par1Str);
 	}
 

src/main/java/vazkii/botania/common/block/decor/walls/BlockModWall.java

@@ -23,7 +23,7 @@ import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 import vazkii.botania.api.lexicon.ILexiconable;
 import vazkii.botania.api.lexicon.LexiconEntry;
-import vazkii.botania.common.item.block.ItemBlockMod;
+import vazkii.botania.common.item.block.ItemCubeMod;
 import vazkii.botania.common.lexicon.LexiconData;
 import cpw.mods.fml.common.registry.GameRegistry;
 
@@ -51,7 +51,7 @@ public class BlockModWall extends BlockWall implements ILexiconable {
 	}
 
 	public void register(String name) {
-		GameRegistry.registerBlock(this, ItemBlockMod.class, name);
+		GameRegistry.registerBlock(this, ItemCubeMod.class, name);
 	}
 
 	@Override

src/main/java/vazkii/botania/common/block/decor/walls/BlockVariantWall.java

@@ -17,7 +17,7 @@ import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
-import vazkii.botania.common.item.block.ItemBlockWithMetadataAndName;
+import vazkii.botania.common.item.block.ItemCubeWithMetadataAndName;
 import cpw.mods.fml.common.registry.GameRegistry;
 
 public class BlockVariantWall extends BlockModWall {
@@ -37,7 +37,7 @@ public class BlockVariantWall extends BlockModWall {
 
 	@Override
 	public void register(String name) {
-		GameRegistry.registerBlock(this, ItemBlockWithMetadataAndName.class, name);
+		GameRegistry.registerBlock(this, ItemCubeWithMetadataAndName.class, name);
 	}
 
 	@Override

src/main/java/vazkii/botania/common/block/mana/BlockPool.java

@@ -92,7 +92,9 @@ public class BlockPool extends BlockModContainer implements IWandHUD, IWandable,
 	@Override
 	public void breakBlock(World par1World, int par2, int par3, int par4, Block par5, int par6) {
 		TilePool pool = (TilePool) par1World.getTileEntity(par2, par3, par4);
-		lastFragile = pool.fragile;
+		if (pool != null) {
+			lastFragile = pool.fragile;
+		}
 		super.breakBlock(par1World, par2, par3, par4, par5, par6);
 	}
 

src/main/java/vazkii/botania/common/block/tile/TileAlfPortal.java

@@ -10,17 +10,21 @@
  */
 package vazkii.botania.common.block.tile;
 
+import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Deque;
 import java.util.List;
 
 import net.minecraft.block.Block;
 import net.minecraft.entity.item.EntityItem;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.AxisAlignedBB;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.oredict.OreDictionary;
 import vazkii.botania.api.BotaniaAPI;
 import vazkii.botania.api.lexicon.ILexicon;
 import vazkii.botania.api.lexicon.multiblock.Multiblock;
@@ -61,16 +65,20 @@ public class TileAlfPortal extends TileMod {
 
 	private static final String TAG_TICKS_OPEN = "ticksOpen";
 	private static final String TAG_TICKS_SINCE_LAST_ITEM = "ticksSinceLastItem";
-	private static final String TAG_STACK_COUNT = "stackCount";
+	private static final String TAG_STACK_COUNT = "stackCount"; // Input stacks
+	private static final String TAG_OUTPUT_COUNT = "outputStackCount";
 	private static final String TAG_STACK = "portalStack";
+	private static final String TAG_OUTPUT_STACK = "outputStack";
 	private static final String TAG_PORTAL_FLAG = "_elvenPortal";
 
-	List<ItemStack> stacksIn = new ArrayList();
+	List<ItemStack> stacksIn = new ArrayList<>();
+	Deque<ItemStack> stacksOut = new ArrayDeque<>();
 
 	public int ticksOpen = 0;
 	int ticksSinceLastItem = 0;
 	private boolean closeNow = false;
 	private boolean hasUnloadedParts = false;
+	private boolean explode = false;
 
 	private static final Function<int[], int[]> CONVERTER_X_Z = new Function<int[], int[]>() {
 		@Override
@@ -142,14 +150,18 @@ public class TileAlfPortal extends TileMod {
 						ItemStack stack = item.getEntityItem();
 						if(stack != null && (!(stack.getItem() instanceof IElvenItem) || !((IElvenItem) stack.getItem()).isElvenItem(stack)) && !item.getEntityData().hasKey(TAG_PORTAL_FLAG)) {
 							item.setDead();
-							addItem(stack);
+							if (validateItemUsage(stack)) {
+								addItem(stack);
+							}
 							ticksSinceLastItem = 0;
 						}
 					}
 
 				if(ticksSinceLastItem >= 4) {
-					if(!worldObj.isRemote)
+					if(!worldObj.isRemote) {
 						resolveRecipes();
+						spawnOutput();
+					}
 				}
 			}
 		} else closeNow = false;
@@ -164,11 +176,40 @@ public class TileAlfPortal extends TileMod {
 				for(int i = 0; i < 36; i++)
 					blockParticle(meta);
 			worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, newMeta, 1 | 2);
+		} else if(explode) {
+			worldObj.createExplosion(null, xCoord + .5, yCoord + 2.0, zCoord + .5, 3f, true);
+			explode = false;
 		}
 
 		hasUnloadedParts = false;
 	}
 
+	private boolean validateItemUsage(ItemStack inputStack) {
+		if (inputStack.getItem() instanceof ILexicon) {
+			// lexicon does not formally have a recipe and is handled in a special branch
+			// in resolveRecipe(), therefore it needs a special branch here as well
+			return true;
+		}
+		for(RecipeElvenTrade recipe : BotaniaAPI.elvenTradeRecipes) {
+			for(Object o : recipe.getInputs()) {
+				if(o instanceof String) {
+					for(ItemStack target : OreDictionary.getOres((String) o)) {
+						if(OreDictionary.itemMatches(target, inputStack, false))
+							return true;
+					}
+				} else if(o instanceof ItemStack) {
+					ItemStack target = (ItemStack) o;
+					if(inputStack.getItem() == target.getItem() && inputStack.getItemDamage() == target.getItemDamage())
+						return true;
+				}
+			}
+		}
+		if(inputStack.getItem() == Items.bread) //Don't teleport bread. (See also: #2403)
+			explode = true;
+
+		return false;
+	}
+
 	private void blockParticle(int meta) {
 		int i = worldObj.rand.nextInt(AIR_POSITIONS.length);
 		double[] pos = new double[] {
@@ -210,12 +251,16 @@ public class TileAlfPortal extends TileMod {
 	}
 
 	void resolveRecipes() {
+		if (stacksIn.isEmpty()) {
+			return;
+		}
+
 		int i = 0;
 		for(ItemStack stack : stacksIn) {
 			if(stack != null && stack.getItem() instanceof ILexicon) {
 				((ILexicon) stack.getItem()).unlockKnowledge(stack, BotaniaAPI.elvenKnowledge);
 				ItemLexicon.setForcedPage(stack, LexiconData.elvenMessage.getUnlocalizedName());
-				spawnItem(stack);
+				addOutput(stack);
 				stacksIn.remove(i);
 				return;
 			}
@@ -224,9 +269,48 @@ public class TileAlfPortal extends TileMod {
 
 		for(RecipeElvenTrade recipe : BotaniaAPI.elvenTradeRecipes) {
 			if(recipe.matches(stacksIn, false)) {
-				recipe.matches(stacksIn, true);
-				spawnItem(recipe.getOutput().copy());
-				break;
+				ItemStack output = recipe.getOutput().copy();
+				int stackSize = output.stackSize;
+				output.stackSize = 0;
+				while (recipe.matches(stacksIn, true)) {
+					output.stackSize += stackSize;
+				}
+				addOutput(output);
+				if (stacksIn.isEmpty()) break;
+			}
+		}
+	}
+
+	void addOutput(ItemStack stack) {
+		if (stack == null) {
+			return;
+		}
+		if (stacksOut.isEmpty()) {
+			stacksOut.addLast(stack);
+			return;
+		}
+
+		ItemStack lastStack = stacksOut.getLast();
+		if (stack.isItemEqual(lastStack)) {
+			lastStack.stackSize += stack.stackSize;
+		} else {
+			stacksOut.addLast(stack);
+		}
+	}
+
+	void spawnOutput() {
+		if (!stacksOut.isEmpty()) {
+			ItemStack stack = stacksOut.getFirst();
+			if (stack.stackSize > 1) {
+				--stack.stackSize;
+				stack = stack.copy();
+				stack.stackSize = 1;
+				spawnItem(stack);
+			} else if (stack.stackSize == 1) {
+				stacksOut.removeFirst();
+				spawnItem(stack);
+			} else {
+				stacksOut.removeFirst();
 			}
 		}
 	}
@@ -250,6 +334,15 @@ public class TileAlfPortal extends TileMod {
 			cmp.setTag(TAG_STACK + i, stackcmp);
 			i++;
 		}
+
+		cmp.setInteger(TAG_OUTPUT_COUNT, stacksOut.size());
+		i = 0;
+		for(ItemStack stack : stacksOut) {
+			NBTTagCompound stackcmp = new NBTTagCompound();
+			stack.writeToNBT(stackcmp);
+			cmp.setTag(TAG_OUTPUT_STACK + i, stackcmp);
+			i++;
+		}
 	}
 
 	@Override
@@ -263,6 +356,14 @@ public class TileAlfPortal extends TileMod {
 			ItemStack stack = ItemStack.loadItemStackFromNBT(stackcmp);
 			stacksIn.add(stack);
 		}
+
+		count = cmp.getInteger(TAG_OUTPUT_COUNT);
+		stacksOut.clear();
+		for(int i = 0; i < count; i++) {
+			NBTTagCompound stackcmp = cmp.getCompoundTag(TAG_OUTPUT_STACK + i);
+			ItemStack stack = ItemStack.loadItemStackFromNBT(stackcmp);
+			stacksOut.addLast(stack);
+		}
 	}
 
 	@Override

src/main/java/vazkii/botania/common/block/tile/TileCraftCrate.java

@@ -10,14 +10,11 @@
  */
 package vazkii.botania.common.block.tile;
 
-import java.util.List;
-
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.inventory.Container;
 import net.minecraft.inventory.InventoryCrafting;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.CraftingManager;
-import net.minecraft.item.crafting.IRecipe;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.network.NetworkManager;
 import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
@@ -125,23 +122,20 @@ public class TileCraftCrate extends TileOpenCrate {
 			craft.setInventorySlotContents(i, stack.copy());
 		}
 
-		List<IRecipe> recipes = CraftingManager.getInstance().getRecipeList();
-		for(IRecipe recipe : recipes)
-			if(recipe.matches(craft, worldObj)) {
-				setInventorySlotContents(9, recipe.getCraftingResult(craft));
+		ItemStack result = CraftingManager.getInstance().findMatchingRecipe(craft, worldObj);
+		if (result == null) return false;
+		
+		setInventorySlotContents(9, result);
+		for(int i = 0; i < 9; i++) {
+			ItemStack stack = getStackInSlot(i);
+			if(stack == null)
+				continue;
 
-				for(int i = 0; i < 9; i++) {
-					ItemStack stack = getStackInSlot(i);
-					if(stack == null)
-						continue;
-
-					ItemStack container = stack.getItem().getContainerItem(stack);
-					setInventorySlotContents(i, container);
-				}
-				return true;
-			}
-
-		return false;
+			ItemStack container = stack.getItem().getContainerItem(stack);
+			setInventorySlotContents(i, container);
+		}
+		
+		return true;
 	}
 
 	boolean isFull() {

src/main/java/vazkii/botania/common/brew/potion/PotionBloodthirst.java

@@ -11,6 +11,7 @@
 package vazkii.botania.common.brew.potion;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 import net.minecraft.entity.monster.IMob;
 import net.minecraft.entity.player.EntityPlayer;
@@ -31,17 +32,20 @@ public class PotionBloodthirst extends PotionMod {
 		super(ConfigHandler.potionIDBloodthirst, LibPotionNames.BLOODTHIRST, false, 0xC30000, 3);
 		MinecraftForge.EVENT_BUS.register(this);
 	}
-
 	@SubscribeEvent
 	public void onSpawn(LivingSpawnEvent.CheckSpawn event) {
-		if(event.getResult() != Result.ALLOW && event.entityLiving instanceof IMob) {
-			List<EntityPlayer> players = event.world.getEntitiesWithinAABB(EntityPlayer.class, AxisAlignedBB.getBoundingBox(event.x - RANGE, event.y - RANGE, event.z - RANGE, event.x + RANGE, event.y + RANGE, event.z + RANGE));
-			for(EntityPlayer player : players)
+		if (event.getResult() != Result.ALLOW && event.entityLiving instanceof IMob) {
+			double rangeSq = RANGE * RANGE;
+			List<EntityPlayer> players = (List<EntityPlayer>) event.world.playerEntities.stream()
+					.filter(player -> ((EntityPlayer) player).getDistanceSq(event.x, event.y, event.z) <= rangeSq)
+					.map(player -> (EntityPlayer) player)
+					.collect(Collectors.toList());
+			for (EntityPlayer player : players) {
 				if(hasEffect(player) && !hasEffect(player, ModPotions.emptiness)) {
 					event.setResult(Result.ALLOW);
 					return;
 				}
+			}
 		}
 	}
-
 }

src/main/java/vazkii/botania/common/brew/potion/PotionEmptiness.java

@@ -11,6 +11,7 @@
 package vazkii.botania.common.brew.potion;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 import net.minecraft.entity.monster.IMob;
 import net.minecraft.entity.player.EntityPlayer;
@@ -33,14 +34,18 @@ public class PotionEmptiness extends PotionMod {
 
 	@SubscribeEvent
 	public void onSpawn(LivingSpawnEvent.CheckSpawn event) {
-		if(event.getResult() != Result.ALLOW && event.entityLiving instanceof IMob) {
-			List<EntityPlayer> players = event.world.getEntitiesWithinAABB(EntityPlayer.class, AxisAlignedBB.getBoundingBox(event.x - RANGE, event.y - RANGE, event.z - RANGE, event.x + RANGE, event.y + RANGE, event.z + RANGE));
-			for(EntityPlayer player : players)
-				if(hasEffect(player)) {
+		if (event.getResult() != Result.ALLOW && event.entityLiving instanceof IMob) {
+			double rangeSq = RANGE * RANGE;
+			List<EntityPlayer> players = (List<EntityPlayer>) event.world.playerEntities.stream()
+					.filter(player -> ((EntityPlayer) player).getDistanceSq(event.x, event.y, event.z) <= rangeSq)
+					.map(player -> (EntityPlayer) player)
+					.collect(Collectors.toList());
+			for (EntityPlayer player : players) {
+				if (hasEffect(player)) {
 					event.setResult(Result.DENY);
 					return;
 				}
+			}
 		}
 	}
-
 }

src/main/java/vazkii/botania/common/core/handler/BiomeDecorationHandler.java

@@ -23,6 +23,8 @@ import cpw.mods.fml.common.eventhandler.Event.Result;
 import cpw.mods.fml.common.eventhandler.EventPriority;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 
+import java.util.Arrays;
+
 public class BiomeDecorationHandler {
 
 	@SubscribeEvent(priority = EventPriority.LOWEST)
@@ -37,47 +39,73 @@ public class BiomeDecorationHandler {
 			if(!flowers)
 				return;
 
-			int dist = Math.min(8, Math.max(1, ConfigHandler.flowerPatchSize));
-			for(int i = 0; i < ConfigHandler.flowerQuantity; i++) {
-				if(event.rand.nextInt(ConfigHandler.flowerPatchChance) == 0) {
-					int x = event.chunkX + event.rand.nextInt(16) + 8;
-					int z = event.chunkZ + event.rand.nextInt(16) + 8;
-					int y = event.world.getTopSolidOrLiquidBlock(x, z);
+			if (ConfigHandler.flowerDimensionWhitelist.length == 0
+				|| Arrays.stream(ConfigHandler.flowerDimensionWhitelist).anyMatch(
+					d -> d == event.world.provider.dimensionId
+			)) {
+				if (Arrays.stream(ConfigHandler.flowerDimensionBlacklist).noneMatch(
+					d -> d == event.world.provider.dimensionId
+				)) {
+					generateFlowers(event);
+				}
+			}
 
-					int color = event.rand.nextInt(16);
-					boolean primus = event.rand.nextInt(380) == 0;
+			if (ConfigHandler.mushroomDimensionWhitelist.length == 0
+				|| Arrays.stream(ConfigHandler.mushroomDimensionWhitelist).anyMatch(
+					d -> d == event.world.provider.dimensionId
+			)) {
+				if (Arrays.stream(ConfigHandler.mushroomDimensionBlacklist).noneMatch(
+					d -> d == event.world.provider.dimensionId
+				)) {
+					generateMushrooms(event);
+				}
+			}
+		}
+	}
 
-					for(int j = 0; j < ConfigHandler.flowerDensity * ConfigHandler.flowerPatchChance; j++) {
-						int x1 = x + event.rand.nextInt(dist * 2) - dist;
-						int y1 = y + event.rand.nextInt(4) - event.rand.nextInt(4);
-						int z1 = z + event.rand.nextInt(dist * 2) - dist;
+	private void generateFlowers(DecorateBiomeEvent.Decorate event) {
+		int dist = Math.min(8, Math.max(1, ConfigHandler.flowerPatchSize));
+		for(int i = 0; i < ConfigHandler.flowerQuantity; i++) {
+			if(event.rand.nextInt(ConfigHandler.flowerPatchChance) == 0) {
+				int x = event.chunkX + event.rand.nextInt(16) + 8;
+				int z = event.chunkZ + event.rand.nextInt(16) + 8;
+				int y = event.world.getTopSolidOrLiquidBlock(x, z);
 
-						if(event.world.isAirBlock(x1, y1, z1) && (!event.world.provider.hasNoSky || y1 < 127) && ModBlocks.flower.canBlockStay(event.world, x1, y1, z1)) {
-							if(primus) {
-								event.world.setBlock(x1, y1, z1, ModBlocks.specialFlower, 0, 2);
-								TileSpecialFlower flower = (TileSpecialFlower) event.world.getTileEntity(x1, y1, z1);
-								flower.setSubTile(event.rand.nextBoolean() ? LibBlockNames.SUBTILE_NIGHTSHADE_PRIME : LibBlockNames.SUBTILE_DAYBLOOM_PRIME);
-								SubTileDaybloom subtile = (SubTileDaybloom) flower.getSubTile();
-								subtile.setPrimusPosition();
-							} else {
-								event.world.setBlock(x1, y1, z1, ModBlocks.flower, color, 2);
-								if(event.rand.nextDouble() < ConfigHandler.flowerTallChance && ((BlockModFlower) ModBlocks.flower).func_149851_a(event.world, x1, y1, z1, false))
-									BlockModFlower.placeDoubleFlower(event.world, x1, y1, z1, color, 0);
-							}
+				int color = event.rand.nextInt(16);
+				boolean primus = event.rand.nextInt(380) == 0;
+
+				for(int j = 0; j < ConfigHandler.flowerDensity * ConfigHandler.flowerPatchChance; j++) {
+					int x1 = x + event.rand.nextInt(dist * 2) - dist;
+					int y1 = y + event.rand.nextInt(4) - event.rand.nextInt(4);
+					int z1 = z + event.rand.nextInt(dist * 2) - dist;
+
+					if(event.world.isAirBlock(x1, y1, z1) && (!event.world.provider.hasNoSky || y1 < 127) && ModBlocks.flower.canBlockStay(event.world, x1, y1, z1)) {
+						if(primus) {
+							event.world.setBlock(x1, y1, z1, ModBlocks.specialFlower, 0, 2);
+							TileSpecialFlower flower = (TileSpecialFlower) event.world.getTileEntity(x1, y1, z1);
+							flower.setSubTile(event.rand.nextBoolean() ? LibBlockNames.SUBTILE_NIGHTSHADE_PRIME : LibBlockNames.SUBTILE_DAYBLOOM_PRIME);
+							SubTileDaybloom subtile = (SubTileDaybloom) flower.getSubTile();
+							subtile.setPrimusPosition();
+						} else {
+							event.world.setBlock(x1, y1, z1, ModBlocks.flower, color, 2);
+							if(event.rand.nextDouble() < ConfigHandler.flowerTallChance && ((BlockModFlower) ModBlocks.flower).func_149851_a(event.world, x1, y1, z1, false))
+								BlockModFlower.placeDoubleFlower(event.world, x1, y1, z1, color, 0);
 						}
 					}
 				}
 			}
+		}
+	}
 
-			for(int i = 0; i < ConfigHandler.mushroomQuantity; i++) {
-				int x = event.chunkX + event.rand.nextInt(16) + 8;
-				int z = event.chunkZ + event.rand.nextInt(16) + 8;
-				int y = event.rand.nextInt(26) + 4;
+	private void generateMushrooms(DecorateBiomeEvent.Decorate event) {
+		for(int i = 0; i < ConfigHandler.mushroomQuantity; i++) {
+			int x = event.chunkX + event.rand.nextInt(16) + 8;
+			int z = event.chunkZ + event.rand.nextInt(16) + 8;
+			int y = event.rand.nextInt(26) + 4;
 
-				int color = event.rand.nextInt(16);
-				if(event.world.isAirBlock(x, y, z) && ModBlocks.mushroom.canBlockStay(event.world, x, y, z))
-					event.world.setBlock(x, y, z, ModBlocks.mushroom, color, 2);
-			}
+			int color = event.rand.nextInt(16);
+			if(event.world.isAirBlock(x, y, z) && ModBlocks.mushroom.canBlockStay(event.world, x, y, z))
+				event.world.setBlock(x, y, z, ModBlocks.mushroom, color, 2);
 		}
 	}
 }

src/main/java/vazkii/botania/common/core/handler/ConfigHandler.java

@@ -11,10 +11,13 @@
 package vazkii.botania.common.core.handler;
 
 import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.ArrayList;
+import java.util.stream.Collectors;
 
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.potion.Potion;
@@ -24,7 +27,6 @@ import net.minecraft.util.ChatStyle;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraftforge.common.config.Configuration;
 import net.minecraftforge.common.config.Property;
-import vazkii.botania.common.Botania;
 import vazkii.botania.common.lib.LibMisc;
 import vazkii.botania.common.lib.LibPotionNames;
 import cpw.mods.fml.client.event.ConfigChangedEvent;
@@ -41,9 +43,10 @@ public final class ConfigHandler {
 
 	public static int hardcorePassiveGeneration = 72000;
 
+	public static boolean noMobSpawnOnBlocks = true;
 	public static boolean useAdaptativeConfig = true;
 
-	public static boolean enableDefaultRecipes = false;
+	public static boolean enableDefaultRecipes = true;
 
 	public static boolean useShaders = true;
 	public static boolean lexiconRotatingItems = true;
@@ -66,6 +69,8 @@ public final class ConfigHandler {
 	public static boolean enableArmorModels = true;
 	public static boolean enableFancySkybox = true;
 	public static boolean enableFancySkyboxInNormalWorlds = false;
+	public static boolean enableFancySkyboxInDimension = false;
+	public static HashSet<Integer> fancySkyboxDimensions = new HashSet<Integer>() {};
 	
 	public static int manaBarHeight = 29;
 	public static int flightBarHeight = 49;
@@ -94,13 +99,18 @@ public final class ConfigHandler {
 	public static int harvestLevelWeight = 2;
 	public static int harvestLevelBore = 3;
 
-	public static int flowerQuantity = 0;
+	public static int flowerQuantity = 2;
 	public static int flowerDensity = 2;
 	public static int flowerPatchSize = 6;
 	public static int flowerPatchChance = 16;
 	public static double flowerTallChance = 0.05;
 	public static int mushroomQuantity = 40;
 
+	public static int[] flowerDimensionWhitelist = new int[]{};
+	public static int[] flowerDimensionBlacklist = new int[]{};
+	public static int[] mushroomDimensionWhitelist = new int[]{};
+	public static int[] mushroomDimensionBlacklist = new int[]{};
+
 	private static boolean verifiedPotionArray = false;
 	private static int potionArrayLimit = 0;
 
@@ -127,6 +137,9 @@ public final class ConfigHandler {
 		useAdaptativeConfig = loadPropBool("adaptativeConfig.enabled", desc, useAdaptativeConfig);
 		adaptor = new ConfigAdaptor(useAdaptativeConfig);
 
+		desc = "Mobs cannot Spawn on Blocks";
+		noMobSpawnOnBlocks = loadPropBool("noMobSpawnOnBlocks", desc, noMobSpawnOnBlocks);
+
 		desc = "Set this to false to disable the use of shaders for some of the mod's renders.";
 		useShaders = loadPropBool("shaders.enabled", desc, useShaders);
 
@@ -189,7 +202,13 @@ public final class ConfigHandler {
 		
 		desc = "Set this to true to enable the fancy skybox in non Garden of Glass worlds. (Does not require Garden of Glass loaded to use, needs 'fancySkybox.enable' to be true as well)";
 		enableFancySkyboxInNormalWorlds = loadPropBool("fancySkybox.normalWorlds", desc, enableFancySkyboxInNormalWorlds);
-		
+
+		desc = "Set this to true to enable the fancy skybox in custom dimension. (Does not require Garden of Glass loaded to use, needs 'fancySkybox.enable' to be true as well)";
+		enableFancySkyboxInDimension = loadPropBool("fancySkybox.customDim", desc, enableFancySkyboxInDimension);
+
+		desc = "The ID of the dimension to use";
+		fancySkyboxDimensions = loadPropIntSet("fancySkybox.customDimID", desc, fancySkyboxDimensions);
+
 		desc = "The height of the mana display bar in above the XP bar. You can change this if you have a mod that changes where the XP bar is.";
 		manaBarHeight = loadPropInt("manaBar.height", desc, manaBarHeight);
 
@@ -286,6 +305,18 @@ public final class ConfigHandler {
 		desc = "Enables all built-in recipes. This can be false for expert modpacks that wish to supply their own.";
 		enableDefaultRecipes = loadPropBool("recipes.enabled", desc, enableDefaultRecipes);
 
+		desc = "Whitelist of which dimension generates Botania flowers. Empty means any dimension can.";
+		flowerDimensionWhitelist = loadPropIntArray("worldgen.flower.dimensionWhitelist", desc, flowerDimensionWhitelist);
+
+		desc = "Blacklist of which dimension generates Botania flowers.";
+		flowerDimensionBlacklist = loadPropIntArray("worldgen.flower.dimensionBlacklist", desc, flowerDimensionBlacklist);
+
+		desc = "Whitelist of which dimension generates Botania mushrooms. Empty means any dimension can.";
+		mushroomDimensionWhitelist = loadPropIntArray("worldgen.mushroom.dimensionWhitelist", desc, mushroomDimensionWhitelist);
+
+		desc = "Blacklist of which dimension generates Botania mushrooms.";
+		mushroomDimensionBlacklist = loadPropIntArray("worldgen.mushroom.dimensionBlacklist", desc, mushroomDimensionBlacklist);
+
 		potionIDSoulCross = loadPropPotionId(LibPotionNames.SOUL_CROSS, potionIDSoulCross);
 		potionIDFeatherfeet = loadPropPotionId(LibPotionNames.FEATHER_FEET, potionIDFeatherfeet);
 		potionIDEmptiness = loadPropPotionId(LibPotionNames.EMPTINESS, potionIDEmptiness);
@@ -334,6 +365,29 @@ public final class ConfigHandler {
 		return prop.getBoolean(default_);
 	}
 
+	public static int[] loadPropIntArray(String propName, String desc, int[] intArray) {
+		Property prop = config.get(Configuration.CATEGORY_GENERAL, propName, intArray);
+		prop.comment = desc;
+
+		if(adaptor != null)
+			adaptor.adaptPropertyIntArray(prop, prop.getIntList());
+
+		return prop.getIntList();
+	}
+
+	public static HashSet<Integer> loadPropIntSet(String propName, String desc, HashSet<Integer> intSet) {
+		int[] defaultValues = intSet.stream().mapToInt(Number::intValue).toArray();
+		Property prop = config.get(Configuration.CATEGORY_GENERAL, propName, defaultValues);
+		prop.comment = desc;
+
+		if(adaptor != null)
+			adaptor.adaptPropertyIntArray(prop, prop.getIntList());
+
+		return Arrays.stream(prop.getIntList())
+				.boxed()
+				.collect(Collectors.toCollection(HashSet::new));
+	}
+
 	public static int loadPropPotionId(String propName, int default_) {
 		if(!verifiedPotionArray)
 			verifyPotionArray();
@@ -455,6 +509,10 @@ public final class ConfigHandler {
 			this.<Boolean>adaptProperty(prop, val);
 		}
 
+		public void adaptPropertyIntArray(Property prop, int[] val) {
+			this.<int[]>adaptProperty(prop, val);
+		}
+
 		public static class AdaptableValue<T> {
 
 			public final int version;

src/main/java/vazkii/botania/common/core/handler/ManaNetworkHandler.java

@@ -18,6 +18,7 @@ import java.util.WeakHashMap;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.ChunkCoordinates;
 import net.minecraft.world.World;
+import net.minecraftforge.event.world.WorldEvent;
 import vazkii.botania.api.internal.IManaNetwork;
 import vazkii.botania.api.mana.ManaNetworkEvent;
 import vazkii.botania.api.mana.ManaNetworkEvent.Action;
@@ -30,8 +31,8 @@ public final class ManaNetworkHandler implements IManaNetwork {
 
 	public static final ManaNetworkHandler instance = new ManaNetworkHandler();
 
-	public WeakHashMap<World, List<TileSignature>> manaPools = new WeakHashMap();
-	public WeakHashMap<World, List<TileSignature>> manaCollectors = new WeakHashMap();
+	public WeakHashMap<World, List<TileSignature>> manaPools = new WeakHashMap<>();
+	public WeakHashMap<World, List<TileSignature>> manaCollectors = new WeakHashMap<>();
 
 	@SubscribeEvent
 	public void onNetworkEvent(ManaNetworkEvent event) {
@@ -124,11 +125,11 @@ public final class ManaNetworkHandler implements IManaNetwork {
 
 		List<TileSignature> tiles;
 		if(!map.containsKey(world))
-			map.put(world, new ArrayList());
+			map.put(world, new ArrayList<>());
 
 		tiles = map.get(world);
 
-		if(!tiles.contains(tile))
+		if(tiles.stream().noneMatch(s -> s.tile == tile))
 			tiles.add(new TileSignature(tile, tile.getWorldObj().isRemote));
 	}
 
@@ -144,10 +145,15 @@ public final class ManaNetworkHandler implements IManaNetwork {
 
 	private List<TileSignature> getAllInWorld(Map<World, List<TileSignature>> map, World world) {
 		if(!map.containsKey(world))
-			return new ArrayList();
+			return new ArrayList<>();
 
 		return map.get(world);
 	}
 
-
+	@SubscribeEvent
+	public void onWorldRemoved(WorldEvent.Unload e) {
+		World world = e.world;
+		manaPools.remove(world);
+		manaCollectors.remove(world);
+	}
 }

src/main/java/vazkii/botania/common/core/helper/InventoryHelper.java

@@ -28,6 +28,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.tileentity.TileEntityChest;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.oredict.OreDictionary;
 
 //From OpenBlocksLib: https://github.com/OpenMods/OpenModsLib
 public class InventoryHelper {
@@ -205,6 +206,21 @@ public class InventoryHelper {
 		return slots;
 	}
 
+	public static ItemStack cycleItemStackForDisplay(Object input) {
+		if (input instanceof ItemStack) return (ItemStack) input;
+		List<ItemStack> items = null;
+		if (input instanceof List) {
+			items = (List<ItemStack>) input;
+		} else if (input instanceof String) {
+		items = OreDictionary.getOres((String) input);
+		}
+		if (items != null && items.size() > 0) {
+			int index = (int) (System.currentTimeMillis() / 1000L % items.size());
+			return items.get(index);
+		}
+		return null;
+	}
+
 	public static class GenericInventory implements IInventory {
 
 		protected String inventoryTitle;

src/main/java/vazkii/botania/common/core/helper/LokiCursor.java

@@ -0,0 +1,80 @@
+package vazkii.botania.common.core.helper;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ChunkCoordinates;
+
+
+public class LokiCursor {
+    private static final String TAG_X_OFFSET = "xOffset";
+    private static final String TAG_Y_OFFSET = "yOffset";
+    private static final String TAG_Z_OFFSET = "zOffset";
+    private static final String TAG_MIRROR_MODE = "mirror";
+
+    private static final byte xAxisBitmask = 4; //100
+    private static final byte yAxisBitmask = 2; //010
+    private static final byte zAxisBitmask = 1; //001
+
+    private byte mirrorMode;
+    private ChunkCoordinates coordinates;
+
+    public LokiCursor(int x, int y, int z, byte mode){
+        coordinates = new ChunkCoordinates(x,y,z);
+        mirrorMode = mode;
+    }
+
+    public static LokiCursor fromNBT(NBTTagCompound cmp){
+        int x = cmp.getInteger(TAG_X_OFFSET);
+        int y = cmp.getInteger(TAG_Y_OFFSET);
+        int z = cmp.getInteger(TAG_Z_OFFSET);
+        byte mirror = cmp.getByte(TAG_MIRROR_MODE);
+
+        return new LokiCursor(x,y,z,mirror);
+    }
+    public static boolean isMirrorX(byte mirrorMode){
+        return (mirrorMode & xAxisBitmask) > 0;
+    }
+    public static boolean isMirrorY(byte mirrorMode){
+        return (mirrorMode & yAxisBitmask) > 0;
+    }
+    public static boolean isMirrorZ(byte mirrorMode){
+        return (mirrorMode & zAxisBitmask) > 0;
+    }
+    public  NBTTagCompound toNBT() {
+        NBTTagCompound cmp = new NBTTagCompound();
+        cmp.setInteger(TAG_X_OFFSET, coordinates.posX);
+        cmp.setInteger(TAG_Y_OFFSET, coordinates.posY);
+        cmp.setInteger(TAG_Z_OFFSET, coordinates.posZ);
+        cmp.setInteger(TAG_MIRROR_MODE, mirrorMode);
+        return cmp;
+    }
+
+    public int getX(){
+        return coordinates.posX;
+    }
+
+    public int getY(){
+        return coordinates.posY;
+    }
+
+    public int getZ(){
+        return coordinates.posZ;
+    }
+
+    public ChunkCoordinates getCoordinates(){
+        return coordinates;
+    }
+
+    public boolean isMirrorX(){
+        return isMirrorX(mirrorMode);
+    }
+    public boolean isMirrorY(){
+        return isMirrorY(mirrorMode);
+    }
+    public boolean isMirrorZ(){
+        return isMirrorZ(mirrorMode);
+    }
+
+    public boolean isMirror(){
+        return mirrorMode!=0;
+    }
+}

src/main/java/vazkii/botania/common/core/proxy/CommonProxy.java

@@ -79,6 +79,7 @@ import vazkii.botania.common.integration.etfuturum.ModBanners;
 import vazkii.botania.common.item.ModItems;
 import vazkii.botania.common.lexicon.LexiconData;
 import vazkii.botania.common.network.GuiHandler;
+import vazkii.botania.common.network.PacketHandler;
 import vazkii.botania.common.world.SkyblockWorldEvents;
 import vazkii.botania.common.world.WorldTypeSkyblock;
 import cpw.mods.fml.common.FMLCommonHandler;
@@ -116,6 +117,8 @@ public class CommonProxy {
 		ModAchievements.init();
 		ModMultiblocks.init();
 
+		PacketHandler.initPackets();
+
 		if(Botania.etFuturumLoaded)
 			ModBanners.init();
 

src/main/java/vazkii/botania/common/crafting/ModCraftingRecipes.java

@@ -257,6 +257,7 @@ public final class ModCraftingRecipes {
 	public static IRecipe recipeSwapRing;
 	public static IRecipe recipeSnowHorn;
 	public static IRecipe recipeFlowerBag;
+	public static IRecipe recipeShroomBag;
 	public static IRecipe recipePhantomInk;
 	public static IRecipe recipePoolCart;
 	public static IRecipe recipePump;
@@ -1768,6 +1769,13 @@ public final class ModCraftingRecipes {
 				'W', new ItemStack(Blocks.wool, 1, Short.MAX_VALUE));
 		recipeFlowerBag = BotaniaAPI.getLatestAddedRecipe();
 
+		// Mushroom Pouch Recipe
+		GameRegistry.addShapedRecipe(new ItemStack(ModItems.shroomBag),
+				"WPW", "W W", " W ",
+				'P', new ItemStack(ModBlocks.mushroom, 1, Short.MAX_VALUE),
+				'W', new ItemStack(Blocks.wool, 1, Short.MAX_VALUE));
+		recipeShroomBag = BotaniaAPI.getLatestAddedRecipe();
+
 		// Phantom Ink Recipe
 		addShapelessOreDictRecipe(new ItemStack(ModItems.phantomInk, 4), LibOreDict.MANA_PEARL, "dye", "blockGlass", new ItemStack(Items.glass_bottle), new ItemStack(Items.glass_bottle), new ItemStack(Items.glass_bottle), new ItemStack(Items.glass_bottle));
 		recipePhantomInk = BotaniaAPI.getLatestAddedRecipe();

src/main/java/vazkii/botania/common/integration/corporea/WrappedDeepStorage.java

@@ -1,136 +1,136 @@
-/**
- * This class was created by <Vindex>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- */
-package vazkii.botania.common.integration.corporea;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.logging.log4j.Level;
-
-import cpw.mods.fml.common.FMLLog;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.ItemStack;
-import powercrystals.minefactoryreloaded.api.IDeepStorageUnit;
-import vazkii.botania.api.corporea.CorporeaRequest;
-import vazkii.botania.api.corporea.ICorporeaSpark;
-import vazkii.botania.api.corporea.IWrappedInventory;
-
-/**
- * Wrapper for StorageDrawers compatibility.
- *
- */
-public class WrappedDeepStorage extends WrappedInventoryBase {
-
-	private static boolean checkedInterface = false;
-	private static boolean deepStoragePresent = false;
-
-	private IDeepStorageUnit inv;
-
-	private WrappedDeepStorage(IDeepStorageUnit inv, ICorporeaSpark spark) {
-		this.inv = inv;
-		this.spark = spark;
-	}
-
-	@Override
-	public IInventory getWrappedObject() {
-		return (IInventory) inv;
-	}
-
-	@Override
-	public List<ItemStack> countItems(CorporeaRequest request) {
-		return iterateOverStacks(request, false);
-	}
-
-	@Override
-	public List<ItemStack> extractItems(CorporeaRequest request) {
-		return iterateOverStacks(request, true);
-	}
-
-	private List<ItemStack> iterateOverStacks(CorporeaRequest request, boolean doit) {
-		List<ItemStack> stacks = new ArrayList<ItemStack>();
-		boolean removedAny = false;
-
-		ItemStack prototype = inv.getStoredItemType();
-		if(prototype == null) {
-			// for the case of barrel without contents set
-			return stacks;
-		}
-		int storedCount = prototype.stackSize;
-
-		// WARNING: this code is very similar in all implementations of
-		// IWrappedInventory - keep it synch
-		// this code is also near duplicate to WrappedStorageDrawers - keep it
-		// synchronized
-		if(isMatchingItemStack(request.matcher, request.checkNBT, prototype)) {
-			int rem = Math.min(storedCount, request.count == -1 ? storedCount : request.count);
-
-			if(rem > 0) {
-				ItemStack copy = prototype.copy();
-				copy.stackSize = rem;
-				if(doit) {
-					stacks.addAll(breakDownBigStack(copy));
-				} else {
-					stacks.add(copy);
-				}
-			}
-
-			request.foundItems += storedCount;
-			request.extractedItems += rem;
-
-			if(doit && rem > 0) {
-				decreaseStoredCount(inv, rem);
-
-				removedAny = true;
-				if(spark != null)
-					spark.onItemExtracted(prototype);
-			}
-			if(request.count != -1)
-				request.count -= rem;
-		}
-		if(removedAny) {
-			// inv.markDirtyIfNeeded();
-		}
-		return stacks;
-	}
-
-	private void decreaseStoredCount(IDeepStorageUnit inventory, int rem) {
-		inventory.setStoredItemCount(inventory.getStoredItemType().stackSize - rem);
-	}
-
-	/**
-	 * Creates {@link WrappedDeepStorage} if specified inv can be wrapped.
-	 *
-	 * @return wrapped inventory or null if it has incompatible type.
-	 */
-	public static IWrappedInventory wrap(IInventory inv, ICorporeaSpark spark) {
-		if(!isDeepStorageNeeded()) {
-			return null;
-		}
-		return inv instanceof IDeepStorageUnit ? new WrappedDeepStorage((IDeepStorageUnit) inv, spark) : null;
-	}
-
-	/**
-	 * This method checks for presence of Deep Storage API in the pack - if some
-	 * other mod provides IDeepStorageUnit, support for Deep Storage will be
-	 * used. This way we don't have to ship IDeepStorageUnit in Botania jar.
-	 */
-	private static boolean isDeepStorageNeeded() {
-		if(!checkedInterface) {
-			try {
-				deepStoragePresent = (Class.forName("powercrystals.minefactoryreloaded.api.IDeepStorageUnit") != null);
-			} catch (ClassNotFoundException e) {
-				deepStoragePresent = false;
-			}
-			checkedInterface = true;
-			FMLLog.log(Level.INFO, "[Botania] Corporea support for Deep Storage: %b", deepStoragePresent);
-		}
-		return deepStoragePresent;
-	}
-}
+/**
+ * This class was created by <Vindex>. It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ * 
+ * Botania is Open Source and distributed under the
+ * Botania License: http://botaniamod.net/license.php
+ * 
+ */
+package vazkii.botania.common.integration.corporea;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.logging.log4j.Level;
+
+import cpw.mods.fml.common.FMLLog;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import powercrystals.minefactoryreloaded.api.IDeepStorageUnit;
+import vazkii.botania.api.corporea.CorporeaRequest;
+import vazkii.botania.api.corporea.ICorporeaSpark;
+import vazkii.botania.api.corporea.IWrappedInventory;
+
+/**
+ * Wrapper for StorageDrawers compatibility.
+ *
+ */
+public class WrappedDeepStorage extends WrappedInventoryBase {
+
+	private static boolean checkedInterface = false;
+	private static boolean deepStoragePresent = false;
+
+	private IDeepStorageUnit inv;
+
+	private WrappedDeepStorage(IDeepStorageUnit inv, ICorporeaSpark spark) {
+		this.inv = inv;
+		this.spark = spark;
+	}
+
+	@Override
+	public IInventory getWrappedObject() {
+		return (IInventory) inv;
+	}
+
+	@Override
+	public List<ItemStack> countItems(CorporeaRequest request) {
+		return iterateOverStacks(request, false);
+	}
+
+	@Override
+	public List<ItemStack> extractItems(CorporeaRequest request) {
+		return iterateOverStacks(request, true);
+	}
+
+	private List<ItemStack> iterateOverStacks(CorporeaRequest request, boolean doit) {
+		List<ItemStack> stacks = new ArrayList<ItemStack>();
+		boolean removedAny = false;
+
+		ItemStack prototype = inv.getStoredItemType();
+		if(prototype == null) {
+			// for the case of barrel without contents set
+			return stacks;
+		}
+		int storedCount = prototype.stackSize;
+
+		// WARNING: this code is very similar in all implementations of
+		// IWrappedInventory - keep it synch
+		// this code is also near duplicate to WrappedStorageDrawers - keep it
+		// synchronized
+		if(isMatchingItemStack(request.matcher, request.checkNBT, prototype)) {
+			int rem = Math.min(storedCount, request.count == -1 ? storedCount : request.count);
+
+			if(rem > 0) {
+				ItemStack copy = prototype.copy();
+				copy.stackSize = rem;
+				if(doit) {
+					stacks.addAll(breakDownBigStack(copy));
+				} else {
+					stacks.add(copy);
+				}
+			}
+
+			request.foundItems += storedCount;
+			request.extractedItems += rem;
+
+			if(doit && rem > 0) {
+				decreaseStoredCount(inv, rem);
+
+				removedAny = true;
+				if(spark != null)
+					spark.onItemExtracted(prototype);
+			}
+			if(request.count != -1)
+				request.count -= rem;
+		}
+		if(removedAny) {
+			// inv.markDirtyIfNeeded();
+		}
+		return stacks;
+	}
+
+	private void decreaseStoredCount(IDeepStorageUnit inventory, int rem) {
+		inventory.setStoredItemCount(inventory.getStoredItemType().stackSize - rem);
+	}
+
+	/**
+	 * Creates {@link WrappedDeepStorage} if specified inv can be wrapped.
+	 *
+	 * @return wrapped inventory or null if it has incompatible type.
+	 */
+	public static IWrappedInventory wrap(IInventory inv, ICorporeaSpark spark) {
+		if(!isDeepStorageNeeded()) {
+			return null;
+		}
+		return inv instanceof IDeepStorageUnit ? new WrappedDeepStorage((IDeepStorageUnit) inv, spark) : null;
+	}
+
+	/**
+	 * This method checks for presence of Deep Storage API in the pack - if some
+	 * other mod provides IDeepStorageUnit, support for Deep Storage will be
+	 * used. This way we don't have to ship IDeepStorageUnit in Botania jar.
+	 */
+	private static boolean isDeepStorageNeeded() {
+		if(!checkedInterface) {
+			try {
+				deepStoragePresent = (Class.forName("powercrystals.minefactoryreloaded.api.IDeepStorageUnit") != null);
+			} catch (ClassNotFoundException e) {
+				deepStoragePresent = false;
+			}
+			checkedInterface = true;
+			FMLLog.log(Level.INFO, "[Botania] Corporea support for Deep Storage: %b", deepStoragePresent);
+		}
+		return deepStoragePresent;
+	}
+}

src/main/java/vazkii/botania/common/integration/corporea/WrappedIInventory.java

@@ -1,92 +1,92 @@
-/**
- * This class was created by <Vindex>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- */
-package vazkii.botania.common.integration.corporea;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.ItemStack;
-import vazkii.botania.api.corporea.CorporeaHelper;
-import vazkii.botania.api.corporea.CorporeaRequest;
-import vazkii.botania.api.corporea.ICorporeaSpark;
-import vazkii.botania.api.corporea.IWrappedInventory;
-
-public class WrappedIInventory extends WrappedInventoryBase{
-
-	private IInventory inv;
-
-	private WrappedIInventory(IInventory inv, ICorporeaSpark spark) {
-		this.inv = inv;
-		this.spark = spark;
-	}
-
-	@Override
-	public IInventory getWrappedObject() {
-		return inv;
-	}
-
-	@Override
-	public List<ItemStack> countItems(CorporeaRequest request) {
-		return iterateOverSlots(request, false);
-	}
-
-	@Override
-	public List<ItemStack> extractItems(CorporeaRequest request) {
-		return iterateOverSlots(request, true);
-	}
-
-	private List<ItemStack> iterateOverSlots(CorporeaRequest request, boolean doit) {
-		List<ItemStack> stacks = new ArrayList<ItemStack>();
-
-		boolean removedAny = false;
-		for (int i = inv.getSizeInventory() - 1; i >= 0; i--) {
-			if(!CorporeaHelper.isValidSlot(inv, i))
-				continue;
-
-			ItemStack stackAt = inv.getStackInSlot(i);
-			// WARNING: this code is very similar in all implementations of
-			// IWrappedInventory - keep it synch
-			if(isMatchingItemStack(request.matcher, request.checkNBT, stackAt)) {
-				int rem = Math.min(stackAt.stackSize, request.count == -1 ? stackAt.stackSize : request.count);
-
-				if(rem > 0) {
-					ItemStack copy = stackAt.copy();
-					if(rem < copy.stackSize)
-						copy.stackSize = rem;
-					stacks.add(copy);
-				}
-
-				request.foundItems += stackAt.stackSize;
-				request.extractedItems += rem;
-
-				if(doit && rem > 0) {
-					inv.decrStackSize(i, rem);
-					removedAny = true;
-					if(spark != null)
-						spark.onItemExtracted(stackAt);
-				}
-				if(request.count != -1)
-					request.count -= rem;
-			}
-		}
-
-		if(removedAny) {
-			inv.markDirty();
-		}
-
-		return stacks;
-	}
-
-	public static IWrappedInventory wrap(IInventory inv, ICorporeaSpark spark) {
-		return new WrappedIInventory(inv, spark);
-	}
-
-}
+/**
+ * This class was created by <Vindex>. It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ * 
+ * Botania is Open Source and distributed under the
+ * Botania License: http://botaniamod.net/license.php
+ * 
+ */
+package vazkii.botania.common.integration.corporea;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import vazkii.botania.api.corporea.CorporeaHelper;
+import vazkii.botania.api.corporea.CorporeaRequest;
+import vazkii.botania.api.corporea.ICorporeaSpark;
+import vazkii.botania.api.corporea.IWrappedInventory;
+
+public class WrappedIInventory extends WrappedInventoryBase{
+
+	private IInventory inv;
+
+	private WrappedIInventory(IInventory inv, ICorporeaSpark spark) {
+		this.inv = inv;
+		this.spark = spark;
+	}
+
+	@Override
+	public IInventory getWrappedObject() {
+		return inv;
+	}
+
+	@Override
+	public List<ItemStack> countItems(CorporeaRequest request) {
+		return iterateOverSlots(request, false);
+	}
+
+	@Override
+	public List<ItemStack> extractItems(CorporeaRequest request) {
+		return iterateOverSlots(request, true);
+	}
+
+	private List<ItemStack> iterateOverSlots(CorporeaRequest request, boolean doit) {
+		List<ItemStack> stacks = new ArrayList<ItemStack>();
+
+		boolean removedAny = false;
+		for (int i = inv.getSizeInventory() - 1; i >= 0; i--) {
+			if(!CorporeaHelper.isValidSlot(inv, i))
+				continue;
+
+			ItemStack stackAt = inv.getStackInSlot(i);
+			// WARNING: this code is very similar in all implementations of
+			// IWrappedInventory - keep it synch
+			if(isMatchingItemStack(request.matcher, request.checkNBT, stackAt)) {
+				int rem = Math.min(stackAt.stackSize, request.count == -1 ? stackAt.stackSize : request.count);
+
+				if(rem > 0) {
+					ItemStack copy = stackAt.copy();
+					if(rem < copy.stackSize)
+						copy.stackSize = rem;
+					stacks.add(copy);
+				}
+
+				request.foundItems += stackAt.stackSize;
+				request.extractedItems += rem;
+
+				if(doit && rem > 0) {
+					inv.decrStackSize(i, rem);
+					removedAny = true;
+					if(spark != null)
+						spark.onItemExtracted(stackAt);
+				}
+				if(request.count != -1)
+					request.count -= rem;
+			}
+		}
+
+		if(removedAny) {
+			inv.markDirty();
+		}
+
+		return stacks;
+	}
+
+	public static IWrappedInventory wrap(IInventory inv, ICorporeaSpark spark) {
+		return new WrappedIInventory(inv, spark);
+	}
+
+}

src/main/java/vazkii/botania/common/integration/corporea/WrappedInventoryBase.java

@@ -1,52 +1,52 @@
-/**
- * This class was created by <Vindex>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- */
-package vazkii.botania.common.integration.corporea;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import net.minecraft.item.ItemStack;
-import vazkii.botania.api.corporea.CorporeaHelper;
-import vazkii.botania.api.corporea.ICorporeaSpark;
-import vazkii.botania.api.corporea.IWrappedInventory;
-
-public abstract class WrappedInventoryBase implements IWrappedInventory {
-
-	protected ICorporeaSpark spark;
-
-	@Override
-	public ICorporeaSpark getSpark() {
-		return spark;
-	}
-
-	protected boolean isMatchingItemStack(Object matcher, boolean checkNBT, ItemStack stackAt) {
-		return matcher instanceof ItemStack ? CorporeaHelper.stacksMatch((ItemStack) matcher, stackAt, checkNBT)
-				: matcher instanceof String ? CorporeaHelper.stacksMatch(stackAt, (String) matcher) : false;
-	}
-
-	protected Collection<? extends ItemStack> breakDownBigStack(ItemStack stack) {
-		List<ItemStack> stacks = new ArrayList<ItemStack>();
-		int additionalStacks = stack.stackSize / stack.getMaxStackSize();
-		int lastStackSize = stack.stackSize % stack.getMaxStackSize();
-		if(additionalStacks > 0) {
-			ItemStack fullStack = stack.copy();
-			fullStack.stackSize = stack.getMaxStackSize();
-			for (int i = 0; i < additionalStacks; i++) {
-				stacks.add(fullStack.copy());
-			}
-		}
-		ItemStack lastStack = stack.copy();
-		lastStack.stackSize = lastStackSize;
-		stacks.add(lastStack);
-
-		return stacks;
-	}
-}
+/**
+ * This class was created by <Vindex>. It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ * 
+ * Botania is Open Source and distributed under the
+ * Botania License: http://botaniamod.net/license.php
+ * 
+ */
+package vazkii.botania.common.integration.corporea;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import net.minecraft.item.ItemStack;
+import vazkii.botania.api.corporea.CorporeaHelper;
+import vazkii.botania.api.corporea.ICorporeaSpark;
+import vazkii.botania.api.corporea.IWrappedInventory;
+
+public abstract class WrappedInventoryBase implements IWrappedInventory {
+
+	protected ICorporeaSpark spark;
+
+	@Override
+	public ICorporeaSpark getSpark() {
+		return spark;
+	}
+
+	protected boolean isMatchingItemStack(Object matcher, boolean checkNBT, ItemStack stackAt) {
+		return matcher instanceof ItemStack ? CorporeaHelper.stacksMatch((ItemStack) matcher, stackAt, checkNBT)
+				: matcher instanceof String ? CorporeaHelper.stacksMatch(stackAt, (String) matcher) : false;
+	}
+
+	protected Collection<? extends ItemStack> breakDownBigStack(ItemStack stack) {
+		List<ItemStack> stacks = new ArrayList<ItemStack>();
+		int additionalStacks = stack.stackSize / stack.getMaxStackSize();
+		int lastStackSize = stack.stackSize % stack.getMaxStackSize();
+		if(additionalStacks > 0) {
+			ItemStack fullStack = stack.copy();
+			fullStack.stackSize = stack.getMaxStackSize();
+			for (int i = 0; i < additionalStacks; i++) {
+				stacks.add(fullStack.copy());
+			}
+		}
+		ItemStack lastStack = stack.copy();
+		lastStack.stackSize = lastStackSize;
+		stacks.add(lastStack);
+
+		return stacks;
+	}
+}

src/main/java/vazkii/botania/common/integration/corporea/WrappedStorageDrawers.java

@@ -1,113 +1,113 @@
-/**
- * This class was created by <Vindex>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- */
-package vazkii.botania.common.integration.corporea;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer;
-import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawerGroup;
-
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.ItemStack;
-import vazkii.botania.api.corporea.CorporeaRequest;
-import vazkii.botania.api.corporea.ICorporeaSpark;
-import vazkii.botania.api.corporea.IWrappedInventory;
-
-/**
- * Wrapper for StorageDrawers compatibility.
- *
- */
-public class WrappedStorageDrawers extends WrappedInventoryBase {
-
-	private IDrawerGroup inv;
-
-	private WrappedStorageDrawers(IDrawerGroup inv, ICorporeaSpark spark) {
-		this.inv = inv;
-		this.spark = spark;
-	}
-
-	@Override
-	public IInventory getWrappedObject() {
-		return (IInventory) inv;
-	}
-
-	@Override
-	public List<ItemStack> countItems(CorporeaRequest request) {
-		return iterateOverStacks(request, false);
-	}
-
-	@Override
-	public List<ItemStack> extractItems(CorporeaRequest request) {
-		return iterateOverStacks(request, true);
-	}
-
-	private List<ItemStack> iterateOverStacks(CorporeaRequest request, boolean doit) {
-		List<ItemStack> stacks = new ArrayList<ItemStack>();
-		boolean removedAny = false;
-
-		for(int i = 0; i < inv.getDrawerCount(); i++) {
-			IDrawer drawer = inv.getDrawer(i);
-			if(drawer == null) {
-				continue;
-			}
-			ItemStack prototype = drawer.getStoredItemPrototype();
-			int storedCount = drawer.getStoredItemCount();
-
-			// WARNING: this code is very similar in all implementations of
-			// IWrappedInventory - keep it synch
-			// also this code is near duplicate to WrappedDeepStorage - keep it
-			// synchronized
-			if(isMatchingItemStack(request.matcher, request.checkNBT, prototype)) {
-				int rem = Math.min(storedCount, request.count == -1 ? storedCount : request.count);
-
-				if(rem > 0) {
-					ItemStack copy = prototype.copy();
-					copy.stackSize = rem;
-					if(doit) {
-						stacks.addAll(breakDownBigStack(copy));
-					} else {
-						stacks.add(copy);
-					}
-				}
-
-				request.foundItems += storedCount;
-				request.extractedItems += rem;
-
-				if(doit && rem > 0) {
-					decreaseStoredCount(drawer, rem);
-
-					removedAny = true;
-					if(spark != null)
-						spark.onItemExtracted(prototype);
-				}
-				if(request.count != -1)
-					request.count -= rem;
-			}
-		}
-		if(removedAny) {
-			inv.markDirtyIfNeeded();
-		}
-		return stacks;
-	}
-
-	private void decreaseStoredCount(IDrawer drawer, int rem) {
-		drawer.setStoredItemCount(drawer.getStoredItemCount() - rem);
-	}
-
-	/**
-	 * Creates {@link WrappedStorageDrawers} if specified inv can be wrapped.
-	 * 
-	 * @return wrapped inventory or null if it has incompatible type.
-	 */
-	public static IWrappedInventory wrap(IInventory inv, ICorporeaSpark spark) {
-		return inv instanceof IDrawerGroup ? new WrappedStorageDrawers((IDrawerGroup) inv, spark) : null;
-	}
-}
+/**
+ * This class was created by <Vindex>. It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ * 
+ * Botania is Open Source and distributed under the
+ * Botania License: http://botaniamod.net/license.php
+ * 
+ */
+package vazkii.botania.common.integration.corporea;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawer;
+import com.jaquadro.minecraft.storagedrawers.api.storage.IDrawerGroup;
+
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import vazkii.botania.api.corporea.CorporeaRequest;
+import vazkii.botania.api.corporea.ICorporeaSpark;
+import vazkii.botania.api.corporea.IWrappedInventory;
+
+/**
+ * Wrapper for StorageDrawers compatibility.
+ *
+ */
+public class WrappedStorageDrawers extends WrappedInventoryBase {
+
+	private IDrawerGroup inv;
+
+	private WrappedStorageDrawers(IDrawerGroup inv, ICorporeaSpark spark) {
+		this.inv = inv;
+		this.spark = spark;
+	}
+
+	@Override
+	public IInventory getWrappedObject() {
+		return (IInventory) inv;
+	}
+
+	@Override
+	public List<ItemStack> countItems(CorporeaRequest request) {
+		return iterateOverStacks(request, false);
+	}
+
+	@Override
+	public List<ItemStack> extractItems(CorporeaRequest request) {
+		return iterateOverStacks(request, true);
+	}
+
+	private List<ItemStack> iterateOverStacks(CorporeaRequest request, boolean doit) {
+		List<ItemStack> stacks = new ArrayList<ItemStack>();
+		boolean removedAny = false;
+
+		for(int i = 0; i < inv.getDrawerCount(); i++) {
+			IDrawer drawer = inv.getDrawer(i);
+			if(drawer == null) {
+				continue;
+			}
+			ItemStack prototype = drawer.getStoredItemPrototype();
+			int storedCount = drawer.getStoredItemCount();
+
+			// WARNING: this code is very similar in all implementations of
+			// IWrappedInventory - keep it synch
+			// also this code is near duplicate to WrappedDeepStorage - keep it
+			// synchronized
+			if(isMatchingItemStack(request.matcher, request.checkNBT, prototype)) {
+				int rem = Math.min(storedCount, request.count == -1 ? storedCount : request.count);
+
+				if(rem > 0) {
+					ItemStack copy = prototype.copy();
+					copy.stackSize = rem;
+					if(doit) {
+						stacks.addAll(breakDownBigStack(copy));
+					} else {
+						stacks.add(copy);
+					}
+				}
+
+				request.foundItems += storedCount;
+				request.extractedItems += rem;
+
+				if(doit && rem > 0) {
+					decreaseStoredCount(drawer, rem);
+
+					removedAny = true;
+					if(spark != null)
+						spark.onItemExtracted(prototype);
+				}
+				if(request.count != -1)
+					request.count -= rem;
+			}
+		}
+		if(removedAny) {
+			inv.markDirtyIfNeeded();
+		}
+		return stacks;
+	}
+
+	private void decreaseStoredCount(IDrawer drawer, int rem) {
+		drawer.setStoredItemCount(drawer.getStoredItemCount() - rem);
+	}
+
+	/**
+	 * Creates {@link WrappedStorageDrawers} if specified inv can be wrapped.
+	 * 
+	 * @return wrapped inventory or null if it has incompatible type.
+	 */
+	public static IWrappedInventory wrap(IInventory inv, ICorporeaSpark spark) {
+		return inv instanceof IDrawerGroup ? new WrappedStorageDrawers((IDrawerGroup) inv, spark) : null;
+	}
+}

src/main/java/vazkii/botania/common/item/ItemCraftingHalo.java

@@ -198,15 +198,17 @@ public class ItemCraftingHalo extends ItemMod implements ICraftAchievement {
 			ItemStack stackAt = inv.getStackInSlot(i);
 			if(stackAt != null && stack.isItemEqual(stackAt) && ItemStack.areItemStackTagsEqual(stack, stackAt)) {
 				boolean consume = true;
-
-				ItemStack container = stackAt.getItem().getContainerItem(stackAt);
-				if(container != null) {
-					if(container == stackAt)
-						consume = false;
-					else {
-						InventoryHelper.insertItemIntoInventory(inv, container);
-						if(container.stackSize != 0 && player != null)
-							player.dropPlayerItemWithRandomChoice(container, false);
+				if(stackAt.getItem().hasContainerItem()) {
+					//there are monsters in this world that will return false above but not null below
+					ItemStack container = stackAt.getItem().getContainerItem(stackAt);
+					if (container != null) {
+						if (container == stackAt)
+							consume = false;
+						else {
+							InventoryHelper.insertItemIntoInventory(inv, container);
+							if (container.stackSize != 0 && player != null)
+								player.dropPlayerItemWithRandomChoice(container, false);
+						}
 					}
 				}
 

src/main/java/vazkii/botania/common/item/ItemFlowerBag.java

@@ -1,159 +0,0 @@
-/**
- * This class was created by <Vazkii>. It's distributed as
- * part of the Botania Mod. Get the Source Code in github:
- * https://github.com/Vazkii/Botania
- * 
- * Botania is Open Source and distributed under the
- * Botania License: http://botaniamod.net/license.php
- * 
- * File Created @ [Mar 16, 2015, 6:43:33 PM (GMT)]
- */
-package vazkii.botania.common.item;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.tileentity.TileEntityChest;
-import net.minecraft.world.World;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
-import vazkii.botania.common.Botania;
-import vazkii.botania.common.block.ModBlocks;
-import vazkii.botania.common.core.helper.InventoryHelper;
-import vazkii.botania.common.core.helper.ItemNBTHelper;
-import vazkii.botania.common.lib.LibGuiIDs;
-import vazkii.botania.common.lib.LibItemNames;
-import cpw.mods.fml.common.eventhandler.SubscribeEvent;
-
-public class ItemFlowerBag extends ItemMod {
-
-	private static final String TAG_ITEMS = "InvItems";
-	private static final String TAG_SLOT = "Slot";
-
-	public ItemFlowerBag() {
-		setUnlocalizedName(LibItemNames.FLOWER_BAG);
-		setMaxStackSize(1);
-		MinecraftForge.EVENT_BUS.register(this);
-	}
-
-	@SubscribeEvent
-	public void onPickupItem(EntityItemPickupEvent event) {
-		ItemStack stack = event.item.getEntityItem();
-		if(stack.getItem() == Item.getItemFromBlock(ModBlocks.flower) && stack.stackSize > 0) {
-			int color = stack.getItemDamage();
-			if(color > 15)
-				return;
-
-			for(int i = 0; i < event.entityPlayer.inventory.getSizeInventory(); i++) {
-				if(i == event.entityPlayer.inventory.currentItem)
-					continue; // prevent item deletion
-
-				ItemStack invStack = event.entityPlayer.inventory.getStackInSlot(i);
-				if(invStack != null && invStack.getItem() == this) {
-					ItemStack[] bagInv = loadStacks(invStack);
-					ItemStack stackAt = bagInv[color];
-					boolean didChange = false;
-					if(stackAt == null) {
-						bagInv[color] = stack.copy();
-						stack.stackSize = 0;
-						didChange = true;
-					} else {
-						int stackAtSize = stackAt.stackSize;
-						int stackSize = stack.stackSize;
-						int spare = 64 - stackAtSize;
-						int pass = Math.min(spare, stackSize);
-						if(pass > 0) {
-							stackAt.stackSize += pass;
-							stack.stackSize -= pass;
-							didChange = true;
-						}
-					}
-
-					if(didChange)
-						setStacks(invStack, bagInv);
-				}
-
-				if(stack.stackSize == 0)
-					return;
-			}
-		}
-	}
-
-	@Override
-	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
-		player.openGui(Botania.instance, LibGuiIDs.FLOWER_BAG, world, 0, 0, 0);
-		return stack;
-	}
-
-	@Override
-	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int s, float xs, float ys, float zs) {
-		TileEntity tile = world.getTileEntity(x, y, z);
-		if(tile != null && tile instanceof IInventory) {
-			if(!world.isRemote) {
-				ForgeDirection side = ForgeDirection.getOrientation(s);
-				IInventory inv = (IInventory) tile;
-				ItemStack[] stacks = loadStacks(stack);
-				ItemStack[] newStacks = new ItemStack[stacks.length];
-				boolean putAny = false;
-
-				int i = 0;
-				for(ItemStack petal : stacks) {
-					if(petal != null) {
-						int count = InventoryHelper.testInventoryInsertion(inv, petal, side);
-						InventoryHelper.insertItemIntoInventory(inv, petal, side, -1);
-
-						ItemStack newPetal = petal.copy();
-						if(newPetal.stackSize == 0)
-							newPetal = null;
-
-						newStacks[i] = newPetal;
-						putAny |= count > 0;
-					}
-
-					i++;
-				}
-
-				setStacks(stack, newStacks);
-				if(putAny && inv instanceof TileEntityChest) {
-					inv = InventoryHelper.getInventory(inv);
-					player.displayGUIChest(inv);
-				}
-			}
-
-			return true;
-		}
-		return false;
-	}
-
-	public static ItemStack[] loadStacks(ItemStack stack) {
-		NBTTagList var2 = ItemNBTHelper.getList(stack, TAG_ITEMS, 10, false);
-		ItemStack[] inventorySlots = new ItemStack[16];
-		for(int var3 = 0; var3 < var2.tagCount(); ++var3) {
-			NBTTagCompound var4 = var2.getCompoundTagAt(var3);
-			byte var5 = var4.getByte(TAG_SLOT);
-			if(var5 >= 0 && var5 < inventorySlots.length)
-				inventorySlots[var5] = ItemStack.loadItemStackFromNBT(var4);
-		}
-
-		return inventorySlots;
-	}
-
-	public static void setStacks(ItemStack stack, ItemStack[] inventorySlots) {
-		NBTTagList var2 = new NBTTagList();
-		for(int var3 = 0; var3 < inventorySlots.length; ++var3)
-			if(inventorySlots[var3] != null) {
-				NBTTagCompound var4 = new NBTTagCompound();
-				var4.setByte(TAG_SLOT, (byte)var3);
-				inventorySlots[var3].writeToNBT(var4);
-				var2.appendTag(var4);
-			}
-
-		ItemNBTHelper.setList(stack, TAG_ITEMS, var2);
-	}
-
-}

src/main/java/vazkii/botania/common/item/ModItems.java

@@ -15,6 +15,8 @@ import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.oredict.OreDictionary;
 import vazkii.botania.api.BotaniaAPI;
+import vazkii.botania.common.item.bag.ItemFlowerBag;
+import vazkii.botania.common.item.bag.ItemShroomBag;
 import vazkii.botania.common.item.brew.ItemBrewFlask;
 import vazkii.botania.common.item.brew.ItemBrewVial;
 import vazkii.botania.common.item.brew.ItemIncenseStick;
@@ -232,6 +234,7 @@ public final class ModItems {
 	public static Item cosmetic;
 	public static Item swapRing;
 	public static Item flowerBag;
+	public static Item shroomBag;
 	public static Item phantomInk;
 	public static Item poolMinecart;
 	public static Item pinkinator;
@@ -381,6 +384,7 @@ public final class ModItems {
 		cosmetic = new ItemBaubleCosmetic();
 		swapRing = new ItemSwapRing();
 		flowerBag = new ItemFlowerBag();
+		shroomBag = new ItemShroomBag();
 		phantomInk = new ItemPhantomInk();
 		poolMinecart = new ItemPoolMinecart();
 		pinkinator = new ItemPinkinator();

src/main/java/vazkii/botania/common/item/bag/ItemBagBase.java

@@ -0,0 +1,154 @@
+package vazkii.botania.common.item.bag;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.tileentity.TileEntityChest;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
+import vazkii.botania.common.Botania;
+import vazkii.botania.common.block.ModBlocks;
+import vazkii.botania.common.core.helper.InventoryHelper;
+import vazkii.botania.common.core.helper.ItemNBTHelper;
+import vazkii.botania.common.item.ItemMod;
+import vazkii.botania.common.lib.LibGuiIDs;
+import vazkii.botania.common.lib.LibItemNames;
+
+public abstract class ItemBagBase extends ItemMod {
+
+    private static final String TAG_ITEMS = "InvItems";
+    private static final String TAG_SLOT = "Slot";
+
+    public ItemBagBase(String name) {
+        setUnlocalizedName(name);
+        setMaxStackSize(1);
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+    @SubscribeEvent
+    public void onPickupItem(EntityItemPickupEvent event) {
+        ItemStack stack = event.item.getEntityItem();
+        if(stack.getItem() == Item.getItemFromBlock(getValidPickUp()) && stack.stackSize > 0) {
+            int color = stack.getItemDamage();
+            if(color > 15)
+                return;
+
+            for(int i = 0; i < event.entityPlayer.inventory.getSizeInventory(); i++) {
+                 if(i == event.entityPlayer.inventory.currentItem)
+                    continue; // prevent item deletion
+
+                ItemStack invStack = event.entityPlayer.inventory.getStackInSlot(i);
+                if(invStack != null && invStack.getItem() == this) {
+                    ItemStack[] bagInv = loadStacks(invStack);
+                    ItemStack stackAt = bagInv[color];
+                    boolean didChange = false;
+                    if(stackAt == null) {
+                        bagInv[color] = stack.copy();
+                        stack.stackSize = 0;
+                        didChange = true;
+                    } else {
+                        int stackAtSize = stackAt.stackSize;
+                        int stackSize = stack.stackSize;
+                        int spare = 64 - stackAtSize;
+                        int pass = Math.min(spare, stackSize);
+                        if(pass > 0) {
+                            stackAt.stackSize += pass;
+                            stack.stackSize -= pass;
+                            didChange = true;
+                        }
+                    }
+
+                    if(didChange)
+                        setStacks(invStack, bagInv);
+                }
+
+                if(stack.stackSize == 0)
+                    return;
+            }
+        }
+    }
+
+    @Override
+    public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
+        player.openGui(Botania.instance, getGuiID(), world, 0, 0, 0);
+        return stack;
+    }
+
+    @Override
+    public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int s, float xs, float ys, float zs) {
+        TileEntity tile = world.getTileEntity(x, y, z);
+        if(tile != null && tile instanceof IInventory) {
+            if(!world.isRemote) {
+                ForgeDirection side = ForgeDirection.getOrientation(s);
+                IInventory inv = (IInventory) tile;
+                ItemStack[] stacks = loadStacks(stack);
+                ItemStack[] newStacks = new ItemStack[stacks.length];
+                boolean putAny = false;
+
+                int i = 0;
+                for(ItemStack petal : stacks) {
+                    if(petal != null) {
+                        int count = InventoryHelper.testInventoryInsertion(inv, petal, side);
+                        InventoryHelper.insertItemIntoInventory(inv, petal, side, -1);
+
+                        ItemStack newPetal = petal.copy();
+                        if(newPetal.stackSize == 0)
+                            newPetal = null;
+
+                        newStacks[i] = newPetal;
+                        putAny |= count > 0;
+                    }
+
+                    i++;
+                }
+
+                setStacks(stack, newStacks);
+                if(putAny && inv instanceof TileEntityChest) {
+                    inv = InventoryHelper.getInventory(inv);
+                    player.displayGUIChest(inv);
+                }
+            }
+
+            return true;
+        }
+        return false;
+    }
+
+    public static ItemStack[] loadStacks(ItemStack stack) {
+        NBTTagList var2 = ItemNBTHelper.getList(stack, TAG_ITEMS, 10, false);
+        ItemStack[] inventorySlots = new ItemStack[16];
+        for(int var3 = 0; var3 < var2.tagCount(); ++var3) {
+            NBTTagCompound var4 = var2.getCompoundTagAt(var3);
+            byte var5 = var4.getByte(TAG_SLOT);
+            if(var5 >= 0 && var5 < inventorySlots.length)
+                inventorySlots[var5] = ItemStack.loadItemStackFromNBT(var4);
+        }
+
+        return inventorySlots;
+    }
+
+    public static void setStacks(ItemStack stack, ItemStack[] inventorySlots) {
+        NBTTagList var2 = new NBTTagList();
+        for(int var3 = 0; var3 < inventorySlots.length; ++var3)
+            if(inventorySlots[var3] != null) {
+                NBTTagCompound var4 = new NBTTagCompound();
+                var4.setByte(TAG_SLOT, (byte)var3);
+                inventorySlots[var3].writeToNBT(var4);
+                var2.appendTag(var4);
+            }
+
+        ItemNBTHelper.setList(stack, TAG_ITEMS, var2);
+    }
+
+    protected abstract Block getValidPickUp();
+
+    protected abstract int getGuiID();
+}

src/main/java/vazkii/botania/common/item/bag/ItemFlowerBag.java

@@ -0,0 +1,23 @@
+package vazkii.botania.common.item.bag;
+
+import net.minecraft.block.Block;
+import vazkii.botania.common.block.ModBlocks;
+import vazkii.botania.common.lib.LibGuiIDs;
+import vazkii.botania.common.lib.LibItemNames;
+
+public class ItemFlowerBag extends ItemBagBase {
+
+	public ItemFlowerBag() {
+		super(LibItemNames.FLOWER_BAG);
+	}
+
+	@Override
+	protected Block getValidPickUp() {
+		return ModBlocks.flower;
+	}
+
+	@Override
+	protected int getGuiID() {
+		return LibGuiIDs.FLOWER_BAG;
+	}
+}

src/main/java/vazkii/botania/common/item/bag/ItemShroomBag.java

@@ -0,0 +1,23 @@
+package vazkii.botania.common.item.bag;
+
+import net.minecraft.block.Block;
+import vazkii.botania.common.block.ModBlocks;
+import vazkii.botania.common.lib.LibGuiIDs;
+import vazkii.botania.common.lib.LibItemNames;
+
+public class ItemShroomBag extends ItemBagBase{
+
+    public ItemShroomBag() {
+        super(LibItemNames.SHROOM_BAG);
+    }
+
+    @Override
+    protected Block getValidPickUp() {
+        return ModBlocks.mushroom;
+    }
+
+    @Override
+    protected int getGuiID() {
+        return LibGuiIDs.SHROOM_BAG;
+    }
+}

src/main/java/vazkii/botania/common/item/block/ItemBlockDreamwood.java

@@ -4,7 +4,7 @@ import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
 import vazkii.botania.api.recipe.IElvenItem;
 
-public class ItemBlockDreamwood extends ItemBlockWithMetadataAndName implements IElvenItem {
+public class ItemBlockDreamwood extends ItemCubeWithMetadataAndName implements IElvenItem {
 
 	public ItemBlockDreamwood(Block block) {
 		super(block);

src/main/java/vazkii/botania/common/item/block/ItemBlockElven.java

@@ -11,8 +11,13 @@
 package vazkii.botania.common.item.block;
 
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
 import vazkii.botania.api.recipe.IElvenItem;
+import vazkii.botania.common.core.handler.ConfigHandler;
+
+import java.util.List;
 
 public class ItemBlockElven extends ItemBlockMod implements IElvenItem {
 
@@ -25,4 +30,9 @@ public class ItemBlockElven extends ItemBlockMod implements IElvenItem {
 		return ((IElvenItem) field_150939_a).isElvenItem(stack);
 	}
 
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean advancedTooltips) {
+		if (ConfigHandler.noMobSpawnOnBlocks)
+			list.add(StatCollector.translateToLocal("nomobspawnsonthisblock.tip"));
+	}
 }

src/main/java/vazkii/botania/common/item/block/ItemBlockModSlab.java

@@ -11,9 +11,14 @@
 package vazkii.botania.common.item.block;
 
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemSlab;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
 import vazkii.botania.common.block.decor.slabs.BlockModSlab;
+import vazkii.botania.common.core.handler.ConfigHandler;
+
+import java.util.List;
 
 public class ItemBlockModSlab extends ItemSlab {
 
@@ -25,5 +30,9 @@ public class ItemBlockModSlab extends ItemSlab {
 	public String getUnlocalizedName(ItemStack par1ItemStack) {
 		return field_150939_a.getUnlocalizedName().replaceAll("tile.", "tile.botania:");
 	}
-
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean advancedTooltips) {
+		if (ConfigHandler.noMobSpawnOnBlocks)
+			list.add(StatCollector.translateToLocal("nomobspawnsonthisblock.tip"));
+	}
 }

src/main/java/vazkii/botania/common/item/block/ItemBlockSpecialQuartz.java

@@ -11,9 +11,14 @@
 package vazkii.botania.common.item.block;
 
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemMultiTexture;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
 import vazkii.botania.common.block.decor.quartz.BlockSpecialQuartz;
+import vazkii.botania.common.core.handler.ConfigHandler;
+
+import java.util.List;
 
 public class ItemBlockSpecialQuartz extends ItemMultiTexture {
 
@@ -25,4 +30,10 @@ public class ItemBlockSpecialQuartz extends ItemMultiTexture {
 	public String getUnlocalizedName(ItemStack par1ItemStack) {
 		return par1ItemStack.getItemDamage() >= 3 ? "" : ((BlockSpecialQuartz) field_150939_a).getNames()[par1ItemStack.getItemDamage()];
 	}
+
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean advancedTooltips) {
+		if (ConfigHandler.noMobSpawnOnBlocks)
+			list.add(StatCollector.translateToLocal("nomobspawnsonthisblock.tip"));
+	}
 }

src/main/java/vazkii/botania/common/item/block/ItemBlockStorage.java

@@ -14,7 +14,7 @@ import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
 import vazkii.botania.api.recipe.IElvenItem;
 
-public class ItemBlockStorage extends ItemBlockWithMetadataAndName implements IElvenItem {
+public class ItemBlockStorage extends ItemCubeWithMetadataAndName implements IElvenItem {
 
 	public ItemBlockStorage(Block block) {
 		super(block);

src/main/java/vazkii/botania/common/item/block/ItemCubeMod.java

@@ -0,0 +1,22 @@
+package vazkii.botania.common.item.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
+import vazkii.botania.common.core.handler.ConfigHandler;
+
+import java.util.List;
+
+public class ItemCubeMod extends ItemBlockMod{
+    public ItemCubeMod(Block block) {
+        super(block);
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean advancedTooltips) {
+        if (ConfigHandler.noMobSpawnOnBlocks)
+            list.add(StatCollector.translateToLocal("nomobspawnsonthisblock.tip"));
+    }
+
+}

src/main/java/vazkii/botania/common/item/block/ItemCubeWithMetadataAndName.java

@@ -0,0 +1,22 @@
+package vazkii.botania.common.item.block;
+
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
+import vazkii.botania.common.core.handler.ConfigHandler;
+
+import java.util.List;
+
+public class ItemCubeWithMetadataAndName extends ItemBlockWithMetadataAndName  {
+
+    public ItemCubeWithMetadataAndName(Block par2Block) {
+        super(par2Block);
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean advancedTooltips) {
+        if (ConfigHandler.noMobSpawnOnBlocks)
+            list.add(StatCollector.translateToLocal("nomobspawnsonthisblock.tip"));
+    }
+}

src/main/java/vazkii/botania/common/item/equipment/bauble/ItemBauble.java

@@ -94,8 +94,9 @@ public abstract class ItemBauble extends ItemMod implements IBauble, ICosmeticAt
 
 		String key = vazkii.botania.client.core.helper.RenderHelper.getKeyDisplayString("Baubles Inventory");
 
-		if(key != null)
+		if(key != null && !key.equals("NONE")) {
 			addStringToTooltip(StatCollector.translateToLocal("botania.baubletooltip").replaceAll("%key%", key), par3List);
+		}
 
 		ItemStack cosmetic = getCosmeticItem(par1ItemStack);
 		if(cosmetic != null)
@@ -105,7 +106,7 @@ public abstract class ItemBauble extends ItemMod implements IBauble, ICosmeticAt
 			addStringToTooltip(StatCollector.translateToLocal("botaniamisc.hasPhantomInk"), par3List);
 	}
 
-	void addStringToTooltip(String s, List<String> tooltip) {
+	public void addStringToTooltip(String s, List<String> tooltip) {
 		tooltip.add(s.replaceAll("&", "\u00a7"));
 	}
 

src/main/java/vazkii/botania/common/item/equipment/tool/terrasteel/ItemTerraPick.java

@@ -205,6 +205,15 @@ public class ItemTerraPick extends ItemManasteelPick implements IManaItem, ISequ
 		return pass == 1 && isEnabled(stack) ? iconOverlay : isTipped(stack) ? iconTipped : iconTool;
 	}
 
+	@Override
+	public int getHarvestLevel(ItemStack stack, String toolClass) {
+		if (!"pickaxe".equals(toolClass)) {
+			return super.getHarvestLevel(stack, toolClass);
+		}
+		// Rank S -> level 8 (Manyullyn)
+		return getLevel(stack) + 4;
+	}
+
 	public static boolean isTipped(ItemStack stack) {
 		return ItemNBTHelper.getBoolean(stack, TAG_TIPPED, false);
 	}

src/main/java/vazkii/botania/common/item/relic/ItemLokiRing.java

@@ -10,12 +10,16 @@
  */
 package vazkii.botania.common.item.relic;
 
+
+import java.awt.Color;
 import java.util.ArrayList;
 import java.util.List;
-
+import com.gtnewhorizon.gtnhlib.GTNHLib;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.enchantment.Enchantment;
 import net.minecraft.enchantment.EnchantmentHelper;
 import net.minecraft.entity.EntityLivingBase;
@@ -24,17 +28,27 @@ import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
+
+import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.StatCollector;
 import net.minecraft.world.World;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.event.entity.player.PlayerInteractEvent;
 import net.minecraftforge.event.entity.player.PlayerInteractEvent.Action;
+import net.minecraftforge.event.world.BlockEvent;
+import org.lwjgl.opengl.GL11;
 import vazkii.botania.api.item.IExtendedWireframeCoordinateListProvider;
+import vazkii.botania.api.item.IInWorldRenderable;
 import vazkii.botania.api.item.ISequentialBreaker;
 import vazkii.botania.api.mana.IManaUsingItem;
 import vazkii.botania.api.mana.ManaItemHandler;
+import vazkii.botania.client.core.handler.BoundTileRenderer;
 import vazkii.botania.common.core.helper.ItemNBTHelper;
+import vazkii.botania.common.core.helper.LokiCursor;
 import vazkii.botania.common.item.ModItems;
 import vazkii.botania.common.item.equipment.tool.ToolCommons;
 import vazkii.botania.common.lib.LibItemNames;
@@ -46,29 +60,52 @@ import baubles.common.network.PacketSyncBauble;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import vazkii.botania.common.network.PacketLokiHudNotificationAck;
 
-public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeCoordinateListProvider, IManaUsingItem {
+
+public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeCoordinateListProvider, IManaUsingItem, IInWorldRenderable {
 
 	private static final String TAG_CURSOR_LIST = "cursorList";
 	private static final String TAG_CURSOR_PREFIX = "cursor";
 	private static final String TAG_CURSOR_COUNT = "cursorCount";
-	private static final String TAG_X_OFFSET = "xOffset";
-	private static final String TAG_Y_OFFSET = "yOffset";
-	private static final String TAG_Z_OFFSET = "zOffset";
 	private static final String TAG_X_ORIGIN = "xOrigin";
 	private static final String TAG_Y_ORIGIN = "yOrigin";
 	private static final String TAG_Z_ORIGIN = "zOrigin";
+	private static final String TAG_MODE = "mode";
+	private static final String TAG_BREAKING_MODE = "breaking";
+	private static final String TAG_MIRROR_MODE = "mirror";
+	private boolean recursion = false;
+
+	public static enum HUD_MESSAGE  {
+		MODE, BREAKING, CLEAR, MIRROR, INSUFFICIENT_MANA
+	}
 
 	public ItemLokiRing() {
 		super(LibItemNames.LOKI_RING);
 		MinecraftForge.EVENT_BUS.register(this);
 	}
 
+	@SubscribeEvent
+	public void onBlockBreak(BlockEvent.BreakEvent event) {
+        EntityPlayer player = event.getPlayer();
+        int x = event.x;
+        int y = event.y;
+        int z = event.z;
+        int side = event.blockMetadata;
+        ItemStack stack = player.getCurrentEquippedItem();
+		if(stack == null) return;
+        Item item = player.getCurrentEquippedItem().getItem();
+        breakOnAllCursors(player, item, stack, x, y, z, side);   
+    }
+	
+
 	@SubscribeEvent
 	public void onPlayerInteract(PlayerInteractEvent event) {
+		if(recursion) return;
+		
 		EntityPlayer player = event.entityPlayer;
 		ItemStack lokiRing = getLokiRing(player);
-		if(lokiRing == null || player.worldObj.isRemote)
+		if (lokiRing == null || player.worldObj.isRemote)
 			return;
 
 		int slot = -1;
@@ -84,80 +121,318 @@ public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeC
 		ItemStack heldItemStack = player.getCurrentEquippedItem();
 		ChunkCoordinates originCoords = getOriginPos(lokiRing);
 		MovingObjectPosition lookPos = ToolCommons.raytraceFromEntity(player.worldObj, player, true, 10F);
-		List<ChunkCoordinates> cursors = getCursorList(lokiRing);
+		List<LokiCursor> cursors = getCursorList(lokiRing);
 		int cursorCount = cursors.size();
+		//I don`t think mana for placing should be cruel , so I just made graph with funny line
+		int cost = (int)(50*Math.sin(0.04* cursorCount)+cursorCount+120+20*Math.cos(0.2*cursorCount));
 
-		int cost = Math.min(cursorCount, (int) Math.pow(Math.E, cursorCount * 0.25));
-
-		if(heldItemStack == null && event.action == Action.RIGHT_CLICK_BLOCK && player.isSneaking()) {
+		if (heldItemStack == null && event.action == Action.RIGHT_CLICK_BLOCK && player.isSneaking() && isRingEnabled(lokiRing)) {
 			if(originCoords.posY == -1 && lookPos != null) {
 				setOriginPos(lokiRing, lookPos.blockX, lookPos.blockY, lookPos.blockZ);
-				setCursorList(lokiRing, null);
 				if(player instanceof EntityPlayerMP)
-					PacketHandler.INSTANCE.sendTo(new PacketSyncBauble(player, slot), (EntityPlayerMP) player);
+					syncLokiRing(player);
 			} else if(lookPos != null) {
 				if(originCoords.posX == lookPos.blockX && originCoords.posY == lookPos.blockY && originCoords.posZ == lookPos.blockZ) {
-					setOriginPos(lokiRing, 0, -1, 0);
+					clearMasterCursor(lokiRing);
 					if(player instanceof EntityPlayerMP)
-						PacketHandler.INSTANCE.sendTo(new PacketSyncBauble(player, slot), (EntityPlayerMP) player);
+						syncLokiRing(player);
 				} else {
 					addCursor : {
 					int relX = lookPos.blockX - originCoords.posX;
 					int relY = lookPos.blockY - originCoords.posY;
 					int relZ = lookPos.blockZ - originCoords.posZ;
 
-					for(ChunkCoordinates cursor : cursors)
-						if(cursor.posX == relX && cursor.posY == relY && cursor.posZ == relZ) {
+					for(LokiCursor cursor : cursors)
+						if(cursor.getX() == relX && cursor.getY() == relY && cursor.getZ() == relZ) {
 							cursors.remove(cursor);
 							setCursorList(lokiRing, cursors);
 							if(player instanceof EntityPlayerMP)
-								PacketHandler.INSTANCE.sendTo(new PacketSyncBauble(player, slot), (EntityPlayerMP) player);
+								syncLokiRing(player);
 							break addCursor;
 						}
 
-					addCursor(lokiRing, relX, relY, relZ);
+					addCursor(lokiRing, relX, relY, relZ, getRingMirrorMode(lokiRing) );
 					if(player instanceof EntityPlayerMP)
-						PacketHandler.INSTANCE.sendTo(new PacketSyncBauble(player, slot), (EntityPlayerMP) player);
+						syncLokiRing(player);
 				}
 				}
 			}
-		} else if(heldItemStack != null && event.action == Action.RIGHT_CLICK_BLOCK && lookPos != null && player.isSneaking()) {
-			for(ChunkCoordinates cursor : cursors) {
-				int x = lookPos.blockX + cursor.posX;
-				int y = lookPos.blockY + cursor.posY;
-				int z = lookPos.blockZ + cursor.posZ;
-				Item item = heldItemStack.getItem();
-				if(!player.worldObj.isAirBlock(x, y, z) && ManaItemHandler.requestManaExact(lokiRing, player, cost, true)) {
-					item.onItemUse(player.capabilities.isCreativeMode ? heldItemStack.copy() : heldItemStack, player, player.worldObj, x, y, z, lookPos.sideHit, (float) lookPos.hitVec.xCoord - x, (float) lookPos.hitVec.yCoord - y, (float) lookPos.hitVec.zCoord - z);
-					if(heldItemStack.stackSize == 0) {
-						event.setCanceled(true);
-						return;
+		} else if (heldItemStack != null && event.action == Action.RIGHT_CLICK_BLOCK && lookPos != null && isRingEnabled(lokiRing)) {
+			if(!ManaItemHandler.requestManaExact(lokiRing, player, cost, true)){
+				if(player instanceof EntityPlayerMP){
+					vazkii.botania.common.network.PacketHandler.INSTANCE.sendTo(new PacketLokiHudNotificationAck(HUD_MESSAGE.INSUFFICIENT_MANA),(EntityPlayerMP) player);
+				}
+				else
+				{
+					renderHUDNotification(HUD_MESSAGE.INSUFFICIENT_MANA);
+				}
+				return;
+			}
+
+			recursion = true;
+
+			double oldPosX = player.posX;
+			double oldPosY = player.posY;
+			double oldPosZ = player.posZ;
+			float oldPitch = player.rotationPitch;
+			float oldYaw = player.rotationYaw;
+
+			int masterOffsetX = originCoords.posY == -1 ? 0 :lookPos.blockX - originCoords.posX;
+			int masterOffsetY = originCoords.posY == -1 ? 0 :lookPos.blockY - originCoords.posY;
+			int masterOffsetZ = originCoords.posY == -1 ? 0 :lookPos.blockZ - originCoords.posZ;
+
+			double playerOffsetX = player.posX - originCoords.posX;
+			double playerOffsetY = player.posY - originCoords.posY;
+			double playerOffsetZ = player.posZ - originCoords.posZ;
+
+			for(LokiCursor cursor : cursors) {
+
+				int x = lookPos.blockX + cursor.getX();
+				int y = lookPos.blockY + cursor.getY();
+				int z = lookPos.blockZ + cursor.getZ();
+
+				if(cursor.isMirrorX()){
+					x -= 2*masterOffsetX;
+				}
+				if(cursor.isMirrorY()){
+					y -= 2*masterOffsetY;
+				}
+				if(cursor.isMirrorZ()){
+					z -= 2*masterOffsetZ;
+				}
+
+				if (player.worldObj.isAirBlock(x, y, z) ) {
+					continue;
+				}
+
+				player.posX = cursor.getX()+oldPosX;
+				player.posY = cursor.getY()+oldPosY;
+				player.posZ = cursor.getZ()+oldPosZ;
+				player.rotationYaw = oldYaw;
+
+				if(cursor.isMirrorX()){
+					player.posX -= 2*playerOffsetX;
+					player.rotationYaw = player.rotationYaw * (-1);
+				}
+				if(cursor.isMirrorY()){
+					player.posY -= 2*playerOffsetY;
+					player.rotationPitch = oldPitch * (-1);
+				}
+				if(cursor.isMirrorZ()){
+					player.posZ -= 2*playerOffsetZ;
+					player.rotationYaw = 180 - (Math.abs(player.rotationYaw));
+					if(oldYaw < 0){
+						player.rotationYaw *= -1;
 					}
 				}
+
+				float hitX = (float) (lookPos.hitVec.xCoord - lookPos.blockX);
+				float hitY = (float) (lookPos.hitVec.yCoord - lookPos.blockY);
+				float hitZ = (float) (lookPos.hitVec.zCoord - lookPos.blockZ);
+				if(cursor.isMirrorX()){
+					hitX = 1-hitX;
+				}
+				if(cursor.isMirrorY()){
+					hitY = 1-hitY;
+				}
+				if(cursor.isMirrorZ()){
+					hitZ = 1-hitZ;
+				}
+
+				int hitSide = lookPos.sideHit;
+				if(cursor.isMirrorX() && (hitSide == ForgeDirection.EAST.ordinal() || hitSide == ForgeDirection.WEST.ordinal()) ){
+					hitSide = hitSide ^ 1;
+				}
+				if(cursor.isMirrorY() && (hitSide == ForgeDirection.DOWN.ordinal() || hitSide == ForgeDirection.UP.ordinal()) ){
+					hitSide = hitSide ^ 1;
+				}
+				if(cursor.isMirrorZ() && (hitSide == ForgeDirection.NORTH.ordinal() || hitSide == ForgeDirection.SOUTH.ordinal()) ){
+					hitSide = hitSide ^ 1;
+				}
+
+				Item item = heldItemStack.getItem();
+				Block markedBlock = player.worldObj.getBlock(x, y, z);
+
+				boolean wasActivated = markedBlock.onBlockActivated(player.worldObj, x, y, z, player, hitSide, hitX,hitY,hitZ);
+
+				if (heldItemStack.stackSize == 0 ) {
+					event.setCanceled(true);
+					break;
+				}
+				if (!wasActivated) {
+					item.onItemUse(player.capabilities.isCreativeMode ? heldItemStack.copy() : heldItemStack, player, player.worldObj, x, y, z, hitSide, (float) lookPos.hitVec.xCoord - x, (float) lookPos.hitVec.yCoord - y, (float) lookPos.hitVec.zCoord - z);
+					if(heldItemStack.stackSize == 0) {
+						event.setCanceled(true);
+						break;
+					}
+				}
+
 			}
+			recursion = false;
+			player.posX = oldPosX;
+			player.posY = oldPosY;
+			player.posZ = oldPosZ;
+			player.rotationPitch = oldPitch;
+			player.rotationYaw = oldYaw;
 		}
 	}
 
+	public static void setMode(ItemStack stack, boolean state) {
+		stack.stackTagCompound.setBoolean(TAG_MODE, state);
+	}
+
+	public static void setBreakingMode(ItemStack stack, boolean state) {
+		stack.stackTagCompound.setBoolean(TAG_BREAKING_MODE, state);
+	}
+
+	public static void setMirrorMode (ItemStack stack, byte state) {
+		stack.stackTagCompound.setByte(TAG_MIRROR_MODE, state);
+	}
+
+
+	@SideOnly(Side.CLIENT)
+	public static void renderHUDNotification(HUD_MESSAGE type){
+		Minecraft mc = Minecraft.getMinecraft();
+		String text;
+		switch (type) {
+			case MODE:
+				text = getLokiModeText(getLokiRing(mc.thePlayer));
+				break;
+			case BREAKING:
+				text = getLokiBreakingModeText(getLokiRing(mc.thePlayer));
+				break;
+			case CLEAR:
+				text = getLokiCearText(getLokiRing(mc.thePlayer));
+				break;
+			case MIRROR:
+				text = getLokiMirrorText(getLokiRing(mc.thePlayer));
+				break;
+			case INSUFFICIENT_MANA:
+				text = EnumChatFormatting.RED + StatCollector.translateToLocal("botaniamisc.insufficient_mana");
+				break;
+			default:
+				return;
+				
+		}
+		 
+		GTNHLib.proxy.printMessageAboveHotbar(text, 60, true, true);
+	}
+	
+	public static String getOnOffString(boolean state){
+		return state ? EnumChatFormatting.GREEN + StatCollector.translateToLocal("botaniamisc.lokiOn") :
+				EnumChatFormatting.RED + StatCollector.translateToLocal("botaniamisc.lokiOff");
+	}
+
+	public static String getAxisString(byte state) {
+		EnumChatFormatting x = LokiCursor.isMirrorX(state) ? EnumChatFormatting.GREEN : EnumChatFormatting.RED;
+		EnumChatFormatting y = LokiCursor.isMirrorY(state) ? EnumChatFormatting.GREEN : EnumChatFormatting.RED;
+		EnumChatFormatting z = LokiCursor.isMirrorZ(state) ? EnumChatFormatting.GREEN : EnumChatFormatting.RED;
+
+		return x + "X " + y + "Y " + z + "Z";
+	}
+
+	public static String getLokiModeText(ItemStack stack){
+		return EnumChatFormatting.GOLD + StatCollector.translateToLocal("item.botania:lokiRing.name") + " " + getOnOffString(isRingEnabled(stack));
+	}
+
+	public static String getLokiMirrorText(ItemStack stack){
+		return EnumChatFormatting.GOLD + StatCollector.translateToLocal("botaniamisc.lokiMirror") + " "+
+				getAxisString(getRingMirrorMode(stack));
+	}
+
+	public static String getLokiCearText(ItemStack stack){
+		return EnumChatFormatting.GOLD + StatCollector.translateToLocal("botaniamisc.lokiClear");		
+	}
+
+	public static String getLokiBreakingModeText(ItemStack stack){
+		return EnumChatFormatting.GOLD + StatCollector.translateToLocal("item.botania:lokiRing.name") + " "+
+				StatCollector.translateToLocal("botaniamisc.breaking") + " " + getOnOffString(isRingBreakingEnabled(stack));
+	}
+
+
+
+	public static boolean isRingEnabled (final ItemStack stack){
+		if (stack.hasTagCompound())
+		{
+			return stack.stackTagCompound.getBoolean(TAG_MODE);
+		}
+		return false;
+	}
+
+	public static boolean isRingBreakingEnabled (final ItemStack stack){
+		if (stack.hasTagCompound())
+		{
+			return stack.stackTagCompound.getBoolean(TAG_BREAKING_MODE);
+		}
+		return false;
+	}
+
+	public static byte getRingMirrorMode(final ItemStack stack){
+		if(stack.hasTagCompound()){
+			return stack.stackTagCompound.getByte(TAG_MIRROR_MODE);
+		}
+		return 0;
+	}
 	public static void breakOnAllCursors(EntityPlayer player, Item item, ItemStack stack, int x, int y, int z, int side) {
 		ItemStack lokiRing = getLokiRing(player);
-		if(lokiRing == null || player.worldObj.isRemote || !(item instanceof ISequentialBreaker))
+		if (lokiRing == null || player.worldObj.isRemote || !isRingEnabled(lokiRing) || !isRingBreakingEnabled(lokiRing))
 			return;
+		List<LokiCursor> cursors = getCursorList(lokiRing);
+		//In case someone wants to mine ore veins with loki, this should make 1 manapool worth of mana last for 2 veins
+		int cost = 30 * cursors.size();
+		if (!ManaItemHandler.requestManaExact(lokiRing, player, cost, true)) {
 
-		List<ChunkCoordinates> cursors = getCursorList(lokiRing);
-		ISequentialBreaker breaker = (ISequentialBreaker) item;
+		if (player instanceof EntityPlayerMP) {
+			vazkii.botania.common.network.PacketHandler.INSTANCE.sendTo(new PacketLokiHudNotificationAck(HUD_MESSAGE.INSUFFICIENT_MANA), (EntityPlayerMP) player);
+		} else {
+			renderHUDNotification(HUD_MESSAGE.INSUFFICIENT_MANA);
+		}
+		}
+		ISequentialBreaker breaker  = null;
+		if(item instanceof ISequentialBreaker)
+			breaker = (ISequentialBreaker) item;
 		World world = player.worldObj;
 		boolean silk = EnchantmentHelper.getEnchantmentLevel(Enchantment.silkTouch.effectId, stack) > 0;
 		int fortune = EnchantmentHelper.getEnchantmentLevel(Enchantment.fortune.effectId, stack);
-		boolean dispose = breaker.disposeOfTrashBlocks(stack);
+		boolean dispose = breaker == null? true : breaker.disposeOfTrashBlocks(stack);
+
+		ChunkCoordinates originCoords = getOriginPos(lokiRing);
+
+		int masterOffsetX = originCoords.posY == -1 ? 0 :x - originCoords.posX;
+		int masterOffsetY = originCoords.posY == -1 ? 0 :y - originCoords.posY;
+		int masterOffsetZ = originCoords.posY == -1 ? 0 :z - originCoords.posZ;
 
 		for(int i = 0; i < cursors.size(); i++) {
-			ChunkCoordinates coords = cursors.get(i);
-			int xp = x + coords.posX;
-			int yp = y + coords.posY;
-			int zp = z + coords.posZ;
+			LokiCursor cursor = cursors.get(i);
+			int xp = x + cursor.getX();
+			int yp = y + cursor.getY();
+			int zp = z + cursor.getZ();
+			if(cursor.isMirrorX()){
+				xp -= 2*masterOffsetX;
+			}
+			if(cursor.isMirrorY()){
+				yp -= 2*masterOffsetY;
+			}
+			if(cursor.isMirrorZ()){
+				zp -= 2*masterOffsetZ;
+			}
+
+			if(cursor.isMirrorX() && (side == ForgeDirection.EAST.ordinal() || side == ForgeDirection.WEST.ordinal()) ){
+				side = side ^ 1;
+			}
+			if(cursor.isMirrorY() && (side == ForgeDirection.DOWN.ordinal() || side == ForgeDirection.UP.ordinal()) ){
+				side = side ^ 1;
+			}
+			if(cursor.isMirrorZ() && (side == ForgeDirection.NORTH.ordinal() || side == ForgeDirection.SOUTH.ordinal()) ){
+				side = side ^ 1;
+			}
+
+
+
 			Block block = world.getBlock(xp, yp, zp);
-			breaker.breakOtherBlock(player, stack, xp, yp, zp, x, y, z, side);
-			ToolCommons.removeBlockWithDrops(player, stack, player.worldObj, xp, yp, zp, x, y, z, block, new Material[] { block.getMaterial() }, silk, fortune, block.getBlockHardness(world, xp, yp, zp), dispose);
+			if(breaker != null)
+				breaker.breakOtherBlock(player, stack, xp, yp, zp, x, y, z, side);
+			ToolCommons.removeBlockWithDrops(player, stack, player.worldObj, xp, yp, zp, x, y, z, block, new Material[] { block.getMaterial() }, silk, fortune, block.getBlockHardness(world, xp, yp, zp), true);
 		}
 	}
 
@@ -168,34 +443,55 @@ public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeC
 
 	@Override
 	public void onUnequipped(ItemStack stack, EntityLivingBase player) {
-		setCursorList(stack, null);
+		clearCursors(stack);
+	}
+
+	@Override
+	public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean adv) {
+		addStringToTooltip(StatCollector.translateToLocal("botaniamisc.lokiDescription"), list);
+		addStringToTooltip(StatCollector.translateToLocal("botaniamisc.lokiDescription2"), list);
+		addStringToTooltip("", list);
+		addStringToTooltip(EnumChatFormatting.WHITE +StatCollector.translateToLocal("botaniamisc.lokiCurrent"), list);
+		addStringToTooltip(StatCollector.translateToLocal("botaniamisc.lokiState") + ": " + getOnOffString(isRingEnabled(stack)), list);
+		addStringToTooltip(StatCollector.translateToLocal("botaniamisc.breaking") + ": " + getOnOffString(isRingBreakingEnabled(stack)), list);
+		addStringToTooltip(StatCollector.translateToLocal("botaniamisc.lokiMirror") + getAxisString(getRingMirrorMode(stack)), list);
+		addStringToTooltip("", list);
+		addStringToTooltip(StatCollector.translateToLocal("botaniamisc.lokiToggleDescription") + " " + getOnOffString(true) + EnumChatFormatting.RESET + "/"+ getOnOffString(false), list);
+		addStringToTooltip(StatCollector.translateToLocal("botaniamisc.lokiBreakingDescription") + " " + getOnOffString(true) + EnumChatFormatting.RESET+"/" + getOnOffString(false), list);	
+		super.addInformation(stack, player, list, adv);
 	}
 
 	@Override
 	@SideOnly(Side.CLIENT)
 	public List<ChunkCoordinates> getWireframesToDraw(EntityPlayer player, ItemStack stack) {
-		if(getLokiRing(player) != stack)
+		ItemStack lokiRing = getLokiRing(player);
+		if(lokiRing != stack || !isRingEnabled(lokiRing) )
 			return null;
 
 		MovingObjectPosition lookPos = Minecraft.getMinecraft().objectMouseOver;
 
-		if(lookPos != null && !player.worldObj.isAirBlock(lookPos.blockX, lookPos.blockY, lookPos.blockZ) && lookPos.entityHit == null) {
-			List<ChunkCoordinates> list = getCursorList(stack);
+		if(lookPos != null && lookPos.entityHit == null) {
+			List<LokiCursor> list = getCursorList(stack);
 			ChunkCoordinates origin = getOriginPos(stack);
+			List<ChunkCoordinates> toDraw = new ArrayList<>();
 
 			if(origin.posY != -1) {
-				for(ChunkCoordinates coords : list) {
+				for(LokiCursor cursor : list) {
+					ChunkCoordinates coords = cursor.getCoordinates();
 					coords.posX += origin.posX;
 					coords.posY += origin.posY;
 					coords.posZ += origin.posZ;
+					toDraw.add(coords);
 				}
-			} else for(ChunkCoordinates coords : list) {
+			} else for(LokiCursor cursor : list) {
+				ChunkCoordinates coords = cursor.getCoordinates();
 				coords.posX += lookPos.blockX;
 				coords.posY += lookPos.blockY;
 				coords.posZ += lookPos.blockZ;
+				toDraw.add(coords);
 			}
 
-			return list;
+			return toDraw;
 		}
 
 		return null;
@@ -203,16 +499,35 @@ public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeC
 
 	@Override
 	public ChunkCoordinates getSourceWireframe(EntityPlayer player, ItemStack stack) {
-		return getLokiRing(player) == stack ? getOriginPos(stack) : null;
+		return getLokiRing(player) == stack && isRingEnabled(stack) ? getOriginPos(stack) : null;
 	}
 
-	private static ItemStack getLokiRing(EntityPlayer player) {
+	public static void clearCursors(ItemStack stack){
+		setCursorList(stack, null);
+	}
+	
+	public static void clearMasterCursor(ItemStack stack){
+		setOriginPos(stack, 0, -1, 0);
+	}
+
+	public static ItemStack getLokiRing(EntityPlayer player) {
 		InventoryBaubles baubles = PlayerHandler.getPlayerBaubles(player);
 		ItemStack stack1 = baubles.getStackInSlot(1);
 		ItemStack stack2 = baubles.getStackInSlot(2);
 		return isLokiRing(stack1) ? stack1 : isLokiRing(stack2) ? stack2 : null;
 	}
 
+	public static int getLokiRingSlot(EntityPlayer player) {
+		InventoryBaubles baubles = PlayerHandler.getPlayerBaubles(player);
+		ItemStack stack1 = baubles.getStackInSlot(1);
+		ItemStack stack2 = baubles.getStackInSlot(2);
+		return isLokiRing(stack1) ? 1 : isLokiRing(stack2) ? 2 : null;
+	}
+
+	public static void syncLokiRing(EntityPlayer player){
+		baubles.common.network.PacketHandler.INSTANCE.sendTo(new PacketSyncBauble(player, getLokiRingSlot(player)), (EntityPlayerMP) player);
+	}
+
 	private static boolean isLokiRing(ItemStack stack) {
 		return stack != null && (stack.getItem() == ModItems.lokiRing || stack.getItem() == ModItems.aesirRing);
 	}
@@ -230,28 +545,26 @@ public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeC
 		ItemNBTHelper.setInt(stack, TAG_Z_ORIGIN, z);
 	}
 
-	private static List<ChunkCoordinates> getCursorList(ItemStack stack) {
+	private static List<LokiCursor> getCursorList(ItemStack stack) {
 		NBTTagCompound cmp = ItemNBTHelper.getCompound(stack, TAG_CURSOR_LIST, false);
-		List<ChunkCoordinates> cursors = new ArrayList();
+		List<LokiCursor> cursors = new ArrayList();
 
 		int count = cmp.getInteger(TAG_CURSOR_COUNT);
 		for(int i = 0; i < count; i++) {
 			NBTTagCompound cursorCmp = cmp.getCompoundTag(TAG_CURSOR_PREFIX + i);
-			int x = cursorCmp.getInteger(TAG_X_OFFSET);
-			int y = cursorCmp.getInteger(TAG_Y_OFFSET);
-			int z = cursorCmp.getInteger(TAG_Z_OFFSET);
-			cursors.add(new ChunkCoordinates(x, y, z));
+			cursors.add(LokiCursor.fromNBT(cursorCmp));
+
 		}
 
 		return cursors;
 	}
 
-	private static void setCursorList(ItemStack stack, List<ChunkCoordinates> cursors) {
+	private static void setCursorList(ItemStack stack, List<LokiCursor> cursors) {
 		NBTTagCompound cmp = new NBTTagCompound();
 		if(cursors != null) {
 			int i = 0;
-			for(ChunkCoordinates cursor : cursors) {
-				NBTTagCompound cursorCmp = cursorToCmp(cursor.posX, cursor.posY, cursor.posZ);
+			for(LokiCursor cursor : cursors) {
+				NBTTagCompound cursorCmp = cursor.toNBT();
 				cmp.setTag(TAG_CURSOR_PREFIX + i, cursorCmp);
 				i++;
 			}
@@ -261,18 +574,12 @@ public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeC
 		ItemNBTHelper.setCompound(stack, TAG_CURSOR_LIST, cmp);
 	}
 
-	private static NBTTagCompound cursorToCmp(int x, int y, int z) {
-		NBTTagCompound cmp = new NBTTagCompound();
-		cmp.setInteger(TAG_X_OFFSET, x);
-		cmp.setInteger(TAG_Y_OFFSET, y);
-		cmp.setInteger(TAG_Z_OFFSET, z);
-		return cmp;
-	}
 
-	private static void addCursor(ItemStack stack, int x, int y, int z) {
+
+	private static void addCursor(ItemStack stack, int x, int y, int z, byte mirrorMode) {
 		NBTTagCompound cmp = ItemNBTHelper.getCompound(stack, TAG_CURSOR_LIST, false);
 		int count = cmp.getInteger(TAG_CURSOR_COUNT);
-		cmp.setTag(TAG_CURSOR_PREFIX + count, cursorToCmp(x, y, z));
+		cmp.setTag(TAG_CURSOR_PREFIX + count, new LokiCursor(x,y,z, mirrorMode).toNBT());
 		cmp.setInteger(TAG_CURSOR_COUNT, count + 1);
 		ItemNBTHelper.setCompound(stack, TAG_CURSOR_LIST, cmp);
 	}
@@ -282,5 +589,117 @@ public class ItemLokiRing extends ItemRelicBauble implements IExtendedWireframeC
 		return true;
 	}
 
+	@Override
+	@SideOnly(Side.CLIENT)
+	public void renderInWorld(EntityPlayer player, ItemStack stack){
+		renderMirrors(player,stack);
+	}
+
+	@SideOnly(Side.CLIENT)
+	private void renderMirrors(EntityPlayer player,ItemStack stack) {
+		ItemStack lokiRing = getLokiRing(player);
+		if(lokiRing != stack || !isRingEnabled(lokiRing) )
+			return;
+
+		World world = Minecraft.getMinecraft().theWorld;
+		List<LokiCursor> cursors = getCursorList(stack);
+		ChunkCoordinates origin = getOriginPos(stack);
+		MovingObjectPosition lookPos = Minecraft.getMinecraft().objectMouseOver;
+
+
+		for(LokiCursor cursor : cursors) {
+			if(!cursor.isMirror()) {
+				continue;
+			}
+			ChunkCoordinates pos = cursor.getCoordinates();
+			if(origin.posY != -1){
+
+				pos.posX += origin.posX;
+				pos.posY += origin.posY;
+				pos.posZ += origin.posZ;
+			}else{
+				pos.posX += lookPos.blockX;
+				pos.posY += lookPos.blockY;
+				pos.posZ += lookPos.blockZ;
+			}
+
+
+			GL11.glPushMatrix();
+			GL11.glTranslated(pos.posX - RenderManager.renderPosX, pos.posY - RenderManager.renderPosY, pos.posZ - RenderManager.renderPosZ + 1);
+			Color colorRGB = new Color(BoundTileRenderer.getWireframeColor());
+			GL11.glColor4ub((byte) colorRGB.getRed(), (byte) colorRGB.getGreen(), (byte) colorRGB.getBlue(), (byte) 255);
+			Block block = world.getBlock(pos.posX, pos.posY, pos.posZ);
+
+			if (block != null) {
+				AxisAlignedBB axis = block.getSelectedBoundingBoxFromPool(world, pos.posX, pos.posY, pos.posZ);
+
+				if (axis != null) {
+					axis.minX -= pos.posX;
+					axis.maxX -= pos.posX;
+					axis.minY -= pos.posY;
+					axis.maxY -= pos.posY;
+					axis.minZ -= pos.posZ + 1;
+					axis.maxZ -= pos.posZ + 1;
+
+					GL11.glScalef(1F, 1F, 1F);
+
+					GL11.glLineWidth(1F);
+					Tessellator tessellator = Tessellator.instance;
+					tessellator.startDrawing(GL11.GL_LINES);
+					if (cursor.isMirrorX()) {
+
+						tessellator.addVertex(axis.minX,axis.minY,axis.minZ);
+						tessellator.addVertex(axis.minX,axis.maxY,axis.maxZ);
+
+						tessellator.addVertex(axis.minX,axis.maxY,axis.minZ);
+						tessellator.addVertex(axis.minX,axis.minY,axis.maxZ);
+
+						tessellator.addVertex(axis.maxX,axis.minY,axis.minZ);
+						tessellator.addVertex(axis.maxX,axis.maxY,axis.maxZ);
+
+						tessellator.addVertex(axis.maxX,axis.maxY,axis.minZ);
+						tessellator.addVertex(axis.maxX,axis.minY,axis.maxZ);
+
+					}
+					if (cursor.isMirrorY()) {
+
+						tessellator.addVertex(axis.minX,axis.minY,axis.minZ);
+						tessellator.addVertex(axis.maxX,axis.minY,axis.maxZ);
+
+						tessellator.addVertex(axis.maxX,axis.minY,axis.minZ);
+						tessellator.addVertex(axis.minX,axis.minY,axis.maxZ);
+
+						tessellator.addVertex(axis.minX,axis.maxY,axis.minZ);
+						tessellator.addVertex(axis.maxX,axis.maxY,axis.maxZ);
+
+						tessellator.addVertex(axis.maxX,axis.maxY,axis.minZ);
+						tessellator.addVertex(axis.minX,axis.maxY,axis.maxZ);
+
+					}
+					if (cursor.isMirrorZ()) {
+
+						tessellator.addVertex(axis.minX,axis.minY,axis.minZ);
+						tessellator.addVertex(axis.maxX,axis.maxY,axis.minZ);
+
+						tessellator.addVertex(axis.minX,axis.maxY,axis.minZ);
+						tessellator.addVertex(axis.maxX,axis.minY,axis.minZ);
+
+						tessellator.addVertex(axis.minX,axis.minY,axis.maxZ);
+						tessellator.addVertex(axis.maxX,axis.maxY,axis.maxZ);
+
+						tessellator.addVertex(axis.minX,axis.maxY,axis.maxZ);
+						tessellator.addVertex(axis.maxX,axis.minY,axis.maxZ);
+
+
+					}
+					tessellator.draw();
+				}
+			}
+
+			GL11.glPopMatrix();
+		}
+	}
+
+
 }
 

src/main/java/vazkii/botania/common/lexicon/LexiconData.java

@@ -69,6 +69,7 @@ public final class LexiconData {
 	public static LexiconEntry terrasteel;
 	public static LexiconEntry blackLotus;
 	public static LexiconEntry flowerBag;
+	public static LexiconEntry shroomBag;
 	public static LexiconEntry gardenOfGlass;
 
 	public static LexiconEntry manaIntro;
@@ -395,6 +396,10 @@ public final class LexiconData {
 		flowerBag.setLexiconPages(new PageText("0"), new PageText("2"),
 				new PageCraftingRecipe("1", ModCraftingRecipes.recipeFlowerBag));
 
+		shroomBag = new BLexiconEntry(LibLexicon.BASICS_SHROOM_BAG, categoryBasics);
+		shroomBag.setLexiconPages(new PageText("0"),
+				new PageCraftingRecipe("1", ModCraftingRecipes.recipeShroomBag));
+
 		if (Botania.gardenOfGlassLoaded) {
 			gardenOfGlass = new BLexiconEntry(LibLexicon.BASICS_GARDEN_OF_GLASS, categoryBasics);
 			gardenOfGlass.setLexiconPages(new PageText("0"), new PageText("1"), new PageText("2"),

src/main/java/vazkii/botania/common/lexicon/page/PageCraftingRecipe.java

@@ -36,6 +36,7 @@ import vazkii.botania.client.lib.LibResources;
 import cpw.mods.fml.relauncher.ReflectionHelper;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import vazkii.botania.common.core.helper.InventoryHelper;
 
 public class PageCraftingRecipe extends PageRecipe {
 
@@ -140,7 +141,7 @@ public class PageCraftingRecipe extends PageRecipe {
 				for(int x = 0; x < width; x++) {
 					Object input = shaped.getInput()[y * width + x];
 					if(input != null)
-						renderItemAtGridPos(gui, 1 + x, 1 + y, input instanceof ItemStack ? (ItemStack) input : ((ArrayList<ItemStack>) input).get(0), true);
+						renderItemAtGridPos(gui, 1 + x, 1 + y, InventoryHelper.cycleItemStackForDisplay(input), true);
 				}
 
 			oreDictRecipe = true;
@@ -173,7 +174,7 @@ public class PageCraftingRecipe extends PageRecipe {
 
 						Object input = shapeless.getInput().get(index);
 						if(input != null)
-							renderItemAtGridPos(gui, 1 + x, 1 + y, input instanceof ItemStack ? (ItemStack) input : ((ArrayList<ItemStack>) input).get(0), true);
+							renderItemAtGridPos(gui, 1 + x, 1 + y, InventoryHelper.cycleItemStackForDisplay(input), true);
 					}
 			}
 

src/main/java/vazkii/botania/common/lexicon/page/PageRecipe.java

@@ -38,7 +38,7 @@ import cpw.mods.fml.relauncher.SideOnly;
 public class PageRecipe extends LexiconPage {
 
 	int relativeMouseX, relativeMouseY;
-	ItemStack tooltipStack, tooltipContainerStack;
+	ItemStack tooltipStack;
 	boolean tooltipEntry;
 
 	static boolean mouseDownLastTick = false;
@@ -80,14 +80,10 @@ public class PageRecipe extends LexiconPage {
 
 			if(tooltipEntry) {
 				vazkii.botania.client.core.helper.RenderHelper.renderTooltipOrange(mx, my + tooltipY, Arrays.asList(EnumChatFormatting.GRAY + StatCollector.translateToLocal("botaniamisc.clickToRecipe")));
-				tooltipY += 18;
 			}
-
-			if(tooltipContainerStack != null)
-				vazkii.botania.client.core.helper.RenderHelper.renderTooltipGreen(mx, my + tooltipY, Arrays.asList(EnumChatFormatting.AQUA + StatCollector.translateToLocal("botaniamisc.craftingContainer"), tooltipContainerStack.getDisplayName()));
 		}
 
-		tooltipStack = tooltipContainerStack = null;
+		tooltipStack = null;
 		tooltipEntry = false;
 		GL11.glDisable(GL11.GL_BLEND);
 		mouseDownLastTick = Mouse.isButtonDown(0);
@@ -170,12 +166,6 @@ public class PageRecipe extends LexiconPage {
 					Minecraft.getMinecraft().displayGuiScreen(newGui);
 				}
 			} else tooltipEntry = false;
-
-			if(accountForContainer) {
-				ItemStack containerStack = stack.getItem().getContainerItem(stack);
-				if(containerStack != null && containerStack.getItem() != null)
-					tooltipContainerStack = containerStack;
-			}
 		}
 
 		GL11.glDisable(GL11.GL_LIGHTING);

src/main/java/vazkii/botania/common/lib/LibGuiIDs.java

@@ -17,4 +17,6 @@ public final class LibGuiIDs {
 	public static final int FLOWER_BAG = 2;
 	public static final int BAUBLE_BOX = 3;
 
+	public static final int SHROOM_BAG = 4;
+
 }