fix: hide direction labels in the P2P Tunnel - ME Dual Interface GUI (#481)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.github/workflows/optimize-images.yml

@@ -0,0 +1,17 @@
+name: Optimize images
+
+on:
+  pull_request:
+    branches: [ master, main, release/** ]
+    paths:
+      - "**/*.png"
+
+  push:
+    branches: [ master, main, release/** ]
+    paths:
+      - "**/*.png"
+
+jobs:
+  optimize-images:
+    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/optimize-images.yml@master
+    secrets: inherit

.gitignore

@@ -1,9 +1,39 @@
-*.bat
-.gradle/
-.idea/
-out/
+.gradle
+.settings
+/.idea/
+/.vscode/
+/run/
+/build/
+/eclipse/
+.classpath
+.project
+/bin/
+/config/
+/crash-reports/
+/logs/
+options.txt
+/saves/
+usernamecache.json
+banned-ips.json
+banned-players.json
+eula.txt
+ops.json
+server.properties
+servers.dat
+usercache.json
+whitelist.json
+/out/
 *.iml
 *.ipr
 *.iws
-run/
-build/
+src/main/resources/mixins.*([!.]).json
+*.bat
+*.sh
+*.DS_Store
+!gradlew.bat
+.factorypath
+addon.local.gradle
+addon.local.gradle.kts
+addon.late.local.gradle
+addon.late.local.gradle.kts
+layout.json

dependencies.gradle

@@ -1,22 +1,55 @@
-// Add your dependencies here
-
+/*
+ * Add your dependencies here. Supported configurations:
+ *  - api("group:name:version:classifier"): if you use the types from this dependency in the public API of this mod
+ *       Available at runtime and compiletime for mods depending on this mod
+ *  - implementation("g:n:v:c"): if you need this for internal implementation details of the mod, but none of it is visible via the public API
+ *       Available at runtime but not compiletime for mods depending on this mod
+ *  - compileOnly("g:n:v:c"): if the mod you're building doesn't need this dependency during runtime at all, e.g. for optional mods
+ *       Not available at all for mods depending on this mod, only visible at compiletime for this mod
+ *  - compileOnlyApi("g:n:v:c"): like compileOnly, but also visible at compiletime for mods depending on this mod
+ *       Available at compiletime but not runtime for mods depending on this mod
+ *  - runtimeOnlyNonPublishable("g:n:v:c"): if you want to include a mod in this mod's runClient/runServer runs, but not publish it as a dependency
+ *       Not available at all for mods depending on this mod, only visible at runtime for this mod
+ *  - devOnlyNonPublishable("g:n:v:c"): a combination of runtimeOnlyNonPublishable and compileOnly for dependencies present at both compiletime and runtime,
+ *       but not published as Maven dependencies - useful for RFG-deobfuscated dependencies or local testing
+ *  - runtimeOnly("g:n:v:c"): if you don't need this at compile time, but want it to be present at runtime
+ *       Available at runtime for mods depending on this mod
+ *  - annotationProcessor("g:n:v:c"): mostly for java compiler plugins, if you know you need this, use it, otherwise don't worry
+ *  - testCONFIG("g:n:v:c") - replace CONFIG by one of the above (except api), same as above but for the test sources instead of main
+ *
+ *  - shadowImplementation("g:n:v:c"): effectively the same as API, but the dependency is included in your jar under a renamed package name
+ *       Requires you to enable usesShadowedDependencies in gradle.properties
+ *
+ *  - compile("g:n:v:c"): deprecated, replace with "api" (works like the old "compile") or "implementation" (can be more efficient)
+ *
+ * You can exclude transitive dependencies (dependencies of the chosen dependency) by appending { transitive = false } if needed,
+ * but use this sparingly as it can break using your mod as another mod's dependency if you're not careful.
+ *
+ * To depend on obfuscated jars you can use `devOnlyNonPublishable(rfg.deobf("dep:spec:1.2.3"))` to fetch an obfuscated jar from maven,
+ * or `devOnlyNonPublishable(rfg.deobf(project.files("libs/my-mod-jar.jar")))` to use a file.
+ *
+ * Gradle names for some of the configuration can be misleading, compileOnlyApi and runtimeOnly both get published as dependencies in Maven, but compileOnly does not.
+ * The buildscript adds runtimeOnlyNonPublishable to also have a runtime dependency that's not published.
+ *
+ * For more details, see https://docs.gradle.org/8.0.1/userguide/java_library_plugin.html#sec:java_library_configurations_graph
+ */
 dependencies {
-    api('com.github.GTNewHorizons:NotEnoughItems:2.3.50-GTNH:dev')
-    api('com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-215-GTNH:dev')
-    api('curse.maven:cofh-core-69162:2388751')
-    api('com.github.GTNewHorizons:waila:1.6.0:dev')
-    api('com.github.GTNewHorizons:Baubles:1.0.1.16:dev')
+    api('com.github.GTNewHorizons:NotEnoughItems:2.8.160-GTNH:dev')
+    api('com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-1078-GTNH:dev')
+    api('com.github.GTNewHorizons:waila:1.19.34:dev')
+    api("com.github.GTNewHorizons:GTNHLib:0.11.52:dev")
 
-    compileOnly('com.github.GTNewHorizons:ExtraCells2:2.5.34:dev') { transitive = false }
-    compileOnly("com.github.GTNewHorizons:WirelessCraftingTerminal:1.9.0:dev")
+    compileOnly('com.github.GTNewHorizons:Baubles-Expanded:2.2.25-GTNH:dev')
+    compileOnly('com.github.GTNewHorizons:BuildCraft:7.1.64:dev') {transitive = false}
+    compileOnly('com.github.GTNewHorizons:ExtraCells2:2.5.35:dev') { transitive = false }
+    compileOnly('com.github.GTNewHorizons:ForestryMC:4.11.39:dev')
+    compileOnly('com.github.GTNewHorizons:EnderIO:2.10.49:dev')
+    compileOnly('com.github.GTNewHorizons:OpenComputers:1.12.64-GTNH:dev') { transitive = false }
 
-    compileOnly('com.github.GTNewHorizons:ForestryMC:4.6.7:dev')
-    compileOnly('com.github.GTNewHorizons:EnderIO:2.4.14:dev')
-    compileOnly('com.github.GTNewHorizons:GT5-Unofficial:5.09.43.21:dev')
-    compileOnly('thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev')
-    compileOnly('com.gregoriust.gregtech:gregtech_1.7.10:6.14.23:dev') { transitive = false }
-    compileOnly('com.github.GTNewHorizons:OpenComputers:1.9.5-GTNH:dev') { transitive = false }
-    compileOnly('com.github.GTNewHorizons:ThaumicEnergistics:1.4.2-GTNH:dev') { transitive = false }
-    compileOnly('com.github.GTNewHorizons:GTplusplus:1.9.4:dev') { transitive = false }
-    compileOnly("com.github.GTNewHorizons:Hodgepodge:2.2.10:dev") { transitive = false }
+    compileOnly("org.jetbrains:annotations:26.1.0")
+
+    runtimeOnlyNonPublishable("com.github.GTNewHorizons:DuraDisplay:1.4.6:dev")
+    runtimeOnlyNonPublishable("com.github.GTNewHorizons:WirelessCraftingTerminal:1.12.16:dev") {
+        exclude group: 'com.github.GTNewHorizons', module: 'Applied-Energistics-2-Unofficial'
+    }
 }

gradle.properties

@@ -1,71 +1,243 @@
-modName = Fluid Craft For AE2
+# 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
 
-# This is a case-sensitive string to identify your mod. Convention is to use lower case.
+# Human-readable mod name, available for mcmod.info population.
+modName = AE2 Fluid Crafting
+
+# Case-sensitive identifier string, available for mcmod.info population and used for automatic mixin JSON generation.
+# Conventionally lowercase.
 modId = ae2fc
 
+# Root package of the mod, used to find various classes in other properties,
+# mcmod.info substitution, enabling assertions in run tasks, etc.
 modGroup = com.glodblock.github
 
-# 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.
+# When false, com.github.GTNewHorizons is used.
+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 user name each time you
-# restart Minecraft in development. Choose this dependent on your mod:
-# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
-# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
+# 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
 
-# Enables using modern java syntax (up to version 17) via Jabel, while still targetting JVM 8.
-# See https://github.com/bsideup/jabel for details on how this works.
-enableModernJavaSyntax = true
+# Enables modern Java syntax support. Valid values:
+# - false: No modern syntax, Java 8 only
+# - jabel: Jabel syntax-only support, compiles to J8 bytecode
+# - jvmDowngrader: Full modern Java via JVM Downgrader (syntax + stdlib APIs)
+# - modern: Native modern Java bytecode, no downgrading
+enableModernJavaSyntax = jabel
 
-# Define a source file of your project with:
+# If set, ignores the above setting and compiles with the given toolchain. This may cause unexpected issues,
+# and should *not* be used in most situations. -1 disables this.
+# forceToolchainVersion = -1
+
+# Target JVM version for JVM Downgrader bytecode downgrading.
+# Only used when enableModernJavaSyntax = jvmDowngrader
+# downgradeTargetVersion = 8
+
+# Comma-separated list of Java versions for multi-release jar support (JVM Downgrader only).
+# Classes will be available in META-INF/versions/N/ for each version N in this list.
+# Default: "21,25" (J25+ gets native classes, J21-24 gets partial downgrade, J8-20 gets full downgrade).
+# jvmDowngraderMultiReleaseVersions = 21,25
+
+# Specifies how JVM Downgrader API stubs are provided. Options:
+# - shade: Shade minimized stubs into the jar
+# - gtnhlib: GTNHLib provides stubs at runtime (adds version constraint)
+# - external: Another dependency provides stubs (no constraint, no warning)
+# - (empty): Warning reminding you to configure stubs
+# Note: 'shade' option requires you to verify license compliance, see: https://github.com/unimined/JvmDowngrader/blob/main/LICENSE.md
+# jvmDowngraderStubsProvider =
+
+# 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 = true
+
+# 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 = com.glodblock.github.FCTags
+
+# Name of the token containing the project's current version to generate/replace.
+gradleTokenVersion = 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 mods version when compiled. You should use this to specify your mod's
-# version in @Mod([...], version = VERSION, [...])
-# Leave these properties empty to skip individual token replacements
-replaceGradleTokenInFile = FluidCraft.java
-gradleTokenModId = GRADLETOKEN_MODID
-gradleTokenModName = GRADLETOKEN_MODNAME
-gradleTokenVersion = GRADLETOKEN_VERSION
-gradleTokenGroupName = GRADLETOKEN_GROUPNAME
+# 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.
+replaceGradleTokenInFile =
 
 # 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. I must be placed into /src/main/resources/META-INF/
-# Example value: mymodid_at.cfg
+# Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/META-INF/
+# There can be multiple files in a space-separated list.
+# Example value: mymodid_at.cfg nei_at.cfg
 accessTransformersFile = ae2fc_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!
+
+# Specify the package that contains all of your Mixins. The package must exist or
+# the build will fail. If you have a package property defined in your mixins.<modid>.json,
+# it must match with this 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
-coreModClass = coremod.FluidCraftCore
+# 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 'shadowCompile' 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
-# projects. New projects should not use this parameter.
-#customArchiveBaseName =
+# 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
 
-# Optional parameter to prevent the source code from being published
-# noPublishedSources =
+# 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: UniMixins 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 =
+
+# Comma-separated supported CurseForge environments: client, server (case-insensitive).
+# Use client or server for mods that only support one environment. Defaults to client,server.
+# These tags describe where the mod can run, not whether installation is required on both sides.
+curseForgeEnvironments = client,server
+
+# 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 =
+
+# Optional parameter to customize the default working directory used by the runClient* tasks. Relative to the project directory.
+# runClientWorkingDirectory = run/client
+
+# Optional parameter to customize the default working directory used by the runServer* tasks. Relative to the project directory.
+# runServerWorkingDirectory = run/server
+
+# 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
+
+# Non-GTNH properties
+org.gradle.configuration-cache = true
+org.gradle.parallel = true

gradle/gradle-daemon-jvm.properties

@@ -0,0 +1,12 @@
+#This file is generated by updateDaemonJvm
+toolchainUrl.FREE_BSD.AARCH64=https\://api.foojay.io/disco/v3.0/ids/539ea72837c6244075f8ee037babc29e/redirect
+toolchainUrl.FREE_BSD.X86_64=https\://api.foojay.io/disco/v3.0/ids/876dbbf00bf4ef6190f7da074cee903a/redirect
+toolchainUrl.LINUX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/539ea72837c6244075f8ee037babc29e/redirect
+toolchainUrl.LINUX.X86_64=https\://api.foojay.io/disco/v3.0/ids/876dbbf00bf4ef6190f7da074cee903a/redirect
+toolchainUrl.MAC_OS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/9064f22734b42ac03e85df04b632e167/redirect
+toolchainUrl.MAC_OS.X86_64=https\://api.foojay.io/disco/v3.0/ids/4d0277c49991306ac78048580fe34bcf/redirect
+toolchainUrl.UNIX.AARCH64=https\://api.foojay.io/disco/v3.0/ids/539ea72837c6244075f8ee037babc29e/redirect
+toolchainUrl.UNIX.X86_64=https\://api.foojay.io/disco/v3.0/ids/876dbbf00bf4ef6190f7da074cee903a/redirect
+toolchainUrl.WINDOWS.AARCH64=https\://api.foojay.io/disco/v3.0/ids/a9fa3b809e484a1e1ac4308a5dda661a/redirect
+toolchainUrl.WINDOWS.X86_64=https\://api.foojay.io/disco/v3.0/ids/aa99913fa6d767d899ffc96082da01ca/redirect
+toolchainVersion=25

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,9 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.1-bin.zip
 networkTimeout=10000
+retries=0
+retryBackOffMs=500
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 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,10 +15,12 @@
 # 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 POSIX generated by Gradle.
+#   gradlew start up script for POSIX generated by Gradle.
 #
 #   Important for running:
 #
@@ -27,7 +29,7 @@
 #       bash, then to run this script, type that shell name before the whole
 #       command line, like:
 #
-#           ksh Gradle
+#           ksh gradlew
 #
 #       Busybox and similar reduced shells will NOT work, because this script
 #       requires all of these POSIX shell features:
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/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/.
@@ -83,10 +85,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# 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"'
+# 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\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -114,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -133,10 +132,13 @@ 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.
+    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.
@@ -144,7 +146,7 @@ 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=SC3045 
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +154,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -169,7 +171,6 @@ fi
 # 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" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -197,16 +198,19 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# 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, 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 \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew.bat

@@ -0,0 +1,82 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  gradlew startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables, and ensure extensions are enabled
+setlocal EnableExtensions
+
+set DIRNAME=%~dp0
+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"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+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
+
+"%COMSPEC%" /c exit 1
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+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
+
+"%COMSPEC%" /c exit 1
+
+:execute
+@rem Setup the command line
+
+
+
+@rem Execute gradlew
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
+
+:exitWithErrorLevel
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
+"%COMSPEC%" /c exit %ERRORLEVEL%

repositories.gradle

@@ -1,4 +1,5 @@
 // Add any additional repositories for your dependencies here
 
 repositories {
+    mavenLocal()
 }

settings.gradle

@@ -4,10 +4,10 @@ pluginManagement {
         maven {
             // RetroFuturaGradle
             name "GTNH Maven"
-            url "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
-            allowInsecureProtocol = true
+            url "https://nexus.gtnewhorizons.com/repository/public/"
             mavenContent {
-                includeGroup("com.gtnewhorizons.retrofuturagradle")
+                includeGroup("com.gtnewhorizons")
+                includeGroupByRegex("com\\.gtnewhorizons\\..+")
             }
         }
         gradlePluginPortal()
@@ -17,12 +17,7 @@ pluginManagement {
 }
 
 plugins {
-    id 'com.diffplug.blowdryerSetup' version '1.6.0'
-    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.4.0' // Provides java toolchains
+    id 'com.gtnewhorizons.gtnhsettingsconvention' version '2.0.34'
 }
 
-blowdryerSetup {
-    repoSubfolder 'gtnhShared'
-    github('GTNewHorizons/ExampleMod1.7.10', 'tag', '0.2.0')
-    //devLocal '.' // Use this when testing config updates locally
-}
+

src/main/java/com/glodblock/github/FluidCraft.java

@@ -3,36 +3,35 @@ package com.glodblock.github;
 import net.minecraft.util.ResourceLocation;
 
 import com.glodblock.github.common.Config;
-import com.glodblock.github.common.storage.FluidCellHandler;
-import com.glodblock.github.crossmod.extracells.EC2Replacer;
 import com.glodblock.github.crossmod.opencomputers.OCDriverInit;
 import com.glodblock.github.crossmod.waila.WailaInit;
 import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.loader.CalculatorV2PluginLoader;
 import com.glodblock.github.loader.ChannelLoader;
 import com.glodblock.github.loader.ItemAndBlockHolder;
 import com.glodblock.github.loader.RecipeLoader;
-import com.glodblock.github.loader.filter.FluidFilter;
-import com.glodblock.github.network.SPacketMEUpdateBuffer;
 import com.glodblock.github.proxy.CommonProxy;
+import com.glodblock.github.util.FluidCellHandler;
 import com.glodblock.github.util.ModAndClassUtil;
 
 import appeng.api.AEApi;
 import cpw.mods.fml.common.Mod;
 import cpw.mods.fml.common.SidedProxy;
-import cpw.mods.fml.common.event.*;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import cpw.mods.fml.common.network.NetworkRegistry;
 
 @Mod(
         modid = FluidCraft.MODID,
         version = FluidCraft.VERSION,
         name = FluidCraft.MODNAME,
-        dependencies = "required-after:appliedenergistics2;required-after:CoFHCore;required-after:Baubles;after:waila;after:thaumicenergistics;after:ae2wct")
+        dependencies = "required-after:appliedenergistics2@[rv3-beta-238,);after:waila;after:thaumicenergistics;after:ae2wct")
 public class FluidCraft {
 
-    public static final String MODID = "GRADLETOKEN_MODID";
-    public static final String VERSION = "GRADLETOKEN_VERSION";
-    public static final String MODNAME = "GRADLETOKEN_MODNAME";
+    public static final String MODID = "ae2fc";
+    public static final String VERSION = FCTags.VERSION;
+    public static final String MODNAME = "AE2 Fluid Crafting";
 
     @Mod.Instance(MODID)
     public static FluidCraft INSTANCE;
@@ -51,7 +50,6 @@ public class FluidCraft {
 
     @Mod.EventHandler
     public static void init(FMLInitializationEvent event) {
-        ModAndClassUtil.init();
         if (ModAndClassUtil.OC) {
             OCDriverInit.run();
         }
@@ -64,45 +62,27 @@ public class FluidCraft {
     @Mod.EventHandler
     public static void postInit(FMLPostInitializationEvent event) {
         NetworkRegistry.INSTANCE.registerGuiHandler(FluidCraft.INSTANCE, new InventoryHandler());
-
         AEApi.instance().registries().cell().addCellHandler(new FluidCellHandler());
         ItemAndBlockHolder.loadSetting();
 
         if (!Config.removeRecipe) {
             RecipeLoader.INSTANCE.run();
         }
+        if (!ModAndClassUtil.NEW_HORIZONS_CORE_MOD) {
+            RecipeLoader.addTerminalCards();
+            RecipeLoader.addInfiniteWaterCell();
+        }
         RecipeLoader.runTerminalRecipe();
-
-        if (ModAndClassUtil.isV2) {
-            CalculatorV2PluginLoader.installCalculatorV2Plugins();
-        }
-        if (ModAndClassUtil.isTypeFilter) {
-            AEApi.instance().registries().itemDisplay().addItemFilter(FluidFilter::filter);
-        }
+        RecipeLoader.addDisassembleRecipe();
 
         proxy.postInit(event);
     }
 
     @Mod.EventHandler
-    public void onServerStart(FMLServerStartingEvent event) {
-        SPacketMEUpdateBuffer.init();
+    public void onLoadComplete(FMLLoadCompleteEvent event) {
+        proxy.onLoadComplete(event);
     }
 
-    @Mod.EventHandler
-    public void onServerStop(FMLServerStoppedEvent event) {
-        SPacketMEUpdateBuffer.disable();
-    }
-
-    @Mod.EventHandler
-    public void missingMappings(FMLMissingMappingsEvent event) {
-        if (!ModAndClassUtil.EC2 && Config.replaceEC2) {
-            EC2Replacer.replaceExtraCells(event);
-        }
-    }
-
-    @Mod.EventHandler
-    public void onLoadComplete(FMLLoadCompleteEvent event) {}
-
     public static ResourceLocation resource(String path) {
         return new ResourceLocation(MODID, path);
     }

src/main/java/com/glodblock/github/api/FluidCraftAPI.java

@@ -5,6 +5,9 @@ import java.util.Set;
 
 import net.minecraftforge.fluids.Fluid;
 
+import com.glodblock.github.api.registries.ILevelTerminalRegistry;
+import com.glodblock.github.util.LevelTerminalRegistry;
+
 public final class FluidCraftAPI implements IFluidCraftAPI {
 
     private static final FluidCraftAPI API = new FluidCraftAPI();
@@ -42,4 +45,9 @@ public final class FluidCraftAPI implements IFluidCraftAPI {
     public boolean isBlacklistedInDisplay(Class<? extends Fluid> fluid) {
         return blacklistedDispFluids.contains(fluid);
     }
+
+    @Override
+    public ILevelTerminalRegistry levelTerminalRegistry() {
+        return LevelTerminalRegistry.instance();
+    }
 }

src/main/java/com/glodblock/github/api/IFluidCraftAPI.java

@@ -2,6 +2,8 @@ package com.glodblock.github.api;
 
 import net.minecraftforge.fluids.Fluid;
 
+import com.glodblock.github.api.registries.ILevelTerminalRegistry;
+
 @SuppressWarnings("unused")
 public interface IFluidCraftAPI {
 
@@ -24,4 +26,9 @@ public interface IFluidCraftAPI {
      * Mostly for internal use; queries whether the fluid is blacklisted from being displayed.
      */
     boolean isBlacklistedInDisplay(Class<? extends Fluid> fluid);
+
+    /**
+     * Get instance of `ILevelTerminalRegistry` to add new supported machines into terminal
+     */
+    ILevelTerminalRegistry levelTerminalRegistry();
 }

src/main/java/com/glodblock/github/api/ISide.java

@@ -0,0 +1,8 @@
+package com.glodblock.github.api;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface ISide {
+
+    ForgeDirection getSide();
+}

src/main/java/com/glodblock/github/api/registries/ILevelTerminalRegistry.java

@@ -0,0 +1,21 @@
+package com.glodblock.github.api.registries;
+
+import java.util.Set;
+
+import appeng.api.features.ILevelViewable;
+import appeng.api.networking.IGridHost;
+
+public interface ILevelTerminalRegistry {
+
+    void register(Class<? extends ILevelViewable> clazz);
+
+    void register(Class<? extends IGridHost> aeClass, ILevelViewableAdapter adapter);
+
+    Set<Class<? extends ILevelViewable>> getSupportedClasses();
+
+    boolean isAdopted(Class<? extends ILevelViewable> clazz);
+
+    Class<? extends IGridHost> getAdopted(Class<? extends ILevelViewable> clazz);
+
+    ILevelViewableAdapter getAdapter(Class<? extends ILevelViewable> clazz);
+}

src/main/java/com/glodblock/github/api/registries/ILevelViewableAdapter.java

@@ -0,0 +1,9 @@
+package com.glodblock.github.api.registries;
+
+import appeng.api.features.ILevelViewable;
+import appeng.api.networking.IGridHost;
+
+public interface ILevelViewableAdapter extends ILevelViewable {
+
+    ILevelViewable adapt(IGridHost gridHost);
+}

src/main/java/com/glodblock/github/client/FluidInterfaceButtons.java

@@ -0,0 +1,98 @@
+package com.glodblock.github.client;
+
+import java.util.List;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.renderer.entity.RenderItem;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.StatCollector;
+
+import org.lwjgl.input.Mouse;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.loader.ItemAndBlockHolder;
+import com.glodblock.github.network.CPacketCustomButtonUpdate;
+import com.glodblock.github.network.CPacketSwitchGuis;
+
+import appeng.api.config.Settings;
+import appeng.api.config.SidelessMode;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketConfigButton;
+import appeng.helpers.ICustomButtonDataObject;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import io.netty.buffer.ByteBuf;
+
+public class FluidInterfaceButtons implements ICustomButtonDataObject {
+
+    private GuiImgButton sidelessMode;
+    private GuiTabButton switcher;
+    private final boolean fullBlock;
+    public SidelessMode sidelessSate;
+
+    public FluidInterfaceButtons(final boolean fullBlock) {
+        this.fullBlock = fullBlock;
+    }
+
+    @SideOnly(Side.CLIENT)
+    @Override
+    public void initCustomButtons(int guiLeft, int guiTop, int xSize, int ySize, int xOffset, int yOffset,
+            List<GuiButton> buttonList) {
+        if (fullBlock) {
+            this.sidelessMode = new GuiImgButton(
+                    guiLeft - 18,
+                    guiTop + yOffset,
+                    Settings.SIDELESS_MODE,
+                    SidelessMode.SIDELESS);
+            buttonList.add(this.sidelessMode);
+        }
+
+        this.switcher = new GuiTabButton(
+                guiLeft + 132,
+                guiTop,
+                !fullBlock ? ItemAndBlockHolder.FLUID_INTERFACE.stack() : ItemAndBlockHolder.INTERFACE.stack(),
+                StatCollector.translateToLocal("ae2fc.tooltip.switch_fluid_interface"),
+                RenderItem.getInstance());
+        buttonList.add(this.switcher);
+
+        FluidCraft.proxy.netHandler.sendToServer(new CPacketCustomButtonUpdate());
+    }
+
+    @SideOnly(Side.CLIENT)
+    @Override
+    public boolean actionPerformedCustomButtons(final GuiButton btn) {
+        if (btn == this.switcher) {
+            FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis());
+            return true;
+        } else if (fullBlock && btn == this.sidelessMode) {
+            final boolean backwards = Mouse.isButtonDown(1);
+            NetworkHandler.instance.sendToServer(new PacketConfigButton(this.sidelessMode.getSetting(), backwards));
+            FluidCraft.proxy.netHandler.sendToServer(new CPacketCustomButtonUpdate());
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void readData(NBTTagCompound tag) {}
+
+    @Override
+    public void writeData(NBTTagCompound tag) {}
+
+    @Override
+    public void readByte(ByteBuf buf) {
+        this.sidelessMode.set(SidelessMode.values()[buf.readInt()]);
+    }
+
+    @Override
+    public void writeByte(ByteBuf buf) {
+        buf.writeInt(this.sidelessSate.ordinal());
+    }
+
+    public void setSidelessMode(SidelessMode sm) {
+        this.sidelessSate = sm;
+    }
+}

src/main/java/com/glodblock/github/client/UltraTerminalButtons.java

@@ -0,0 +1,246 @@
+package com.glodblock.github.client;
+
+import static appeng.util.Platform.nextEnum;
+import static com.glodblock.github.common.item.ItemWirelessUltraTerminal.MODE;
+import static com.glodblock.github.inventory.item.WirelessMagnet.modeKey;
+
+import java.util.List;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.GuiFCImgButton;
+import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.network.CPacketFluidPatternTermBtns;
+import com.glodblock.github.network.CPacketSwitchGuis;
+import com.glodblock.github.util.UltraTerminalModes;
+
+import appeng.helpers.ICustomButtonDataObject;
+import appeng.util.Platform;
+import io.netty.buffer.ByteBuf;
+
+public class UltraTerminalButtons implements ICustomButtonDataObject {
+
+    public static String restockItems = "restock";
+
+    private ItemStack terminal;
+
+    private GuiFCImgButton CraftingTerminal;
+    private GuiFCImgButton PatternTerminal;
+    private GuiFCImgButton InterfaceTerminal;
+    private GuiFCImgButton LevelTerminal;
+    private GuiFCImgButton PatternTerminalEx;
+
+    private GuiFCImgButton magnetOff;
+    private GuiFCImgButton magnetInv;
+    private GuiFCImgButton magnetME;
+
+    private GuiFCImgButton magnetFilter;
+
+    private GuiFCImgButton restockEnableBtn;
+    private GuiFCImgButton restockDisableBtn;
+
+    private WirelessMagnet.Mode magnetMode;
+    private boolean reStock;
+    public UltraTerminalModes terminalMode;
+
+    private int offset;
+
+    public UltraTerminalButtons(ItemStack terminal) {
+        this.terminal = terminal;
+    }
+
+    public void initCustomButtons(int guiLeft, int guiTop, int xSize, int ySize, int xOffset, int yOffset,
+            List<GuiButton> buttonList) {
+        this.offset = yOffset;
+        buttonList.add(
+                this.magnetOff = new GuiFCImgButton(guiLeft + xSize - 17, guiTop + ySize - 65, "MAGNET_CARD", "OFF"));
+        buttonList.add(
+                this.magnetInv = new GuiFCImgButton(guiLeft + xSize - 17, guiTop + ySize - 65, "MAGNET_CARD", "INV"));
+        buttonList.add(
+                this.magnetME = new GuiFCImgButton(guiLeft + xSize - 17, guiTop + ySize - 65, "MAGNET_CARD", "ME"));
+
+        buttonList.add(
+                this.magnetFilter = new GuiFCImgButton(
+                        guiLeft + xSize - 17,
+                        guiTop + ySize - 45,
+                        "MAGNET_CARD",
+                        "FILTER"));
+        buttonList.add(
+                this.restockEnableBtn = new GuiFCImgButton(
+                        guiLeft + xSize - 17,
+                        guiTop + ySize - 25,
+                        "RESTOCK",
+                        "ENABLE"));
+
+        buttonList.add(
+                this.restockDisableBtn = new GuiFCImgButton(
+                        guiLeft + xSize - 17,
+                        guiTop + ySize - 25,
+                        "RESTOCK",
+                        "DISABLE"));
+
+        buttonList.add(this.CraftingTerminal = new GuiFCImgButton(guiLeft - 18, yOffset, "CRAFT_TEM", "YES"));
+
+        buttonList.add(this.PatternTerminal = new GuiFCImgButton(guiLeft - 18, yOffset, "PATTERN_TEM", "YES"));
+
+        buttonList.add(this.PatternTerminalEx = new GuiFCImgButton(guiLeft - 18, yOffset, "PATTERN_EX_TEM", "YES"));
+
+        buttonList.add(this.InterfaceTerminal = new GuiFCImgButton(guiLeft - 18, yOffset, "INTERFACE_TEM", "YES"));
+
+        buttonList.add(this.LevelTerminal = new GuiFCImgButton(guiLeft - 18, yOffset, "LEVEL_TEM", "YES"));
+
+        toggleSwitchButtons();
+        toggleMagnetButtonsVisibility();
+        toggleRestockVisibility();
+    }
+
+    @Override
+    public boolean actionPerformedCustomButtons(final GuiButton btn) {
+        if (btn instanceof GuiFCImgButton) {
+            UltraTerminalModes mode = null;
+            if (btn == this.CraftingTerminal) {
+                mode = UltraTerminalModes.CRAFTING;
+            } else if (btn == this.PatternTerminal) {
+                mode = UltraTerminalModes.PATTERN;
+            } else if (btn == this.InterfaceTerminal) {
+                mode = UltraTerminalModes.INTERFACE;
+            } else if (btn == this.LevelTerminal) {
+                mode = UltraTerminalModes.LEVEL;
+            } else if (btn == this.PatternTerminalEx) {
+                mode = UltraTerminalModes.PATTERN_EX;
+            }
+            if (mode != null) {
+                ItemWirelessUltraTerminal.setMode(this.terminal, mode);
+                FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(mode, true));
+            }
+
+            if (btn == this.magnetOff || btn == this.magnetME || btn == this.magnetInv) {
+                FluidCraft.proxy.netHandler.sendToServer(
+                        new CPacketFluidPatternTermBtns(
+                                CPacketFluidPatternTermBtns.Command.MAGNET_MODE,
+                                this.magnetMode.ordinal()));
+            } else if (btn == this.magnetFilter) FluidCraft.proxy.netHandler.sendToServer(
+                    new CPacketFluidPatternTermBtns(CPacketFluidPatternTermBtns.Command.MAGNET_OPEN_FILTER, 0));
+            else if (btn == this.restockDisableBtn || btn == this.restockEnableBtn) {
+                FluidCraft.proxy.netHandler
+                        .sendToServer(new CPacketFluidPatternTermBtns(CPacketFluidPatternTermBtns.Command.RESTOCK, 1));
+            }
+
+            return true;
+        }
+        return false;
+    }
+
+    public void toggleRestock() {
+        this.reStock = !this.reStock;
+    }
+
+    public void toggleRestockVisibility() {
+        if (Platform.isClient()) {
+            if (this.reStock) {
+                this.restockEnableBtn.setVisibility(true);
+                this.restockDisableBtn.setVisibility(false);
+            } else {
+                this.restockEnableBtn.setVisibility(false);
+                this.restockDisableBtn.setVisibility(true);
+            }
+        }
+    }
+
+    public void toggleMagnetMode() {
+        this.magnetMode = nextEnum(this.magnetMode);
+    }
+
+    public void toggleMagnetButtonsVisibility() {
+        switch (this.magnetMode) {
+            case Off -> {
+                this.magnetME.setVisibility(false);
+                this.magnetInv.setVisibility(false);
+                this.magnetOff.setVisibility(true);
+            }
+            case ME -> {
+                this.magnetME.setVisibility(true);
+                this.magnetInv.setVisibility(false);
+                this.magnetOff.setVisibility(false);
+            }
+            case Inv -> {
+                this.magnetME.setVisibility(false);
+                this.magnetInv.setVisibility(true);
+                this.magnetOff.setVisibility(false);
+            }
+        }
+    }
+
+    public void toggleSwitchButtons() {
+        int offset = this.offset;
+
+        CraftingTerminal.setVisibility(false);
+        PatternTerminal.setVisibility(false);
+        InterfaceTerminal.setVisibility(false);
+        LevelTerminal.setVisibility(false);
+        PatternTerminalEx.setVisibility(false);
+
+        if (this.terminalMode != UltraTerminalModes.CRAFTING) {
+            this.CraftingTerminal.setVisibility(true);
+            this.CraftingTerminal.yPosition = offset;
+            offset += 20;
+        }
+        if (this.terminalMode != UltraTerminalModes.PATTERN) {
+            this.PatternTerminal.setVisibility(true);
+            this.PatternTerminal.yPosition = offset;
+            offset += 20;
+        }
+        if (this.terminalMode != UltraTerminalModes.PATTERN_EX) {
+            this.PatternTerminalEx.setVisibility(true);
+            this.PatternTerminalEx.yPosition = offset;
+            offset += 20;
+        }
+        if (this.terminalMode != UltraTerminalModes.INTERFACE) {
+            this.InterfaceTerminal.setVisibility(true);
+            this.InterfaceTerminal.yPosition = offset;
+            offset += 20;
+        }
+        if (this.terminalMode != UltraTerminalModes.LEVEL) {
+            this.LevelTerminal.setVisibility(true);
+            this.LevelTerminal.yPosition = offset;
+            offset += 20;
+        }
+    }
+
+    @Override
+    public void readData(NBTTagCompound tag) {
+        this.reStock = tag.getBoolean(restockItems);
+        this.magnetMode = WirelessMagnet.Mode.values()[tag.getInteger(modeKey)];
+        this.terminalMode = UltraTerminalModes.VALUES[tag.getInteger(MODE)];
+    }
+
+    @Override
+    public void writeData(NBTTagCompound tag) {
+        tag.setBoolean(restockItems, this.reStock);
+        tag.setInteger(modeKey, this.magnetMode.ordinal());
+        tag.setInteger(MODE, this.terminalMode.ordinal());
+    }
+
+    @Override
+    public void readByte(ByteBuf buf) {
+        this.reStock = buf.readBoolean();
+        this.magnetMode = WirelessMagnet.Mode.values()[buf.readInt()];
+        this.terminalMode = UltraTerminalModes.VALUES[buf.readInt()];
+        ItemWirelessUltraTerminal.setMode(this.terminal, this.terminalMode);
+
+        toggleMagnetButtonsVisibility();
+        toggleRestockVisibility();
+        toggleSwitchButtons();
+    }
+
+    @Override
+    public void writeByte(ByteBuf buf) {
+        buf.writeBoolean(this.reStock);
+        buf.writeInt(this.magnetMode.ordinal());
+        buf.writeInt(this.terminalMode.ordinal());
+    }
+}

src/main/java/com/glodblock/github/client/gui/FCGuiBaseButton.java

@@ -0,0 +1,87 @@
+
+package com.glodblock.github.client.gui;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+// copy from WirelessCraftingTerminal WCTGuiButton
+public class FCGuiBaseButton extends GuiButton {
+
+    protected static final ResourceLocation buttonTextures = new ResourceLocation(
+            "minecraft",
+            "textures/gui/widgets.png");
+
+    public FCGuiBaseButton(int id, int xPosition, int yPosition, int width, int height, String displayString) {
+        super(id, xPosition, yPosition, width, height, displayString);
+        this.enabled = true;
+        this.visible = true;
+        this.id = id;
+        this.xPosition = xPosition;
+        this.yPosition = yPosition;
+        this.width = width;
+        this.height = height;
+        this.displayString = displayString;
+    }
+
+    @Override
+    public void drawButton(Minecraft mc, int mouseX, int mouseY) {
+        if (this.visible) {
+            FontRenderer fontrenderer = mc.fontRenderer;
+            mc.getTextureManager().bindTexture(buttonTextures);
+            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+            this.field_146123_n = mouseX >= this.xPosition && mouseY >= this.yPosition
+                    && mouseX < this.xPosition + this.width
+                    && mouseY < this.yPosition + this.height;
+            int k = this.getHoverState(this.field_146123_n);
+            GL11.glEnable(GL11.GL_BLEND);
+            OpenGlHelper.glBlendFunc(770, 771, 1, 0);
+            GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+            this.drawTexturedModalRect(this.xPosition, this.yPosition, 0, 46 + k * 20, this.width / 2, this.height);
+            this.drawTexturedModalRect(
+                    this.xPosition + this.width / 2,
+                    this.yPosition,
+                    200 - this.width / 2,
+                    46 + k * 20,
+                    this.width / 2,
+                    this.height - 2);
+            this.drawTexturedModalRect(
+                    this.xPosition + 2,
+                    this.yPosition + (this.height - 2),
+                    200 - (this.width - 2),
+                    64 + k * 20,
+                    this.width - 2,
+                    2);
+            this.drawTexturedModalRect(
+                    this.xPosition,
+                    this.yPosition + (this.height - 1),
+                    200 - this.width,
+                    65 + k * 20,
+                    this.width,
+                    1);
+            this.mouseDragged(mc, mouseX, mouseY);
+
+            int l = 14737632;
+
+            if (packedFGColour != 0) {
+                l = packedFGColour;
+            } else if (!this.enabled) {
+                l = 10526880;
+            } else if (this.field_146123_n) {
+                l = 16777120;
+            }
+
+            this.drawCenteredString(
+                    fontrenderer,
+                    this.displayString,
+                    this.xPosition + this.width / 2,
+                    this.yPosition + (this.height - 8) / 2,
+                    l);
+        }
+    }
+}

src/main/java/com/glodblock/github/client/gui/FCGuiLineField.java

@@ -6,8 +6,6 @@ public class FCGuiLineField extends FCGuiTextField {
 
     private final int _xPos;
     private final int _yPos;
-    private final int _width;
-    private final FontRenderer _fontRender;
 
     public FCGuiLineField(FontRenderer fontRenderer, int xPos, int yPos, int width) {
         this(fontRenderer, xPos, yPos, width, 5);
@@ -17,8 +15,6 @@ public class FCGuiLineField extends FCGuiTextField {
         super(fontRenderer, xPos, yPos, width, height);
         this._xPos = xPos;
         this._yPos = yPos;
-        this._width = width;
-        this._fontRender = fontRenderer;
     }
 
     @Override

src/main/java/com/glodblock/github/client/gui/FCGuiTextField.java

@@ -71,9 +71,9 @@ public class FCGuiTextField extends GuiTextField {
                 mouseY = 15;
             }
             if (mouseX + length + 20 >= gui.width) {
-                gui.drawTooltip(mouseX - length - 20, mouseY + 4 + offsetY, 0, this.getMessage());
+                gui.drawTooltip(mouseX - length - 20, mouseY + 4 + offsetY, this.getMessage());
             } else {
-                gui.drawTooltip(mouseX, mouseY + 4 + offsetY, 0, this.getMessage());
+                gui.drawTooltip(mouseX, mouseY + 4 + offsetY, this.getMessage());
             }
         }
     }

src/main/java/com/glodblock/github/client/gui/GuiDualInterface.java

@@ -1,180 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.util.StatCollector;
-
-import org.lwjgl.input.Mouse;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.container.ContainerDualInterface;
-import com.glodblock.github.common.parts.PartFluidInterface;
-import com.glodblock.github.common.tile.TileFluidInterface;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.loader.ItemAndBlockHolder;
-import com.glodblock.github.network.CPacketSwitchGuis;
-import com.glodblock.github.util.ModAndClassUtil;
-import com.glodblock.github.util.NameConst;
-
-import appeng.api.config.*;
-import appeng.client.gui.implementations.GuiUpgradeable;
-import appeng.client.gui.widgets.GuiImgButton;
-import appeng.client.gui.widgets.GuiTabButton;
-import appeng.client.gui.widgets.GuiToggleButton;
-import appeng.container.implementations.ContainerInterface;
-import appeng.core.localization.GuiText;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketConfigButton;
-import appeng.helpers.IInterfaceHost;
-
-public class GuiDualInterface extends GuiUpgradeable {
-
-    private GuiTabButton priority;
-    private GuiTabButton switcher;
-    private GuiImgButton BlockMode;
-    private GuiToggleButton interfaceMode;
-    private GuiImgButton insertionMode;
-    private GuiImgButton sidelessMode;
-    private GuiImgButton advancedBlockingMode;
-    private final IInterfaceHost host;
-
-    public GuiDualInterface(InventoryPlayer inventoryPlayer, IInterfaceHost te) {
-        super(new ContainerDualInterface(inventoryPlayer, te));
-        this.host = te;
-        this.ySize = 211;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    protected void addButtons() {
-        this.priority = new GuiTabButton(
-                this.guiLeft + 154,
-                this.guiTop,
-                2 + 4 * 16,
-                GuiText.Priority.getLocal(),
-                itemRender);
-        this.buttonList.add(this.priority);
-
-        this.switcher = new GuiTabButton(
-                this.guiLeft + 132,
-                this.guiTop,
-                host instanceof PartFluidInterface ? ItemAndBlockHolder.FLUID_INTERFACE.stack()
-                        : ItemAndBlockHolder.INTERFACE.stack(),
-                StatCollector.translateToLocal("ae2fc.tooltip.switch_fluid_interface"),
-                itemRender);
-        this.buttonList.add(this.switcher);
-
-        this.BlockMode = new GuiImgButton(this.guiLeft - 18, this.guiTop + 8, Settings.BLOCK, YesNo.NO);
-        this.buttonList.add(this.BlockMode);
-
-        this.interfaceMode = new GuiToggleButton(
-                this.guiLeft - 18,
-                this.guiTop + 26,
-                84,
-                85,
-                GuiText.InterfaceTerminal.getLocal(),
-                GuiText.InterfaceTerminalHint.getLocal());
-        this.buttonList.add(this.interfaceMode);
-
-        this.insertionMode = new GuiImgButton(
-                this.guiLeft - 18,
-                this.guiTop + 44,
-                Settings.INSERTION_MODE,
-                InsertionMode.DEFAULT);
-        this.buttonList.add(this.insertionMode);
-
-        this.advancedBlockingMode = new GuiImgButton(
-                this.guiLeft - 18,
-                this.guiTop + 62,
-                Settings.ADVANCED_BLOCKING_MODE,
-                AdvancedBlockingMode.DEFAULT);
-        this.buttonList.add(this.advancedBlockingMode);
-
-        if (isTile()) {
-            this.sidelessMode = new GuiImgButton(
-                    this.guiLeft - 18,
-                    this.guiTop + 80,
-                    Settings.SIDELESS_MODE,
-                    SidelessMode.SIDELESS);
-            this.buttonList.add(this.sidelessMode);
-        }
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        if (this.BlockMode != null) {
-            this.BlockMode.set(((ContainerInterface) this.cvb).getBlockingMode());
-        }
-
-        if (this.interfaceMode != null) {
-            this.interfaceMode.setState(((ContainerInterface) this.cvb).getInterfaceTerminalMode() == YesNo.YES);
-        }
-        if (this.insertionMode != null) {
-            this.insertionMode.set(((ContainerInterface) this.cvb).getInsertionMode());
-        }
-        if (this.sidelessMode != null) {
-            this.sidelessMode.set(((ContainerDualInterface) this.cvb).getSidelessMode());
-        }
-        if (this.advancedBlockingMode != null) {
-            this.advancedBlockingMode.set(((ContainerDualInterface) this.cvb).getAdvancedBlockingMode());
-        }
-        this.fontRendererObj.drawString(
-                getGuiDisplayName(StatCollector.translateToLocal(NameConst.GUI_FLUID_INTERFACE)),
-                8,
-                6,
-                4210752);
-    }
-
-    @Override
-    protected String getBackground() {
-        if (!ModAndClassUtil.isBigInterface) return "guis/interface.png";
-        return switch (((ContainerInterface) this.cvb).getPatternCapacityCardsInstalled()) {
-            case 1 -> "guis/interface2.png";
-            case 2 -> "guis/interface3.png";
-            case 3 -> "guis/interface4.png";
-            default -> "guis/interface.png";
-        };
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        final boolean backwards = Mouse.isButtonDown(1);
-        if (btn == null) {
-            return;
-        }
-        if (btn == this.priority) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(GuiType.PRIORITY));
-        }
-
-        if (btn == this.switcher) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(GuiType.DUAL_INTERFACE_FLUID));
-        }
-
-        if (btn == this.interfaceMode) {
-            NetworkHandler.instance.sendToServer(new PacketConfigButton(Settings.INTERFACE_TERMINAL, backwards));
-        }
-
-        if (btn == this.BlockMode) {
-            NetworkHandler.instance.sendToServer(new PacketConfigButton(this.BlockMode.getSetting(), backwards));
-        }
-        if (btn == this.insertionMode) {
-            NetworkHandler.instance.sendToServer(new PacketConfigButton(this.insertionMode.getSetting(), backwards));
-        }
-        if (btn == this.sidelessMode) {
-            NetworkHandler.instance.sendToServer(new PacketConfigButton(this.sidelessMode.getSetting(), backwards));
-        }
-        if (btn == this.advancedBlockingMode) {
-            NetworkHandler.instance
-                    .sendToServer(new PacketConfigButton(this.advancedBlockingMode.getSetting(), backwards));
-        }
-    }
-
-    private boolean isPart() {
-        return this.host instanceof PartFluidInterface;
-    }
-
-    private boolean isTile() {
-        return this.host instanceof TileFluidInterface;
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiEssentiaTerminal.java

@@ -1,109 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.fluids.FluidStack;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.container.ContainerEssentiaMonitor;
-import com.glodblock.github.client.me.EssentiaRepo;
-import com.glodblock.github.common.item.ItemFluidDrop;
-import com.glodblock.github.crossmod.thaumcraft.AspectRender;
-import com.glodblock.github.crossmod.thaumcraft.AspectUtil;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.network.CPacketFluidUpdate;
-import com.glodblock.github.util.Ae2ReflectClient;
-
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.client.me.SlotME;
-import appeng.client.render.AppEngRenderItem;
-
-public class GuiEssentiaTerminal extends GuiFluidMonitor {
-
-    private final AppEngRenderItem stackSizeRenderer = Ae2ReflectClient.getStackSizeRenderer(this);
-    protected EntityPlayer player;
-
-    public GuiEssentiaTerminal(InventoryPlayer inventoryPlayer, IWirelessTerminal te) {
-        super(inventoryPlayer, te, new ContainerEssentiaMonitor(inventoryPlayer, te));
-        this.repo = new EssentiaRepo(getScrollBar(), this);
-        this.player = inventoryPlayer.player;
-    }
-
-    @Override
-    public void setTextFieldValue(String displayName, int mousex, int mousey, ItemStack stack) {
-        if (AspectUtil.getAspectFromJar(stack) != null) {
-            setSearchString(Objects.requireNonNull(AspectUtil.getAspectFromJar(stack)).getName(), true);
-        }
-    }
-
-    @Override
-    public void func_146977_a(final Slot s) {
-        if (drawSlot0(s)) super.func_146977_a(s);
-    }
-
-    public boolean drawSlot0(Slot slot) {
-        if (slot instanceof SlotME) {
-            IAEItemStack stack = ((SlotME) slot).getAEStack();
-            if (stack == null) return true;
-            FluidStack fluidStack = ItemFluidDrop.getFluidStack(slot.getStack());
-            AspectRender.drawAspect(
-                    this.player,
-                    slot.xDisplayPosition,
-                    slot.yDisplayPosition,
-                    this.zLevel,
-                    AspectUtil.getAspectFromGas(fluidStack),
-                    fluidStack.amount);
-            IAEItemStack gas = stack.copy().setStackSize(stack.getStackSize() / AspectUtil.R);
-            stackSizeRenderer.setAeStack(gas);
-            stackSizeRenderer.renderItemOverlayIntoGUI(
-                    fontRendererObj,
-                    mc.getTextureManager(),
-                    gas.getItemStack(),
-                    slot.xDisplayPosition,
-                    slot.yDisplayPosition);
-            return false;
-        }
-        return true;
-    }
-
-    @Override
-    protected void handleMouseClick(final Slot slot, final int slotIdx, final int ctrlDown, final int mouseButton) {
-        if (slot instanceof SlotME && AspectUtil.isEssentiaContainer(player.inventory.getItemStack())) {
-            Map<Integer, IAEFluidStack> tmp = new HashMap<>();
-            ItemStack itemStack = this.player.inventory.getItemStack().copy();
-            tmp.put(0, ItemFluidDrop.getAeFluidStack(((SlotME) slot).getAEStack()));
-            if (!isShiftKeyDown()) {
-                itemStack.stackSize = 1;
-            }
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidUpdate(tmp, itemStack));
-        }
-        if (mouseButton == 3 && slot instanceof SlotME) {
-            return;
-        }
-        super.handleMouseClick(slot, slotIdx, ctrlDown, mouseButton);
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        if (btn == craftingStatusBtn) {
-            InventoryHandler.switchGui(GuiType.CRAFTING_STATUS);
-        } else {
-            super.actionPerformed(btn);
-        }
-    }
-
-    public void update(ItemStack itemStack) {
-        this.player.inventory.setItemStack(itemStack);
-    }
-
-}

src/main/java/com/glodblock/github/client/gui/GuiFCImgButton.java

@@ -22,6 +22,7 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
     private static Map<EnumPair, ButtonAppearance> appearances;
     private final String buttonSetting;
     private boolean halfSize = false;
+    private boolean threeFourths = false;
     private String fillVar;
     private String currentValue;
     private final boolean background;
@@ -48,7 +49,7 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
             this.registerApp(2, "FORCE_PRIO", "DO_PRIO", "prio");
             this.registerApp(3, "NOT_PRIO", "DONT_PRIO", "not_prio");
             this.registerApp(4, "SUBMIT", "SUBMIT", "submit");
-            this.registerApp(5, "EDIT", "YES", "edit");
+            this.registerApp(5, "RENAME", "YES", "rename");
             this.registerApp(6, "DISABLE", "DISABLE", "disable");
             this.registerApp(7, "ENABLE", "ENABLE", "enable");
             this.registerApp(10, "FLUID_TEM", "YES", "fluid_terminal_w");
@@ -59,6 +60,23 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
             this.registerApp(15, "PATTERN_EX_TEM", "YES", "pattern_terminal_ex_w");
             this.registerApp(16, "FILL_PATTERN", "DO_FILL", "fill_pattern");
             this.registerApp(17, "NOT_FILL_PATTERN", "DONT_FILL", "not_fill_pattern");
+            this.registerApp(20, "LEVEL_TEM", "YES", "level_terminal_w");
+            this.registerApp(21, "SWITCH", "ON", "edit");
+            this.registerApp(22, "SWITCH", "OFF", "view");
+            this.registerApp(21, "SWITCH", "ENABLE", "enable");
+            this.registerApp(22, "SWITCH", "DISABLE", "disable");
+            this.registerApp(23, "OPEN_GUI", "YES", "open_gui");
+            this.registerApp(24, "HIGHLIGHT", "YES", "block_highlight");
+            this.registerApp(26, "stock mode button", "normalMode", "Normal.mode");
+            this.registerApp(27, "stock mode button", "fullstockMode", "Full-stock.mode");
+            this.registerApp(30, "MAGNET_CARD", "INV", "magnet_card.inv");
+            this.registerApp(30, "MAGNET_CARD", "ME", "magnet_card.me");
+            this.registerApp(30, "MAGNET_CARD", "FILTER", "magnet_card.filter");
+            this.registerApp(31, "MAGNET_CARD", "OFF", "magnet_card.off");
+            this.registerApp(32, "ENABLE_12x", "ENABLE", "enable");
+            this.registerApp(33, "DISABLE_12x", "DISABLE", "disable");
+            this.registerApp(34, "RESTOCK", "ENABLE", "restock.on");
+            this.registerApp(35, "RESTOCK", "DISABLE", "restock.off");
         }
     }
 
@@ -110,6 +128,10 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
         return this.currentValue;
     }
 
+    public boolean getMouseIn() {
+        return this.field_146123_n;
+    }
+
     public void set(final String e) {
         if (!this.currentValue.equals(e)) {
             this.currentValue = e;
@@ -124,6 +146,14 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
         this.halfSize = halfSize;
     }
 
+    public boolean isThreeFourths() {
+        return threeFourths;
+    }
+
+    public void setThreeFourths(boolean threeFourths) {
+        this.threeFourths = threeFourths;
+    }
+
     public String getFillVar() {
         return this.fillVar;
     }
@@ -144,12 +174,12 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
 
     @Override
     public int getWidth() {
-        return this.halfSize ? 8 : 16;
+        return this.halfSize ? 8 : threeFourths ? 12 : 16;
     }
 
     @Override
     public int getHeight() {
-        return this.halfSize ? 8 : 16;
+        return this.halfSize ? 8 : threeFourths ? 12 : 16;
     }
 
     @Override
@@ -206,79 +236,44 @@ public class GuiFCImgButton extends GuiButton implements ITooltip {
         if (this.visible) {
             final int iconIndex = this.getIconIndex();
             final int iconPage = this.getIconPage();
+            this.width = getWidth();
+            this.height = getHeight();
+            float scaleFactor = halfSize ? 3 : threeFourths ? 4.5f : 6;
 
-            if (this.halfSize) {
-                this.width = 8;
-                this.height = 8;
-
-                GL11.glPushMatrix();
-                GL11.glTranslatef(this.xPosition, this.yPosition, 0.0F);
-                GL11.glScalef(0.5f / 16 * 3, 0.5f / 16 * 3, 0.5f / 16 * 3);
-
-                if (this.enabled) {
-                    GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-                } else {
-                    GL11.glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
-                }
-
-                par1Minecraft.renderEngine.bindTexture(FluidCraft.resource("textures/gui/states" + iconPage + ".png"));
-                this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition
-                        && par2 < this.xPosition + this.width
-                        && par3 < this.yPosition + this.height;
-
-                final int uv_y = (int) Math.floor(iconIndex / 3.0);
-                final int uv_x = iconIndex - uv_y * 3;
-                if (this.background) {
-                    this.drawTexturedModalRect(
-                            0,
-                            0,
-                            Math.round(32F * 16F / 3F),
-                            Math.round(32F * 16F / 3F),
-                            Math.round(16F * 16F / 3F),
-                            Math.round(16F * 16F / 3F));
-                }
-                this.drawTexturedModalRect(
-                        0,
-                        0,
-                        Math.round(uv_x * 16F * 16F / 3F),
-                        Math.round(uv_y * 16F * 16F / 3F),
-                        Math.round(16F * 16F / 3F),
-                        Math.round(16F * 16F / 3F));
+            GL11.glPushMatrix();
+            GL11.glTranslatef(this.xPosition, this.yPosition, 0.0F);
+            GL11.glScalef(0.5f / 16 * scaleFactor, 0.5f / 16 * scaleFactor, 0.5f / 16 * scaleFactor);
 
+            if (this.enabled) {
+                GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
             } else {
-                GL11.glPushMatrix();
-                GL11.glTranslatef(this.xPosition, this.yPosition, 0.0F);
-                GL11.glScalef(0.5f / 16 * 6, 0.5f / 16 * 6, 0.5f / 16 * 6);
-                if (this.enabled) {
-                    GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-                } else {
-                    GL11.glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
-                }
+                GL11.glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
+            }
 
-                par1Minecraft.renderEngine.bindTexture(FluidCraft.resource("textures/gui/states" + iconPage + ".png"));
-                this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition
-                        && par2 < this.xPosition + this.width
-                        && par3 < this.yPosition + this.height;
+            par1Minecraft.renderEngine.bindTexture(FluidCraft.resource("textures/gui/states" + iconPage + ".png"));
+            this.field_146123_n = par2 >= this.xPosition && par3 >= this.yPosition
+                    && par2 < this.xPosition + this.width
+                    && par3 < this.yPosition + this.height;
 
-                final int uv_y = (int) Math.floor(iconIndex / 3.0);
-                final int uv_x = iconIndex - uv_y * 3;
-                if (this.background) {
-                    this.drawTexturedModalRect(
-                            0,
-                            0,
-                            Math.round(32F * 16F / 3F),
-                            Math.round(32F * 16F / 3F),
-                            Math.round(16F * 16F / 3F),
-                            Math.round(16F * 16F / 3F));
-                }
+            final int uv_y = (int) Math.floor(iconIndex / 3.0);
+            final int uv_x = iconIndex - uv_y * 3;
+            if (this.background) {
                 this.drawTexturedModalRect(
                         0,
                         0,
-                        Math.round(uv_x * 16F * 16F / 3F),
-                        Math.round(uv_y * 16F * 16F / 3F),
+                        Math.round(32F * 16F / 3F),
+                        Math.round(32F * 16F / 3F),
                         Math.round(16F * 16F / 3F),
                         Math.round(16F * 16F / 3F));
             }
+            this.drawTexturedModalRect(
+                    0,
+                    0,
+                    Math.round(uv_x * 16F * 16F / 3F),
+                    Math.round(uv_y * 16F * 16F / 3F),
+                    Math.round(16F * 16F / 3F),
+                    Math.round(16F * 16F / 3F));
+
             this.mouseDragged(par1Minecraft, par2, par3);
             GL11.glPopMatrix();
         }

src/main/java/com/glodblock/github/client/gui/GuiFCPriority.java

@@ -1,101 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import java.io.IOException;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.client.gui.base.FCGuiAmount;
-import com.glodblock.github.common.parts.PartFluidStorageBus;
-import com.glodblock.github.inventory.IDualHost;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.loader.ItemAndBlockHolder;
-
-import appeng.container.implementations.ContainerPriority;
-import appeng.core.AELog;
-import appeng.core.localization.GuiText;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketValueConfig;
-import appeng.helpers.IPriorityHost;
-import appeng.util.calculators.ArithHelper;
-import appeng.util.calculators.Calculator;
-
-public class GuiFCPriority extends FCGuiAmount {
-
-    public GuiFCPriority(final InventoryPlayer inventoryPlayer, final IPriorityHost te) {
-        super(new ContainerPriority(inventoryPlayer, te));
-    }
-
-    @Override
-    public void initGui() {
-        super.initGui();
-        this.submit.enabled = false;
-        this.submit.visible = false;
-        this.buttonList.remove(this.submit);
-        ((ContainerPriority) this.inventorySlots).setTextField(this.amountBox);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(GuiText.Priority.getLocal(), 8, 6, 0x404040);
-    }
-
-    @Override
-    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        super.drawBG(offsetX, offsetY, mouseX, mouseY);
-        this.amountBox.drawTextBox();
-    }
-
-    @Override
-    protected void addQty(final int i) {
-        try {
-            this.amountBox.setText(Long.toString(getAmount() + i));
-        } catch (final NumberFormatException ignore) {}
-        try {
-            NetworkHandler.instance
-                    .sendToServer(new PacketValueConfig("PriorityHost.Priority", String.valueOf(getAmount())));
-        } catch (IOException e) {
-            AELog.debug(e);
-        }
-    }
-
-    @Override
-    protected void setOriginGUI(Object target) {
-        if (target instanceof IDualHost) {
-            this.myIcon = ItemAndBlockHolder.INTERFACE.stack();
-            this.originalGui = GuiType.DUAL_INTERFACE;
-        } else if (target instanceof PartFluidStorageBus) {
-            this.myIcon = ItemAndBlockHolder.FLUID_STORAGE_BUS.stack();
-            this.originalGui = GuiType.FLUID_STORAGE_BUS;
-        }
-    }
-
-    @Override
-    protected void keyTyped(final char character, final int key) {
-        super.keyTyped(character, key);
-        try {
-            NetworkHandler.instance
-                    .sendToServer(new PacketValueConfig("PriorityHost.Priority", String.valueOf(getAmount())));
-        } catch (IOException e) {
-            AELog.debug(e);
-        }
-    }
-
-    @Override
-    protected int getAmount() {
-        try {
-            String out = this.amountBox.getText();
-            double result = Calculator.conversion(out);
-            if (Double.isNaN(result)) {
-                return 0;
-            } else {
-                return (int) ArithHelper.round(result, 0);
-            }
-        } catch (final NumberFormatException e) {
-            return 0;
-        }
-    }
-
-    protected String getBackground() {
-        return "guis/priority.png";
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidAutoFiller.java

@@ -8,12 +8,13 @@ import net.minecraft.util.ResourceLocation;
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.gui.container.ContainerFluidAutoFiller;
 import com.glodblock.github.common.tile.TileFluidAutoFiller;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 
-import appeng.client.gui.AEBaseMEGui;
+import appeng.client.gui.AEBaseGui;
 import appeng.core.localization.GuiText;
 
-public class GuiFluidAutoFiller extends AEBaseMEGui {
+public class GuiFluidAutoFiller extends AEBaseGui {
 
     protected EntityPlayer player;
     private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/fluid_auto_filler.png");
@@ -31,7 +32,12 @@ public class GuiFluidAutoFiller extends AEBaseMEGui {
 
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_AUTO_FILLER)), 8, 6, 0x404040);
-        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        fontRendererObj.drawString(
+                getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_AUTO_FILLER)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
+        fontRendererObj
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
     }
 }

src/main/java/com/glodblock/github/client/gui/GuiFluidCraftAmount.java

@@ -1,89 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.base.FCGuiAmount;
-import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminalEx;
-import com.glodblock.github.common.parts.PartFluidTerminal;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.inventory.item.WirelessPatternTerminalInventory;
-import com.glodblock.github.loader.ItemAndBlockHolder;
-import com.glodblock.github.network.CPacketCraftRequest;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.container.implementations.ContainerCraftAmount;
-import appeng.core.localization.GuiText;
-
-public class GuiFluidCraftAmount extends FCGuiAmount {
-
-    public GuiFluidCraftAmount(final InventoryPlayer inventoryPlayer, final ITerminalHost te) {
-        super(new ContainerCraftAmount(inventoryPlayer, te));
-    }
-
-    @Override
-    public void initGui() {
-        super.initGui();
-        this.amountBox.setText("1");
-        this.amountBox.setSelectionPos(0);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(GuiText.SelectAmount.getLocal(), 8, 6, 0x404040);
-    }
-
-    @Override
-    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        super.drawBG(offsetX, offsetY, mouseX, mouseY);
-        this.submit.displayString = isShiftKeyDown() ? GuiText.Start.getLocal() : GuiText.Next.getLocal();
-        try {
-            this.submit.enabled = getAmount() > 0;
-        } catch (final NumberFormatException e) {
-            this.submit.enabled = false;
-        }
-        this.amountBox.drawTextBox();
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        try {
-            if (btn == this.submit && this.submit.enabled) {
-                FluidCraft.proxy.netHandler.sendToServer(new CPacketCraftRequest(getAmount(), isShiftKeyDown()));
-            }
-        } catch (final NumberFormatException e) {
-            this.amountBox.setText("1");
-        }
-    }
-
-    @Override
-    protected void setOriginGUI(Object target) {
-        if (target instanceof PartFluidPatternTerminal) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.FLUID_TERMINAL, 1);
-            this.originalGui = GuiType.FLUID_PATTERN_TERMINAL;
-        } else if (target instanceof PartFluidPatternTerminalEx) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.FLUID_TERMINAL_EX, 1);
-            this.originalGui = GuiType.FLUID_PATTERN_TERMINAL_EX;
-        } else if (target instanceof PartFluidTerminal) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.FLUID_TERM, 1);
-            this.originalGui = GuiType.FLUID_TERMINAL;
-        } else if (target instanceof IWirelessTerminal && ((IWirelessTerminal) target).isUniversal(target)) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.WIRELESS_ULTRA_TERM, 1);
-            this.originalGui = ItemWirelessUltraTerminal.readMode(((IWirelessTerminal) target).getItemStack());
-        } else if (target instanceof WirelessPatternTerminalInventory) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.WIRELESS_PATTERN_TERM, 1);
-            this.originalGui = GuiType.FLUID_TERMINAL;
-        }
-    }
-
-    @Override
-    protected String getBackground() {
-        return "guis/craftAmt.png";
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidCraftConfirm.java

@@ -1,38 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminalEx;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.inventory.item.WirelessPatternTerminalInventory;
-import com.glodblock.github.network.CPacketSwitchGuis;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.client.gui.implementations.GuiCraftConfirm;
-
-public class GuiFluidCraftConfirm extends GuiCraftConfirm {
-
-    private GuiType OriginalGui;
-
-    public GuiFluidCraftConfirm(final InventoryPlayer inventoryPlayer, final ITerminalHost te) {
-        super(inventoryPlayer, te);
-        if (te instanceof PartFluidPatternTerminal) {
-            this.OriginalGui = GuiType.FLUID_PATTERN_TERMINAL;
-        } else if (te instanceof PartFluidPatternTerminalEx) {
-            this.OriginalGui = GuiType.FLUID_PATTERN_TERMINAL_EX;
-        } else if (te instanceof IWirelessTerminal && ((IWirelessTerminal) te).isUniversal(te)) {
-            this.OriginalGui = ItemWirelessUltraTerminal.readMode(((IWirelessTerminal) te).getItemStack());
-        } else if (te instanceof WirelessPatternTerminalInventory) {
-            this.OriginalGui = GuiType.FLUID_TERMINAL;
-        }
-    }
-
-    @Override
-    public void switchToOriginalGUI() {
-        FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(this.OriginalGui));
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidCraftingWireless.java

@@ -1,85 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Container;
-import net.minecraft.inventory.Slot;
-
-import com.glodblock.github.client.gui.container.ContainerCraftingWireless;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-
-import appeng.api.config.ActionItems;
-import appeng.api.config.Settings;
-import appeng.client.gui.widgets.GuiImgButton;
-import appeng.container.slot.SlotCraftingMatrix;
-import appeng.core.localization.GuiColors;
-import appeng.core.localization.GuiText;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketInventoryAction;
-import appeng.helpers.InventoryAction;
-
-public class GuiFluidCraftingWireless extends GuiItemMonitor {
-
-    private GuiImgButton clearBtn;
-
-    public GuiFluidCraftingWireless(final InventoryPlayer inventoryPlayer, final IWirelessTerminal te) {
-        super(inventoryPlayer, te, new ContainerCraftingWireless(inventoryPlayer, te));
-        this.setReservedSpace(73);
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        if (btn == craftingStatusBtn) {
-            InventoryHandler.switchGui(GuiType.CRAFTING_STATUS);
-        } else {
-            super.actionPerformed(btn);
-            if (this.clearBtn == btn) {
-                Slot s = null;
-                final Container c = this.inventorySlots;
-                for (final Object j : c.inventorySlots) {
-                    if (j instanceof SlotCraftingMatrix) {
-                        s = (Slot) j;
-                    }
-                }
-                if (s != null) {
-                    final PacketInventoryAction p = new PacketInventoryAction(
-                            InventoryAction.MOVE_REGION,
-                            s.slotNumber,
-                            0);
-                    NetworkHandler.instance.sendToServer(p);
-                }
-            }
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void initGui() {
-        super.initGui();
-        this.buttonList.add(
-                this.clearBtn = new GuiImgButton(
-                        this.guiLeft + 92,
-                        this.guiTop + this.ySize - 156,
-                        Settings.ACTIONS,
-                        ActionItems.STASH));
-        this.clearBtn.setHalfSize(true);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        super.drawFG(offsetX, offsetY, mouseX, mouseY);
-        this.fontRendererObj.drawString(
-                GuiText.CraftingTerminal.getLocal(),
-                8,
-                this.ySize - 96 + 1 - this.getReservedSpace(),
-                GuiColors.CraftingTerminalTitle.getColor());
-    }
-
-    @Override
-    protected String getBackground() {
-        return "gui/crafting.png";
-    }
-
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidIO.java

@@ -1,72 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.resources.I18n;
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.client.gui.container.ContainerFluidIO;
-import com.glodblock.github.common.parts.PartFluidExportBus;
-import com.glodblock.github.common.parts.PartFluidImportBus;
-import com.glodblock.github.common.parts.base.FCSharedFluidBus;
-import com.glodblock.github.util.NameConst;
-
-import appeng.api.config.Upgrades;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.client.gui.implementations.GuiUpgradeable;
-import appeng.core.localization.GuiText;
-
-public class GuiFluidIO extends GuiUpgradeable {
-
-    private final FCSharedFluidBus bus;
-
-    public GuiFluidIO(InventoryPlayer inventoryPlayer, FCSharedFluidBus te) {
-        super(new ContainerFluidIO(inventoryPlayer, te));
-        this.bus = te;
-    }
-
-    @Override
-    protected GuiText getName() {
-        return this.bus instanceof PartFluidImportBus ? GuiText.ImportBus : GuiText.ExportBus;
-    }
-
-    public void update(int id, IAEFluidStack stack) {
-        ((ContainerFluidIO) this.cvb).getBus().setFluidInSlot(id, stack);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(
-                this.getGuiDisplayName(
-                        I18n.format(
-                                this.bus instanceof PartFluidImportBus ? NameConst.GUI_FLUID_IMPORT
-                                        : NameConst.GUI_FLUID_EXPORT)),
-                8,
-                6,
-                4210752);
-        this.fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, 4210752);
-
-        if (this.redstoneMode != null) {
-            this.redstoneMode.set(this.cvb.getRedStoneMode());
-        }
-
-        if (this.fuzzyMode != null) {
-            this.fuzzyMode.set(this.cvb.getFuzzyMode());
-        }
-
-        if (this.craftMode != null) {
-            this.craftMode.set(this.cvb.getCraftingMode());
-        }
-
-        if (this.schedulingMode != null) {
-            this.schedulingMode.set(this.cvb.getSchedulingMode());
-        }
-    }
-
-    @Override
-    protected void handleButtonVisibility() {
-        super.handleButtonVisibility();
-        if (this.schedulingMode != null) {
-            this.schedulingMode.setVisibility(
-                    this.bc.getInstalledUpgrades(Upgrades.CAPACITY) > 0 && this.bc instanceof PartFluidExportBus);
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidInterface.java

@@ -1,43 +1,35 @@
 package com.glodblock.github.client.gui;
 
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.client.renderer.texture.TextureMap;
 import net.minecraft.client.resources.I18n;
 import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
 import net.minecraft.util.ResourceLocation;
-import net.minecraft.util.StatCollector;
 import net.minecraftforge.common.util.ForgeDirection;
 
 import org.lwjgl.opengl.GL11;
 
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.gui.container.ContainerFluidInterface;
-import com.glodblock.github.common.parts.PartFluidInterface;
 import com.glodblock.github.inventory.IAEFluidTank;
 import com.glodblock.github.inventory.IDualHost;
-import com.glodblock.github.inventory.gui.GuiType;
 import com.glodblock.github.inventory.gui.MouseRegionManager;
 import com.glodblock.github.inventory.gui.TankMouseHandler;
-import com.glodblock.github.loader.ItemAndBlockHolder;
-import com.glodblock.github.network.CPacketSwitchGuis;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 import com.glodblock.github.util.RenderUtil;
 
+import appeng.api.parts.IPart;
 import appeng.api.storage.data.IAEFluidStack;
-import appeng.client.gui.AEBaseGui;
-import appeng.client.gui.widgets.GuiTabButton;
+import appeng.client.gui.GuiSub;
 import appeng.core.localization.GuiText;
 
-public class GuiFluidInterface extends AEBaseGui {
+public class GuiFluidInterface extends GuiSub {
 
     private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/interface_fluid.png");
     private static final int TANK_X = 35, TANK_X_OFF = 18, TANK_Y = 53;
     private static final int TANK_WIDTH = 16, TANK_HEIGHT = 68;
     private final ContainerFluidInterface cont;
 
-    private GuiTabButton switcher;
     private final MouseRegionManager mouseRegions = new MouseRegionManager(this);
 
     public GuiFluidInterface(InventoryPlayer ipl, IDualHost tile) {
@@ -58,37 +50,26 @@ public class GuiFluidInterface extends AEBaseGui {
         }
     }
 
-    @Override
-    public void func_146977_a(final Slot s) {
-        try {
-            GuiContainer.class.getDeclaredMethod("func_146977_a_original", Slot.class).invoke(this, s);
-        } catch (final Exception ignore) {}
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void initGui() {
-        super.initGui();
-        this.switcher = new GuiTabButton(
-                this.guiLeft + 154,
-                this.guiTop,
-                isPart() ? ItemAndBlockHolder.FLUID_INTERFACE.stack() : ItemAndBlockHolder.INTERFACE.stack(),
-                StatCollector.translateToLocal("ae2fc.tooltip.switch_fluid_interface"),
-                itemRender);
-        this.buttonList.add(this.switcher);
-    }
-
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_INTERFACE)), 8, 6, 0x404040);
-        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        fontRendererObj.drawString(
+                getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_INTERFACE)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
+        fontRendererObj
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
         GL11.glColor4f(1F, 1F, 1F, 1F);
 
         IAEFluidTank fluidInv = cont.getTile().getInternalFluid();
         mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
         for (int i = 0; i < 6; i++) {
             if (!isPart()) {
-                fontRendererObj.drawString(dirName(i), TANK_X + i * TANK_X_OFF + 5, 22, 0x404040);
+                fontRendererObj.drawString(
+                        dirName(i),
+                        TANK_X + i * TANK_X_OFF + 5,
+                        22,
+                        FCGuiColors.guiTextColorGray.getColor());
             }
             RenderUtil.renderFluidIntoGui(
                     this,
@@ -113,14 +94,6 @@ public class GuiFluidInterface extends AEBaseGui {
         drawTexturedModalRect(offsetX, offsetY, 0, 0, 176, ySize);
     }
 
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        if (btn == this.switcher) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(GuiType.DUAL_INTERFACE));
-        }
-    }
-
     public void update(int id, IAEFluidStack stack) {
         if (id >= 100) {
             cont.getTile().setConfig(id - 100, stack);
@@ -130,6 +103,6 @@ public class GuiFluidInterface extends AEBaseGui {
     }
 
     private boolean isPart() {
-        return this.cont.getTile() instanceof PartFluidInterface;
+        return this.cont.getTile() instanceof IPart;
     }
 }

src/main/java/com/glodblock/github/client/gui/GuiFluidLevelEmitter.java

@@ -1,210 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.container.ContainerFluidLevelEmitter;
-import com.glodblock.github.common.parts.PartFluidLevelEmitter;
-import com.glodblock.github.network.CPacketValueConfig;
-import com.glodblock.github.util.Ae2ReflectClient;
-import com.glodblock.github.util.NameConst;
-
-import appeng.api.config.*;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.client.gui.implementations.GuiUpgradeable;
-import appeng.client.gui.widgets.GuiImgButton;
-import appeng.client.gui.widgets.GuiNumberBox;
-import appeng.client.render.AppEngRenderItem;
-import appeng.core.AEConfig;
-import appeng.core.AELog;
-import appeng.core.localization.GuiColors;
-import appeng.core.localization.GuiText;
-
-public class GuiFluidLevelEmitter extends GuiUpgradeable {
-
-    private GuiNumberBox level;
-    private final AppEngRenderItem stackSizeRenderer = Ae2ReflectClient.getStackSizeRenderer(this);
-    private GuiButton plus1;
-    private GuiButton plus10;
-    private GuiButton plus100;
-    private GuiButton plus1000;
-    private GuiButton minus1;
-    private GuiButton minus10;
-    private GuiButton minus100;
-    private GuiButton minus1000;
-    private boolean isMul = false;
-
-    public GuiFluidLevelEmitter(final InventoryPlayer inventoryPlayer, final PartFluidLevelEmitter te) {
-        super(new ContainerFluidLevelEmitter(inventoryPlayer, te));
-    }
-
-    @Override
-    public void initGui() {
-        super.initGui();
-
-        this.level = new GuiNumberBox(this.fontRendererObj, 24, 43, 79, this.fontRendererObj.FONT_HEIGHT, Long.class);
-        this.level.setEnableBackgroundDrawing(false);
-        this.level.setMaxStringLength(16);
-        this.level.setTextColor(GuiColors.LevelEmitterValue.getColor());
-        this.level.setVisible(true);
-        this.level.setFocused(true);
-        ((ContainerFluidLevelEmitter) this.inventorySlots).setTextField(this.level);
-    }
-
-    @Override
-    protected void addButtons() {
-        this.redstoneMode = new GuiImgButton(
-                this.guiLeft - 18,
-                this.guiTop + 8,
-                Settings.REDSTONE_EMITTER,
-                RedstoneMode.LOW_SIGNAL);
-
-        final int a = AEConfig.instance.levelByStackAmounts(0);
-        final int b = AEConfig.instance.levelByStackAmounts(1);
-        final int c = AEConfig.instance.levelByStackAmounts(2);
-        final int d = AEConfig.instance.levelByStackAmounts(3);
-
-        this.buttonList.add(this.plus1 = new GuiButton(0, this.guiLeft + 20, this.guiTop + 17, 22, 20, "+" + a));
-        this.buttonList.add(this.plus10 = new GuiButton(0, this.guiLeft + 48, this.guiTop + 17, 28, 20, "+" + b));
-        this.buttonList.add(this.plus100 = new GuiButton(0, this.guiLeft + 82, this.guiTop + 17, 32, 20, "+" + c));
-        this.buttonList.add(this.plus1000 = new GuiButton(0, this.guiLeft + 120, this.guiTop + 17, 38, 20, "+" + d));
-
-        this.buttonList.add(this.minus1 = new GuiButton(0, this.guiLeft + 20, this.guiTop + 59, 22, 20, "-" + a));
-        this.buttonList.add(this.minus10 = new GuiButton(0, this.guiLeft + 48, this.guiTop + 59, 28, 20, "-" + b));
-        this.buttonList.add(this.minus100 = new GuiButton(0, this.guiLeft + 82, this.guiTop + 59, 32, 20, "-" + c));
-        this.buttonList.add(this.minus1000 = new GuiButton(0, this.guiLeft + 120, this.guiTop + 59, 38, 20, "-" + d));
-
-        this.buttonList.add(this.redstoneMode);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(
-                NameConst.i18n(NameConst.GUI_FLUID_LEVEL_EMITTER),
-                8,
-                6,
-                GuiColors.UpgradableTitle.getColor());
-        this.fontRendererObj.drawString(
-                GuiText.inventory.getLocal(),
-                8,
-                this.ySize - 96 + 3,
-                GuiColors.UpgradableInventory.getColor());
-        this.redstoneMode.set(this.cvb.getRedStoneMode());
-        this.level.drawTextBox();
-        if (isShiftKeyDown() && !isMul) {
-            for (Object btn : this.buttonList) {
-                if (btn instanceof GuiButton) {
-                    ((GuiButton) btn).displayString += "000";
-                }
-            }
-            isMul = true;
-        } else if (!isShiftKeyDown() && isMul) {
-            for (Object btn : this.buttonList) {
-                if (btn instanceof GuiButton) {
-                    ((GuiButton) btn).displayString = ((GuiButton) btn).displayString
-                            .substring(0, ((GuiButton) btn).displayString.lastIndexOf("000"));
-                }
-            }
-            isMul = false;
-        }
-    }
-
-    @Override
-    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        super.drawBG(offsetX, offsetY, mouseX, mouseY);
-    }
-
-    @Override
-    protected void handleButtonVisibility() {}
-
-    @Override
-    protected String getBackground() {
-        return "guis/lvlemitter.png";
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        final boolean isPlus = btn == this.plus1 || btn == this.plus10 || btn == this.plus100 || btn == this.plus1000;
-        final boolean isMinus = btn == this.minus1 || btn == this.minus10
-                || btn == this.minus100
-                || btn == this.minus1000;
-
-        if (isPlus || isMinus) {
-            this.addQty(this.getQty(btn));
-        }
-    }
-
-    private void addQty(final long i) {
-        try {
-            String Out = this.level.getText();
-
-            boolean Fixed = false;
-            while (Out.startsWith("0") && Out.length() > 1) {
-                Out = Out.substring(1);
-                Fixed = true;
-            }
-
-            if (Fixed) {
-                this.level.setText(Out);
-            }
-
-            if (Out.isEmpty()) {
-                Out = "0";
-            }
-
-            long result = Long.parseLong(Out);
-            result += i;
-            if (result < 0) {
-                result = 0;
-            }
-
-            this.level.setText(Out = Long.toString(result));
-
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketValueConfig(result, 0));
-        } catch (final NumberFormatException e) {
-            this.level.setText("0");
-        }
-    }
-
-    @Override
-    protected void keyTyped(final char character, final int key) {
-        if (!this.checkHotbarKeys(key)) {
-            if ((key == 211 || key == 205 || key == 203 || key == 14 || Character.isDigit(character))
-                    && this.level.textboxKeyTyped(character, key)) {
-                try {
-                    String Out = this.level.getText();
-
-                    boolean Fixed = false;
-                    while (Out.startsWith("0") && Out.length() > 1) {
-                        Out = Out.substring(1);
-                        Fixed = true;
-                    }
-
-                    if (Fixed) {
-                        this.level.setText(Out);
-                    }
-
-                    if (Out.isEmpty()) {
-                        Out = "0";
-                    }
-                    FluidCraft.proxy.netHandler.sendToServer(new CPacketValueConfig(Long.parseLong(Out), 0));
-                } catch (final NumberFormatException e) {
-                    AELog.debug(e);
-                }
-            } else {
-                super.keyTyped(character, key);
-            }
-        }
-    }
-
-    @Override
-    protected boolean drawUpgrades() {
-        return false;
-    }
-
-    public void update(Integer key, IAEFluidStack value) {
-        ((ContainerFluidLevelEmitter) this.cvb).getBus().setFluidInSlot(key, value);
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidMonitor.java

@@ -1,61 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import java.util.List;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.client.gui.base.FCGuiMonitor;
-import com.glodblock.github.client.gui.container.ContainerFluidMonitor;
-import com.glodblock.github.client.me.FluidRepo;
-import com.glodblock.github.common.item.ItemFluidDrop;
-import com.glodblock.github.util.Util;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.core.localization.GuiText;
-import appeng.util.item.AEItemStack;
-
-public class GuiFluidMonitor extends FCGuiMonitor<IAEFluidStack> {
-
-    public GuiFluidMonitor(final InventoryPlayer inventoryPlayer, final ITerminalHost te,
-            final ContainerFluidMonitor c) {
-        super(inventoryPlayer, te, c);
-        this.repo = new FluidRepo(getScrollBar(), this);
-    }
-
-    @Override
-    public void postUpdate(final List<IAEFluidStack> list, boolean resort) {
-        for (final IAEFluidStack is : list) {
-            IAEItemStack stack = AEItemStack.create(ItemFluidDrop.newDisplayStack(is.getFluidStack()));
-            stack.setStackSize(is.getStackSize());
-            this.repo.postUpdate(stack);
-        }
-        if (resort) {
-            this.repo.updateView();
-        }
-        this.setScrollBar();
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(this.getGuiDisplayName(GuiText.Terminal.getLocal()), 8, 6, 4210752);
-        this.fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, 4210752);
-    }
-
-    @Override
-    protected IAEItemStack transformItem(IAEItemStack stack) {
-        if (stack.getItem() instanceof ItemFluidDrop) {
-            return ItemFluidDrop.newAeStack(ItemFluidDrop.getAeFluidStack(stack));
-        }
-        return stack;
-    }
-
-    @Override
-    public void setTextFieldValue(String displayName, int mousex, int mousey, ItemStack stack) {
-        if (Util.getFluidFromItem(stack) != null) {
-            setSearchString(Util.getFluidFromItem(stack).getLocalizedName(), true);
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidPacketDecoder.java

@@ -7,6 +7,7 @@ import net.minecraft.util.ResourceLocation;
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.gui.container.ContainerFluidPacketDecoder;
 import com.glodblock.github.common.tile.TileFluidPacketDecoder;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 
 import appeng.client.gui.AEBaseGui;
@@ -28,7 +29,12 @@ public class GuiFluidPacketDecoder extends AEBaseGui {
 
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_PACKET_DECODER)), 8, 6, 0x404040);
-        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        fontRendererObj.drawString(
+                getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_PACKET_DECODER)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
+        fontRendererObj
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
     }
 }

src/main/java/com/glodblock/github/client/gui/GuiFluidPatternEncoder.java

@@ -13,6 +13,8 @@ import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.fluids.FluidStack;
 
+import org.lwjgl.opengl.GL11;
+
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.gui.container.ContainerFluidPatternEncoder;
 import com.glodblock.github.common.item.ItemFluidPacket;
@@ -20,13 +22,11 @@ import com.glodblock.github.common.tile.TileFluidPatternEncoder;
 import com.glodblock.github.inventory.gui.MouseRegionManager;
 import com.glodblock.github.inventory.slot.ISlotFluid;
 import com.glodblock.github.inventory.slot.SlotSingleItem;
-import com.glodblock.github.network.CPacketEncodePattern;
-import com.glodblock.github.util.Ae2ReflectClient;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 
 import appeng.api.storage.data.IAEItemStack;
 import appeng.client.gui.AEBaseGui;
-import appeng.client.render.AppEngRenderItem;
 import appeng.core.localization.GuiText;
 
 public class GuiFluidPatternEncoder extends AEBaseGui {
@@ -35,7 +35,6 @@ public class GuiFluidPatternEncoder extends AEBaseGui {
 
     private final ContainerFluidPatternEncoder cont;
     private final MouseRegionManager mouseRegions = new MouseRegionManager(this);
-    private final AppEngRenderItem stackSizeRenderer = Ae2ReflectClient.getStackSizeRenderer(this);
 
     public GuiFluidPatternEncoder(InventoryPlayer ipl, TileFluidPatternEncoder tile) {
         super(new ContainerFluidPatternEncoder(ipl, tile));
@@ -51,7 +50,7 @@ public class GuiFluidPatternEncoder extends AEBaseGui {
             public boolean onClick(int button) {
                 if (button == 0) {
                     if (cont.canEncodePattern()) {
-                        FluidCraft.proxy.netHandler.sendToServer(new CPacketEncodePattern());
+                        // FluidCraft.proxy.netHandler.sendToServer(new CPacketEncodePattern());
                     }
                     return true;
                 }
@@ -75,8 +74,13 @@ public class GuiFluidPatternEncoder extends AEBaseGui {
 
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_PATTERN_ENCODER)), 8, 6, 0x404040);
-        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        fontRendererObj.drawString(
+                getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_PATTERN_ENCODER)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
+        fontRendererObj
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
         mouseRegions.render(mouseX, mouseY);
     }
 
@@ -95,13 +99,15 @@ public class GuiFluidPatternEncoder extends AEBaseGui {
                 if (ItemFluidPacket.getFluidStack(stack) != null && ItemFluidPacket.getFluidStack(stack).amount > 0)
                     fake.setStackSize(ItemFluidPacket.getFluidStack(stack).amount);
             }
-            stackSizeRenderer.setAeStack(fake);
-            stackSizeRenderer.renderItemOverlayIntoGUI(
+            aeRenderItem.setAeStack(fake);
+            GL11.glTranslatef(0.0f, 0.0f, 200.0f);
+            aeRenderItem.renderItemOverlayIntoGUI(
                     fontRendererObj,
                     mc.getTextureManager(),
                     stack.getItemStack(),
                     slot.xDisplayPosition,
                     slot.yDisplayPosition);
+            GL11.glTranslatef(0.0f, 0.0f, -200.0f);
         } else {
             super.func_146977_a(slot);
         }

src/main/java/com/glodblock/github/client/gui/GuiFluidPatternExWireless.java

@@ -1,24 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-
-import appeng.container.slot.AppEngSlot;
-import appeng.container.slot.SlotDisabled;
-
-public class GuiFluidPatternExWireless extends GuiFluidPatternTerminalEx {
-
-    public GuiFluidPatternExWireless(InventoryPlayer inventoryPlayer, IWirelessTerminal te) {
-        super(inventoryPlayer, te);
-    }
-
-    @Override
-    protected void repositionSlot(final AppEngSlot s) {
-        if (s instanceof SlotDisabled || s.isPlayerSide()) {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 5;
-        } else {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 3;
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidPatternTerminal.java

@@ -1,166 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.init.Blocks;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.StatCollector;
-
-import com.glodblock.github.client.gui.base.FCGuiEncodeTerminal;
-import com.glodblock.github.client.gui.container.ContainerFluidPatternTerminal;
-import com.glodblock.github.client.gui.container.ContainerFluidPatternWireless;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.util.ModAndClassUtil;
-import com.glodblock.github.util.NameConst;
-
-import appeng.api.config.ActionItems;
-import appeng.api.config.ItemSubstitution;
-import appeng.api.config.PatternBeSubstitution;
-import appeng.api.config.Settings;
-import appeng.api.storage.ITerminalHost;
-import appeng.client.gui.widgets.GuiImgButton;
-import appeng.client.gui.widgets.GuiTabButton;
-import appeng.container.slot.OptionalSlotFake;
-import appeng.container.slot.SlotFakeCraftingMatrix;
-import appeng.container.slot.SlotPatternTerm;
-import appeng.core.localization.GuiText;
-
-public class GuiFluidPatternTerminal extends FCGuiEncodeTerminal {
-
-    public GuiFluidPatternTerminal(final InventoryPlayer inventoryPlayer, final ITerminalHost te) {
-        super(inventoryPlayer, te, new ContainerFluidPatternTerminal(inventoryPlayer, te));
-    }
-
-    public GuiFluidPatternTerminal(final InventoryPlayer inventoryPlayer, final IWirelessTerminal te) {
-        super(inventoryPlayer, te, new ContainerFluidPatternWireless(inventoryPlayer, te));
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void initGui() {
-        super.initGui();
-        this.tabCraftButton = new GuiTabButton(
-                this.guiLeft + 173,
-                this.guiTop + this.ySize - 177,
-                new ItemStack(Blocks.crafting_table),
-                GuiText.CraftingPattern.getLocal(),
-                itemRender);
-        this.buttonList.add(this.tabCraftButton);
-
-        this.tabProcessButton = new GuiTabButton(
-                this.guiLeft + 173,
-                this.guiTop + this.ySize - 177,
-                new ItemStack(Blocks.furnace),
-                GuiText.ProcessingPattern.getLocal(),
-                itemRender);
-        this.buttonList.add(this.tabProcessButton);
-
-        this.substitutionsEnabledBtn = new GuiImgButton(
-                this.guiLeft + 84,
-                this.guiTop + this.ySize - 163,
-                Settings.ACTIONS,
-                ItemSubstitution.ENABLED);
-        this.substitutionsEnabledBtn.setHalfSize(true);
-        this.buttonList.add(this.substitutionsEnabledBtn);
-
-        this.substitutionsDisabledBtn = new GuiImgButton(
-                this.guiLeft + 84,
-                this.guiTop + this.ySize - 163,
-                Settings.ACTIONS,
-                ItemSubstitution.DISABLED);
-        this.substitutionsDisabledBtn.setHalfSize(true);
-        this.buttonList.add(this.substitutionsDisabledBtn);
-
-        this.clearBtn = new GuiImgButton(
-                this.guiLeft + 74,
-                this.guiTop + this.ySize - 163,
-                Settings.ACTIONS,
-                ActionItems.CLOSE);
-        this.clearBtn.setHalfSize(true);
-        this.buttonList.add(this.clearBtn);
-
-        this.encodeBtn = new GuiImgButton(
-                this.guiLeft + 147,
-                this.guiTop + this.ySize - 142,
-                Settings.ACTIONS,
-                ActionItems.ENCODE);
-        this.buttonList.add(this.encodeBtn);
-
-        int combineLeft = 74;
-        int combineTop = 153;
-        if (ModAndClassUtil.isDoubleButton) {
-            this.doubleBtn = new GuiImgButton(
-                    this.guiLeft + 74,
-                    this.guiTop + this.ySize - 153,
-                    Settings.ACTIONS,
-                    ActionItems.DOUBLE);
-            this.doubleBtn.setHalfSize(true);
-            this.buttonList.add(this.doubleBtn);
-            combineLeft = 84;
-        }
-        if (ModAndClassUtil.isBeSubstitutionsButton) {
-            combineLeft = 74;
-            combineTop -= 11;
-            this.beSubstitutionsEnabledBtn = new GuiImgButton(
-                    this.guiLeft + 84,
-                    this.guiTop + this.ySize - 153,
-                    Settings.ACTIONS,
-                    PatternBeSubstitution.ENABLED);
-            this.beSubstitutionsEnabledBtn.setHalfSize(true);
-            this.buttonList.add(this.beSubstitutionsEnabledBtn);
-
-            this.beSubstitutionsDisabledBtn = new GuiImgButton(
-                    this.guiLeft + 84,
-                    this.guiTop + this.ySize - 153,
-                    Settings.ACTIONS,
-                    PatternBeSubstitution.DISABLED);
-            this.beSubstitutionsDisabledBtn.setHalfSize(true);
-            this.buttonList.add(this.beSubstitutionsDisabledBtn);
-        }
-        this.combineEnableBtn = new GuiFCImgButton(
-                this.guiLeft + combineLeft,
-                this.guiTop + this.ySize - combineTop,
-                "FORCE_COMBINE",
-                "DO_COMBINE");
-        this.combineEnableBtn.setHalfSize(true);
-        this.buttonList.add(this.combineEnableBtn);
-
-        this.combineDisableBtn = new GuiFCImgButton(
-                this.guiLeft + combineLeft,
-                this.guiTop + this.ySize - combineTop,
-                "NOT_COMBINE",
-                "DONT_COMBINE");
-        this.combineDisableBtn.setHalfSize(true);
-        this.buttonList.add(this.combineDisableBtn);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        super.drawFG(offsetX, offsetY, mouseX, mouseY);
-        this.fontRendererObj.drawString(
-                StatCollector.translateToLocal(NameConst.GUI_FLUID_PATTERN_TERMINAL),
-                8,
-                this.ySize - 96 + 2 - getReservedSpace(),
-                4210752);
-    }
-
-    @Override
-    protected void handleMouseClick(final Slot slot, final int slotIdx, final int ctrlDown, final int mouseButton) {
-        if (mouseButton == 3) {
-            if (this.container.isCraftingMode()
-                    && (slot instanceof OptionalSlotFake || slot instanceof SlotFakeCraftingMatrix
-                            || slot instanceof SlotPatternTerm)) {
-                return;
-            }
-        }
-        super.handleMouseClick(slot, slotIdx, ctrlDown, mouseButton);
-    }
-
-    @Override
-    protected String getBackground() {
-        if (this.container.isCraftingMode()) {
-            return "gui/pattern.png";
-        }
-        return "gui/pattern2.png";
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidPatternTerminalCraftingStatus.java

@@ -1,74 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminalEx;
-import com.glodblock.github.common.parts.PartFluidTerminal;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.inventory.item.WirelessFluidTerminalInventory;
-import com.glodblock.github.inventory.item.WirelessInterfaceTerminalInventory;
-import com.glodblock.github.inventory.item.WirelessPatternTerminalInventory;
-import com.glodblock.github.loader.ItemAndBlockHolder;
-import com.glodblock.github.util.Ae2ReflectClient;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.client.gui.implementations.GuiCraftingStatus;
-import appeng.client.gui.widgets.GuiTabButton;
-
-public class GuiFluidPatternTerminalCraftingStatus extends GuiCraftingStatus {
-
-    private GuiTabButton originalGuiBtn;
-    private final ITerminalHost host;
-
-    public GuiFluidPatternTerminalCraftingStatus(InventoryPlayer inventoryPlayer, ITerminalHost te) {
-        super(inventoryPlayer, te);
-        host = te;
-    }
-
-    @Override
-    public void initGui() {
-        if (host instanceof PartFluidPatternTerminal)
-            Ae2ReflectClient.rewriteIcon(this, new ItemStack(ItemAndBlockHolder.FLUID_TERMINAL, 1));
-        else if (host instanceof PartFluidPatternTerminalEx)
-            Ae2ReflectClient.rewriteIcon(this, new ItemStack(ItemAndBlockHolder.FLUID_TERMINAL_EX, 1));
-        else if (host instanceof PartFluidTerminal) {
-            Ae2ReflectClient.rewriteIcon(this, new ItemStack(ItemAndBlockHolder.FLUID_TERM, 1));
-        } else if (host instanceof IWirelessTerminal && ((IWirelessTerminal) host).isUniversal(host)) {
-            Ae2ReflectClient.rewriteIcon(this, new ItemStack(ItemAndBlockHolder.WIRELESS_ULTRA_TERM, 1));
-        } else if (host instanceof WirelessFluidTerminalInventory) {
-            Ae2ReflectClient.rewriteIcon(this, new ItemStack(ItemAndBlockHolder.WIRELESS_FLUID_TERM, 1));
-        } else if (host instanceof WirelessPatternTerminalInventory) {
-            Ae2ReflectClient.rewriteIcon(this, new ItemStack(ItemAndBlockHolder.WIRELESS_PATTERN_TERM, 1));
-        } else if (host instanceof WirelessInterfaceTerminalInventory) {
-            Ae2ReflectClient.rewriteIcon(this, new ItemStack(ItemAndBlockHolder.WIRELESS_INTERFACE_TERM, 1));
-        }
-        super.initGui();
-        originalGuiBtn = Ae2ReflectClient.getOriginalGuiButton(this);
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        if (btn == originalGuiBtn) {
-            if (host instanceof PartFluidPatternTerminal) InventoryHandler.switchGui(GuiType.FLUID_PATTERN_TERMINAL);
-            else if (host instanceof PartFluidPatternTerminalEx)
-                InventoryHandler.switchGui(GuiType.FLUID_PATTERN_TERMINAL_EX);
-            else if (host instanceof PartFluidTerminal) InventoryHandler.switchGui(GuiType.FLUID_TERMINAL);
-            else if (host instanceof IWirelessTerminal && ((IWirelessTerminal) host).isUniversal(host)) InventoryHandler
-                    .switchGui(ItemWirelessUltraTerminal.readMode(((IWirelessTerminal) host).getItemStack()));
-            else if (host instanceof WirelessFluidTerminalInventory)
-                InventoryHandler.switchGui(GuiType.WIRELESS_FLUID_TERMINAL);
-            else if (host instanceof WirelessPatternTerminalInventory)
-                InventoryHandler.switchGui(GuiType.WIRELESS_FLUID_PATTERN_TERMINAL);
-            else if (host instanceof WirelessInterfaceTerminalInventory)
-                InventoryHandler.switchGui(GuiType.WIRELESS_INTERFACE_TERMINAL);
-        } else {
-            super.actionPerformed(btn);
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidPatternTerminalEx.java

@@ -1,222 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.util.StatCollector;
-
-import org.lwjgl.input.Mouse;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.base.FCGuiEncodeTerminal;
-import com.glodblock.github.client.gui.container.ContainerFluidPatternExWireless;
-import com.glodblock.github.client.gui.container.ContainerFluidPatternTerminalEx;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.network.CPacketFluidPatternTermBtns;
-import com.glodblock.github.util.ModAndClassUtil;
-import com.glodblock.github.util.NameConst;
-
-import appeng.api.config.*;
-import appeng.api.storage.ITerminalHost;
-import appeng.client.gui.widgets.GuiImgButton;
-
-public class GuiFluidPatternTerminalEx extends FCGuiEncodeTerminal {
-
-    public GuiFluidPatternTerminalEx(final InventoryPlayer inventoryPlayer, final ITerminalHost te) {
-        super(inventoryPlayer, te, new ContainerFluidPatternTerminalEx(inventoryPlayer, te));
-        processingScrollBar.setHeight(70).setWidth(7).setLeft(6).setRange(0, 1, 1);
-        processingScrollBar.setTexture(FluidCraft.MODID, "gui/pattern3.png", 242, 0);
-    }
-
-    public GuiFluidPatternTerminalEx(final InventoryPlayer inventoryPlayer, final IWirelessTerminal te) {
-        super(inventoryPlayer, te, new ContainerFluidPatternExWireless(inventoryPlayer, te));
-        processingScrollBar.setHeight(70).setWidth(7).setLeft(6).setRange(0, 1, 1);
-        processingScrollBar.setTexture(FluidCraft.MODID, "gui/pattern3.png", 242, 0);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void initGui() {
-        super.initGui();
-
-        this.substitutionsEnabledBtn = new GuiImgButton(
-                this.guiLeft + 97,
-                this.guiTop + this.ySize - 163,
-                Settings.ACTIONS,
-                ItemSubstitution.ENABLED);
-        this.substitutionsEnabledBtn.setHalfSize(true);
-        this.buttonList.add(this.substitutionsEnabledBtn);
-
-        this.substitutionsDisabledBtn = new GuiImgButton(
-                this.guiLeft + 97,
-                this.guiTop + this.ySize - 163,
-                Settings.ACTIONS,
-                ItemSubstitution.DISABLED);
-        this.substitutionsDisabledBtn.setHalfSize(true);
-        this.buttonList.add(this.substitutionsDisabledBtn);
-
-        this.fluidPrioritizedEnabledBtn = new GuiFCImgButton(
-                this.guiLeft + 97,
-                this.guiTop + this.ySize - 114,
-                "FORCE_PRIO",
-                "DO_PRIO");
-        this.fluidPrioritizedEnabledBtn.setHalfSize(true);
-        this.buttonList.add(this.fluidPrioritizedEnabledBtn);
-
-        this.fluidPrioritizedDisabledBtn = new GuiFCImgButton(
-                this.guiLeft + 97,
-                this.guiTop + this.ySize - 114,
-                "NOT_PRIO",
-                "DONT_PRIO");
-        this.fluidPrioritizedDisabledBtn.setHalfSize(true);
-        this.buttonList.add(this.fluidPrioritizedDisabledBtn);
-
-        invertBtn = new GuiImgButton(
-                this.guiLeft + 87,
-                this.guiTop + this.ySize - 153,
-                Settings.ACTIONS,
-                container.inverted ? PatternSlotConfig.C_4_16 : PatternSlotConfig.C_16_4);
-        invertBtn.setHalfSize(true);
-        this.buttonList.add(this.invertBtn);
-
-        this.clearBtn = new GuiImgButton(
-                this.guiLeft + 87,
-                this.guiTop + this.ySize - 163,
-                Settings.ACTIONS,
-                ActionItems.CLOSE);
-        this.clearBtn.setHalfSize(true);
-        this.buttonList.add(this.clearBtn);
-
-        this.encodeBtn = new GuiImgButton(
-                this.guiLeft + 147,
-                this.guiTop + this.ySize - 142,
-                Settings.ACTIONS,
-                ActionItems.ENCODE);
-        this.buttonList.add(this.encodeBtn);
-
-        if (ModAndClassUtil.isDoubleButton) {
-            this.doubleBtn = new GuiImgButton(
-                    this.guiLeft + 97,
-                    this.guiTop + this.ySize - 153,
-                    Settings.ACTIONS,
-                    ActionItems.DOUBLE);
-            this.doubleBtn.setHalfSize(true);
-            this.buttonList.add(this.doubleBtn);
-        }
-
-        this.combineEnableBtn = new GuiFCImgButton(
-                this.guiLeft + 87,
-                this.guiTop + this.ySize - 114,
-                "FORCE_COMBINE",
-                "DO_COMBINE");
-        this.combineEnableBtn.setHalfSize(true);
-        this.buttonList.add(this.combineEnableBtn);
-
-        this.combineDisableBtn = new GuiFCImgButton(
-                this.guiLeft + 87,
-                this.guiTop + this.ySize - 114,
-                "NOT_COMBINE",
-                "DONT_COMBINE");
-        this.combineDisableBtn.setHalfSize(true);
-        this.buttonList.add(this.combineDisableBtn);
-        if (ModAndClassUtil.isBeSubstitutionsButton) {
-            this.beSubstitutionsEnabledBtn = new GuiImgButton(
-                    this.guiLeft + 87,
-                    this.guiTop + this.ySize - 103,
-                    Settings.ACTIONS,
-                    PatternBeSubstitution.ENABLED);
-            this.beSubstitutionsEnabledBtn.setHalfSize(true);
-            this.buttonList.add(this.beSubstitutionsEnabledBtn);
-
-            this.beSubstitutionsDisabledBtn = new GuiImgButton(
-                    this.guiLeft + 87,
-                    this.guiTop + this.ySize - 103,
-                    Settings.ACTIONS,
-                    PatternBeSubstitution.DISABLED);
-            this.beSubstitutionsDisabledBtn.setHalfSize(true);
-            this.buttonList.add(this.beSubstitutionsDisabledBtn);
-        }
-        processingScrollBar.setTop(this.ySize - 164);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        super.drawFG(offsetX, offsetY, mouseX, mouseY);
-        this.fontRendererObj.drawString(
-                StatCollector.translateToLocal(NameConst.GUI_FLUID_PATTERN_TERMINAL_EX),
-                8,
-                this.ySize - 96 + 2 - getReservedSpace(),
-                4210752);
-        this.processingScrollBar.draw(this);
-    }
-
-    @Override
-    protected String getBackground() {
-        return container.inverted ? "gui/pattern4.png" : "gui/pattern3.png";
-    }
-
-    @Override
-    public void drawScreen(final int mouseX, final int mouseY, final float btn) {
-        final int offset = container.inverted ? 18 * -3 : 0;
-        substitutionsEnabledBtn.xPosition = this.guiLeft + 97 + offset;
-        substitutionsDisabledBtn.xPosition = this.guiLeft + 97 + offset;
-        beSubstitutionsEnabledBtn.xPosition = this.guiLeft + 97 + offset;
-        beSubstitutionsDisabledBtn.xPosition = this.guiLeft + 97 + offset;
-        fluidPrioritizedEnabledBtn.xPosition = this.guiLeft + 97 + offset;
-        fluidPrioritizedDisabledBtn.xPosition = this.guiLeft + 97 + offset;
-        doubleBtn.xPosition = this.guiLeft + 97 + offset;
-        clearBtn.xPosition = this.guiLeft + 87 + offset;
-        invertBtn.xPosition = this.guiLeft + 87 + offset;
-        combineEnableBtn.xPosition = this.guiLeft + 87 + offset;
-        combineDisableBtn.xPosition = this.guiLeft + 87 + offset;
-        processingScrollBar.setCurrentScroll(container.activePage);
-        super.drawScreen(mouseX, mouseY, btn);
-    }
-
-    @Override
-    protected void mouseClicked(final int xCoord, final int yCoord, final int btn) {
-        final int currentScroll = this.processingScrollBar.getCurrentScroll();
-        this.processingScrollBar.click(this, xCoord - this.guiLeft, yCoord - this.guiTop);
-        super.mouseClicked(xCoord, yCoord, btn);
-
-        if (currentScroll != this.processingScrollBar.getCurrentScroll()) {
-            changeActivePage();
-        }
-    }
-
-    @Override
-    protected void mouseClickMove(final int x, final int y, final int c, final long d) {
-        final int currentScroll = this.processingScrollBar.getCurrentScroll();
-        this.processingScrollBar.click(this, x - this.guiLeft, y - this.guiTop);
-        super.mouseClickMove(x, y, c, d);
-
-        if (currentScroll != this.processingScrollBar.getCurrentScroll()) {
-            changeActivePage();
-        }
-    }
-
-    @Override
-    public void handleMouseInput() {
-        super.handleMouseInput();
-        final int wheel = Mouse.getEventDWheel();
-
-        if (wheel != 0) {
-            final int x = Mouse.getEventX() * this.width / this.mc.displayWidth;
-            final int y = this.height - Mouse.getEventY() * this.height / this.mc.displayHeight;
-
-            if (this.processingScrollBar.contains(x - this.guiLeft, y - this.guiTop)) {
-                final int currentScroll = this.processingScrollBar.getCurrentScroll();
-                this.processingScrollBar.wheel(wheel);
-
-                if (currentScroll != this.processingScrollBar.getCurrentScroll()) {
-                    changeActivePage();
-                }
-            }
-        }
-    }
-
-    private void changeActivePage() {
-        FluidCraft.proxy.netHandler.sendToServer(
-                new CPacketFluidPatternTermBtns(
-                        "PatternTerminal.ActivePage",
-                        String.valueOf(this.processingScrollBar.getCurrentScroll())));
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidPatternWireless.java

@@ -1,24 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-
-import appeng.container.slot.AppEngSlot;
-import appeng.container.slot.SlotDisabled;
-
-public class GuiFluidPatternWireless extends GuiFluidPatternTerminal {
-
-    public GuiFluidPatternWireless(InventoryPlayer inventoryPlayer, IWirelessTerminal te) {
-        super(inventoryPlayer, te);
-    }
-
-    @Override
-    protected void repositionSlot(final AppEngSlot s) {
-        if (s instanceof SlotDisabled || s.isPlayerSide()) {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 5;
-        } else {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 3;
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidPortableCell.java

@@ -1,30 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.client.gui.container.ContainerFluidPortableCell;
-import com.glodblock.github.inventory.item.IFluidPortableCell;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-
-import appeng.container.slot.AppEngSlot;
-
-public class GuiFluidPortableCell extends GuiFluidTerminal {
-
-    public GuiFluidPortableCell(final InventoryPlayer inventoryPlayer, final IFluidPortableCell te) {
-        super(inventoryPlayer, te, new ContainerFluidPortableCell(inventoryPlayer, te));
-    }
-
-    @Override
-    protected void repositionSlot(final AppEngSlot s) {
-        s.yDisplayPosition = s.getY() + this.ySize - 78 - 5;
-    }
-
-    @Override
-    protected int getMaxRows() {
-        if (this.container.getHost() instanceof IWirelessTerminal) {
-            return super.getMaxRows();
-        } else {
-            return 3;
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidStorageBus.java

@@ -1,105 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.resources.I18n;
-import net.minecraft.entity.player.InventoryPlayer;
-
-import org.lwjgl.input.Mouse;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.container.ContainerFluidStorageBus;
-import com.glodblock.github.common.parts.PartFluidStorageBus;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.network.CPacketFluidPatternTermBtns;
-import com.glodblock.github.network.CPacketSwitchGuis;
-import com.glodblock.github.util.NameConst;
-
-import appeng.api.config.AccessRestriction;
-import appeng.api.config.ActionItems;
-import appeng.api.config.Settings;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.client.gui.implementations.GuiUpgradeable;
-import appeng.client.gui.widgets.GuiImgButton;
-import appeng.client.gui.widgets.GuiTabButton;
-import appeng.core.localization.GuiColors;
-import appeng.core.localization.GuiText;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketConfigButton;
-
-public class GuiFluidStorageBus extends GuiUpgradeable {
-
-    private GuiImgButton rwMode;
-    private GuiTabButton priority;
-    private GuiImgButton partition;
-    private GuiImgButton clear;
-
-    public GuiFluidStorageBus(InventoryPlayer inventoryPlayer, PartFluidStorageBus te) {
-        super(new ContainerFluidStorageBus(inventoryPlayer, te));
-        this.ySize = 251;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    protected void addButtons() {
-        this.clear = new GuiImgButton(this.guiLeft - 18, this.guiTop + 8, Settings.ACTIONS, ActionItems.CLOSE);
-        this.partition = new GuiImgButton(this.guiLeft - 18, this.guiTop + 28, Settings.ACTIONS, ActionItems.WRENCH);
-        this.rwMode = new GuiImgButton(
-                this.guiLeft - 18,
-                this.guiTop + 48,
-                Settings.ACCESS,
-                AccessRestriction.READ_WRITE);
-        this.priority = new GuiTabButton(
-                this.guiLeft + 154,
-                this.guiTop,
-                2 + 4 * 16,
-                GuiText.Priority.getLocal(),
-                itemRender);
-
-        this.buttonList.add(this.priority);
-        this.buttonList.add(this.rwMode);
-        this.buttonList.add(this.partition);
-        this.buttonList.add(this.clear);
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(
-                this.getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_STORAGE_BUS)),
-                8,
-                6,
-                GuiColors.StorageBusTitle.getColor());
-        this.fontRendererObj.drawString(
-                GuiText.inventory.getLocal(),
-                8,
-                this.ySize - 96 + 3,
-                GuiColors.StorageBusInventory.getColor());
-
-        if (this.rwMode != null) {
-            this.rwMode.set(((ContainerFluidStorageBus) this.cvb).getReadWriteMode());
-        }
-    }
-
-    @Override
-    protected String getBackground() {
-        return "guis/storagebus.png";
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        final boolean backwards = Mouse.isButtonDown(1);
-        if (btn == this.partition) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidPatternTermBtns("StorageBus.Action", "Partition"));
-        } else if (btn == this.clear) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidPatternTermBtns("StorageBus.Action", "Clear"));
-        } else if (btn == this.priority) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(GuiType.PRIORITY));
-        } else if (btn == this.rwMode) {
-            NetworkHandler.instance.sendToServer(new PacketConfigButton(this.rwMode.getSetting(), backwards));
-        }
-    }
-
-    public void update(int id, IAEFluidStack stack) {
-        ((ContainerFluidStorageBus) this.cvb).bus.setFluidInSlot(id, stack);
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiFluidTerminal.java

@@ -1,133 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.renderer.texture.TextureMap;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.fluids.Fluid;
-import net.minecraftforge.fluids.FluidStack;
-
-import org.lwjgl.opengl.GL11;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.container.ContainerFluidMonitor;
-import com.glodblock.github.common.item.ItemFluidDrop;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.network.CPacketFluidUpdate;
-import com.glodblock.github.util.Ae2ReflectClient;
-import com.glodblock.github.util.Util;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.client.me.SlotME;
-import appeng.client.render.AppEngRenderItem;
-import appeng.container.slot.AppEngSlot;
-
-public class GuiFluidTerminal extends GuiFluidMonitor {
-
-    private final AppEngRenderItem stackSizeRenderer = Ae2ReflectClient.getStackSizeRenderer(this);
-    protected EntityPlayer player;
-    public ContainerFluidMonitor container;
-
-    public GuiFluidTerminal(InventoryPlayer inventoryPlayer, ITerminalHost te) {
-        super(inventoryPlayer, te, new ContainerFluidMonitor(inventoryPlayer, te));
-        this.container = new ContainerFluidMonitor(inventoryPlayer, te);
-        this.player = inventoryPlayer.player;
-        this.showViewBtn = false;
-    }
-
-    public GuiFluidTerminal(final InventoryPlayer inventoryPlayer, final ITerminalHost te,
-            final ContainerFluidMonitor c) {
-        super(inventoryPlayer, te, c);
-        this.container = c;
-        this.player = inventoryPlayer.player;
-        this.showViewBtn = false;
-    }
-
-    @Override
-    protected void repositionSlot(final AppEngSlot s) {
-        if (s.isPlayerSide()) {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 5;
-        } else {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 3;
-        }
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        if (btn == craftingStatusBtn) {
-            InventoryHandler.switchGui(GuiType.CRAFTING_STATUS);
-        } else {
-            super.actionPerformed(btn);
-        }
-    }
-
-    @Override
-    public void func_146977_a(final Slot s) {
-        if (drawSlot0(s)) super.func_146977_a(s);
-    }
-
-    public boolean drawSlot0(Slot slot) {
-        if (slot instanceof SlotME) {
-            IAEItemStack stack = ((SlotME) slot).getAEStack();
-            if (stack == null) return true;
-            FluidStack fluidStack = ItemFluidDrop.getFluidStack(slot.getStack());
-            this.drawWidget(slot.xDisplayPosition, slot.yDisplayPosition, fluidStack.getFluid());
-            stackSizeRenderer.setAeStack(stack);
-            stackSizeRenderer.renderItemOverlayIntoGUI(
-                    fontRendererObj,
-                    mc.getTextureManager(),
-                    stack.getItemStack(),
-                    slot.xDisplayPosition,
-                    slot.yDisplayPosition);
-            return false;
-        }
-        return true;
-    }
-
-    private void drawWidget(int posX, int posY, Fluid fluid) {
-        Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);
-        GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glColor3f(1, 1, 1);
-        if (fluid != null && fluid.getIcon() != null) {
-            GL11.glColor3f(
-                    (fluid.getColor() >> 16 & 0xFF) / 255.0F,
-                    (fluid.getColor() >> 8 & 0xFF) / 255.0F,
-                    (fluid.getColor() & 0xFF) / 255.0F);
-            drawTexturedModelRectFromIcon(posX, posY, fluid.getIcon(), 16, 16);
-        }
-        GL11.glEnable(GL11.GL_LIGHTING);
-        GL11.glDisable(GL11.GL_BLEND);
-    }
-
-    @Override
-    protected void handleMouseClick(final Slot slot, final int slotIdx, final int ctrlDown, final int mouseButton) {
-        if (slot instanceof SlotME && Util.FluidUtil.isFluidContainer(player.inventory.getItemStack())) {
-            Map<Integer, IAEFluidStack> tmp = new HashMap<>();
-            ItemStack itemStack = this.player.inventory.getItemStack().copy();
-            tmp.put(0, ItemFluidDrop.getAeFluidStack(((SlotME) slot).getAEStack()));
-            if (!isShiftKeyDown()) {
-                itemStack.stackSize = 1;
-            }
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidUpdate(tmp, itemStack));
-        }
-        if (mouseButton == 3 && slot instanceof SlotME) {
-            return;
-        }
-        super.handleMouseClick(slot, slotIdx, ctrlDown, mouseButton);
-    }
-
-    public void update(ItemStack itemStack) {
-        this.player.inventory.setItemStack(itemStack);
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiIngredientBuffer.java

@@ -15,6 +15,7 @@ import com.glodblock.github.inventory.IAEFluidTank;
 import com.glodblock.github.inventory.gui.ButtonMouseHandler;
 import com.glodblock.github.inventory.gui.MouseRegionManager;
 import com.glodblock.github.inventory.gui.TankMouseHandler;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 import com.glodblock.github.util.RenderUtil;
 
@@ -66,8 +67,13 @@ public class GuiIngredientBuffer extends AEBaseGui {
 
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_INGREDIENT_BUFFER)), 8, 6, 0x404040);
-        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        fontRendererObj.drawString(
+                getGuiDisplayName(I18n.format(NameConst.GUI_INGREDIENT_BUFFER)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
+        fontRendererObj
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
         GL11.glColor4f(1F, 1F, 1F, 1F);
 
         IAEFluidTank fluidInv = cont.getTile().getInternalFluid();

src/main/java/com/glodblock/github/client/gui/GuiInterfaceTerminalWireless.java

@@ -1,743 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import java.util.*;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraft.util.ChatComponentTranslation;
-import net.minecraft.world.World;
-import net.minecraftforge.common.util.ForgeDirection;
-
-import org.lwjgl.input.Mouse;
-import org.lwjgl.opengl.GL11;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.base.FCBaseMEGui;
-import com.glodblock.github.client.gui.container.ContainerInterfaceWireless;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.network.CPacketRenamer;
-import com.glodblock.github.util.ModAndClassUtil;
-import com.glodblock.github.util.Util;
-import com.google.common.collect.HashMultimap;
-
-import appeng.api.AEApi;
-import appeng.api.config.*;
-import appeng.api.util.WorldCoord;
-import appeng.client.gui.widgets.*;
-import appeng.client.me.ClientDCInternalInv;
-import appeng.client.me.SlotDisconnected;
-import appeng.client.render.BlockPosHighlighter;
-import appeng.container.slot.AppEngSlot;
-import appeng.core.AEConfig;
-import appeng.core.CommonHelper;
-import appeng.core.localization.ButtonToolTips;
-import appeng.core.localization.GuiColors;
-import appeng.core.localization.GuiText;
-import appeng.core.localization.PlayerMessages;
-import appeng.helpers.PatternHelper;
-import appeng.integration.IntegrationRegistry;
-import appeng.integration.IntegrationType;
-import appeng.util.Platform;
-
-public class GuiInterfaceTerminalWireless extends FCBaseMEGui implements IDropToFillTextField {
-
-    protected int offsetY;
-    private static final int MAGIC_HEIGHT_NUMBER = 52 + 99;
-    private static final int offsetX = 21;
-
-    private final HashMap<Long, ClientDCInternalInv> byId = new HashMap<>();
-    private final HashMultimap<String, ClientDCInternalInv> byName = HashMultimap.create();
-    private final HashMap<ClientDCInternalInv, Util.DimensionalCoordSide> blockPosHashMap = new HashMap<>();
-    private final HashMap<GuiButton, ClientDCInternalInv> guiButtonHashMap = new HashMap<>();
-    private final ArrayList<String> names = new ArrayList<>();
-    private final ArrayList<Object> lines = new ArrayList<>();
-    private final Set<Object> matchedStacks = new HashSet<>();
-
-    private final Map<String, Set<Object>> cachedSearches = new WeakHashMap<>();
-
-    protected static String searchFieldOutputsText = "";
-    protected static String searchFieldInputsText = "";
-    protected static String searchFieldNamesText = "";
-    private final MEGuiTextField searchFieldOutputs;
-    private final MEGuiTextField searchFieldInputs;
-    private final MEGuiTextField searchFieldNames;
-    private final GuiImgButton guiButtonHideFull;
-    private final GuiImgButton guiButtonAssemblersOnly;
-    private final GuiImgButton guiButtonBrokenRecipes;
-    private GuiImgButton searchStringSave;
-    private GuiImgButton terminalStyleBox;
-    private boolean refreshList = false;
-    protected static boolean onlyMolecularAssemblers = false;
-    protected static boolean onlyBrokenRecipes = false;
-    protected GuiTabButton craftingStatusBtn;
-
-    private int rows = 3;
-
-    private static final String MOLECULAR_ASSEMBLER = "tile.appliedenergistics2.BlockMolecularAssembler";
-
-    public GuiInterfaceTerminalWireless(final InventoryPlayer inventoryPlayer, final IWirelessTerminal te) {
-        super(inventoryPlayer, new ContainerInterfaceWireless(inventoryPlayer, te));
-
-        this.setScrollBar(new GuiScrollbar());
-        this.xSize = 208;
-        this.ySize = 255;
-
-        searchFieldInputs = new MEGuiTextField(86, 12, ButtonToolTips.SearchFieldInputs.getLocal()) {
-
-            @Override
-            public void onTextChange(final String oldText) {
-                refreshList();
-            }
-        };
-
-        searchFieldOutputs = new MEGuiTextField(86, 12, ButtonToolTips.SearchFieldOutputs.getLocal()) {
-
-            @Override
-            public void onTextChange(final String oldText) {
-                refreshList();
-            }
-        };
-
-        searchFieldNames = new MEGuiTextField(71, 12, ButtonToolTips.SearchFieldNames.getLocal()) {
-
-            @Override
-            public void onTextChange(final String oldText) {
-                refreshList();
-            }
-        };
-        searchFieldNames.setFocused(true);
-
-        guiButtonAssemblersOnly = new GuiImgButton(0, 0, Settings.ACTIONS, null);
-        guiButtonHideFull = new GuiImgButton(0, 0, Settings.ACTIONS, null);
-        guiButtonBrokenRecipes = new GuiImgButton(0, 0, Settings.ACTIONS, null);
-    }
-
-    @Override
-    public int getOffsetY() {
-        return this.offsetY;
-    }
-
-    @Override
-    public void setOffsetY(int y) {
-        this.offsetY = y;
-    }
-
-    private void setScrollBar() {
-        this.getScrollBar().setTop(52).setLeft(189).setHeight(this.rows * 18 - 2);
-        this.getScrollBar().setRange(0, this.lines.size() - this.rows, 2);
-    }
-
-    @Override
-    public void initGui() {
-        super.initGui();
-        this.rows = calculateRowsCount();
-        this.ySize = MAGIC_HEIGHT_NUMBER + this.rows * 18;
-        final int unusedSpace = this.height - this.ySize;
-        this.guiTop = (int) Math.floor(unusedSpace / (unusedSpace < 0 ? 3.8f : 2.0f));
-        this.offsetY = this.guiTop + 8;
-        this.buttonList.add(
-                this.terminalStyleBox = new GuiImgButton(
-                        this.guiLeft - 18,
-                        this.offsetY,
-                        Settings.TERMINAL_STYLE,
-                        AEConfig.instance.settings.getSetting(Settings.TERMINAL_STYLE)));
-        this.offsetY += 20;
-        this.buttonList.add(
-                this.searchStringSave = new GuiImgButton(
-                        this.guiLeft - 18,
-                        this.offsetY,
-                        Settings.SAVE_SEARCH,
-                        AEConfig.instance.settings.getSetting(Settings.SAVE_SEARCH)));
-        this.offsetY += 20;
-
-        searchFieldInputs.x = guiLeft + Math.max(32, offsetX);
-        searchFieldInputs.y = guiTop + 25;
-
-        searchFieldOutputs.x = guiLeft + Math.max(32, offsetX);
-        searchFieldOutputs.y = guiTop + 38;
-
-        searchFieldNames.x = guiLeft + Math.max(32, offsetX) + 99;
-        searchFieldNames.y = guiTop + 38;
-
-        guiButtonAssemblersOnly.xPosition = guiLeft + Math.max(32, offsetX) + 99;
-        guiButtonAssemblersOnly.yPosition = guiTop + 20;
-
-        guiButtonHideFull.xPosition = guiButtonAssemblersOnly.xPosition + 18;
-        guiButtonHideFull.yPosition = guiTop + 20;
-
-        guiButtonBrokenRecipes.xPosition = guiButtonHideFull.xPosition + 18;
-        guiButtonBrokenRecipes.yPosition = guiTop + 20;
-
-        terminalStyleBox.xPosition = guiLeft - 18;
-        terminalStyleBox.yPosition = guiTop + 8;
-        this.buttonList.add(
-                this.craftingStatusBtn = new GuiTabButton(
-                        this.guiLeft + this.xSize - 24,
-                        this.guiTop - 4,
-                        2 + 11 * 16,
-                        GuiText.CraftingStatus.getLocal(),
-                        itemRender));
-        this.craftingStatusBtn.setHideEdge(13); // GuiTabButton implementation //
-
-        if (ModAndClassUtil.isSearchBar && (AEConfig.instance.preserveSearchBar || this.isSubGui())) {
-            setSearchString();
-        }
-
-        this.setScrollBar();
-        this.repositionSlots();
-        this.initGuiDone();
-    }
-
-    @Override
-    public void onGuiClosed() {
-        super.onGuiClosed();
-        searchFieldOutputsText = this.searchFieldOutputs.getText();
-        searchFieldInputsText = this.searchFieldInputs.getText();
-        searchFieldNamesText = this.searchFieldNames.getText();
-    }
-
-    public void setSearchString() {
-        this.searchFieldOutputs.setText(searchFieldOutputsText);
-        this.searchFieldInputs.setText(searchFieldInputsText);
-        this.searchFieldNames.setText(searchFieldNamesText);
-    }
-
-    protected void repositionSlots() {
-        for (final Object obj : this.inventorySlots.inventorySlots) {
-            if (obj instanceof final AppEngSlot slot) {
-                slot.yDisplayPosition = this.ySize + slot.getY() - 78 - 7;
-            }
-        }
-    }
-
-    protected int calculateRowsCount() {
-        final int maxRows = this.getMaxRows();
-        final boolean hasNEI = IntegrationRegistry.INSTANCE.isEnabled(IntegrationType.NEI);
-        final int input = 22;
-        final int topPanel = 18;
-        final int NEIPadding = hasNEI ? input + topPanel : 0;
-        final int extraSpace = this.height - MAGIC_HEIGHT_NUMBER - NEIPadding;
-
-        return Math.max(3, Math.min(maxRows, extraSpace / 18));
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        fontRendererObj.drawString(
-                getGuiDisplayName(GuiText.InterfaceTerminal.getLocal()),
-                8,
-                6,
-                GuiColors.InterfaceTerminalTitle.getColor());
-        fontRendererObj.drawString(
-                GuiText.inventory.getLocal(),
-                GuiInterfaceTerminalWireless.offsetX + 2,
-                this.ySize - 96,
-                GuiColors.InterfaceTerminalInventory.getColor());
-
-        int offset = 51;
-        final int ex = getScrollBar().getCurrentScroll();
-        for (int x = 0; x < this.rows && ex + x < this.lines.size(); x++) {
-            final Object lineObj = this.lines.get(ex + x);
-            if (lineObj instanceof final ClientDCInternalInv inv) {
-                for (int z = 0; z < inv.getInventory().getSizeInventory(); z++) {
-                    if (this.matchedStacks.contains(inv.getInventory().getStackInSlot(z))) drawRect(
-                            z * 18 + 22,
-                            1 + offset,
-                            z * 18 + 22 + 16,
-                            1 + offset + 16,
-                            GuiColors.InterfaceTerminalMatch.getColor());
-                }
-            } else if (lineObj instanceof String name) {
-                final int rows = this.byName.get(name).size();
-                String postfix = "";
-
-                if (rows > 1) {
-                    postfix = " (" + rows + ')';
-                }
-
-                while (name.length() > 2 && this.fontRendererObj.getStringWidth(name + postfix) > 158) {
-                    name = name.substring(0, name.length() - 1);
-                }
-
-                this.fontRendererObj.drawString(
-                        name + postfix,
-                        GuiInterfaceTerminalWireless.offsetX + 3,
-                        6 + offset,
-                        GuiColors.InterfaceTerminalName.getColor());
-            }
-
-            offset += 18;
-        }
-    }
-
-    @Override
-    public void drawScreen(final int mouseX, final int mouseY, final float btn) {
-
-        buttonList.clear();
-        inventorySlots.inventorySlots.removeIf(slot -> slot instanceof SlotDisconnected);
-
-        guiButtonAssemblersOnly.set(
-                onlyMolecularAssemblers ? ActionItems.MOLECULAR_ASSEMBLEERS_ON : ActionItems.MOLECULAR_ASSEMBLEERS_OFF);
-        guiButtonHideFull.set(
-                AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal
-                        ? ActionItems.TOGGLE_SHOW_FULL_INTERFACES_OFF
-                        : ActionItems.TOGGLE_SHOW_FULL_INTERFACES_ON);
-        guiButtonBrokenRecipes.set(
-                onlyBrokenRecipes ? ActionItems.TOGGLE_SHOW_ONLY_INVALID_PATTERN_OFF
-                        : ActionItems.TOGGLE_SHOW_ONLY_INVALID_PATTERN_ON);
-
-        terminalStyleBox.set(AEConfig.instance.settings.getSetting(Settings.TERMINAL_STYLE));
-
-        buttonList.add(guiButtonAssemblersOnly);
-        buttonList.add(guiButtonHideFull);
-        buttonList.add(guiButtonBrokenRecipes);
-
-        buttonList.add(terminalStyleBox);
-        buttonList.add(searchStringSave);
-        buttonList.add(craftingStatusBtn);
-        this.guiButtonHashMap.clear();
-        addSwitchGuiBtns();
-
-        int offset = 51;
-        final int ex = this.getScrollBar().getCurrentScroll();
-        for (int x = 0; x < this.rows && ex + x < this.lines.size(); x++) {
-            final Object lineObj = this.lines.get(ex + x);
-            if (lineObj instanceof final ClientDCInternalInv inv) {
-                for (int z = 0; z < inv.getInventory().getSizeInventory(); z++) {
-                    inventorySlots.inventorySlots.add(new SlotDisconnected(inv, z, z * 18 + 22, 1 + offset));
-                }
-
-                GuiButton guiButton = new GuiImgButton(
-                        guiLeft + 4,
-                        guiTop + offset + 1,
-                        Settings.ACTIONS,
-                        ActionItems.HIGHLIGHT_INTERFACE);
-                GuiFCImgButton editButton = new GuiFCImgButton(guiLeft + 4, guiTop + offset + 1, "EDIT", "YES");
-                guiButtonHashMap.put(guiButton, inv);
-                guiButtonHashMap.put(editButton, inv);
-                if (isShiftKeyDown()) {
-                    buttonList.add(editButton);
-                } else {
-                    buttonList.add(guiButton);
-                }
-            }
-
-            offset += 18;
-        }
-
-        super.drawScreen(mouseX, mouseY, btn);
-
-        handleTooltip(mouseX, mouseY, searchFieldInputs);
-        handleTooltip(mouseX, mouseY, searchFieldOutputs);
-        handleTooltip(mouseX, mouseY, searchFieldNames);
-    }
-
-    @Override
-    protected void mouseClicked(final int xCoord, final int yCoord, final int btn) {
-        searchFieldInputs.mouseClicked(xCoord, yCoord, btn);
-        searchFieldOutputs.mouseClicked(xCoord, yCoord, btn);
-        searchFieldNames.mouseClicked(xCoord, yCoord, btn);
-
-        super.mouseClicked(xCoord, yCoord, btn);
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        if (guiButtonHashMap.containsKey(btn)) {
-            Util.DimensionalCoordSide blockPos = blockPosHashMap.get(guiButtonHashMap.get(btn));
-            if (btn instanceof GuiFCImgButton) {
-                FluidCraft.proxy.netHandler.sendToServer(
-                        new CPacketRenamer(
-                                blockPos.x,
-                                blockPos.y,
-                                blockPos.z,
-                                blockPos.getDimension(),
-                                blockPos.getSide()));
-            } else {
-
-                WorldCoord blockPos2 = new WorldCoord(
-                        (int) mc.thePlayer.posX,
-                        (int) mc.thePlayer.posY,
-                        (int) mc.thePlayer.posZ);
-                if (mc.theWorld.provider.dimensionId != blockPos.getDimension()) {
-                    mc.thePlayer.addChatMessage(
-                            new ChatComponentTranslation(
-                                    PlayerMessages.InterfaceInOtherDim.getName(),
-                                    blockPos.getDimension()));
-                } else {
-                    BlockPosHighlighter.highlightBlock(
-                            blockPos,
-                            System.currentTimeMillis() + 500 * WorldCoord.getTaxicabDistance(blockPos, blockPos2));
-                    mc.thePlayer.addChatMessage(
-                            new ChatComponentTranslation(
-                                    PlayerMessages.InterfaceHighlighted.getName(),
-                                    blockPos.x,
-                                    blockPos.y,
-                                    blockPos.z));
-                }
-                mc.thePlayer.closeScreen();
-            }
-        } else if (btn == guiButtonHideFull) {
-            AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal = !AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal;
-            this.refreshList();
-        } else if (btn == guiButtonAssemblersOnly) {
-            onlyMolecularAssemblers = !onlyMolecularAssemblers;
-            this.refreshList();
-        } else if (btn == guiButtonBrokenRecipes) {
-            onlyBrokenRecipes = !onlyBrokenRecipes;
-            this.refreshList();
-        } else if (ModAndClassUtil.isSaveText && btn == searchStringSave) {
-            final boolean backwards = Mouse.isButtonDown(1);
-            final GuiImgButton iBtn = (GuiImgButton) btn;
-            final Enum<?> cv = iBtn.getCurrentValue();
-            final Enum<?> next = Platform.rotateEnum(cv, backwards, iBtn.getSetting().getPossibleValues());
-            AEConfig.instance.preserveSearchBar = next == YesNo.YES;
-            AEConfig.instance.settings.putSetting(Settings.SAVE_SEARCH, next);
-            this.searchStringSave.set(next);
-
-        } else if (btn == craftingStatusBtn) {
-            InventoryHandler.switchGui(GuiType.CRAFTING_STATUS);
-        } else if (btn instanceof final GuiImgButton iBtn) {
-            if (iBtn.getSetting() != Settings.ACTIONS) {
-                final Enum cv = iBtn.getCurrentValue();
-                final boolean backwards = Mouse.isButtonDown(1);
-                final Enum next = Platform.rotateEnum(cv, backwards, iBtn.getSetting().getPossibleValues());
-
-                if (btn == this.terminalStyleBox) {
-                    AEConfig.instance.settings.putSetting(iBtn.getSetting(), next);
-
-                    this.reinitialize();
-                }
-
-                iBtn.set(next);
-            }
-        }
-        super.actionPerformed(btn);
-    }
-
-    private void reinitialize() {
-        this.buttonList.clear();
-        this.initGui();
-    }
-
-    @Override
-    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.bindTexture("guis/newinterfaceterminal.png");
-        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, this.xSize, 53);
-
-        int offset = 51;
-        final int ex = this.getScrollBar().getCurrentScroll();
-
-        for (int x = 0; x < this.rows; x++) {
-            this.drawTexturedModalRect(offsetX, offsetY + 53 + x * 18, 0, 52, this.xSize, 18);
-        }
-
-        for (int x = 0; x < this.rows && ex + x < this.lines.size(); x++) {
-
-            final Object lineObj = this.lines.get(ex + x);
-            if (lineObj instanceof final ClientDCInternalInv inv) {
-
-                GL11.glColor4f(1, 1, 1, 1);
-                final int width = inv.getInventory().getSizeInventory() * 18;
-                this.drawTexturedModalRect(offsetX + 20, offsetY + offset, 20, 173, width, 18);
-            }
-
-            offset += 18;
-        }
-
-        this.drawTexturedModalRect(offsetX, offsetY + 50 + this.rows * 18, 0, 158, this.xSize, 99);
-
-        searchFieldInputs.drawTextBox();
-        searchFieldOutputs.drawTextBox();
-        searchFieldNames.drawTextBox();
-    }
-
-    @Override
-    protected void keyTyped(final char character, final int key) {
-        if (!checkHotbarKeys(key)) {
-            if (character == ' ') {
-                if ((searchFieldInputs.getText().isEmpty() && searchFieldInputs.isFocused())
-                        || (searchFieldOutputs.getText().isEmpty() && searchFieldOutputs.isFocused())
-                        || (searchFieldNames.getText().isEmpty() && searchFieldNames.isFocused()))
-                    return;
-            } else if (character == '\t') {
-                if (handleTab()) return;
-            }
-            if (searchFieldInputs.textboxKeyTyped(character, key) || searchFieldOutputs.textboxKeyTyped(character, key)
-                    || searchFieldNames.textboxKeyTyped(character, key)) {
-                refreshList();
-            } else {
-                super.keyTyped(character, key);
-            }
-        }
-    }
-
-    private boolean handleTab() {
-        if (searchFieldInputs.isFocused()) {
-            searchFieldInputs.setFocused(false);
-            if (isShiftKeyDown()) searchFieldNames.setFocused(true);
-            else searchFieldOutputs.setFocused(true);
-            return true;
-        } else if (searchFieldOutputs.isFocused()) {
-            searchFieldOutputs.setFocused(false);
-            if (isShiftKeyDown()) searchFieldInputs.setFocused(true);
-            else searchFieldNames.setFocused(true);
-            return true;
-        } else if (searchFieldNames.isFocused()) {
-            searchFieldNames.setFocused(false);
-            if (isShiftKeyDown()) searchFieldOutputs.setFocused(true);
-            else searchFieldInputs.setFocused(true);
-            return true;
-        }
-        return false;
-    }
-
-    public void postUpdate(final NBTTagCompound in) {
-        if (in.getBoolean("clear")) {
-            this.byId.clear();
-            this.refreshList = true;
-        }
-
-        for (final Object oKey : in.func_150296_c()) {
-            final String key = (String) oKey;
-            if (key.startsWith("=")) {
-                try {
-                    final long id = Long.parseLong(key.substring(1), Character.MAX_RADIX);
-                    final NBTTagCompound invData = in.getCompoundTag(key);
-                    final ClientDCInternalInv current = this
-                            .getById(id, invData.getLong("sortBy"), invData.getString("un"));
-                    int X = invData.getInteger("x");
-                    int Y = invData.getInteger("y");
-                    int Z = invData.getInteger("z");
-                    int dim = invData.getInteger("dim");
-                    ForgeDirection side = ForgeDirection.getOrientation(invData.getInteger("side"));
-                    blockPosHashMap.put(
-                            current,
-                            new Util.DimensionalCoordSide(X, Y, Z, dim, side, current.getUnlocalizedName()));
-
-                    for (int x = 0; x < current.getInventory().getSizeInventory(); x++) {
-                        final String which = Integer.toString(x);
-                        if (invData.hasKey(which)) {
-                            current.getInventory().setInventorySlotContents(
-                                    x,
-                                    ItemStack.loadItemStackFromNBT(invData.getCompoundTag(which)));
-                        }
-                    }
-                } catch (final NumberFormatException ignored) {}
-            }
-        }
-
-        if (this.refreshList) {
-            this.refreshList = false;
-            // invalidate caches on refresh
-            this.cachedSearches.clear();
-            this.refreshList();
-        }
-    }
-
-    /**
-     * Rebuilds the list of interfaces.
-     * <p>
-     * Respects a search term if present (ignores case) and adding only matching patterns.
-     */
-    private void refreshList() {
-        this.byName.clear();
-        this.buttonList.clear();
-        this.matchedStacks.clear();
-
-        final String searchFieldInputs = this.searchFieldInputs.getText().toLowerCase();
-        final String searchFieldOutputs = this.searchFieldOutputs.getText().toLowerCase();
-        final String searchFieldNames = this.searchFieldNames.getText().toLowerCase();
-
-        final Set<Object> cachedSearch = this.getCacheForSearchTerm(
-                "IN:" + searchFieldInputs
-                        + "OUT:"
-                        + searchFieldOutputs
-                        + "NAME:"
-                        + searchFieldNames
-                        + AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal
-                        + onlyMolecularAssemblers
-                        + onlyBrokenRecipes);
-        final boolean rebuild = cachedSearch.isEmpty();
-
-        for (final ClientDCInternalInv entry : this.byId.values()) {
-            // ignore inventory if not doing a full rebuild and cache already marks it as miss.
-            if (!rebuild && !cachedSearch.contains(entry)) {
-                continue;
-            }
-
-            // Shortcut to skip any filter if search term is ""/empty
-            boolean found = searchFieldInputs.isEmpty() && searchFieldOutputs.isEmpty();
-            boolean interfaceHasFreeSlots = false;
-            boolean interfaceHasBrokenRecipes = false;
-
-            // Search if the current inventory holds a pattern containing the search term.
-            if (!found || AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal || onlyBrokenRecipes) {
-                for (final ItemStack itemStack : entry.getInventory()) {
-                    // If only Interfaces with empty slots should be shown, check that here
-                    if (itemStack == null) {
-                        interfaceHasFreeSlots = true;
-                        continue;
-                    }
-
-                    if (onlyBrokenRecipes && recipeIsBroken(itemStack)) {
-                        interfaceHasBrokenRecipes = true;
-                    }
-
-                    if ((!searchFieldInputs.isEmpty() && itemStackMatchesSearchTerm(itemStack, searchFieldInputs, 0))
-                            || (!searchFieldOutputs.isEmpty()
-                                    && itemStackMatchesSearchTerm(itemStack, searchFieldOutputs, 1))) {
-                        found = true;
-                        matchedStacks.add(itemStack);
-                    }
-                }
-            }
-
-            if ((found && entry.getName().toLowerCase().contains(searchFieldNames))
-                    && (!onlyMolecularAssemblers || entry.getUnlocalizedName().contains(MOLECULAR_ASSEMBLER))
-                    && (!AEConfig.instance.showOnlyInterfacesWithFreeSlotsInInterfaceTerminal || interfaceHasFreeSlots)
-                    && (!onlyBrokenRecipes || interfaceHasBrokenRecipes)) {
-                this.byName.put(entry.getName(), entry);
-                cachedSearch.add(entry);
-            } else {
-                cachedSearch.remove(entry);
-            }
-        }
-
-        this.names.clear();
-        this.names.addAll(this.byName.keySet());
-
-        Collections.sort(this.names);
-
-        this.lines.clear();
-        this.lines.ensureCapacity(this.names.size() + this.byId.size());
-
-        for (final String n : this.names) {
-            this.lines.add(n);
-            final ArrayList<ClientDCInternalInv> clientInventories = new ArrayList<>(this.byName.get(n));
-            Collections.sort(clientInventories);
-            this.lines.addAll(clientInventories);
-        }
-
-        this.setScrollBar();
-    }
-
-    private boolean itemStackMatchesSearchTerm(final ItemStack itemStack, final String searchTerm, int pass) {
-        if (itemStack == null) {
-            return false;
-        }
-
-        final NBTTagCompound encodedValue = itemStack.getTagCompound();
-
-        if (encodedValue == null) {
-            return false;
-        }
-
-        final NBTTagList tags = encodedValue.getTagList(pass == 0 ? "in" : "out", 10);
-        final boolean containsInvalidDisplayName = GuiText.UnknownItem.getLocal().toLowerCase().contains(searchTerm);
-
-        for (int i = 0; i < tags.tagCount(); i++) {
-            final NBTTagCompound tag = tags.getCompoundTagAt(i);
-            final ItemStack parsedItemStack = ItemStack.loadItemStackFromNBT(tag);
-
-            if (parsedItemStack != null) {
-                final String displayName = Platform
-                        .getItemDisplayName(AEApi.instance().storage().createItemStack(parsedItemStack)).toLowerCase();
-                if (displayName.contains(searchTerm)) {
-                    return true;
-                }
-            } else if (containsInvalidDisplayName && !tag.hasNoTags()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    private boolean recipeIsBroken(final ItemStack itemStack) {
-
-        if (itemStack == null) {
-            return false;
-        }
-
-        final NBTTagCompound encodedValue = itemStack.getTagCompound();
-        if (encodedValue == null) {
-            return true;
-        }
-
-        final World w = CommonHelper.proxy.getWorld();
-        if (w == null) {
-            return false;
-        }
-
-        try {
-            new PatternHelper(itemStack, w);
-            return false;
-        } catch (final Throwable t) {
-            return true;
-        }
-    }
-
-    /**
-     * Tries to retrieve a cache for a with search term as keyword.
-     * <p>
-     * If this cache should be empty, it will populate it with an earlier cache if available or at least the cache for
-     * the empty string.
-     *
-     * @param searchTerm the corresponding search
-     * @return a Set matching a superset of the search term
-     */
-    private Set<Object> getCacheForSearchTerm(final String searchTerm) {
-        if (!this.cachedSearches.containsKey(searchTerm)) {
-            this.cachedSearches.put(searchTerm, new HashSet<>());
-        }
-
-        final Set<Object> cache = this.cachedSearches.get(searchTerm);
-
-        if (cache.isEmpty() && searchTerm.length() > 1) {
-            cache.addAll(this.getCacheForSearchTerm(searchTerm.substring(0, searchTerm.length() - 1)));
-            return cache;
-        }
-
-        return cache;
-    }
-
-    private int getMaxRows() {
-        return AEConfig.instance.getConfigManager().getSetting(Settings.TERMINAL_STYLE) == TerminalStyle.SMALL
-                ? AEConfig.instance.InterfaceTerminalSmallSize
-                : Integer.MAX_VALUE;
-    }
-
-    private ClientDCInternalInv getById(final long id, final long sortBy, final String unlocalizedName) {
-        ClientDCInternalInv o = this.byId.get(id);
-
-        if (o == null) {
-            this.byId.put(id, o = new ClientDCInternalInv(9, id, sortBy, unlocalizedName));
-            this.refreshList = true;
-        }
-
-        return o;
-    }
-
-    public boolean isOverTextField(final int mousex, final int mousey) {
-        return searchFieldInputs.isMouseIn(mousex, mousey) || searchFieldOutputs.isMouseIn(mousex, mousey)
-                || searchFieldNames.isMouseIn(mousex, mousey);
-    }
-
-    public void setTextFieldValue(final String displayName, final int mousex, final int mousey, final ItemStack stack) {
-
-        if (searchFieldInputs.isMouseIn(mousex, mousey)) {
-            searchFieldInputs.setText(displayName);
-        } else if (searchFieldOutputs.isMouseIn(mousex, mousey)) {
-            searchFieldOutputs.setText(displayName);
-        } else if (searchFieldNames.isMouseIn(mousex, mousey)) {
-            searchFieldNames.setText(displayName);
-        }
-    }
-
-}

src/main/java/com/glodblock/github/client/gui/GuiItemMonitor.java

@@ -1,53 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import java.util.List;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.client.gui.base.FCGuiMonitor;
-import com.glodblock.github.client.gui.container.ContainerItemMonitor;
-import com.glodblock.github.util.ModAndClassUtil;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.client.me.ItemRepo;
-import appeng.core.AEConfig;
-import appeng.core.localization.GuiText;
-
-public class GuiItemMonitor extends FCGuiMonitor<IAEItemStack> {
-
-    public GuiItemMonitor(final InventoryPlayer inventoryPlayer, final ITerminalHost te, final ContainerItemMonitor c) {
-        super(inventoryPlayer, te, c);
-        this.repo = new ItemRepo(getScrollBar(), this);
-    }
-
-    @Override
-    public void postUpdate(final List<IAEItemStack> list, boolean resort) {
-        for (final IAEItemStack is : list) {
-            this.repo.postUpdate(is);
-        }
-        if (resort) {
-            this.repo.updateView();
-        }
-        this.setScrollBar();
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(this.getGuiDisplayName(GuiText.Terminal.getLocal()), 8, 6, 4210752);
-        this.fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, 4210752);
-    }
-
-    @Override
-    public void drawScreen(final int mouseX, final int mouseY, final float btn) {
-        super.drawScreen(mouseX, mouseY, btn);
-        if (ModAndClassUtil.isSearchBar && AEConfig.instance.preserveSearchBar && searchField != null)
-            handleTooltip(mouseX, mouseY, searchField.new TooltipProvider());
-    }
-
-    @Override
-    public void setTextFieldValue(String displayName, int mousex, int mousey, ItemStack stack) {
-        setSearchString(displayName, true);
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiLargeIngredientBuffer.java

@@ -15,6 +15,7 @@ import com.glodblock.github.inventory.IAEFluidTank;
 import com.glodblock.github.inventory.gui.ButtonMouseHandler;
 import com.glodblock.github.inventory.gui.MouseRegionManager;
 import com.glodblock.github.inventory.gui.TankMouseHandler;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 import com.glodblock.github.util.RenderUtil;
 
@@ -66,9 +67,13 @@ public class GuiLargeIngredientBuffer extends AEBaseGui {
 
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        fontRendererObj.drawString(
+                getGuiDisplayName(I18n.format(NameConst.GUI_LARGE_INGREDIENT_BUFFER)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
         fontRendererObj
-                .drawString(getGuiDisplayName(I18n.format(NameConst.GUI_LARGE_INGREDIENT_BUFFER)), 8, 6, 0x404040);
-        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
         GL11.glColor4f(1F, 1F, 1F, 1F);
 
         IAEFluidTank fluidInv = cont.getTile().getInternalFluid();

src/main/java/com/glodblock/github/client/gui/GuiLevelEmitterProxy.java

@@ -0,0 +1,48 @@
+package com.glodblock.github.client.gui;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+
+import appeng.api.parts.ILevelEmitter;
+import appeng.client.gui.IGuiSub;
+import appeng.client.gui.implementations.GuiLevelEmitter;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.container.interfaces.IContainerSubGui;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketSwitchGuis;
+
+public class GuiLevelEmitterProxy extends GuiLevelEmitter implements IGuiSub {
+
+    protected final IContainerSubGui container;
+    protected GuiTabButton originalGuiBtn;;
+
+    public GuiLevelEmitterProxy(final InventoryPlayer inventoryPlayer, final ILevelEmitter te) {
+        super(inventoryPlayer, te);
+        this.container = (IContainerSubGui) inventorySlots;
+        this.container.setGuiLink(this);
+    }
+
+    @Override
+    public void initGui() {
+        super.initGui();
+        if (container.getPrimaryGuiIcon() != null) initPrimaryGuiButton();
+    }
+
+    public void initPrimaryGuiButton() {
+        this.buttonList.add(
+                this.originalGuiBtn = new GuiTabButton(
+                        this.guiLeft + this.xSize - 57,
+                        this.guiTop,
+                        container.getPrimaryGuiIcon(),
+                        container.getPrimaryGuiIcon().getDisplayName(),
+                        itemRender));
+    }
+
+    @Override
+    protected void actionPerformed(GuiButton btn) {
+        super.actionPerformed(btn);
+        if (btn == this.originalGuiBtn) {
+            NetworkHandler.instance.sendToServer(new PacketSwitchGuis());
+        }
+    }
+}

src/main/java/com/glodblock/github/client/gui/GuiLevelMaintainer.java

@@ -1,114 +1,121 @@
 package com.glodblock.github.client.gui;
 
-import java.awt.*;
+import java.text.NumberFormat;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.inventory.GuiContainer;
 import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.StatCollector;
 
+import org.jetbrains.annotations.Nullable;
 import org.lwjgl.input.Keyboard;
 
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.gui.container.ContainerLevelMaintainer;
 import com.glodblock.github.common.tile.TileLevelMaintainer;
 import com.glodblock.github.inventory.gui.MouseRegionManager;
-import com.glodblock.github.inventory.slot.SlotFluidConvertingFake;
-import com.glodblock.github.inventory.slot.SlotSingleItem;
 import com.glodblock.github.network.CPacketLevelMaintainer;
-import com.glodblock.github.util.Ae2ReflectClient;
+import com.glodblock.github.network.CPacketLevelMaintainer.Action;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 
-import appeng.api.storage.data.IAEItemStack;
-import appeng.client.gui.AEBaseGui;
-import appeng.client.render.AppEngRenderItem;
-import appeng.container.slot.SlotFake;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketNEIDragClick;
-import codechicken.nei.VisiblityData;
-import codechicken.nei.api.INEIGuiHandler;
-import codechicken.nei.api.TaggedInventoryArea;
-import cofh.core.render.CoFHFontRenderer;
-import cpw.mods.fml.common.Optional;
+import appeng.api.features.LevelState;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IAEStackType;
+import appeng.client.gui.GuiSub;
+import appeng.client.gui.slots.VirtualMEPhantomSlot;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.client.gui.widgets.GuiToggleButton;
+import appeng.core.localization.GuiText;
+import appeng.util.calculators.ArithHelper;
+import appeng.util.calculators.Calculator;
 
-@Optional.Interface(modid = "NotEnoughItems", iface = "codechicken.nei.api.INEIGuiHandler")
-public class GuiLevelMaintainer extends AEBaseGui implements INEIGuiHandler {
+public class GuiLevelMaintainer extends GuiSub {
 
     private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/level_maintainer.png");
     private final ContainerLevelMaintainer cont;
     private final Component[] component = new Component[TileLevelMaintainer.REQ_COUNT];
     private final MouseRegionManager mouseRegions = new MouseRegionManager(this);
-    private final AppEngRenderItem stackSizeRenderer = Ae2ReflectClient.getStackSizeRenderer(this);
-    private FCGuiTextField input;
-    private int lastWorkingTick;
-    private int refreshTick;
-    private final CoFHFontRenderer render;
+    private Widget focusedWidget;
+    private final FontRenderer render;
+    private GuiToggleButton liteMode;
 
     public GuiLevelMaintainer(InventoryPlayer ipl, TileLevelMaintainer tile) {
         super(new ContainerLevelMaintainer(ipl, tile));
         this.cont = (ContainerLevelMaintainer) inventorySlots;
         this.xSize = 195;
         this.ySize = 214;
-        this.render = new CoFHFontRenderer(
+        this.render = new FontRenderer(
                 Minecraft.getMinecraft().gameSettings,
                 TEX_BG,
                 Minecraft.getMinecraft().getTextureManager(),
                 true);
-        this.refreshTick = 0;
-    }
-
-    public void postUpdate(List<IAEItemStack> list) {
-        for (Slot slot : this.cont.getRequestSlots()) {
-            if (!slot.getHasStack()) {
-                component[slot.getSlotIndex()].setState(TileLevelMaintainer.State.Nothing);
-            }
-        }
-        for (IAEItemStack is : list) {
-            NBTTagCompound data = is.getItemStack().getTagCompound();
-            long size = data.getLong("Batch");
-            int i = data.getInteger("Index");
-            boolean isEnable = data.getBoolean("Enable");
-            TileLevelMaintainer.State state = TileLevelMaintainer.State.values()[data.getInteger("State")];
-            component[i].getQty().textField.setText(String.valueOf(is.getStackSize()));
-            component[i].getBatch().textField.setText(String.valueOf(size));
-            component[i].setEnable(isEnable);
-            component[i].setState(state);
-        }
     }
 
+    @Override
     public void initGui() {
         super.initGui();
-        this.lastWorkingTick = this.refreshTick;
+
+        for (int i = 0; i < TileLevelMaintainer.REQ_COUNT; i++) {
+            VirtualMEPhantomSlot slot = new VirtualMEPhantomSlot(
+                    27,
+                    20 + i * 19,
+                    this.cont.getTile().getAEStackInventory(),
+                    i,
+                    GuiLevelMaintainer::acceptType);
+            slot.setShowAmount(true);
+            slot.setShowAmountAlways(true);
+            this.registerVirtualSlots(slot);
+        }
+
         for (int i = 0; i < TileLevelMaintainer.REQ_COUNT; i++) {
             component[i] = new Component(
                     new Widget(
                             new FCGuiTextField(this.fontRendererObj, guiLeft + 46, guiTop + 19 + 19 * i, 52, 14),
                             NameConst.TT_LEVEL_MAINTAINER_REQUEST_SIZE,
                             i,
-                            "TileLevelMaintainer.Quantity"),
+                            Action.Quantity),
                     new Widget(
                             new FCGuiTextField(this.fontRendererObj, guiLeft + 100, guiTop + 19 + 19 * i, 52, 14),
                             NameConst.TT_LEVEL_MAINTAINER_BATCH_SIZE,
                             i,
-                            "TileLevelMaintainer.Batch"),
+                            Action.Batch),
                     new GuiFCImgButton(guiLeft + 105 + 47, guiTop + 17 + 19 * i, "SUBMIT", "SUBMIT", false),
                     new GuiFCImgButton(guiLeft + 9, guiTop + 20 + 19 * i, "ENABLE", "ENABLE", false),
                     new GuiFCImgButton(guiLeft + 9, guiTop + 20 + 19 * i, "DISABLE", "DISABLE", false),
-                    new FCGuiLineField(fontRendererObj, guiLeft + 47, guiTop + 33 + 19 * i, 125),
-                    this.buttonList);
+                    new FCGuiLineField(fontRendererObj, guiLeft + 47, guiTop + 33 + 19 * i, 120),
+                    this.buttonList,
+                    this.cont);
         }
-        FluidCraft.proxy.netHandler.sendToServer(new CPacketLevelMaintainer("TileLevelMaintainer.refresh"));
+        this.buttonList.add(
+                this.liteMode = new GuiToggleButton(
+                        guiLeft - 18,
+                        guiTop + 2,
+                        178,
+                        194,
+                        GuiText.CraftingModeLite.getLocal(),
+                        NameConst.TT_LEVEL_MAINTAINER_LITE_CRAFT_DESC));
+        this.liteMode.setState(false);
     }
 
+    @Override
+    public void initPrimaryGuiButton() {
+        this.originalGuiBtn = new GuiTabButton(
+                this.guiLeft + 151,
+                this.guiTop - 4,
+                this.cont.getPrimaryGuiIcon(),
+                this.cont.getPrimaryGuiIcon().getDisplayName(),
+                itemRender);
+        this.originalGuiBtn.setHideEdge(13);
+        this.buttonList.add(originalGuiBtn);
+    }
+
+    @Override
     public void drawScreen(final int mouseX, final int mouseY, final float btn) {
-        this.refreshTick++;
         super.drawScreen(mouseX, mouseY, btn);
         for (Component com : this.component) {
             com.getQty().textField.handleTooltip(mouseX, mouseY, this);
@@ -121,12 +128,7 @@ public class GuiLevelMaintainer extends AEBaseGui implements INEIGuiHandler {
     public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) {
         mc.getTextureManager().bindTexture(TEX_BG);
         drawTexturedModalRect(offsetX, offsetY, 0, 0, 176, ySize);
-        int tick = this.refreshTick;
-        int interval = 20;
-        if (tick > lastWorkingTick + interval && this.input == null) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketLevelMaintainer("TileLevelMaintainer.refresh"));
-            lastWorkingTick = this.refreshTick;
-        }
+
         for (int i = 0; i < TileLevelMaintainer.REQ_COUNT; i++) {
             this.component[i].draw();
         }
@@ -134,218 +136,215 @@ public class GuiLevelMaintainer extends AEBaseGui implements INEIGuiHandler {
 
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        fontRendererObj.drawString(getGuiDisplayName(NameConst.i18n(NameConst.GUI_LEVEL_MAINTAINER)), 8, 6, 0x404040);
+        fontRendererObj.drawString(
+                getGuiDisplayName(NameConst.i18n(NameConst.GUI_LEVEL_MAINTAINER)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
         mouseRegions.render(mouseX, mouseY);
     }
 
-    @Override
-    public void func_146977_a(final Slot s) {
-        if (drawSlot0(s)) super.func_146977_a(s);
-    }
-
-    public boolean drawSlot0(Slot slot) {
-        if (slot instanceof SlotFake) {
-            IAEItemStack stack = ((SlotFluidConvertingFake) slot).getAeStack();
-            super.func_146977_a(new SlotSingleItem(slot));
-            if (stack == null) return true;
-            IAEItemStack fake = stack.copy();
-            if (this.component[slot.getSlotIndex()].getQty().textField.getText().matches("[0-9]+")) {
-                fake.setStackSize(Long.parseLong(this.component[slot.getSlotIndex()].getQty().textField.getText()));
-            } else {
-                fake.setStackSize(0);
-            }
-            stackSizeRenderer.setAeStack(fake);
-            stackSizeRenderer.renderItemOverlayIntoGUI(
-                    fontRendererObj,
-                    mc.getTextureManager(),
-                    stack.getItemStack(),
-                    slot.xDisplayPosition,
-                    slot.yDisplayPosition);
-            return false;
-        }
-        return true;
-    }
-
     @Override
     protected void mouseClicked(final int xCoord, final int yCoord, final int btn) {
         if (btn == 0) {
-            if (input != null) {
-                input.setFocused(false);
-            }
             for (Component com : this.component) {
-                FCGuiTextField textField = com.isMouseIn(xCoord, yCoord);
+                Widget textField = com.isMouseIn(xCoord, yCoord);
                 if (textField != null) {
-                    textField.setFocused(true);
-                    this.input = textField;
+                    this.focusWidget(textField);
                     super.mouseClicked(xCoord, yCoord, btn);
                     return;
                 }
             }
-            this.input = null;
+            this.focusWidget(null);
         }
         super.mouseClicked(xCoord, yCoord, btn);
     }
 
     @Override
     protected void keyTyped(final char character, final int key) {
-        if (this.input == null) {
+        if (this.focusedWidget == null) {
             super.keyTyped(character, key);
             return;
         }
         if (!this.checkHotbarKeys(key)) {
-            if (!((character == ' ') && this.input.getText().isEmpty())) {
-                this.input.textboxKeyTyped(character, key);
+            if (!((character == ' ') && this.focusedWidget.textField.getText().isEmpty())) {
+                this.focusedWidget.textField.textboxKeyTyped(character, key);
             }
             super.keyTyped(character, key);
-            if (!this.input.getText().matches("^[0-9]+")) {
-                this.input.setTextColor(0xFF0000);
-            } else {
-                this.input.setTextColor(0xFFFFFF);
+
+            this.focusedWidget.validate();
+
+            if (key == Keyboard.KEY_RETURN || key == Keyboard.KEY_NUMPADENTER) {
+                this.component[this.focusedWidget.componentIndex].submit();
+                this.focusWidget(null);
             }
-            if (key == Keyboard.KEY_RETURN) {
-                this.input.setFocused(false);
-                this.input = null;
+
+            if (key == Keyboard.KEY_TAB) {
+                this.focusAdjacentWidget(isShiftKeyDown());
             }
         }
     }
 
-    @Override
-    protected void handleMouseClick(final Slot slot, final int slotIdx, final int ctrlDown, final int mouseButton) {
-        if (slot instanceof SlotFluidConvertingFake && this.cont.getPlayerInv().getItemStack() != null) {
-            this.component[slot.getSlotIndex()].getQty().textField
-                    .setText(String.valueOf(this.cont.getPlayerInv().getItemStack().stackSize));
-            return;
+    private void focusWidget(@Nullable Widget widget) {
+        if (this.focusedWidget != null) {
+            this.focusedWidget.textField.setFocused(false);
+        }
+        this.focusedWidget = widget;
+        if (this.focusedWidget != null) {
+            this.focusedWidget.textField.setFocused(true);
         }
-        super.handleMouseClick(slot, slotIdx, ctrlDown, mouseButton);
     }
 
-    public void updateAmount(int idx, int stackSize) {
-        this.component[idx].getQty().textField.setText(String.valueOf(stackSize));
+    private void focusAdjacentWidget(boolean backwards) {
+        this.focusedWidget.validate();
+        this.focusWidget(this.getAdjacentWidget(backwards));
+    }
+
+    private Widget getAdjacentWidget(boolean backwards) {
+        int index = this.focusedWidget.componentIndex;
+        boolean isBatch = this.focusedWidget.action == Action.Batch;
+
+        if (backwards) {
+            if (isBatch) {
+                return this.component[index].getQty();
+            }
+            return this.component[(index + TileLevelMaintainer.REQ_COUNT - 1) % TileLevelMaintainer.REQ_COUNT]
+                    .getBatch();
+        }
+
+        if (isBatch) {
+            return this.component[(index + 1) % TileLevelMaintainer.REQ_COUNT].getQty();
+        }
+        return this.component[index].getBatch();
     }
 
     @Override
     protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
         for (Component com : this.component) {
             if (com.sendToServer(btn)) {
-                break;
+                return;
             }
         }
-    }
-
-    @Override
-    public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility) {
-        return currentVisibility;
-    }
-
-    @Override
-    public Iterable<Integer> getItemSpawnSlots(GuiContainer gui, ItemStack item) {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public List<TaggedInventoryArea> getInventoryAreas(GuiContainer gui) {
-        return null;
-    }
-
-    private Rectangle getSlotArea(SlotFake slot) {
-        return new Rectangle(guiLeft + slot.getX(), guiTop + slot.getY(), 16, 16);
-    }
-
-    @Override
-    public boolean handleDragNDrop(GuiContainer gui, int mouseX, int mouseY, ItemStack draggedStack, int button) {
-        for (SlotFluidConvertingFake slot : this.cont.getRequestSlots()) {
-            if (getSlotArea(slot).contains(mouseX, mouseY)) {
-                slot.putStack(draggedStack);
-                NetworkHandler.instance.sendToServer(new PacketNEIDragClick(draggedStack, slot.getSlotIndex()));
-                if (draggedStack != null) {
-                    this.updateAmount(slot.getSlotIndex(), draggedStack.stackSize);
-                    draggedStack.stackSize = 0;
-                }
-                return true;
+        if (btn == this.liteMode) {
+            if (isShiftKeyDown()) {
+                FluidCraft.proxy.netHandler.sendToServer(new CPacketLevelMaintainer(Action.ClearLiteMode));
+            } else {
+                FluidCraft.proxy.netHandler.sendToServer(new CPacketLevelMaintainer(Action.ToggleLiteMode));
             }
+            return;
         }
-        if (draggedStack != null) {
-            draggedStack.stackSize = 0;
-        }
-        return false;
+        super.actionPerformed(btn);
     }
 
-    @Override
-    public boolean hideItemPanelSlot(GuiContainer gui, int x, int y, int w, int h) {
-        return false;
+    public void updateComponent(int index, long quantity, long batchSize, boolean isEnabled, LevelState state) {
+        if (index < 0 || index >= TileLevelMaintainer.REQ_COUNT) return;
+        component[index].setEnable(isEnabled);
+        component[index].setState(state);
+        component[index].getQty().textField.setText(String.valueOf(quantity));
+        component[index].getBatch().textField.setText(String.valueOf(batchSize));
+        component[index].getQty().validate();
+        component[index].getBatch().validate();
+    }
+
+    public void updateComponent(int index, LevelState state) {
+        if (index < 0 || index >= TileLevelMaintainer.REQ_COUNT) return;
+        component[index].setState(state);
+    }
+
+    public void updateComponent(boolean isLiteMode) {
+        this.liteMode.setState(isLiteMode);
+    }
+
+    private static boolean acceptType(VirtualMEPhantomSlot slot, IAEStackType<?> type, int mouseButton) {
+        return true;
     }
 
     private class Component {
 
-        public boolean isEnable = true;
+        public boolean isEnable = false;
         private final Widget qty;
         private final Widget batch;
         private final GuiFCImgButton disable;
         private final GuiFCImgButton enable;
         private final GuiFCImgButton submit;
         private final FCGuiLineField line;
-        private TileLevelMaintainer.State state;
+        private LevelState state;
+        private final ContainerLevelMaintainer container;
 
         public Component(Widget qtyInput, Widget batchInput, GuiFCImgButton submitBtn, GuiFCImgButton enableBtn,
-                GuiFCImgButton disableBtn, FCGuiLineField line, List buttonList) {
+                GuiFCImgButton disableBtn, FCGuiLineField line, List<GuiButton> buttonList,
+                ContainerLevelMaintainer container) {
             this.qty = qtyInput;
             this.batch = batchInput;
             this.enable = enableBtn;
             this.disable = disableBtn;
             this.submit = submitBtn;
             this.line = line;
-            this.state = TileLevelMaintainer.State.Nothing;
+            this.state = LevelState.None;
+            this.container = container;
             buttonList.add(this.submit);
             buttonList.add(this.enable);
             buttonList.add(this.disable);
         }
 
         public int getIndex() {
-            return this.getQty().idx;
+            return this.qty.componentIndex;
         }
 
         public void setEnable(boolean enable) {
             this.isEnable = enable;
         }
 
-        private boolean send(Widget widget) {
-            if (((SlotFluidConvertingFake) cont.inventorySlots.get(widget.idx)).getHasStack()) {
-                if (!widget.textField.getText().isEmpty() && widget.textField.getText().matches("^[0-9]+")) {
-                    String str = widget.textField.getText().replaceAll("^(0+)", "");
-                    widget.textField.setText(str.isEmpty() ? "0" : str);
-                    FluidCraft.proxy.netHandler.sendToServer(
-                            new CPacketLevelMaintainer(widget.action, widget.idx, widget.textField.getText()));
-                    widget.textField.setTextColor(0xFFFFFF);
-                    return true;
-                } else {
-                    widget.textField.setTextColor(0xFF0000);
-                    return false;
-                }
+        public IAEStack<?> getStack() {
+            return this.container.getTile().getAEStackInventory().getAEStackInSlot(this.getIndex());
+        }
+
+        private void send(Widget widget) {
+            if (this.getStack() != null && widget.getAmount() != null) {
+                FluidCraft.proxy.netHandler.sendToServer(
+                        new CPacketLevelMaintainer(widget.action, widget.componentIndex, widget.getAmount()));
             }
-            return false;
+        }
+
+        public void submit() {
+            this.sendToServer(this.submit);
         }
 
         protected boolean sendToServer(GuiButton btn) {
             boolean didSomething = false;
             if (this.submit == btn) {
-                if (this.send(this.getQty())) this.send(this.getBatch());
+                final Widget qty = this.getQty();
+                final Widget batch = this.getBatch();
+                qty.validate();
+                batch.validate();
+                if (qty.getAmount() != null) {
+                    this.send(qty);
+                    qty.textField.setText(String.valueOf(qty.getAmount()));
+                }
+                if (batch.getAmount() != null) {
+                    this.send(batch);
+                    batch.textField.setText(String.valueOf(batch.getAmount()));
+                }
+
                 didSomething = true;
             } else if (this.enable == btn) {
-                FluidCraft.proxy.netHandler
-                        .sendToServer(new CPacketLevelMaintainer("TileLevelMaintainer.Enable", this.getIndex()));
+                this.setEnable(false);
+                FluidCraft.proxy.netHandler.sendToServer(new CPacketLevelMaintainer(Action.Enable, this.getIndex()));
                 didSomething = true;
             } else if (this.disable == btn) {
-                FluidCraft.proxy.netHandler
-                        .sendToServer(new CPacketLevelMaintainer("TileLevelMaintainer.Disable", this.getIndex()));
-                didSomething = true;
+                if (this.getStack() != null) {
+                    this.setEnable(true);
+                    FluidCraft.proxy.netHandler
+                            .sendToServer(new CPacketLevelMaintainer(Action.Disable, this.getIndex()));
+                    didSomething = true;
+                }
             }
             return didSomething;
         }
 
-        public FCGuiTextField isMouseIn(final int xCoord, final int yCoord) {
-            if (this.getQty().textField.isMouseIn(xCoord, yCoord)) return this.getQty().textField;
-            if (this.getBatch().textField.isMouseIn(xCoord, yCoord)) return this.getBatch().textField;
+        public Widget isMouseIn(final int xCoord, final int yCoord) {
+            if (this.qty.textField.isMouseIn(xCoord, yCoord)) return this.getQty();
+            if (this.batch.textField.isMouseIn(xCoord, yCoord)) return this.getBatch();
             return null;
         }
 
@@ -362,33 +361,51 @@ public class GuiLevelMaintainer extends AEBaseGui implements INEIGuiHandler {
         }
 
         public void draw() {
-            this.getQty().draw();
-            this.getBatch().draw();
+            this.qty.draw();
+            this.batch.draw();
             ArrayList<String> message = new ArrayList<>();
             message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_TITLE) + "\n");
             switch (this.state) {
-                case Idling -> {
-                    this.line.setColor(0xFF55FF55);
+                case Idle -> {
+                    this.line.setColor(FCGuiColors.stateIdle.getColor());
                     message.add(
-                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT)
+                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
                                     + NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_IDLE));
                 }
-                case Crafting -> {
-                    this.line.setColor(0xFFFFFF55);
+                case Craft -> {
+                    this.line.setColor(FCGuiColors.stateCraft.getColor());
                     message.add(
-                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT)
+                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
                                     + NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_LINK));
                 }
-                case Exporting -> {
-                    this.line.setColor(0xFFAA00AA);
+                case Export -> {
+                    this.line.setColor(FCGuiColors.stateExport.getColor());
                     message.add(
-                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT)
+                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
                                     + NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_EXPORT));
                 }
-                default -> {
-                    this.line.setColor(0);
+                case Error -> {
+                    this.line.setColor(FCGuiColors.stateError.getColor());
                     message.add(
-                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT)
+                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
+                                    + NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_ERROR));
+                }
+                case NotFound -> {
+                    this.line.setColor(FCGuiColors.stateError.getColor());
+                    message.add(
+                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
+                                    + NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_NOT_FOUND));
+                }
+                case CantCraft -> {
+                    this.line.setColor(FCGuiColors.stateError.getColor());
+                    message.add(
+                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
+                                    + NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CANT_CRAFT));
+                }
+                default -> {
+                    this.line.setColor(FCGuiColors.stateNone.getColor());
+                    message.add(
+                            NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
                                     + NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_NONE));
                 }
             }
@@ -399,7 +416,13 @@ public class GuiLevelMaintainer extends AEBaseGui implements INEIGuiHandler {
                 message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_LINK));
                 message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_LINK_DESC) + "\n");
                 message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_EXPORT));
-                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_EXPORT_DESC));
+                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_EXPORT_DESC) + "\n");
+                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_ERROR));
+                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_ERROR_DESC) + "\n");
+                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_NOT_FOUND));
+                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_NOT_FOUND_DESC) + "\n");
+                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CANT_CRAFT));
+                message.add(NameConst.i18n(NameConst.TT_LEVEL_MAINTAINER_CANT_CRAFT_DESC));
             } else {
                 message.add(NameConst.i18n(NameConst.TT_SHIFT_FOR_MORE));
             }
@@ -415,35 +438,48 @@ public class GuiLevelMaintainer extends AEBaseGui implements INEIGuiHandler {
             }
         }
 
-        public void setState(TileLevelMaintainer.State state) {
+        public void setState(LevelState state) {
             this.state = state;
         }
     }
 
     private class Widget {
 
-        public final int idx;
-        public final String action;
-        private final FCGuiTextField textField;
+        public final int componentIndex;
+        public final Action action;
+        public final FCGuiTextField textField;
         private final String tooltip;
+        private Long amount;
 
-        public Widget(FCGuiTextField textField, String tooltip, int idx, String action) {
+        public Widget(FCGuiTextField textField, String tooltip, int componentIndex, Action action) {
             this.textField = textField;
             this.textField.setEnableBackgroundDrawing(false);
             this.textField.setText("0");
-            this.textField.setMaxStringLength(10); // this length is enough to useful
-            this.idx = idx;
+            this.textField.setMaxStringLength(16); // this length is enough to be useful
+            this.componentIndex = componentIndex;
             this.action = action;
             this.tooltip = tooltip;
         }
 
         public void draw() {
+            String current = amount != null
+                    ? StatCollector.translateToLocal(NameConst.TT_LEVEL_MAINTAINER_CURRENT) + " "
+                            + NumberFormat.getNumberInstance().format(amount)
+                            + "\n"
+                    : "";
             if (isShiftKeyDown()) {
-                this.setTooltip(render.wrapFormattedStringToWidth(NameConst.i18n(this.tooltip), xSize / 2));
+                this.setTooltip(
+                        render.wrapFormattedStringToWidth(
+                                StatCollector.translateToLocal(this.tooltip) + "\n"
+                                        + current
+                                        + "\n"
+                                        + StatCollector.translateToLocal(this.tooltip + ".hint"),
+                                xSize / 2));
             } else {
                 this.setTooltip(
                         render.wrapFormattedStringToWidth(
                                 NameConst.i18n(this.tooltip, "\n", false) + "\n"
+                                        + current
                                         + NameConst.i18n(NameConst.TT_SHIFT_FOR_MORE),
                                 (int) Math.floor(xSize * 0.8)));
             }
@@ -453,5 +489,27 @@ public class GuiLevelMaintainer extends AEBaseGui implements INEIGuiHandler {
         public void setTooltip(String message) {
             this.textField.setMessage(message);
         }
+
+        public void validate() {
+            final double result = Calculator.conversion(this.textField.getText());
+            if (Double.isNaN(result) || result < 0) {
+                this.amount = null;
+                this.textField.setTextColor(FCGuiColors.guiLevelMaintainerError.getColor());
+            } else {
+                this.amount = (long) ArithHelper.round(result, 0);
+                this.textField.setTextColor(FCGuiColors.guiTextColorGray.getColor());
+            }
+
+            IAEStack<?> stack = component[this.componentIndex].getStack();
+            if (stack != null) {
+                Long amount = component[this.componentIndex].getQty().getAmount();
+                stack.setStackSize(amount != null ? amount : 0);
+            }
+        }
+
+        @Nullable
+        public Long getAmount() {
+            return this.amount;
+        }
     }
 }

src/main/java/com/glodblock/github/client/gui/GuiLevelWireless.java

@@ -0,0 +1,24 @@
+package com.glodblock.github.client.gui;
+
+import net.minecraft.entity.player.InventoryPlayer;
+
+import com.glodblock.github.client.gui.container.ContainerLevelWireless;
+import com.glodblock.github.inventory.item.IWirelessTerminal;
+
+import appeng.container.slot.AppEngSlot;
+
+public class GuiLevelWireless extends GuiLevelTerminal {
+
+    public GuiLevelWireless(final InventoryPlayer inventoryPlayer, final IWirelessTerminal te) {
+        super(inventoryPlayer, new ContainerLevelWireless(inventoryPlayer, te));
+    }
+
+    @Override
+    protected void repositionSlots() {
+        for (final Object obj : this.inventorySlots.inventorySlots) {
+            if (obj instanceof final AppEngSlot slot) {
+                slot.yDisplayPosition = this.ySize + slot.getY() - 78 - 4;
+            }
+        }
+    }
+}

src/main/java/com/glodblock/github/client/gui/GuiMagnetFilter.java

@@ -0,0 +1,218 @@
+package com.glodblock.github.client.gui;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.input.Keyboard;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.container.ContainerMagnetFilter;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.network.CPacketFluidPatternTermBtns;
+import com.glodblock.github.util.FCGuiColors;
+import com.glodblock.github.util.NameConst;
+
+import appeng.api.config.ActionItems;
+import appeng.api.config.Settings;
+import appeng.api.storage.ITerminalHost;
+import appeng.client.gui.GuiSub;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.MEGuiTextField;
+
+public class GuiMagnetFilter extends GuiSub {
+
+    protected FCGuiBaseButton listModeBtn;
+    protected ContainerMagnetFilter cont;
+    private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/magnet_filter.png");
+
+    protected Component[] components = new Component[4];
+    protected MEGuiTextField oreDict;
+    protected GuiImgButton clearBtn;
+
+    public GuiMagnetFilter(InventoryPlayer ip, ITerminalHost container) {
+        super(new ContainerMagnetFilter(ip, container));
+        this.xSize = 176;
+        this.ySize = 214;
+        this.cont = (ContainerMagnetFilter) this.inventorySlots;
+        oreDict = new MEGuiTextField(149, 12, NameConst.i18n(NameConst.TT_MAGNET_CARD_OREDICT));
+    }
+
+    private class Component {
+
+        private final GuiFCImgButton enable;
+        private final GuiFCImgButton disable;
+        private final CPacketFluidPatternTermBtns.Command action;
+        private boolean var;
+
+        public Component(int x, int y, boolean var, CPacketFluidPatternTermBtns.Command action) {
+            this.enable = new GuiFCImgButton(x, y, "ENABLE_12x", "ENABLE", false);
+            this.disable = new GuiFCImgButton(x, y, "DISABLE_12x", "DISABLE", false);
+            this.var = var;
+            this.action = action;
+            enable.setThreeFourths(true);
+            disable.setThreeFourths(true);
+            buttonList.add(this.enable);
+            buttonList.add(this.disable);
+        }
+
+        public boolean sameBtn(GuiButton btn) {
+            return btn == this.enable || btn == this.disable;
+        }
+
+        public boolean getVar() {
+            return this.var;
+        }
+
+        public void setVar(boolean var) {
+            this.var = var;
+        }
+
+        public void send() {
+            FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidPatternTermBtns(this.action, !this.getVar()));
+        }
+
+        public void draw() {
+            if (var) {
+                this.enable.visible = true;
+                this.disable.visible = false;
+            } else {
+                this.enable.visible = false;
+                this.disable.visible = true;
+            }
+        }
+    }
+
+    @Override
+    public void initGui() {
+        super.initGui();
+        this.buttonList.clear();
+
+        this.buttonList.add(
+                this.listModeBtn = new FCGuiBaseButton(
+                        0,
+                        this.guiLeft + 86,
+                        this.guiTop + 4,
+                        64,
+                        14,
+                        NameConst.i18n(
+                                this.cont.listMode == WirelessMagnet.ListMode.WhiteList
+                                        ? NameConst.GUI_MAGNET_CARD_WhiteList
+                                        : NameConst.GUI_MAGNET_CARD_BlackList)));
+        this.components[0] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 18,
+                this.cont.nbt,
+                CPacketFluidPatternTermBtns.Command.MAGNET_FILTER_NBT);
+        this.components[1] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 31,
+                this.cont.meta,
+                CPacketFluidPatternTermBtns.Command.MAGNET_FILTER_META);
+        this.components[2] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 44,
+                this.cont.ore,
+                CPacketFluidPatternTermBtns.Command.MAGNET_FILTER_ORE);
+        this.components[3] = new Component(
+                this.guiLeft + 157,
+                this.guiTop + 112,
+                this.cont.oreDict,
+                CPacketFluidPatternTermBtns.Command.MAGNET_FILTER_OREDICT_STATE);
+
+        oreDict.x = this.guiLeft + 7;
+        oreDict.y = this.guiTop + 112;
+        oreDict.setText(this.cont.oreDictFilter);
+
+        this.clearBtn = new GuiImgButton(this.guiLeft + 7, this.guiTop + 48, Settings.ACTIONS, ActionItems.CLOSE);
+        this.clearBtn.setHalfSize(true);
+        this.buttonList.add(this.clearBtn);
+    }
+
+    @Override
+    public void drawScreen(int mouseX, int mouseY, float btn) {
+        handleTooltip(mouseX, mouseY, oreDict);
+        super.drawScreen(mouseX, mouseY, btn);
+    }
+
+    @Override
+    public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        this.fontRendererObj
+                .drawString(NameConst.i18n(NameConst.GUI_MAGNET_CARD), 8, 6, FCGuiColors.guiTextColorGray.getColor());
+        this.fontRendererObj.drawString(
+                NameConst.i18n(NameConst.GUI_MAGNET_CARD_NBT),
+                61,
+                22,
+                FCGuiColors.guiTextColorGray.getColor());
+        this.fontRendererObj.drawString(
+                NameConst.i18n(NameConst.GUI_MAGNET_CARD_META),
+                61,
+                34,
+                FCGuiColors.guiTextColorGray.getColor());
+        this.fontRendererObj.drawString(
+                NameConst.i18n(NameConst.GUI_MAGNET_CARD_ORE),
+                61,
+                46,
+                FCGuiColors.guiTextColorGray.getColor());
+        this.components[0].setVar(this.cont.nbt);
+        this.components[1].setVar(this.cont.meta);
+        this.components[2].setVar(this.cont.ore);
+        this.components[3].setVar(this.cont.oreDict);
+        // the synced value arrives after initGui, so re-apply it while the field is not being edited
+        if (!oreDict.isFocused() && this.cont.oreDictFilter != null
+                && !this.cont.oreDictFilter.equals(oreDict.getText())) {
+            oreDict.setText(this.cont.oreDictFilter, true);
+        }
+        for (Component c : components) {
+            c.draw();
+        }
+        this.listModeBtn.displayString = NameConst.i18n(
+                this.cont.listMode == WirelessMagnet.ListMode.WhiteList ? NameConst.GUI_MAGNET_CARD_WhiteList
+                        : NameConst.GUI_MAGNET_CARD_BlackList);
+    }
+
+    @Override
+    public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        bindTexture(TEX_BG);
+        drawTexturedModalRect(offsetX, offsetY, 0, 0, xSize, ySize);
+        oreDict.drawTextBox();
+    }
+
+    @Override
+    protected void keyTyped(char typedChar, int keyCode) {
+        if (oreDict.isFocused() && (Keyboard.KEY_NUMPADENTER == keyCode || Keyboard.KEY_RETURN == keyCode)) {
+            FluidCraft.proxy.netHandler.sendToServer(
+                    new CPacketFluidPatternTermBtns(
+                            CPacketFluidPatternTermBtns.Command.MAGNET_FILTER_OREDICT_FILTER,
+                            oreDict.getText()));
+        }
+
+        if (!oreDict.textboxKeyTyped(typedChar, keyCode)) super.keyTyped(typedChar, keyCode);
+    }
+
+    @Override
+    protected void mouseClicked(int xCoord, int yCoord, int btn) {
+        oreDict.mouseClicked(xCoord, yCoord, btn);
+        super.mouseClicked(xCoord, yCoord, btn);
+    }
+
+    @Override
+    protected void actionPerformed(GuiButton btn) {
+        for (Component c : components) {
+            if (c.sameBtn(btn)) {
+                c.send();
+                break;
+            }
+        }
+        if (btn == this.listModeBtn) {
+            FluidCraft.proxy.netHandler.sendToServer(
+                    new CPacketFluidPatternTermBtns(
+                            CPacketFluidPatternTermBtns.Command.MAGNET_FILTER_MODE,
+                            this.cont.listMode != WirelessMagnet.ListMode.WhiteList));
+        } else if (btn == this.clearBtn) {
+            FluidCraft.proxy.netHandler.sendToServer(
+                    new CPacketFluidPatternTermBtns(CPacketFluidPatternTermBtns.Command.MAGNET_FILTER_CLEAR, 1));
+        }
+        super.actionPerformed(btn);
+    }
+}

src/main/java/com/glodblock/github/client/gui/GuiOCPatternEditor.java

@@ -7,6 +7,7 @@ import net.minecraft.util.ResourceLocation;
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.gui.container.ContainerOCPatternEditor;
 import com.glodblock.github.common.tile.TileOCPatternEditor;
+import com.glodblock.github.util.FCGuiColors;
 import com.glodblock.github.util.NameConst;
 
 import appeng.client.gui.AEBaseGui;
@@ -29,7 +30,12 @@ public class GuiOCPatternEditor extends AEBaseGui {
 
     @Override
     public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_OC_PATTERN_EDITOR)), 8, 6, 0x404040);
-        fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040);
+        fontRendererObj.drawString(
+                getGuiDisplayName(I18n.format(NameConst.GUI_OC_PATTERN_EDITOR)),
+                8,
+                6,
+                FCGuiColors.guiTextColorGray.getColor());
+        fontRendererObj
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
     }
 }

src/main/java/com/glodblock/github/client/gui/GuiPatternValueAmount.java

@@ -1,93 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.base.FCGuiAmount;
-import com.glodblock.github.client.gui.container.ContainerPatternValueAmount;
-import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminalEx;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.inventory.item.WirelessPatternTerminalInventory;
-import com.glodblock.github.loader.ItemAndBlockHolder;
-import com.glodblock.github.network.CPacketPatternValueSet;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.core.localization.GuiText;
-
-public class GuiPatternValueAmount extends FCGuiAmount {
-
-    public GuiPatternValueAmount(final InventoryPlayer inventoryPlayer, final ITerminalHost te) {
-        super(new ContainerPatternValueAmount(inventoryPlayer, te));
-    }
-
-    @Override
-    public void initGui() {
-        super.initGui();
-        this.submit.displayString = GuiText.Set.getLocal();
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.fontRendererObj.drawString(GuiText.SelectAmount.getLocal(), 8, 6, 0x404040);
-    }
-
-    @Override
-    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        super.drawBG(offsetX, offsetY, mouseX, mouseY);
-        try {
-            int result = getAmount();
-            this.submit.enabled = result > 0;
-        } catch (final NumberFormatException e) {
-            this.submit.enabled = false;
-        }
-        this.amountBox.drawTextBox();
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        try {
-            if (btn == this.submit && btn.enabled) {
-                FluidCraft.proxy.netHandler.sendToServer(
-                        new CPacketPatternValueSet(
-                                originalGui.ordinal(),
-                                getAmount(),
-                                ((ContainerPatternValueAmount) this.inventorySlots).getValueIndex()));
-            }
-        } catch (final NumberFormatException e) {
-            this.amountBox.setText("1");
-        }
-    }
-
-    @Override
-    protected void setOriginGUI(Object target) {
-        if (target instanceof PartFluidPatternTerminal) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.FLUID_TERMINAL, 1);
-            this.originalGui = GuiType.FLUID_PATTERN_TERMINAL;
-        } else if (target instanceof PartFluidPatternTerminalEx) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.FLUID_TERMINAL_EX, 1);
-            this.originalGui = GuiType.FLUID_PATTERN_TERMINAL_EX;
-        } else if (target instanceof IWirelessTerminal && ((IWirelessTerminal) target).isUniversal(target)) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.WIRELESS_ULTRA_TERM, 1);
-            this.originalGui = ItemWirelessUltraTerminal.readMode(((IWirelessTerminal) target).getItemStack());
-        } else if (target instanceof WirelessPatternTerminalInventory) {
-            this.myIcon = new ItemStack(ItemAndBlockHolder.WIRELESS_PATTERN_TERM, 1);
-            this.originalGui = GuiType.WIRELESS_FLUID_PATTERN_TERMINAL;
-        }
-    }
-
-    @Override
-    protected String getBackground() {
-        return "guis/craftAmt.png";
-    }
-
-    public void setAmount(int amount) {
-        this.amountBox.setText(String.valueOf(amount));
-        this.amountBox.setSelectionPos(0);
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiRenamer.java

@@ -1,76 +0,0 @@
-package com.glodblock.github.client.gui;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.container.ContainerRenamer;
-import com.glodblock.github.network.CPacketRenamer;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.client.gui.AEBaseGui;
-import appeng.client.gui.widgets.IDropToFillTextField;
-import appeng.client.gui.widgets.MEGuiTextField;
-import appeng.core.localization.GuiColors;
-import appeng.core.localization.GuiText;
-
-public class GuiRenamer extends AEBaseGui implements IDropToFillTextField {
-
-    private final MEGuiTextField textField;
-
-    public GuiRenamer(InventoryPlayer ip, ITerminalHost monitorable) {
-        super(new ContainerRenamer(ip, monitorable));
-        this.xSize = 256;
-
-        this.textField = new MEGuiTextField(230, 12);
-        this.textField.setMaxStringLength(32);
-    }
-
-    @Override
-    public void initGui() {
-        super.initGui();
-        FluidCraft.proxy.netHandler.sendToServer(new CPacketRenamer(CPacketRenamer.Action.GET_TEXT));
-        this.textField.x = this.guiLeft + 12;
-        this.textField.y = this.guiTop + 35;
-        this.textField.setFocused(true);
-    }
-
-    @Override
-    public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        this.fontRendererObj.drawString(GuiText.Renamer.getLocal(), 12, 8, GuiColors.RenamerTitle.getColor());
-    }
-
-    @Override
-    public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) {
-        this.bindTexture("guis/renamer.png");
-        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, this.xSize, this.ySize);
-        this.textField.drawTextBox();
-    }
-
-    @Override
-    protected void mouseClicked(final int xCoord, final int yCoord, final int btn) {
-        this.textField.mouseClicked(xCoord, yCoord, btn);
-        super.mouseClicked(xCoord, yCoord, btn);
-    }
-
-    @Override
-    protected void keyTyped(final char character, final int key) {
-        if (key == 28) { // Enter
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketRenamer(this.textField.getText()));
-        } else if (!this.textField.textboxKeyTyped(character, key)) {
-            super.keyTyped(character, key);
-        }
-    }
-
-    public boolean isOverTextField(final int mousex, final int mousey) {
-        return textField.isMouseIn(mousex, mousey);
-    }
-
-    public void setTextFieldValue(final String displayName, final int mousex, final int mousey, final ItemStack stack) {
-        textField.setText(displayName);
-    }
-
-    public void postUpdate(String text) {
-        this.textField.setText(text);
-    }
-}

src/main/java/com/glodblock/github/client/gui/GuiSuperStockReplenisher.java

@@ -0,0 +1,165 @@
+package com.glodblock.github.client.gui;
+
+import java.text.DecimalFormat;
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+
+import org.lwjgl.opengl.GL11;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.container.ContainerSuperStockReplenisher;
+import com.glodblock.github.common.tile.TileSuperStockReplenisher;
+import com.glodblock.github.util.FCGuiColors;
+
+import appeng.api.storage.StorageName;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IAEStackType;
+import appeng.client.gui.AEBaseGui;
+import appeng.client.gui.slots.VirtualMEPhantomSlot;
+import appeng.client.gui.slots.VirtualMEPhantomSlotPrecise;
+import appeng.core.localization.GuiText;
+import appeng.util.item.AEFluidStackType;
+import appeng.util.item.AEItemStackType;
+
+public class GuiSuperStockReplenisher extends AEBaseGui {
+
+    private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/superStockReplenisher.png");
+    private final DecimalFormat df = new DecimalFormat("#.#");
+    private Map<Integer, IAEStack<?>> list = new HashMap<>();
+    private final ContainerSuperStockReplenisher containerSuperStockReplenisher;
+    private final TileSuperStockReplenisher tileSuperStockReplenisher;
+
+    private final VirtualMEPhantomSlotPrecise[] configFluidsSlots = new VirtualMEPhantomSlotPrecise[9];
+    private final VirtualMEPhantomSlotPrecise[] configItemsSlots = new VirtualMEPhantomSlotPrecise[63];
+
+    private GuiFCImgButton StockModeButton;
+
+    public GuiSuperStockReplenisher(InventoryPlayer ipl, TileSuperStockReplenisher tile) {
+        super(new ContainerSuperStockReplenisher(ipl, tile));
+
+        this.containerSuperStockReplenisher = (ContainerSuperStockReplenisher) inventorySlots;
+        this.tileSuperStockReplenisher = tile;
+
+        this.ySize = 251;
+        this.xSize = 216;
+    }
+
+    @Override
+    public void initGui() {
+        super.initGui();
+
+        this.StockModeButton = new GuiFCImgButton(
+                guiLeft - 18,
+                guiTop + 8,
+                "stock mode button",
+                this.containerSuperStockReplenisher.isFullStockMode() ? "fullstockMode" : "normalMode",
+                true);
+        this.containerSuperStockReplenisher.setModeButton(this.StockModeButton);
+        buttonList.add(this.StockModeButton);
+        this.initSlots();
+    }
+
+    private void initSlots() {
+
+        final int xo = 8;
+        final int yo = 8;
+
+        for (int i = 0; i < 9; i++) {
+            VirtualMEPhantomSlotPrecise slot = new VirtualMEPhantomSlotPrecise(
+                    xo + i * 18,
+                    yo,
+                    this.containerSuperStockReplenisher.configFluidsSlots,
+                    i,
+                    this::acceptType);
+            this.configFluidsSlots[i] = slot;
+            this.registerVirtualSlots(slot);
+        }
+
+        final int iyo = 29;
+        for (int y = 0; y < 7; y++) {
+            for (int ix = 0; ix < 9; ix++) {
+                VirtualMEPhantomSlotPrecise slot = new VirtualMEPhantomSlotPrecise(
+                        xo + ix * 18,
+                        iyo + y * 18,
+                        this.containerSuperStockReplenisher.configItemsSlots,
+                        y * 9 + ix,
+                        this::acceptType);
+                this.configItemsSlots[y * 9 + ix] = slot;
+                this.registerVirtualSlots(slot);
+            }
+        }
+    }
+
+    private void drawFillStatus(VirtualMEPhantomSlotPrecise virtualSlot) {
+        final int offsetX = virtualSlot.getX() - 8;
+        final int offsetY = virtualSlot.getY() - 12;
+        final IAEStack<?> aes = virtualSlot.getAEStack();
+        final long stackSize = aes != null ? aes.getStackSize() : 0;
+        final int slotIndex = virtualSlot.getStorageName() == StorageName.NONE ? virtualSlot.getSlotIndex()
+                : virtualSlot.getSlotIndex() + 100;
+
+        if (stackSize != 0) {
+            String s = "0%";
+            IAEStack<?> aeStack = list.get(slotIndex);
+
+            if (aeStack != null) s = df.format((float) aeStack.getStackSize() / stackSize * 100) + "%";
+
+            float scale = 0.5f;
+            float shiftX = 2;
+            float shiftY = 1;
+            final float inverseScaleFactor = 1.0f / scale;
+
+            final int X = (int) (((float) offsetX - shiftX + 10.0f) * inverseScaleFactor) + 1;
+            final int Y = (int) (((float) offsetY - shiftY + 16.0f - 7.0f * scale) * inverseScaleFactor) + 2;
+            GL11.glTranslatef(0.0f, 0.0f, 200.0f);
+            GL11.glScaled(scale, scale, scale);
+            this.fontRendererObj.drawStringWithShadow(s, X, Y, 16777215);
+            GL11.glScaled(inverseScaleFactor, inverseScaleFactor, inverseScaleFactor);
+            GL11.glTranslatef(0.0f, 0.0f, -200.0f);
+        }
+    }
+
+    private void drawVirtualSlots() {
+        for (VirtualMEPhantomSlotPrecise slot : this.configFluidsSlots) this.drawFillStatus(slot);
+        for (VirtualMEPhantomSlotPrecise slot : this.configItemsSlots) this.drawFillStatus(slot);
+    }
+
+    @Override
+    public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        fontRendererObj
+                .drawString(GuiText.inventory.getLocal(), 8, ySize - 94, FCGuiColors.guiTextColorGray.getColor());
+        this.drawVirtualSlots();
+    }
+
+    @Override
+    public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) {
+        this.bindTexture(TEX_BG);
+        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, xSize, ySize);
+    }
+
+    @Override
+    protected void actionPerformed(final GuiButton btn) {
+        if (actionPerformedCustomButtons(btn)) return;
+        if (btn == StockModeButton) {
+            boolean newMode = !containerSuperStockReplenisher.isFullStockMode();
+            this.containerSuperStockReplenisher.setFullStockMode(newMode);
+            StockModeButton.set(newMode ? "fullstockMode" : "normalMode");
+
+            this.flushPendingSync();
+        }
+        super.actionPerformed(btn);
+    }
+
+    public void update(Map<Integer, IAEStack<?>> map) {
+        this.list = map;
+    }
+
+    private boolean acceptType(VirtualMEPhantomSlot slot, IAEStackType<?> type, int mouseButton) {
+        if (slot.getStorageName() == StorageName.NONE) return type == AEFluidStackType.FLUID_STACK_TYPE;
+        else return type == AEItemStackType.ITEM_STACK_TYPE;
+    }
+}

src/main/java/com/glodblock/github/client/gui/base/FCBaseMEGui.java

@@ -1,41 +1,14 @@
 package com.glodblock.github.client.gui.base;
 
-import java.util.ArrayList;
-import java.util.List;
-
-import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.Container;
 
-import com.glodblock.github.client.gui.*;
-import com.glodblock.github.client.gui.container.base.FCBaseContainer;
-import com.glodblock.github.common.item.ItemWirelessUltraTerminal;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.util.ModAndClassUtil;
+import appeng.client.gui.AEBaseGui;
 
-import appeng.client.gui.AEBaseMEGui;
-
-public abstract class FCBaseMEGui extends AEBaseMEGui {
-
-    protected GuiFCImgButton FluidTerminal;
-    protected GuiFCImgButton CraftingTerminal;
-    protected GuiFCImgButton PatternTerminal;
-    protected GuiFCImgButton EssentiaTerminal;
-    protected GuiFCImgButton InterfaceTerminal;
-    protected GuiFCImgButton PatternTerminaleEx;
-    protected List<GuiFCImgButton> termBtns = new ArrayList<>();
-    protected boolean drawSwitchGuiBtn;
+public abstract class FCBaseMEGui extends AEBaseGui {
 
     public FCBaseMEGui(final InventoryPlayer inventoryPlayer, Container container) {
         super(container);
-        if (container instanceof FCBaseContainer) {
-            Object target = ((FCBaseContainer) container).getTarget();
-            if (target instanceof IWirelessTerminal
-                    && ((IWirelessTerminal) target).getItemStack().getItem() instanceof ItemWirelessUltraTerminal) {
-                this.drawSwitchGuiBtn = true;
-            }
-        }
     }
 
     @Override
@@ -43,102 +16,25 @@ public abstract class FCBaseMEGui extends AEBaseMEGui {
         super.onGuiClosed();
     }
 
-    protected void initGuiDone() {
-        if (drawSwitchGuiBtn) {
-            drawSwitchGuiBtns();
-        }
-    }
-
-    public abstract int getOffsetY();
-
-    public abstract void setOffsetY(int y);
-
-    @SuppressWarnings("unchecked")
-    protected void drawSwitchGuiBtns() {
-        if (!drawSwitchGuiBtn) return;
-        if (!termBtns.isEmpty()) {
-            this.termBtns.clear();
-        }
-        if (!(this instanceof GuiFluidCraftingWireless)) {
-            this.buttonList.add(
-                    this.CraftingTerminal = new GuiFCImgButton(
-                            this.guiLeft - 18,
-                            this.getOffsetY(),
-                            "CRAFT_TEM",
-                            "YES"));
-            this.setOffsetY(this.getOffsetY() + 20);
-            termBtns.add(this.CraftingTerminal);
-        }
-        if (!(this instanceof GuiFluidPatternWireless)) {
-            this.buttonList.add(
-                    this.PatternTerminal = new GuiFCImgButton(
-                            this.guiLeft - 18,
-                            this.getOffsetY(),
-                            "PATTERN_TEM",
-                            "YES"));
-            this.setOffsetY(this.getOffsetY() + 20);
-            termBtns.add(this.PatternTerminal);
-        }
-        if (!(this instanceof GuiFluidPatternExWireless)) {
-            this.buttonList.add(
-                    this.PatternTerminaleEx = new GuiFCImgButton(
-                            this.guiLeft - 18,
-                            this.getOffsetY(),
-                            "PATTERN_EX_TEM",
-                            "YES"));
-            this.setOffsetY(this.getOffsetY() + 20);
-            termBtns.add(this.PatternTerminaleEx);
-        }
-        if (!(this instanceof GuiFluidPortableCell)) {
-            this.buttonList.add(
-                    this.FluidTerminal = new GuiFCImgButton(this.guiLeft - 18, this.getOffsetY(), "FLUID_TEM", "YES"));
-            this.setOffsetY(this.getOffsetY() + 20);
-            termBtns.add(this.FluidTerminal);
-        }
-        if (!(this instanceof GuiInterfaceTerminalWireless)) {
-            this.buttonList.add(
-                    this.InterfaceTerminal = new GuiFCImgButton(
-                            this.guiLeft - 18,
-                            this.getOffsetY(),
-                            "INTERFACE_TEM",
-                            "YES"));
-            this.setOffsetY(this.getOffsetY() + 20);
-            termBtns.add(this.InterfaceTerminal);
-        }
-        if (ModAndClassUtil.ThE && !(this instanceof GuiEssentiaTerminal)) {
-            this.buttonList.add(
-                    this.EssentiaTerminal = new GuiFCImgButton(
-                            this.guiLeft - 18,
-                            this.getOffsetY(),
-                            "ESSENTIA_TEM",
-                            "YES"));
-            this.setOffsetY(this.getOffsetY() + 20);
-            termBtns.add(this.EssentiaTerminal);
-        }
-    }
-
-    protected void addSwitchGuiBtns() {
-        if (!drawSwitchGuiBtn) return;
-        this.buttonList.addAll(termBtns);
-    }
+    private boolean scheduleGuiResize;
 
     @Override
-    protected void actionPerformed(final GuiButton btn) {
-        if (btn instanceof GuiFCImgButton) {
-            if (btn == this.FluidTerminal) {
-                ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_FLUID_TERMINAL);
-            } else if (btn == this.CraftingTerminal) {
-                ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_CRAFTING_TERMINAL);
-            } else if (btn == this.EssentiaTerminal) {
-                ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_ESSENTIA_TERMINAL);
-            } else if (btn == this.PatternTerminal) {
-                ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_FLUID_PATTERN_TERMINAL);
-            } else if (btn == this.InterfaceTerminal) {
-                ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_INTERFACE_TERMINAL);
-            } else if (btn == this.PatternTerminaleEx) {
-                ItemWirelessUltraTerminal.switchTerminal(this.mc.thePlayer, GuiType.WIRELESS_FLUID_PATTERN_TERMINAL_EX);
-            }
+    protected void mouseClicked(int xCoord, int yCoord, int btn) {
+        super.mouseClicked(xCoord, yCoord, btn);
+        if (scheduleGuiResize) {
+            // in the GuiScreen class, the implementation of super.mouseClicked
+            // ends up looping on the button list and execute the action for any
+            // button below the mouse.
+            // Therefore, if we initGui() the terminal in the actionPerformed method below
+            // it will run the actionPerformed a second time for the new button
+            // that will end up being below the mouse (if any) after the initGui()
+            buttonList.clear();
+            initGui();
+            scheduleGuiResize = false;
         }
-        super.actionPerformed(btn);
+    }
+
+    protected final void scheduleGuiResize() {
+        scheduleGuiResize = true;
     }
 }

src/main/java/com/glodblock/github/client/gui/base/FCGuiAmount.java

@@ -1,151 +0,0 @@
-package com.glodblock.github.client.gui.base;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiTextField;
-import net.minecraft.inventory.Container;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.network.CPacketSwitchGuis;
-
-import appeng.client.gui.AEBaseGui;
-import appeng.client.gui.widgets.GuiTabButton;
-import appeng.container.AEBaseContainer;
-import appeng.core.AEConfig;
-import appeng.core.localization.GuiText;
-import appeng.util.calculators.ArithHelper;
-import appeng.util.calculators.Calculator;
-
-public abstract class FCGuiAmount extends AEBaseGui {
-
-    protected GuiTextField amountBox;
-    protected GuiTabButton originalGuiBtn;
-    protected GuiButton submit;
-    protected GuiButton plus1;
-    protected GuiButton plus10;
-    protected GuiButton plus100;
-    protected GuiButton plus1000;
-    protected GuiButton minus1;
-    protected GuiButton minus10;
-    protected GuiButton minus100;
-    protected GuiButton minus1000;
-    protected GuiType originalGui;
-    protected ItemStack myIcon;
-
-    public FCGuiAmount(Container container) {
-        super(container);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void initGui() {
-        super.initGui();
-        final int a = AEConfig.instance.craftItemsByStackAmounts(0);
-        final int b = AEConfig.instance.craftItemsByStackAmounts(1);
-        final int c = AEConfig.instance.craftItemsByStackAmounts(2);
-        final int d = AEConfig.instance.craftItemsByStackAmounts(3);
-
-        this.buttonList.add(this.plus1 = new GuiButton(0, this.guiLeft + 20, this.guiTop + 26, 22, 20, "+" + a));
-        this.buttonList.add(this.plus10 = new GuiButton(0, this.guiLeft + 48, this.guiTop + 26, 28, 20, "+" + b));
-        this.buttonList.add(this.plus100 = new GuiButton(0, this.guiLeft + 82, this.guiTop + 26, 32, 20, "+" + c));
-        this.buttonList.add(this.plus1000 = new GuiButton(0, this.guiLeft + 120, this.guiTop + 26, 38, 20, "+" + d));
-
-        this.buttonList.add(this.minus1 = new GuiButton(0, this.guiLeft + 20, this.guiTop + 75, 22, 20, "-" + a));
-        this.buttonList.add(this.minus10 = new GuiButton(0, this.guiLeft + 48, this.guiTop + 75, 28, 20, "-" + b));
-        this.buttonList.add(this.minus100 = new GuiButton(0, this.guiLeft + 82, this.guiTop + 75, 32, 20, "-" + c));
-        this.buttonList.add(this.minus1000 = new GuiButton(0, this.guiLeft + 120, this.guiTop + 75, 38, 20, "-" + d));
-
-        this.buttonList.add(
-                this.submit = new GuiButton(0, this.guiLeft + 128, this.guiTop + 51, 38, 20, GuiText.Next.getLocal()));
-
-        setOriginGUI(((AEBaseContainer) this.inventorySlots).getTarget());
-        if (this.originalGui != null && this.myIcon != null) {
-            this.buttonList.add(
-                    this.originalGuiBtn = new GuiTabButton(
-                            this.guiLeft + 154,
-                            this.guiTop,
-                            this.myIcon,
-                            this.myIcon.getDisplayName(),
-                            itemRender));
-        }
-
-        this.amountBox = new GuiTextField(
-                this.fontRendererObj,
-                this.guiLeft + 62,
-                this.guiTop + 57,
-                59,
-                this.fontRendererObj.FONT_HEIGHT);
-        this.amountBox.setEnableBackgroundDrawing(false);
-        this.amountBox.setMaxStringLength(16);
-        this.amountBox.setTextColor(0xFFFFFF);
-        this.amountBox.setVisible(true);
-        this.amountBox.setFocused(true);
-    }
-
-    @Override
-    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.bindTexture(getBackground());
-        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, this.xSize, this.ySize);
-    }
-
-    @Override
-    protected void keyTyped(final char character, final int key) {
-        if (!this.checkHotbarKeys(key)) {
-            if (key == 28) {
-                this.actionPerformed(this.submit);
-            }
-            this.amountBox.textboxKeyTyped(character, key);
-            super.keyTyped(character, key);
-        }
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        if (btn == this.originalGuiBtn) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(this.originalGui));
-        }
-        final boolean isPlus = btn == this.plus1 || btn == this.plus10 || btn == this.plus100 || btn == this.plus1000;
-        final boolean isMinus = btn == this.minus1 || btn == this.minus10
-                || btn == this.minus100
-                || btn == this.minus1000;
-
-        if (isPlus || isMinus) {
-            this.addQty(this.getQty(btn));
-        }
-    }
-
-    protected void addQty(final int i) {
-        try {
-            long resultI = getAmount();
-            if (resultI == 1 && i > 1) {
-                resultI = 0;
-            }
-            resultI += i;
-            if (resultI < 1) {
-                resultI = 1;
-            }
-            String out = Long.toString(resultI);
-            this.amountBox.setText(out);
-        } catch (final NumberFormatException ignore) {}
-    }
-
-    protected abstract void setOriginGUI(Object target);
-
-    protected abstract String getBackground();
-
-    protected int getAmount() {
-        try {
-            String out = this.amountBox.getText();
-            double result = Calculator.conversion(out);
-            if (result <= 0 || Double.isNaN(result)) {
-                return 0;
-            } else {
-                return (int) ArithHelper.round(result, 0);
-            }
-        } catch (final NumberFormatException e) {
-            return 0;
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/base/FCGuiEncodeTerminal.java

@@ -1,198 +0,0 @@
-package com.glodblock.github.client.gui.base;
-
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-
-import org.lwjgl.input.Keyboard;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.GuiFCImgButton;
-import com.glodblock.github.client.gui.GuiItemMonitor;
-import com.glodblock.github.client.gui.container.base.FCContainerEncodeTerminal;
-import com.glodblock.github.common.item.ItemFluidPacket;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.slot.SlotSingleItem;
-import com.glodblock.github.network.CPacketFluidPatternTermBtns;
-import com.glodblock.github.util.Ae2ReflectClient;
-import com.glodblock.github.util.ModAndClassUtil;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.client.gui.widgets.GuiImgButton;
-import appeng.client.gui.widgets.GuiScrollbar;
-import appeng.client.gui.widgets.GuiTabButton;
-import appeng.client.render.AppEngRenderItem;
-import appeng.container.slot.AppEngSlot;
-import appeng.container.slot.SlotFake;
-import appeng.util.item.AEItemStack;
-
-public abstract class FCGuiEncodeTerminal extends GuiItemMonitor {
-
-    private static final String SUBSTITUTION_DISABLE = "0";
-    private static final String SUBSTITUTION_ENABLE = "1";
-    private static final String PRIORITY_DISABLE = "0";
-    private static final String PRIORITY_ENABLE = "1";
-    private static final String MODE_CRAFTING = "1";
-    private static final String MODE_PROCESSING = "0";
-    public FCContainerEncodeTerminal container;
-    protected GuiTabButton tabCraftButton;
-    protected GuiTabButton tabProcessButton;
-    protected GuiImgButton substitutionsEnabledBtn;
-    protected GuiImgButton substitutionsDisabledBtn;
-    protected GuiFCImgButton fluidPrioritizedEnabledBtn;
-    protected GuiFCImgButton fluidPrioritizedDisabledBtn;
-    protected GuiImgButton encodeBtn;
-    protected GuiImgButton invertBtn;
-    protected GuiImgButton clearBtn;
-    protected GuiImgButton doubleBtn;
-    protected GuiImgButton beSubstitutionsEnabledBtn;
-    protected GuiImgButton beSubstitutionsDisabledBtn;
-    protected GuiFCImgButton combineEnableBtn;
-    protected GuiFCImgButton combineDisableBtn;
-    protected GuiFCImgButton autoFillPatternEnableBtn;
-    protected GuiFCImgButton autoFillPatternDisableBtn;
-    protected final GuiScrollbar processingScrollBar = new GuiScrollbar();
-    protected final AppEngRenderItem stackSizeRenderer = Ae2ReflectClient.getStackSizeRenderer(this);
-
-    public FCGuiEncodeTerminal(final InventoryPlayer inventoryPlayer, final ITerminalHost te,
-            final FCContainerEncodeTerminal c) {
-        super(inventoryPlayer, te, c);
-        this.container = (FCContainerEncodeTerminal) this.inventorySlots;
-        c.setGui(this);
-        setReservedSpace(81);
-    }
-
-    @Override
-    public void initGui() {
-        super.initGui();
-        this.buttonList.add(
-                this.autoFillPatternEnableBtn = new GuiFCImgButton(
-                        this.guiLeft - 18,
-                        this.offsetY,
-                        "FILL_PATTERN",
-                        "DO_FILL"));
-        this.buttonList.add(
-                this.autoFillPatternDisableBtn = new GuiFCImgButton(
-                        this.guiLeft - 18,
-                        this.offsetY,
-                        "NOT_FILL_PATTERN",
-                        "DONT_FILL"));
-        this.offsetY += 20;
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        super.actionPerformed(btn);
-        if (btn == craftingStatusBtn) {
-            InventoryHandler.switchGui(GuiType.CRAFTING_STATUS);
-        } else if (this.tabCraftButton == btn || this.tabProcessButton == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns(
-                            "PatternTerminal.CraftMode",
-                            this.tabProcessButton == btn ? MODE_CRAFTING : MODE_PROCESSING));
-        } else if (this.encodeBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns(
-                            "PatternTerminal.Encode",
-                            (isCtrlKeyDown() ? 1 : 0) << 1 | (isShiftKeyDown() ? 1 : 0)));
-        } else if (this.clearBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidPatternTermBtns("PatternTerminal.Clear", "1"));
-        } else if (this.substitutionsEnabledBtn == btn || this.substitutionsDisabledBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns(
-                            "PatternTerminal.Substitute",
-                            this.substitutionsEnabledBtn == btn ? SUBSTITUTION_DISABLE : SUBSTITUTION_ENABLE));
-        } else if (this.fluidPrioritizedEnabledBtn == btn || this.fluidPrioritizedDisabledBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns(
-                            "PatternTerminal.Prioritize",
-                            isShiftKeyDown() ? "2" : (container.prioritize ? PRIORITY_DISABLE : PRIORITY_ENABLE)));
-        } else if (this.invertBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns("PatternTerminal.Invert", container.inverted ? "0" : "1"));
-        } else if (this.combineDisableBtn == btn || this.combineEnableBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns(
-                            "PatternTerminal.Combine",
-                            this.combineDisableBtn == btn ? "1" : "0"));
-        } else if (ModAndClassUtil.isDoubleButton && doubleBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns(
-                            "PatternTerminal.Double",
-                            Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) ? "1" : "0"));
-        } else if (ModAndClassUtil.isBeSubstitutionsButton && beSubstitutionsDisabledBtn == btn) {
-            FluidCraft.proxy.netHandler
-                    .sendToServer(new CPacketFluidPatternTermBtns("PatternTerminal.beSubstitute", "1"));
-        } else if (ModAndClassUtil.isBeSubstitutionsButton && beSubstitutionsEnabledBtn == btn) {
-            FluidCraft.proxy.netHandler
-                    .sendToServer(new CPacketFluidPatternTermBtns("PatternTerminal.beSubstitute", "0"));
-        } else if (this.autoFillPatternDisableBtn == btn || this.autoFillPatternEnableBtn == btn) {
-            FluidCraft.proxy.netHandler.sendToServer(
-                    new CPacketFluidPatternTermBtns(
-                            "PatternTerminal.AutoFillerPattern",
-                            this.autoFillPatternDisableBtn == btn ? "1" : "0"));
-        }
-    }
-
-    @Override
-    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        updateButton(this.tabCraftButton, this.container.isCraftingMode());
-        updateButton(this.tabProcessButton, !this.container.isCraftingMode());
-        updateButton(this.doubleBtn, !this.container.isCraftingMode());
-        updateButton(this.substitutionsEnabledBtn, this.container.substitute);
-        updateButton(this.substitutionsDisabledBtn, !this.container.substitute);
-        updateButton(this.combineEnableBtn, !this.container.isCraftingMode() && this.container.combine);
-        updateButton(this.combineDisableBtn, !this.container.isCraftingMode() && !this.container.combine);
-        updateButton(this.beSubstitutionsEnabledBtn, this.container.beSubstitute);
-        updateButton(this.beSubstitutionsDisabledBtn, !this.container.beSubstitute);
-        updateButton(this.fluidPrioritizedEnabledBtn, this.container.prioritize);
-        updateButton(this.fluidPrioritizedDisabledBtn, !this.container.prioritize);
-        updateButton(this.autoFillPatternEnableBtn, this.container.autoFillPattern);
-        updateButton(this.autoFillPatternDisableBtn, !this.container.autoFillPattern);
-        super.drawFG(offsetX, offsetY, mouseX, mouseY);
-    }
-
-    protected void updateButton(GuiButton button, boolean vis) {
-        if (button != null) {
-            button.visible = vis;
-        }
-    }
-
-    @Override
-    protected void repositionSlot(final AppEngSlot s) {
-        if (s.isPlayerSide()) {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 5;
-        } else {
-            s.yDisplayPosition = s.getY() + this.ySize - 78 - 3;
-        }
-    }
-
-    @Override
-    public void func_146977_a(final Slot s) {
-        if (drawSlot0(s)) super.func_146977_a(s);
-    }
-
-    public boolean drawSlot0(Slot slot) {
-        if (slot instanceof SlotFake && !this.container.isCraftingMode()) {
-            AEItemStack stack = AEItemStack.create(slot.getStack());
-            super.func_146977_a(new SlotSingleItem(slot));
-            if (stack == null) return true;
-            IAEItemStack fake = stack.copy();
-            if (fake.getItemStack().getItem() instanceof ItemFluidPacket) {
-                if (ItemFluidPacket.getFluidStack(stack) != null && ItemFluidPacket.getFluidStack(stack).amount > 0)
-                    fake.setStackSize(ItemFluidPacket.getFluidStack(stack).amount);
-            } else return true;
-            stackSizeRenderer.setAeStack(fake);
-            stackSizeRenderer.renderItemOverlayIntoGUI(
-                    fontRendererObj,
-                    mc.getTextureManager(),
-                    stack.getItemStack(),
-                    slot.xDisplayPosition,
-                    slot.yDisplayPosition);
-            return false;
-        }
-        return true;
-    }
-}

src/main/java/com/glodblock/github/client/gui/base/FCGuiMonitor.java

@@ -1,759 +0,0 @@
-package com.glodblock.github.client.gui.base;
-
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.util.List;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.ResourceLocation;
-
-import org.lwjgl.input.Keyboard;
-import org.lwjgl.input.Mouse;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.*;
-import com.glodblock.github.client.gui.container.base.FCContainerMonitor;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.network.CPacketInventoryAction;
-import com.glodblock.github.util.Ae2ReflectClient;
-import com.glodblock.github.util.ModAndClassUtil;
-
-import appeng.api.config.*;
-import appeng.api.implementations.tiles.IViewCellStorage;
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.api.storage.data.IAEStack;
-import appeng.api.storage.data.IDisplayRepo;
-import appeng.api.util.IConfigManager;
-import appeng.api.util.IConfigurableObject;
-import appeng.client.gui.widgets.*;
-import appeng.client.me.InternalSlotME;
-import appeng.client.me.SlotDisconnected;
-import appeng.client.me.SlotME;
-import appeng.container.AEBaseContainer;
-import appeng.container.slot.*;
-import appeng.core.AEConfig;
-import appeng.core.AELog;
-import appeng.core.localization.ButtonToolTips;
-import appeng.core.localization.GuiText;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketInventoryAction;
-import appeng.core.sync.packets.PacketValueConfig;
-import appeng.helpers.InventoryAction;
-import appeng.integration.IntegrationRegistry;
-import appeng.integration.IntegrationType;
-import appeng.util.IConfigManagerHost;
-import appeng.util.Platform;
-import appeng.util.item.AEItemStack;
-import codechicken.nei.LayoutManager;
-import codechicken.nei.util.TextHistory;
-
-public abstract class FCGuiMonitor<T extends IAEStack<T>> extends FCBaseMEGui
-        implements ISortSource, IConfigManagerHost, IDropToFillTextField {
-
-    public static int craftingGridOffsetX;
-    public static int craftingGridOffsetY;
-    protected static String memoryText = "";
-    protected final int offsetX = 9;
-    protected final int lowerTextureOffset = 0;
-    public IConfigManager configSrc;
-    protected final boolean viewCell;
-    protected final ItemStack[] myCurrentViewCells = new ItemStack[5];
-    public FCContainerMonitor<T> monitorableContainer;
-    public GuiTabButton craftingStatusBtn;
-    protected IDisplayRepo repo;
-    protected GuiImgButton craftingStatusImgBtn;
-    protected FCGuiTextField searchField;
-    protected int perRow = 9;
-    protected int reservedSpace = 0;
-    protected boolean customSortOrder = true;
-    protected boolean showViewBtn = true;
-    protected int rows = 0;
-    protected int maxRows = Integer.MAX_VALUE;
-    protected int standardSize;
-    protected int offsetY;
-    protected GuiImgButton ViewBox;
-    protected GuiImgButton SortByBox;
-    protected GuiImgButton SortDirBox;
-    protected GuiImgButton searchBoxSettings;
-    protected GuiImgButton terminalStyleBox;
-    protected GuiImgButton searchStringSave;
-    protected GuiImgButton typeFilter;
-
-    @SuppressWarnings("unchecked")
-    public FCGuiMonitor(final InventoryPlayer inventoryPlayer, final ITerminalHost te, final FCContainerMonitor<T> c) {
-        super(inventoryPlayer, c);
-        final GuiScrollbar scrollbar = new GuiScrollbar();
-        this.setScrollBar(scrollbar);
-        this.xSize = 195;
-        this.ySize = 204;
-        this.standardSize = this.xSize;
-        this.configSrc = ((IConfigurableObject) this.inventorySlots).getConfigManager();
-        (this.monitorableContainer = (FCContainerMonitor<T>) this.inventorySlots).setGui(this);
-        this.viewCell = te instanceof IViewCellStorage;
-    }
-
-    public int getOffsetY() {
-        return offsetY;
-    }
-
-    public void setOffsetY(int y) {
-        offsetY = y;
-    }
-
-    public abstract void postUpdate(final List<T> list, boolean resort);
-
-    protected void setScrollBar() {
-        this.getScrollBar().setTop(18).setLeft(175).setHeight(this.rows * 18 - 2);
-        this.getScrollBar().setRange(
-                0,
-                (this.repo.size() + this.perRow - 1) / this.perRow - this.rows,
-                Math.max(1, this.rows / 6));
-    }
-
-    @Override
-    protected void actionPerformed(final GuiButton btn) {
-        if (btn == this.craftingStatusBtn || btn == this.craftingStatusImgBtn) {
-            InventoryHandler.switchGui(GuiType.CRAFTING_STATUS);
-        }
-        if (btn instanceof final GuiImgButton iBtn) {
-            final boolean backwards = Mouse.isButtonDown(1);
-            if (iBtn.getSetting() != Settings.ACTIONS) {
-                final Enum<?> cv = iBtn.getCurrentValue();
-                final Enum<?> next = Platform.rotateEnum(cv, backwards, iBtn.getSetting().getPossibleValues());
-                if (btn == this.terminalStyleBox) {
-                    AEConfig.instance.settings.putSetting(iBtn.getSetting(), next);
-                } else if (btn == this.searchBoxSettings) {
-                    AEConfig.instance.settings.putSetting(iBtn.getSetting(), next);
-                } else if (ModAndClassUtil.isSaveText && btn == this.searchStringSave) {
-                    AEConfig.instance.preserveSearchBar = next == YesNo.YES;
-                } else {
-                    try {
-                        NetworkHandler.instance
-                                .sendToServer(new PacketValueConfig(iBtn.getSetting().name(), next.name()));
-                    } catch (final IOException e) {
-                        AELog.debug(e);
-                    }
-                }
-                iBtn.set(next);
-                if (next.getClass() == SearchBoxMode.class || next.getClass() == TerminalStyle.class) {
-                    this.reInitalize();
-                }
-            }
-        }
-        super.actionPerformed(btn);
-    }
-
-    protected void reInitalize() {
-        this.buttonList.clear();
-        this.initGui();
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void initGui() {
-        Keyboard.enableRepeatEvents(true);
-
-        this.maxRows = this.getMaxRows();
-        this.perRow = AEConfig.instance.getConfigManager().getSetting(Settings.TERMINAL_STYLE) != TerminalStyle.FULL ? 9
-                : 9 + ((this.width - this.standardSize) / 18);
-
-        final boolean hasNEI = IntegrationRegistry.INSTANCE.isEnabled(IntegrationType.NEI);
-
-        final int NEI = 0;
-        int top = hasNEI ? 22 : 0;
-
-        final int magicNumber = 114 + 1;
-        final int extraSpace = this.height - magicNumber - NEI - top - this.reservedSpace;
-
-        this.rows = (int) Math.floor(extraSpace / 18.0);
-        if (this.rows > this.maxRows) {
-            this.rows = this.maxRows;
-        }
-
-        if (hasNEI) {
-            this.rows--;
-        }
-
-        if (this.rows < 3) {
-            this.rows = 3;
-        }
-
-        this.getMeSlots().clear();
-        for (int y = 0; y < this.rows; y++) {
-            for (int x = 0; x < this.perRow; x++) {
-                this.getMeSlots()
-                        .add(new InternalSlotME(this.repo, x + y * this.perRow, this.offsetX + x * 18, 18 + y * 18));
-            }
-        }
-
-        if (AEConfig.instance.getConfigManager().getSetting(Settings.TERMINAL_STYLE) != TerminalStyle.FULL) {
-            this.xSize = this.standardSize + ((this.perRow - 9) * 18);
-        } else {
-            this.xSize = this.standardSize;
-        }
-
-        super.initGui();
-        // full size : 204
-        // extra slots : 72
-        // slot 18
-
-        this.ySize = magicNumber + this.rows * 18 + this.reservedSpace;
-        final int unusedSpace = this.height - this.ySize;
-        this.guiTop = (int) Math.floor(unusedSpace / (unusedSpace < 0 ? 3.8f : 2.0f));
-
-        this.offsetY = this.guiTop + 8;
-
-        if (this.customSortOrder) {
-            this.buttonList.add(
-                    this.SortByBox = new GuiImgButton(
-                            this.guiLeft - 18,
-                            this.offsetY,
-                            Settings.SORT_BY,
-                            this.configSrc.getSetting(Settings.SORT_BY)));
-            this.offsetY += 20;
-        }
-        if (this.showViewBtn) {
-            this.buttonList.add(
-                    this.ViewBox = new GuiImgButton(
-                            this.guiLeft - 18,
-                            this.offsetY,
-                            Settings.VIEW_MODE,
-                            this.configSrc.getSetting(Settings.VIEW_MODE)));
-            this.offsetY += 20;
-        }
-        if (ModAndClassUtil.isTypeFilter && this instanceof GuiItemMonitor) {
-            this.buttonList.add(
-                    this.typeFilter = new GuiImgButton(
-                            this.guiLeft - 18,
-                            this.offsetY,
-                            Settings.TYPE_FILTER,
-                            this.configSrc.getSetting(Settings.TYPE_FILTER)));
-            this.offsetY += 20;
-        }
-
-        this.buttonList.add(
-                this.SortDirBox = new GuiImgButton(
-                        this.guiLeft - 18,
-                        this.offsetY,
-                        Settings.SORT_DIRECTION,
-                        this.configSrc.getSetting(Settings.SORT_DIRECTION)));
-        this.offsetY += 20;
-
-        this.buttonList.add(
-                this.searchBoxSettings = new GuiImgButton(
-                        this.guiLeft - 18,
-                        this.offsetY,
-                        Settings.SEARCH_MODE,
-                        AEConfig.instance.settings.getSetting(Settings.SEARCH_MODE)));
-        this.offsetY += 20;
-
-        if (ModAndClassUtil.isSaveText) {
-            this.buttonList.add(
-                    this.searchStringSave = new GuiImgButton(
-                            this.guiLeft - 18,
-                            this.offsetY,
-                            Settings.SAVE_SEARCH,
-                            AEConfig.instance.preserveSearchBar ? YesNo.YES : YesNo.NO));
-            this.offsetY += 20;
-        }
-
-        this.buttonList.add(
-                this.terminalStyleBox = new GuiImgButton(
-                        this.guiLeft - 18,
-                        this.offsetY,
-                        Settings.TERMINAL_STYLE,
-                        AEConfig.instance.settings.getSetting(Settings.TERMINAL_STYLE)));
-        this.offsetY += 20;
-
-        // Right now 80 > offsetX, but that can be changed later.
-        // noinspection DataFlowIssue
-        this.searchField = new FCGuiTextField(
-                this.fontRendererObj,
-                this.guiLeft + Math.max(80, this.offsetX),
-                this.guiTop + 4,
-                90,
-                12);
-        this.searchField.setEnableBackgroundDrawing(false);
-        this.searchField.setMaxStringLength(25);
-        this.searchField.setTextColor(0xFFFFFF);
-        this.searchField.setVisible(true);
-        if (ModAndClassUtil.isSearchStringTooltip)
-            searchField.setMessage(ButtonToolTips.SearchStringTooltip.getLocal());
-
-        if (this.viewCell) {
-            if (ModAndClassUtil.isCraftStatus && AEConfig.instance.getConfigManager()
-                    .getSetting(Settings.CRAFTING_STATUS).equals(CraftingStatus.BUTTON)) {
-                this.buttonList.add(
-                        this.craftingStatusImgBtn = new GuiImgButton(
-                                this.guiLeft - 18,
-                                this.offsetY,
-                                Settings.CRAFTING_STATUS,
-                                AEConfig.instance.settings.getSetting(Settings.CRAFTING_STATUS)));
-                this.offsetY += 20;
-            } else {
-                this.buttonList.add(
-                        this.craftingStatusBtn = new GuiTabButton(
-                                this.guiLeft + 170,
-                                this.guiTop - 4,
-                                2 + 11 * 16,
-                                GuiText.CraftingStatus.getLocal(),
-                                itemRender));
-                this.craftingStatusBtn.setHideEdge(13); // GuiTabButton implementation //
-            }
-        }
-
-        final Enum<?> setting = AEConfig.instance.settings.getSetting(Settings.SEARCH_MODE);
-        this.searchField.setFocused(SearchBoxMode.AUTOSEARCH == setting || SearchBoxMode.NEI_AUTOSEARCH == setting);
-
-        if (ModAndClassUtil.isSearchBar && (AEConfig.instance.preserveSearchBar || this.isSubGui())) {
-            setSearchString(memoryText, false);
-        }
-        if (this.isSubGui()) {
-            this.repo.updateView();
-            this.setScrollBar();
-        }
-
-        craftingGridOffsetX = Integer.MAX_VALUE;
-        craftingGridOffsetY = Integer.MAX_VALUE;
-
-        for (final Object s : this.inventorySlots.inventorySlots) {
-            if (s instanceof AppEngSlot) {
-                if (((Slot) s).xDisplayPosition < 195 || s instanceof SlotDisabled) {
-                    this.repositionSlot((AppEngSlot) s);
-                }
-            }
-
-            if (s instanceof SlotCraftingMatrix || s instanceof SlotFakeCraftingMatrix) {
-                final Slot g = (Slot) s;
-                if (g.xDisplayPosition > 0 && g.yDisplayPosition > 0) {
-                    craftingGridOffsetX = Math.min(craftingGridOffsetX, g.xDisplayPosition);
-                    craftingGridOffsetY = Math.min(craftingGridOffsetY, g.yDisplayPosition);
-                }
-            }
-        }
-
-        craftingGridOffsetX -= 25;
-        craftingGridOffsetY -= 6;
-        initGuiDone();
-    }
-
-    public void setSearchString(String memoryText, boolean updateView) {
-        this.searchField.setText(memoryText);
-        this.repo.setSearchString(memoryText);
-        if (updateView) {
-            this.repo.updateView();
-            this.setScrollBar();
-        }
-    }
-
-    @Override
-    protected void mouseClicked(final int xCoord, final int yCoord, final int btn) {
-        final Enum<?> searchMode = AEConfig.instance.settings.getSetting(Settings.SEARCH_MODE);
-        if (searchMode != SearchBoxMode.AUTOSEARCH && searchMode != SearchBoxMode.NEI_AUTOSEARCH) {
-            this.searchField.mouseClicked(xCoord, yCoord, btn);
-        }
-        if (btn == 1 && this.searchField.isMouseIn(xCoord, yCoord)) {
-            setSearchString("", true);
-        }
-        super.mouseClicked(xCoord, yCoord, btn);
-    }
-
-    @Override
-    public void handleMouseInput() {
-        final int wheel = Mouse.getEventDWheel();
-        final int x = Mouse.getEventX() * this.width / this.mc.displayWidth;
-        final int y = this.height - Mouse.getEventY() * this.height / this.mc.displayHeight;
-
-        if (wheel != 0 && this.searchField.isMouseIn(x, y) && isCtrlKeyDown()) {
-            final Enum<?> searchMode = AEConfig.instance.settings.getSetting(Settings.SEARCH_MODE);
-            if (searchMode == SearchBoxMode.NEI_MANUAL_SEARCH || searchMode == SearchBoxMode.NEI_AUTOSEARCH) {
-                try {
-                    Field cls = LayoutManager.searchField.getClass().getDeclaredField("history");
-                    cls.setAccessible(true);
-                    TextHistory history = ((TextHistory) cls.get("get"));
-                    TextHistory.Direction direction;
-                    if (wheel > 0) {
-                        direction = TextHistory.Direction.PREVIOUS;
-                    } else {
-                        direction = TextHistory.Direction.NEXT;
-                    }
-                    history.get(direction, this.searchField.getText()).map(newText -> {
-                        setSearchString(newText, true);
-                        return true;
-                    }).orElse(false);
-                    return;
-                } catch (NoSuchFieldException | IllegalAccessException ignore) {}
-            }
-        }
-        super.handleMouseInput();
-    }
-
-    @Override
-    protected void handleMouseClick(final Slot slot, final int slotIdx, final int ctrlDown, final int mouseButton) {
-        final EntityPlayer player = Minecraft.getMinecraft().thePlayer;
-        if (mouseButton == 3) {
-            if (slot instanceof OptionalSlotFake || slot instanceof SlotFakeCraftingMatrix) {
-                if (slot.getHasStack()) {
-                    InventoryAction action = InventoryAction.SET_PATTERN_VALUE;
-                    IAEItemStack stack = AEItemStack.create(slot.getStack());
-                    ((AEBaseContainer) this.inventorySlots).setTargetStack(stack);
-                    for (int i = 0; i < this.inventorySlots.inventorySlots.size(); i++) {
-                        if (slot.equals(this.inventorySlots.inventorySlots.get(i))) {
-                            FluidCraft.proxy.netHandler.sendToServer(new CPacketInventoryAction(action, i, 0, stack));
-                        }
-                    }
-                    return;
-                }
-            }
-        }
-
-        if (slot instanceof SlotFake) {
-            InventoryAction action = ctrlDown == 1 ? InventoryAction.SPLIT_OR_PLACE_SINGLE
-                    : InventoryAction.PICKUP_OR_SET_DOWN;
-            if (Keyboard.isKeyDown(Keyboard.KEY_LMENU) || Keyboard.isKeyDown(Keyboard.KEY_RMENU)) {
-                if (action == InventoryAction.SPLIT_OR_PLACE_SINGLE) {
-                    action = InventoryAction.MOVE_REGION;
-                } else {
-                    action = InventoryAction.PICKUP_SINGLE;
-                }
-            }
-            if (Ae2ReflectClient.getDragClick(this).size() > 1) {
-                return;
-            }
-            final PacketInventoryAction p = new PacketInventoryAction(action, slotIdx, 0);
-            NetworkHandler.instance.sendToServer(p);
-            return;
-        }
-
-        if (slot instanceof SlotPatternTerm) {
-            if (mouseButton == 6) {
-                return; // prevents weird double clicks
-            }
-            try {
-                NetworkHandler.instance.sendToServer(((SlotPatternTerm) slot).getRequest(isShiftKeyDown()));
-            } catch (final IOException e) {
-                AELog.debug(e);
-            }
-        } else if (slot instanceof SlotCraftingTerm) {
-            if (mouseButton == 6) {
-                return; // prevents weird double clicks
-            }
-            InventoryAction action;
-            if (isShiftKeyDown()) {
-                action = InventoryAction.CRAFT_SHIFT;
-            } else {
-                // Craft a stack on right-click, craft a single one on left-click
-                action = (mouseButton == 1) ? InventoryAction.CRAFT_STACK : InventoryAction.CRAFT_ITEM;
-            }
-            final PacketInventoryAction p = new PacketInventoryAction(action, slotIdx, 0);
-            NetworkHandler.instance.sendToServer(p);
-            return;
-        }
-
-        if (Keyboard.isKeyDown(Keyboard.KEY_SPACE)) {
-            if (this.enableSpaceClicking() && !(slot instanceof SlotPatternTerm)) {
-                IAEItemStack stack = null;
-                if (slot instanceof SlotME) {
-                    stack = ((SlotME) slot).getAEStack();
-                }
-                int slotNum = Ae2ReflectClient.getInventorySlots(this).size();
-                if (!(slot instanceof SlotME) && slot != null) {
-                    slotNum = slot.slotNumber;
-                }
-                ((AEBaseContainer) this.inventorySlots).setTargetStack(stack);
-                final PacketInventoryAction p = new PacketInventoryAction(InventoryAction.MOVE_REGION, slotNum, 0);
-                NetworkHandler.instance.sendToServer(p);
-                return;
-            }
-        }
-
-        if (slot instanceof SlotDisconnected) {
-            if (Ae2ReflectClient.getDragClick(this).size() > 1) {
-                return;
-            }
-            InventoryAction action = null;
-            switch (mouseButton) {
-                case 0: // pickup / set-down.
-                {
-                    ItemStack heldStack = player.inventory.getItemStack();
-                    if (slot.getStack() == null && heldStack != null) action = InventoryAction.SPLIT_OR_PLACE_SINGLE;
-                    else if (slot.getStack() != null && (heldStack == null || heldStack.stackSize <= 1))
-                        action = InventoryAction.PICKUP_OR_SET_DOWN;
-                }
-                    break;
-                case 1:
-                    action = ctrlDown == 1 ? InventoryAction.PICKUP_SINGLE : InventoryAction.SHIFT_CLICK;
-                    break;
-                case 3: // creative dupe:
-                    if (player.capabilities.isCreativeMode) {
-                        action = InventoryAction.CREATIVE_DUPLICATE;
-                    }
-                    break;
-                default:
-                case 4: // drop item:
-                case 6:
-            }
-            if (action != null) {
-                final PacketInventoryAction p = new PacketInventoryAction(
-                        action,
-                        slot.getSlotIndex(),
-                        ((SlotDisconnected) slot).getSlot().getId());
-                NetworkHandler.instance.sendToServer(p);
-            }
-            return;
-        }
-
-        if (slot instanceof SlotME) {
-            InventoryAction action = null;
-            IAEItemStack stack = null;
-            switch (mouseButton) {
-                case 0: // pickup / set-down.
-                    action = ctrlDown == 1 ? InventoryAction.SPLIT_OR_PLACE_SINGLE : InventoryAction.PICKUP_OR_SET_DOWN;
-                    stack = ((SlotME) slot).getAEStack();
-                    if (stack != null && action == InventoryAction.PICKUP_OR_SET_DOWN
-                            && stack.getStackSize() == 0
-                            && player.inventory.getItemStack() == null) {
-                        action = InventoryAction.AUTO_CRAFT;
-                    }
-                    break;
-                case 1:
-                    action = ctrlDown == 1 ? InventoryAction.PICKUP_SINGLE : InventoryAction.SHIFT_CLICK;
-                    stack = ((SlotME) slot).getAEStack();
-                    break;
-                case 3: // creative dupe:
-                    stack = ((SlotME) slot).getAEStack();
-                    stack = transformItem(stack); // for fluid terminal
-                    if (stack != null && stack.isCraftable()) {
-                        action = InventoryAction.AUTO_CRAFT;
-                    } else if (player.capabilities.isCreativeMode) {
-                        final IAEItemStack slotItem = ((SlotME) slot).getAEStack();
-                        if (slotItem != null) {
-                            action = InventoryAction.CREATIVE_DUPLICATE;
-                        }
-                    }
-                    break;
-                default:
-                case 4: // drop item:
-                case 6:
-            }
-            if (action == InventoryAction.AUTO_CRAFT) {
-                ((AEBaseContainer) this.inventorySlots).setTargetStack(stack);
-                FluidCraft.proxy.netHandler.sendToServer(
-                        new CPacketInventoryAction(action, Ae2ReflectClient.getInventorySlots(this).size(), 0, stack));
-            } else if (action != null) {
-                ((AEBaseContainer) this.inventorySlots).setTargetStack(stack);
-                final PacketInventoryAction p = new PacketInventoryAction(
-                        action,
-                        Ae2ReflectClient.getInventorySlots(this).size(),
-                        0);
-                NetworkHandler.instance.sendToServer(p);
-            }
-
-            return;
-        }
-
-        super.handleMouseClick(slot, slotIdx, ctrlDown, mouseButton);
-    }
-
-    protected IAEItemStack transformItem(IAEItemStack stack) {
-        return stack;
-    }
-
-    @Override
-    public void onGuiClosed() {
-        super.onGuiClosed();
-        Keyboard.enableRepeatEvents(false);
-        memoryText = this.searchField.getText();
-    }
-
-    public void bindTextureBack(final String file) {
-        final ResourceLocation loc = new ResourceLocation(FluidCraft.MODID, "textures/" + file);
-        this.mc.getTextureManager().bindTexture(loc);
-    }
-
-    @Override
-    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
-        this.bindTextureBack(this.getBackground());
-        final int x_width = 195;
-        this.drawTexturedModalRect(offsetX, offsetY, 0, 0, x_width, 18);
-        if (this.viewCell) {
-            this.drawTexturedModalRect(offsetX + x_width, offsetY, x_width, 0, 46, 128);
-        }
-        for (int x = 0; x < this.rows; x++) {
-            this.drawTexturedModalRect(offsetX, offsetY + 18 + x * 18, 0, 18, x_width, 18);
-        }
-        this.drawTexturedModalRect(
-                offsetX,
-                offsetY + 16 + this.rows * 18 + this.lowerTextureOffset,
-                0,
-                106 - 18 - 18,
-                x_width,
-                99 + this.reservedSpace - this.lowerTextureOffset);
-        if (this.viewCell) {
-            boolean update = false;
-            for (int i = 0; i < 5; i++) {
-                if (this.myCurrentViewCells[i] != this.monitorableContainer.getCellViewSlot(i).getStack()) {
-                    update = true;
-                    this.myCurrentViewCells[i] = this.monitorableContainer.getCellViewSlot(i).getStack();
-                }
-            }
-            if (update) {
-                this.repo.setViewCell(this.myCurrentViewCells);
-            }
-        }
-        if (this.searchField != null) {
-            this.searchField.drawTextBox();
-        }
-    }
-
-    protected String getBackground() {
-        return "gui/terminal.png";
-    }
-
-    @Override
-    protected boolean isPowered() {
-        return this.repo.hasPower();
-    }
-
-    protected int getMaxRows() {
-        return AEConfig.instance.getConfigManager().getSetting(Settings.TERMINAL_STYLE) == TerminalStyle.SMALL ? 6
-                : Integer.MAX_VALUE;
-    }
-
-    protected void repositionSlot(final AppEngSlot s) {
-        s.yDisplayPosition = s.getY() + this.ySize - 78 - 5;
-    }
-
-    @Override
-    protected void keyTyped(final char character, final int key) {
-        if (!this.checkHotbarKeys(key)) {
-            if (character == ' ' && this.searchField.getText().isEmpty()) {
-                return;
-            }
-
-            if (this.searchField.textboxKeyTyped(character, key)) {
-                this.repo.setSearchString(this.searchField.getText());
-                this.repo.updateView();
-                this.setScrollBar();
-            } else {
-                super.keyTyped(character, key);
-            }
-        }
-    }
-
-    @Override
-    public void updateScreen() {
-        this.repo.setPowered(this.monitorableContainer.isPowered());
-        super.updateScreen();
-    }
-
-    @Override
-    public Enum<?> getSortBy() {
-        return this.configSrc.getSetting(Settings.SORT_BY);
-    }
-
-    @Override
-    public Enum<?> getSortDir() {
-        return this.configSrc.getSetting(Settings.SORT_DIRECTION);
-    }
-
-    @Override
-    public Enum<?> getSortDisplay() {
-        return this.configSrc.getSetting(Settings.VIEW_MODE);
-    }
-
-    @Override
-    public Enum getTypeFilter() {
-        return this.configSrc.getSetting(Settings.TYPE_FILTER);
-    }
-
-    @Override
-    public void updateSetting(final IConfigManager manager, final Enum settingName, final Enum newValue) {
-        if (this.SortByBox != null) {
-            this.SortByBox.set(this.configSrc.getSetting(Settings.SORT_BY));
-        }
-
-        if (this.SortDirBox != null) {
-            this.SortDirBox.set(this.configSrc.getSetting(Settings.SORT_DIRECTION));
-        }
-
-        if (this.ViewBox != null) {
-            this.ViewBox.set(this.configSrc.getSetting(Settings.VIEW_MODE));
-        }
-        if (this.typeFilter != null) {
-            this.typeFilter.set(this.configSrc.getSetting(Settings.TYPE_FILTER));
-        }
-
-        this.repo.updateView();
-    }
-
-    public int getReservedSpace() {
-        return this.reservedSpace;
-    }
-
-    public void setReservedSpace(final int reservedSpace) {
-        this.reservedSpace = reservedSpace;
-    }
-
-    public boolean isCustomSortOrder() {
-        return this.customSortOrder;
-    }
-
-    public void setCustomSortOrder(final boolean customSortOrder) {
-        this.customSortOrder = customSortOrder;
-    }
-
-    public int getStandardSize() {
-        return this.standardSize;
-    }
-
-    public void setStandardSize(final int standardSize) {
-        this.standardSize = standardSize;
-    }
-
-    @Override
-    public void drawScreen(final int mouseX, final int mouseY, final float btn) {
-        super.drawScreen(mouseX, mouseY, btn);
-        if (ModAndClassUtil.isSearchBar && AEConfig.instance.preserveSearchBar && searchField != null)
-            handleTooltip(mouseX, mouseY, searchField.new TooltipProvider());
-    }
-
-    public boolean isOverSearchField(int x, int y) {
-        return searchField.isMouseIn(x, y);
-    }
-
-    public boolean hideItemPanelSlot(int tx, int ty, int tw, int th) {
-        if (this.viewCell) {
-            int rw = 33;
-            int rh = 14 + myCurrentViewCells.length * 18;
-
-            if (tw <= 0 || th <= 0) {
-                return false;
-            }
-
-            int rx = this.guiLeft + this.xSize;
-            int ry = this.guiTop;
-
-            rw += rx;
-            rh += ry;
-            tw += tx;
-            th += ty;
-
-            // overflow || intersect
-            return (rw < rx || rw > tx) && (rh < ry || rh > ty) && (tw < tx || tw > rx) && (th < ty || th > ry);
-        }
-        return false;
-    }
-
-    @Override
-    public boolean isOverTextField(int mousex, int mousey) {
-        return searchField.isMouseIn(mousex, mousey);
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerCraftingWireless.java

@@ -1,99 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.InventoryCrafting;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.crafting.CraftingManager;
-
-import com.glodblock.github.inventory.item.IWirelessCraftTerminal;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-
-import appeng.container.ContainerNull;
-import appeng.container.slot.SlotCraftingMatrix;
-import appeng.container.slot.SlotCraftingTerm;
-import appeng.helpers.IContainerCraftingPacket;
-import appeng.tile.inventory.AppEngInternalInventory;
-import appeng.tile.inventory.IAEAppEngInventory;
-import appeng.tile.inventory.InvOperation;
-
-public class ContainerCraftingWireless extends ContainerItemMonitor
-        implements IAEAppEngInventory, IContainerCraftingPacket {
-
-    private final IWirelessCraftTerminal it;
-    private final SlotCraftingMatrix[] craftingSlots = new SlotCraftingMatrix[9];
-    private final SlotCraftingTerm outputSlot;
-
-    public ContainerCraftingWireless(final InventoryPlayer ip, final IWirelessTerminal monitorable) {
-        super(ip, monitorable, false);
-        this.it = (IWirelessCraftTerminal) monitorable;
-        final IInventory crafting = this.it.getInventoryByName("crafting");
-        for (int y = 0; y < 3; y++) {
-            for (int x = 0; x < 3; x++) {
-                this.addSlotToContainer(
-                        this.craftingSlots[x + y * 3] = new SlotCraftingMatrix(
-                                this,
-                                crafting,
-                                x + y * 3,
-                                37 + x * 18,
-                                -72 + y * 18));
-            }
-        }
-        AppEngInternalInventory output = new AppEngInternalInventory(this, 1);
-        this.addSlotToContainer(
-                this.outputSlot = new SlotCraftingTerm(
-                        this.getPlayerInv().player,
-                        this.getActionSource(),
-                        this.getPowerSource(),
-                        monitorable,
-                        crafting,
-                        crafting,
-                        output,
-                        131,
-                        -72 + 18,
-                        this));
-        this.bindPlayerInventory(ip, 0, 0);
-        this.onCraftMatrixChanged(crafting);
-    }
-
-    @Override
-    protected boolean isWirelessTerminal() {
-        return true;
-    }
-
-    @Override
-    public void onCraftMatrixChanged(final IInventory par1IInventory) {
-        final ContainerNull cn = new ContainerNull();
-        final InventoryCrafting ic = new InventoryCrafting(cn, 3, 3);
-        for (int x = 0; x < 9; x++) {
-            ic.setInventorySlotContents(x, this.craftingSlots[x].getStack());
-        }
-        this.outputSlot
-                .putStack(CraftingManager.getInstance().findMatchingRecipe(ic, this.getPlayerInv().player.worldObj));
-    }
-
-    @Override
-    public void saveChanges() {
-        // NO-OP
-    }
-
-    @Override
-    public void onChangeInventory(final IInventory inv, final int slot, final InvOperation mc,
-            final ItemStack removedStack, final ItemStack newStack) {
-        // NO-OP
-    }
-
-    @Override
-    public IInventory getInventoryByName(final String name) {
-        if (name.equals("player")) {
-            return this.getInventoryPlayer();
-        }
-        return this.it.getInventoryByName(name);
-    }
-
-    @Override
-    public boolean useRealItems() {
-        return true;
-    }
-
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerDualInterface.java

@@ -1,36 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.common.tile.TileFluidInterface;
-
-import appeng.api.config.Settings;
-import appeng.api.config.SidelessMode;
-import appeng.api.util.IConfigManager;
-import appeng.container.guisync.GuiSync;
-import appeng.container.implementations.ContainerInterface;
-import appeng.helpers.IInterfaceHost;
-
-public class ContainerDualInterface extends ContainerInterface {
-
-    @GuiSync(10)
-    public SidelessMode sidelessMode;
-
-    private final boolean isTile;
-
-    public ContainerDualInterface(InventoryPlayer ip, IInterfaceHost te) {
-        super(ip, te);
-        this.sidelessMode = SidelessMode.SIDELESS;
-        this.isTile = te instanceof TileFluidInterface;
-    }
-
-    public SidelessMode getSidelessMode() {
-        return this.sidelessMode;
-    }
-
-    @Override
-    protected void loadSettingsFromHost(IConfigManager cm) {
-        super.loadSettingsFromHost(cm);
-        this.sidelessMode = this.isTile ? (SidelessMode) cm.getSetting(Settings.SIDELESS_MODE) : SidelessMode.SIDELESS;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerEssentiaMonitor.java

@@ -1,153 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-
-import org.apache.commons.lang3.tuple.MutablePair;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.crossmod.thaumcraft.AspectUtil;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.network.CPacketFluidUpdate;
-import com.glodblock.github.network.SPacketFluidUpdate;
-import com.glodblock.github.util.Util;
-
-import appeng.api.config.Actionable;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.container.slot.SlotPlayerHotBar;
-import appeng.container.slot.SlotPlayerInv;
-import appeng.util.Platform;
-import appeng.util.item.AEFluidStack;
-
-public class ContainerEssentiaMonitor extends ContainerFluidPortableCell {
-
-    public ContainerEssentiaMonitor(InventoryPlayer ip, IWirelessTerminal monitorable) {
-        super(ip, monitorable);
-    }
-
-    @Override
-    public ItemStack transferStackInSlot(final EntityPlayer p, final int idx) {
-        if (Platform.isClient()) {
-            Slot clickSlot = (Slot) this.inventorySlots.get(idx);
-            if ((clickSlot instanceof SlotPlayerInv || clickSlot instanceof SlotPlayerHotBar) && clickSlot.getHasStack()
-                    && AspectUtil.isEssentiaContainer(clickSlot.getStack())) {
-                ItemStack tis = clickSlot.getStack();
-                Map<Integer, IAEFluidStack> tmp = new HashMap<>();
-                tmp.put(0, null);
-                int index = Util.findItemInPlayerInvSlot(p, clickSlot.getStack());
-                FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidUpdate(tmp, tis, index));
-            }
-        }
-        return super.transferStackInSlot(p, idx);
-    }
-
-    @Override
-    public void postChange(Iterable<IAEFluidStack> change, ItemStack fluidContainer, EntityPlayer player,
-            int slotIndex) {
-        for (IAEFluidStack fluid : change) {
-            IAEFluidStack nfluid = this.monitor.getStorageList().findPrecise(fluid);
-            ItemStack out = fluidContainer.copy();
-            out.stackSize = 1;
-            if (AspectUtil.isEmptyEssentiaContainer(fluidContainer) && AspectUtil.isEssentiaGas(fluid)) {
-                // add essentia to jars
-                if (nfluid.getStackSize() / AspectUtil.R <= 0) continue;
-                final IAEFluidStack toExtract = nfluid.copy();
-                MutablePair<Integer, ItemStack> fillStack = AspectUtil
-                        .fillEssentiaFromGas(out, toExtract.getFluidStack());
-                if (fillStack == null || fillStack.right == null || fillStack.left <= 0) continue;
-                toExtract.setStackSize((long) fillStack.left * fluidContainer.stackSize);
-                IAEFluidStack tmp = this.host.getFluidInventory()
-                        .extractItems(toExtract, Actionable.SIMULATE, this.getActionSource());
-                if (tmp == null) continue;
-                fillStack.right.stackSize = (int) (tmp.getStackSize() / fillStack.left);
-                this.dropItem(fillStack.right);
-                out.stackSize = fillStack.right.stackSize;
-                if (AspectUtil.isEssentiaContainer(fillStack.right)) {
-                    this.host.getFluidInventory().extractItems(toExtract, Actionable.MODULATE, this.getActionSource());
-                    if ((int) (tmp.getStackSize() % fillStack.left) / AspectUtil.R > 0) {
-                        this.dropItem(
-                                AspectUtil.setAspectAmount(
-                                        fillStack.right,
-                                        (int) (tmp.getStackSize() % fillStack.left) / AspectUtil.R,
-                                        AspectUtil.getAspectFromGas(toExtract)),
-                                1);
-                        out.stackSize++;
-                    }
-                }
-            } else if (!AspectUtil.isEmptyEssentiaContainer(fluidContainer)) {
-                // add essentia to ae network
-                AEFluidStack fluidStack = AspectUtil.getAEGasFromContainer(fluidContainer);
-                if (fluidStack == null) {
-                    continue;
-                }
-                final IAEFluidStack aeFluidStack = fluidStack.copy();
-                // simulate result is incorrect. so I'm using other solution and ec2 both mod have same issues
-                final IAEFluidStack notInserted = this.host.getFluidInventory()
-                        .injectItems(aeFluidStack, Actionable.MODULATE, this.getActionSource());
-                MutablePair<Integer, ItemStack> drainStack = AspectUtil
-                        .drainEssentiaFromGas(out.copy(), aeFluidStack.getFluidStack());
-                if (notInserted != null && notInserted.getStackSize() > 0 && drainStack != null) {
-                    if (fluidStack.getStackSize() == notInserted.getStackSize()) continue;
-                    aeFluidStack.decStackSize(notInserted.getStackSize());
-
-                    if (drainStack.left > aeFluidStack.getStackSize()
-                            && AspectUtil.isEssentiaContainer(drainStack.right)) {
-                        aeFluidStack.setStackSize(drainStack.left - aeFluidStack.getStackSize());
-                        this.host.getFluidInventory()
-                                .extractItems(aeFluidStack, Actionable.MODULATE, this.getActionSource());
-                        continue;
-                    }
-
-                    // drop empty item
-                    this.dropItem(drainStack.right, (int) (aeFluidStack.getStackSize() / drainStack.left));
-                    out.stackSize = (int) (notInserted.getStackSize() / drainStack.left);
-                    if (AspectUtil.isEssentiaContainer(drainStack.right)) {
-                        if (notInserted.getStackSize() % drainStack.left > 0) {
-                            fluidStack.setStackSize((notInserted.getStackSize() % drainStack.left));
-                            AspectUtil.fillEssentiaFromGas(drainStack.right, fluidStack.getFluidStack());
-                            this.dropItem(drainStack.right, 1);
-                        }
-                    }
-                    if (slotIndex == -1) out.stackSize = fluidContainer.stackSize - out.stackSize;
-                } else if (drainStack != null) {
-                    if (slotIndex == -1) {
-                        out.stackSize = fluidContainer.stackSize;
-                    } else {
-                        out.stackSize = (int) (fluidContainer.stackSize
-                                - (aeFluidStack.getStackSize() / drainStack.left));
-                    }
-                    this.dropItem(drainStack.right, fluidContainer.stackSize); // drop empty item
-                }
-            } else {
-                continue;
-            }
-            if (slotIndex == -1) {
-                player.inventory.getItemStack().stackSize = player.inventory.getItemStack().stackSize - out.stackSize;
-                if (player.inventory.getItemStack().stackSize > 0) {
-                    FluidCraft.proxy.netHandler.sendTo(
-                            new SPacketFluidUpdate(new HashMap<>(), player.inventory.getItemStack()),
-                            (EntityPlayerMP) player);
-                } else {
-                    player.inventory.setItemStack(null);
-                    FluidCraft.proxy.netHandler
-                            .sendTo(new SPacketFluidUpdate(new HashMap<>()), (EntityPlayerMP) player);
-                }
-            } else {
-                player.inventory.setInventorySlotContents(slotIndex, out.stackSize > 0 ? out : null);
-            }
-        }
-        this.detectAndSendChanges();
-    }
-
-    @Override
-    protected boolean isEssentiaMode() {
-        return true;
-    }
-
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidCraftConfirm.java

@@ -1,60 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import java.util.Objects;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.common.util.ForgeDirection;
-
-import com.glodblock.github.common.item.ItemBaseWirelessTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminal;
-import com.glodblock.github.common.parts.PartFluidPatternTerminalEx;
-import com.glodblock.github.inventory.InventoryHandler;
-import com.glodblock.github.inventory.gui.GuiType;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.util.BlockPos;
-
-import appeng.api.networking.security.IActionHost;
-import appeng.api.storage.ITerminalHost;
-import appeng.container.implementations.ContainerCraftConfirm;
-
-public class ContainerFluidCraftConfirm extends ContainerCraftConfirm {
-
-    public ContainerFluidCraftConfirm(final InventoryPlayer ip, final ITerminalHost te) {
-        super(ip, te);
-    }
-
-    @Override
-    public void switchToOriginalGUI() {
-        GuiType originalGui = null;
-
-        final IActionHost ah = this.getActionHost();
-        if (ah instanceof PartFluidPatternTerminal) {
-            originalGui = GuiType.FLUID_PATTERN_TERMINAL;
-        }
-        if (ah instanceof PartFluidPatternTerminalEx) {
-            originalGui = GuiType.FLUID_PATTERN_TERMINAL_EX;
-        }
-        if (ah instanceof IWirelessTerminal) {
-            ItemStack terminal = ((IWirelessTerminal) ah).getItemStack();
-            if (terminal.getItem() instanceof ItemBaseWirelessTerminal) {
-                originalGui = ((ItemBaseWirelessTerminal) terminal.getItem()).guiGuiType(terminal);
-            }
-        }
-        if (ah instanceof IWirelessTerminal) {
-            InventoryHandler.openGui(
-                    this.getInventoryPlayer().player,
-                    getWorld(),
-                    new BlockPos(((IWirelessTerminal) ah).getInventorySlot(), 0, 0),
-                    ForgeDirection.UNKNOWN,
-                    originalGui);
-        } else if (this.getOpenContext() != null) {
-            InventoryHandler.openGui(
-                    this.getInventoryPlayer().player,
-                    getWorld(),
-                    new BlockPos(this.getOpenContext().getTile()),
-                    Objects.requireNonNull(this.getOpenContext().getSide()),
-                    originalGui);
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidIO.java

@@ -1,46 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.client.gui.container.base.FCContainerFluidConfigurable;
-import com.glodblock.github.common.parts.PartFluidExportBus;
-import com.glodblock.github.common.parts.base.FCSharedFluidBus;
-import com.glodblock.github.util.Ae2Reflect;
-
-import appeng.api.config.SchedulingMode;
-import appeng.api.config.Settings;
-import appeng.api.config.YesNo;
-import appeng.api.util.IConfigManager;
-import appeng.tile.inventory.AppEngInternalAEInventory;
-
-public class ContainerFluidIO extends FCContainerFluidConfigurable {
-
-    private final FCSharedFluidBus bus;
-
-    public ContainerFluidIO(InventoryPlayer ip, FCSharedFluidBus te) {
-        super(ip, te);
-        this.bus = te;
-    }
-
-    public FCSharedFluidBus getBus() {
-        return this.bus;
-    }
-
-    @Override
-    public AppEngInternalAEInventory getFakeFluidInv() {
-        return (AppEngInternalAEInventory) this.bus.getInventoryByName("config");
-    }
-
-    @Override
-    protected void loadSettingsFromHost(IConfigManager cm) {
-        super.loadSettingsFromHost(cm);
-        if (Ae2Reflect.getUpgradeableHost(this) instanceof PartFluidExportBus) {
-            this.setCraftingMode((YesNo) cm.getSetting(Settings.CRAFT_ONLY));
-            this.setSchedulingMode((SchedulingMode) cm.getSetting(Settings.SCHEDULING_MODE));
-        }
-    }
-
-    public void setSchedulingMode(final SchedulingMode schedulingMode) {
-        this.schedulingMode = schedulingMode;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidInterface.java

@@ -15,11 +15,11 @@ import com.glodblock.github.inventory.slot.OptionalFluidSlotFakeTypeOnly;
 import com.glodblock.github.network.SPacketFluidUpdate;
 
 import appeng.api.storage.data.IAEFluidStack;
-import appeng.container.AEBaseContainer;
+import appeng.container.ContainerSubGui;
 import appeng.container.slot.IOptionalSlotHost;
 import appeng.util.item.AEFluidStack;
 
-public class ContainerFluidInterface extends AEBaseContainer implements IOptionalSlotHost {
+public class ContainerFluidInterface extends ContainerSubGui implements IOptionalSlotHost {
 
     private final IDualHost tile;
 

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidLevelEmitter.java

@@ -1,103 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.client.gui.GuiTextField;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.IInventory;
-
-import com.glodblock.github.client.gui.container.base.FCContainerFluidConfigurable;
-import com.glodblock.github.common.parts.PartFluidLevelEmitter;
-import com.glodblock.github.inventory.slot.OptionalFluidSlotFakeTypeOnly;
-import com.glodblock.github.util.Ae2Reflect;
-
-import appeng.api.config.*;
-import appeng.api.implementations.IUpgradeableHost;
-import appeng.container.guisync.GuiSync;
-import appeng.tile.inventory.AppEngInternalAEInventory;
-import appeng.util.Platform;
-import cpw.mods.fml.relauncher.Side;
-import cpw.mods.fml.relauncher.SideOnly;
-
-public class ContainerFluidLevelEmitter extends FCContainerFluidConfigurable {
-
-    private final PartFluidLevelEmitter lvlEmitter;
-
-    @SideOnly(Side.CLIENT)
-    private GuiTextField textField;
-
-    @GuiSync(2)
-    public long EmitterValue = -1;
-
-    public ContainerFluidLevelEmitter(final InventoryPlayer ip, final PartFluidLevelEmitter te) {
-        super(ip, te);
-        this.lvlEmitter = te;
-    }
-
-    public PartFluidLevelEmitter getBus() {
-        return this.lvlEmitter;
-    }
-
-    protected IUpgradeableHost getUpgradeable() {
-        return Ae2Reflect.getUpgradeableHost(this);
-    }
-
-    public AppEngInternalAEInventory getFakeFluidInv() {
-        return (AppEngInternalAEInventory) this.lvlEmitter.getInventoryByName("config");
-    }
-
-    @Override
-    protected void setupConfig() {
-        final IInventory inv = this.getUpgradeable().getInventoryByName("config");
-        final int y = 40;
-        final int x = 80 + 44;
-        this.addSlotToContainer(new OptionalFluidSlotFakeTypeOnly(inv, null, this, 0, x, y, 0, 0, 0));
-    }
-
-    @SideOnly(Side.CLIENT)
-    public void setTextField(final GuiTextField level) {
-        this.textField = level;
-        this.textField.setText(String.valueOf(this.EmitterValue));
-    }
-
-    public void setLevel(final long l, final EntityPlayer player) {
-        this.lvlEmitter.setReportingValue(l);
-        this.EmitterValue = l;
-    }
-
-    @Override
-    protected boolean supportCapacity() {
-        return false;
-    }
-
-    @Override
-    public int availableUpgrades() {
-        return 0;
-    }
-
-    public void setRedStoneMode(final RedstoneMode rsMode) {
-        this.rsMode = rsMode;
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        this.verifyPermissions(SecurityPermissions.BUILD, false);
-
-        if (Platform.isServer()) {
-            this.EmitterValue = this.lvlEmitter.getReportingValue();
-            this.setRedStoneMode(
-                    (RedstoneMode) Ae2Reflect.getUpgradeableHost(this).getConfigManager()
-                            .getSetting(Settings.REDSTONE_EMITTER));
-        }
-
-        this.standardDetectAndSendChanges();
-    }
-
-    @Override
-    public void onUpdate(final String field, final Object oldValue, final Object newValue) {
-        if (field.equals("EmitterValue")) {
-            if (this.textField != null) {
-                this.textField.setText(String.valueOf(this.EmitterValue));
-            }
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidMonitor.java

@@ -1,464 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.ICrafting;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.common.util.ForgeDirection;
-import net.minecraftforge.fluids.FluidContainerRegistry;
-import net.minecraftforge.fluids.IFluidContainerItem;
-
-import com.glodblock.github.FluidCraft;
-import com.glodblock.github.client.gui.container.base.FCContainerMonitor;
-import com.glodblock.github.common.item.ItemFluidDrop;
-import com.glodblock.github.network.CPacketFluidUpdate;
-import com.glodblock.github.network.SPacketFluidUpdate;
-import com.glodblock.github.network.SPacketMEUpdateBuffer;
-import com.glodblock.github.util.Util;
-
-import appeng.api.AEApi;
-import appeng.api.config.Actionable;
-import appeng.api.implementations.tiles.IViewCellStorage;
-import appeng.api.networking.IGrid;
-import appeng.api.networking.IGridHost;
-import appeng.api.networking.IGridNode;
-import appeng.api.networking.energy.IEnergyGrid;
-import appeng.api.networking.energy.IEnergySource;
-import appeng.api.networking.security.BaseActionSource;
-import appeng.api.networking.storage.IBaseMonitor;
-import appeng.api.networking.storage.IStorageGrid;
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.api.storage.data.IItemList;
-import appeng.container.slot.SlotPlayerHotBar;
-import appeng.container.slot.SlotPlayerInv;
-import appeng.container.slot.SlotRestrictedInput;
-import appeng.me.helpers.ChannelPowerSrc;
-import appeng.util.Platform;
-import appeng.util.item.AEFluidStack;
-import appeng.util.item.AEItemStack;
-
-public class ContainerFluidMonitor extends FCContainerMonitor<IAEFluidStack> {
-
-    protected final IItemList<IAEFluidStack> fluids = AEApi.instance().storage().createFluidList();
-
-    public ContainerFluidMonitor(final InventoryPlayer ip, final ITerminalHost monitorable) {
-        this(ip, monitorable, true);
-    }
-
-    protected ContainerFluidMonitor(final InventoryPlayer ip, final ITerminalHost monitorable,
-            final boolean bindInventory) {
-        super(ip, monitorable, bindInventory);
-        if (Platform.isServer()) {
-            this.serverCM = monitorable.getConfigManager();
-            if (monitorable instanceof IGridHost) {
-                final IGridNode node = ((IGridHost) monitorable).getGridNode(ForgeDirection.UNKNOWN);
-                if (node != null) {
-                    this.networkNode = node;
-                    final IGrid g = node.getGrid();
-                    if (g != null) {
-                        this.setPowerSource(new ChannelPowerSrc(this.networkNode, g.getCache(IEnergyGrid.class)));
-                        IStorageGrid storageGrid = g.getCache(IStorageGrid.class);
-                        this.monitor = storageGrid.getFluidInventory();
-                        if (this.monitor == null) {
-                            this.setValidContainer(false);
-                        } else {
-                            this.monitor.addListener(this, null);
-                        }
-                    }
-                } else {
-                    this.setValidContainer(false);
-                }
-            } else {
-                this.monitor = monitorable.getFluidInventory();
-                this.monitor.addListener(this, null);
-                this.setPowerSource((IEnergySource) monitorable);
-            }
-        } else {
-            this.monitor = null;
-        }
-
-        this.canAccessViewCells = false;
-        if (monitorable instanceof IViewCellStorage) {
-            for (int y = 0; y < 5; y++) {
-                this.cellView[y] = new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.VIEW_CELL,
-                        ((IViewCellStorage) monitorable).getViewCellStorage(),
-                        y,
-                        206,
-                        y * 18 + 8,
-                        this.getInventoryPlayer());
-                this.cellView[y].setAllowEdit(this.canAccessViewCells);
-                this.addSlotToContainer(this.cellView[y]);
-            }
-        }
-
-        if (bindInventory) {
-            this.bindPlayerInventory(ip, 0, 0);
-        }
-    }
-
-    @Override
-    public ItemStack transferStackInSlot(final EntityPlayer p, final int idx) {
-        if (Platform.isClient() && !isEssentiaMode()) {
-            Slot clickSlot = (Slot) this.inventorySlots.get(idx);
-            if ((clickSlot instanceof SlotPlayerInv || clickSlot instanceof SlotPlayerHotBar) && clickSlot.getHasStack()
-                    && Util.FluidUtil.isFluidContainer(clickSlot.getStack())) {
-                ItemStack tis = clickSlot.getStack();
-                Map<Integer, IAEFluidStack> tmp = new HashMap<>();
-                tmp.put(0, ItemFluidDrop.getAeFluidStack(AEItemStack.create(tis)));
-                int index = Util.findItemInPlayerInvSlot(p, clickSlot.getStack());
-                FluidCraft.proxy.netHandler.sendToServer(new CPacketFluidUpdate(tmp, tis, index));
-            }
-        }
-        return super.transferStackInSlot(p, idx);
-    }
-
-    @Override
-    protected void processItemList() {
-        if (!this.fluids.isEmpty()) {
-            final IItemList<IAEFluidStack> monitorCache = this.monitor.getStorageList();
-            List<IAEFluidStack> toSend = new ArrayList<>();
-            for (final IAEFluidStack is : this.fluids) {
-                final IAEFluidStack send = monitorCache.findPrecise(is);
-                if (send != null) {
-                    toSend.add(send);
-                } else {
-                    is.setStackSize(0);
-                    toSend.add(is);
-                }
-            }
-            for (final Object c : this.crafters) {
-                if (c instanceof EntityPlayerMP) {
-                    SPacketMEUpdateBuffer.scheduleFluidUpdate((EntityPlayerMP) c, toSend);
-                }
-            }
-            this.fluids.resetStatus();
-        }
-    }
-
-    @Override
-    protected void queueInventory(final ICrafting c) {
-        if (Platform.isServer() && c instanceof EntityPlayerMP && this.monitor != null) {
-            final IItemList<IAEFluidStack> monitorCache = this.monitor.getStorageList();
-            List<IAEFluidStack> toSend = new ArrayList<>();
-            for (final IAEFluidStack is : monitorCache) {
-                toSend.add(is);
-            }
-            SPacketMEUpdateBuffer.scheduleFluidUpdate((EntityPlayerMP) c, toSend);
-        }
-    }
-
-    @Override
-    public void postChange(IBaseMonitor<IAEFluidStack> monitor, Iterable<IAEFluidStack> change,
-            BaseActionSource actionSource) {
-        for (final IAEFluidStack is : change) {
-            this.fluids.add(is);
-        }
-    }
-
-    protected void dropItem(ItemStack is) {
-        if (is == null || is.stackSize <= 0) return;
-        ItemStack itemStack = is.copy();
-        int i = itemStack.getMaxStackSize();
-        while (itemStack.stackSize > 0) {
-            if (i > itemStack.stackSize) {
-                if (!getPlayerInv().addItemStackToInventory(itemStack.copy())) {
-                    getPlayerInv().player.entityDropItem(itemStack.copy(), 0);
-                }
-                break;
-            } else {
-                itemStack.stackSize -= i;
-                ItemStack item = itemStack.copy();
-                item.stackSize = i;
-                if (!getPlayerInv().addItemStackToInventory(item)) {
-                    getPlayerInv().player.entityDropItem(item, 0);
-                }
-            }
-        }
-    }
-
-    protected void dropItem(ItemStack itemStack, int stackSize) {
-        if (itemStack == null || itemStack.stackSize <= 0) return;
-        ItemStack is = itemStack.copy();
-        is.stackSize = stackSize;
-        this.dropItem(is);
-    }
-
-    /**
-     * Two operations, insert and extract.
-     *
-     * @param slotIndex The slot. If index == -1, the cursor held itemstack. Else, slotIndex indicates which slot was
-     *                  shift clicked on.
-     */
-    public void postChange(Iterable<IAEFluidStack> change, ItemStack fluidContainer, EntityPlayer player,
-            int slotIndex) {
-        int cursorItems;
-        if (slotIndex == -1) {
-            cursorItems = player.inventory.getItemStack().stackSize;
-        } else {
-            cursorItems = player.inventory.getStackInSlot(slotIndex).stackSize;
-        }
-        for (IAEFluidStack fluid : change) {
-            // The primary output itemstack
-            if (Util.FluidUtil.isEmpty(fluidContainer) && fluid != null) {
-                // Situation 1.a: Empty fluid container, and nonnull slot
-                extractFluid(fluid, fluidContainer, player, cursorItems);
-            } else if (!Util.FluidUtil.isEmpty(fluidContainer)) {
-                // Situation 2.a: We are holding a non-empty container.
-                insertFluid(fluidContainer, player, slotIndex, cursorItems);
-                // End of situation 2.a
-            }
-            // No op (Any other situation)
-        }
-        this.detectAndSendChanges();
-    }
-
-    /**
-     * The insert operation. For input, we have a filled container stack. For outputs, we have the following: 1.
-     * Leftover filled container stack - primary output. 2. Empty containers 3. Partially filled container x1 In order
-     * above, the itemstack at `slotIndex` is transformed into the output.
-     */
-    private void insertFluid(ItemStack fluidContainer, EntityPlayer player, int slotIndex, int heldContainers) {
-        IAEFluidStack fluid;
-        int fluidInTank;
-        if (fluidContainer.getItem() instanceof IFluidContainerItem) {
-            fluid = AEFluidStack.create(((IFluidContainerItem) fluidContainer.getItem()).getFluid(fluidContainer));
-            fluidInTank = (int) fluid.getStackSize();
-        } else if (FluidContainerRegistry.isContainer(fluidContainer)) {
-            fluid = AEFluidStack.create(FluidContainerRegistry.getFluidForFilledItem(fluidContainer));
-            fluidInTank = (int) fluid.getStackSize();
-        } else {
-            return;
-        }
-        // Simulate to know how much will not be inserted
-        IAEFluidStack canSend = fluid.copy();
-        canSend.setStackSize((long) fluidInTank * fluidContainer.stackSize);
-        final IAEFluidStack notInserted = this.host.getFluidInventory()
-                .injectItems(canSend, Actionable.MODULATE, this.getActionSource());
-        int emptyTanks = fluidContainer.stackSize;
-        ItemStack partialStack = fluidContainer.copy();
-        if (notInserted != null && notInserted.getStackSize() > 0) {
-            // Here, we cannot insert everything into the system.
-            if (canSend.getStackSize() == notInserted.getStackSize()) return; // System was full, no op
-            // Now "refill" the buckets that couldn't enter the system
-            int refilled = (int) (notInserted.getStackSize() / fluidInTank); // # of full tanks left
-            emptyTanks -= refilled;
-            final int remainder = (int) (notInserted.getStackSize() % fluidInTank); // partial tank
-            // Now handle remaining if applicable
-            if (remainder > 0) {
-                notInserted.setStackSize(remainder);
-                partialStack.stackSize = 1;
-                if (partialStack.getItem() instanceof IFluidContainerItem) {
-                    ((IFluidContainerItem) partialStack.getItem()).drain(partialStack, fluidInTank - remainder, true);
-                } else if (FluidContainerRegistry.isContainer(fluidContainer)) {
-                    // For "whole containers" (need to round down, no remainders)
-                    ItemStack container = FluidContainerRegistry
-                            .fillFluidContainer(notInserted.getFluidStack(), fluidContainer);
-                    if (container == null) {
-                        // whatever, lets just not have the ME system get filled with any of its fluid
-                        emptyTanks++;
-                        notInserted.setStackSize(fluidInTank - remainder);
-                        this.host.getFluidInventory()
-                                .extractItems(notInserted, Actionable.MODULATE, this.getActionSource());
-                        partialStack.stackSize = 0;
-                    } else {
-                        partialStack = container;
-                    }
-                }
-                emptyTanks -= partialStack.stackSize;
-            } else {
-                partialStack.stackSize = 0;
-            }
-        } else {
-            partialStack.stackSize = 0;
-        }
-        // Now that the 3 outputs are handled, we can now actually put the fluids in
-        ItemStack emptyStack = fluidContainer.copy();
-        emptyStack.stackSize = 1;
-        if (emptyStack.getItem() instanceof IFluidContainerItem) {
-            ((IFluidContainerItem) emptyStack.getItem()).drain(emptyStack, fluidInTank, true);
-        } else {
-            emptyStack = FluidContainerRegistry.drainFluidContainer(emptyStack);
-        }
-        emptyStack.stackSize = emptyTanks;
-        int extraTanks = heldContainers - emptyTanks - partialStack.stackSize;
-        // Done. Put the output in the inventory or ground, and update stack size.
-        boolean shouldSendStack = true;
-        if (slotIndex == -1) {
-            if (extraTanks > 0) {
-                ItemStack stack = player.inventory.getItemStack();
-                stack.stackSize = extraTanks;
-                adjustStack(stack);
-                dropItem(emptyStack);
-                dropItem(partialStack);
-            } else if (emptyTanks != 0) {
-                adjustStack(emptyStack);
-                player.inventory.setItemStack(emptyStack);
-                dropItem(partialStack);
-            } else if (partialStack.stackSize != 0) {
-                player.inventory.setItemStack(partialStack);
-            } else {
-                player.inventory.setItemStack(null);
-                shouldSendStack = false;
-            }
-        } else {
-            ItemStack stack = player.inventory.getStackInSlot(slotIndex);
-            if (extraTanks > 0) {
-                stack.stackSize = extraTanks;
-                adjustStack(stack);
-                dropItem(emptyStack);
-                dropItem(partialStack);
-            } else if (emptyTanks != 0) {
-                adjustStack(emptyStack);
-                player.inventory.setInventorySlotContents(slotIndex, emptyStack);
-                dropItem(partialStack);
-            } else if (partialStack.stackSize != 0) {
-                player.inventory.setInventorySlotContents(slotIndex, partialStack);
-            } else {
-                player.inventory.setItemStack(null);
-                shouldSendStack = false;
-            }
-        }
-        if (shouldSendStack) {
-            FluidCraft.proxy.netHandler.sendTo(
-                    new SPacketFluidUpdate(new HashMap<>(), player.inventory.getItemStack()),
-                    (EntityPlayerMP) player);
-        } else {
-            FluidCraft.proxy.netHandler.sendTo(new SPacketFluidUpdate(new HashMap<>()), (EntityPlayerMP) player);
-
-        }
-    }
-
-    /**
-     * The extract operation. For input, we have an empty container stack. For outputs, we have the following: 1.
-     * Leftover empty container stack - primary output. 2. Filled containers (full) 3. Partially filled container x1 In
-     * order above, the itemstack at `slotIndex` is transformed into the output.
-     */
-    private void extractFluid(IAEFluidStack fluid, ItemStack fluidContainer, EntityPlayer player, int heldContainers) {
-        IAEFluidStack storedFluid = this.monitor.getStorageList().findPrecise(fluid);
-        if (storedFluid == null || storedFluid.getStackSize() <= 0) return;
-        int capacity;
-        if (fluidContainer.getItem() instanceof IFluidContainerItem) {
-            capacity = ((IFluidContainerItem) fluidContainer.getItem()).getCapacity(fluidContainer);
-        } else if (FluidContainerRegistry.isContainer(fluidContainer)) {
-            // Fill with fluid container registry, or abort if it failed
-            ItemStack dummy = FluidContainerRegistry.fillFluidContainer(storedFluid.getFluidStack(), fluidContainer);
-            capacity = FluidContainerRegistry.getContainerCapacity(dummy);
-        } else {
-            return;
-        }
-        if (capacity == 0) return;
-        // The fluidstack that we will try to extract from the system.
-        final IAEFluidStack canExtract = storedFluid.copy();
-        // Maximum amount of fluid we can extract with the given container(s). Guarantees that we won't
-        // run into issues w/ remainder fluid later.
-        canExtract.setStackSize((long) capacity * fluidContainer.stackSize);
-        IAEFluidStack actualExtract = this.host.getFluidInventory()
-                .extractItems(canExtract, Actionable.SIMULATE, this.getActionSource());
-        if (actualExtract == null) return;
-        // Calculate the number of full fluid containers we extracted
-        long toExtract = actualExtract.getStackSize();
-        int filledTanks = (int) (toExtract / capacity);
-        int remainder = (int) (toExtract % capacity);
-        int emptyTanks = heldContainers - filledTanks;
-        // Fill the filled tanks
-        ItemStack filledStack = fluidContainer.copy();
-        filledStack.stackSize = 1;
-        if (filledTanks > 0) {
-            if (filledStack.getItem() instanceof IFluidContainerItem) {
-                int amt = ((IFluidContainerItem) filledStack.getItem())
-                        .fill(filledStack, actualExtract.getFluidStack(), true);
-                assert amt == capacity;
-            } else {
-                // Should not be NPE since we affirmed that we have enough capacity.
-                filledStack = FluidContainerRegistry.fillFluidContainer(actualExtract.getFluidStack(), filledStack);
-                assert capacity == FluidContainerRegistry.getContainerCapacity(filledStack);
-            }
-            filledStack.stackSize = filledTanks;
-        } else {
-            filledStack.stackSize = 0;
-        }
-        // Calculate the remaining fluid to extract, if any
-        ItemStack partialStack = fluidContainer.copy();
-        if (remainder > 0) {
-            actualExtract.setStackSize(remainder);
-            partialStack.stackSize = 1;
-            if (partialStack.getItem() instanceof IFluidContainerItem) {
-                int amt = ((IFluidContainerItem) partialStack.getItem())
-                        .fill(partialStack, actualExtract.getFluidStack(), true);
-                assert amt == remainder;
-                emptyTanks--;
-            } else {
-                ItemStack dummy = FluidContainerRegistry
-                        .fillFluidContainer(actualExtract.getFluidStack(), partialStack);
-                if (dummy == null) {
-                    // Failed to fill partial...
-                    partialStack.stackSize = 0;
-                    toExtract -= remainder;
-                } else {
-                    partialStack = dummy;
-                    toExtract -= FluidContainerRegistry.getContainerCapacity(partialStack);
-                    emptyTanks--;
-                }
-            }
-        } else {
-            partialStack.stackSize = 0;
-        }
-        // Now perform the real extraction.
-        actualExtract.setStackSize(toExtract);
-        this.host.getFluidInventory().extractItems(canExtract, Actionable.MODULATE, this.getActionSource());
-
-        // Done. Put the output in the inventory or ground, and update stack size.
-        // We can assume slotIndex == -1, since we don't actually allow extraction via shift click.
-        boolean shouldSendStack = true;
-        if (emptyTanks > 0) {
-            ItemStack emptyStack = player.inventory.getItemStack();
-            emptyStack.stackSize = emptyTanks;
-            adjustStack(emptyStack);
-            dropItem(filledStack);
-            dropItem(partialStack);
-        } else if (filledStack.stackSize != 0) {
-            adjustStack(filledStack);
-            player.inventory.setItemStack(filledStack);
-            dropItem(partialStack);
-        } else if (partialStack.stackSize != 0) {
-            player.inventory.setItemStack(partialStack);
-        } else {
-            player.inventory.setItemStack(null);
-            shouldSendStack = false;
-        }
-        if (shouldSendStack) {
-            FluidCraft.proxy.netHandler.sendTo(
-                    new SPacketFluidUpdate(new HashMap<>(), player.inventory.getItemStack()),
-                    (EntityPlayerMP) player);
-        } else {
-            FluidCraft.proxy.netHandler.sendTo(new SPacketFluidUpdate(new HashMap<>()), (EntityPlayerMP) player);
-
-        }
-
-    }
-
-    void adjustStack(ItemStack stack) {
-        if (stack.stackSize > stack.getMaxStackSize()) {
-            dropItem(stack, stack.stackSize - stack.getMaxStackSize());
-            stack.stackSize = stack.getMaxStackSize();
-        }
-    }
-
-    protected boolean isEssentiaMode() {
-        return false;
-    }
-
-    @Override
-    protected boolean isWirelessTerminal() {
-        return false;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidPacketDecoder.java

@@ -1,7 +1,10 @@
 package com.glodblock.github.client.gui.container;
 
+import static com.glodblock.github.loader.ItemAndBlockHolder.DROP;
 import static com.glodblock.github.loader.ItemAndBlockHolder.PACKET;
 
+import java.util.Arrays;
+
 import net.minecraft.entity.player.InventoryPlayer;
 
 import com.glodblock.github.common.tile.TileFluidPacketDecoder;
@@ -13,7 +16,14 @@ public class ContainerFluidPacketDecoder extends AEBaseContainer {
 
     public ContainerFluidPacketDecoder(InventoryPlayer ipl, TileFluidPacketDecoder tile) {
         super(ipl, tile);
-        addSlotToContainer(new FCSlotRestrictedInput(PACKET.stack(), tile.getInventory(), 0, 80, 35, ipl));
+        addSlotToContainer(
+                new FCSlotRestrictedInput(
+                        Arrays.asList(PACKET.stack(), DROP.stack()),
+                        tile.getInventory(),
+                        0,
+                        80,
+                        35,
+                        ipl));
         bindPlayerInventory(ipl, 0, 84);
     }
 }

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidPatternEncoder.java

@@ -165,6 +165,7 @@ public class ContainerFluidPatternEncoder extends AEBaseContainer implements IPa
                                 .putConvertedStack(Objects.requireNonNull(Util.copyStackWithSize(stack, 1)));
                     }
                 }
+                default -> {}
             }
         } else {
             super.doAction(player, action, slotId, id);

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidPatternExWireless.java

@@ -1,17 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-
-public class ContainerFluidPatternExWireless extends ContainerFluidPatternTerminalEx {
-
-    public ContainerFluidPatternExWireless(InventoryPlayer ip, IWirelessTerminal monitorable) {
-        super(ip, monitorable);
-    }
-
-    @Override
-    protected boolean isWirelessTerminal() {
-        return true;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidPatternTerminal.java

@@ -1,161 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.InventoryCrafting;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.crafting.CraftingManager;
-
-import com.glodblock.github.client.gui.container.base.FCContainerEncodeTerminal;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.container.slot.OptionalSlotFake;
-import appeng.container.slot.SlotFakeCraftingMatrix;
-import appeng.container.slot.SlotPatternOutputs;
-import appeng.container.slot.SlotPatternTerm;
-import appeng.util.Platform;
-
-public class ContainerFluidPatternTerminal extends FCContainerEncodeTerminal {
-
-    public ContainerFluidPatternTerminal(final InventoryPlayer ip, final ITerminalHost monitorable) {
-        super(ip, monitorable);
-        final IInventory output = this.patternTerminal.getInventoryByName("output");
-        final IInventory patternInv = this.patternTerminal.getInventoryByName("pattern");
-        this.craftingSlots = new SlotFakeCraftingMatrix[9];
-        this.outputSlots = new OptionalSlotFake[3];
-        for (int y = 0; y < 3; y++) {
-            for (int x = 0; x < 3; x++) {
-                this.addSlotToContainer(
-                        this.craftingSlots[x + y * 3] = new SlotFakeCraftingMatrix(
-                                this.crafting,
-                                x + y * 3,
-                                18 + x * 18,
-                                -76 + y * 18));
-            }
-        }
-
-        this.addSlotToContainer(
-                this.craftSlot = new SlotPatternTerm(
-                        ip.player,
-                        this.getActionSource(),
-                        this.getPowerSource(),
-                        monitorable,
-                        this.crafting,
-                        patternInv,
-                        this.cOut,
-                        110,
-                        -76 + 18,
-                        this,
-                        2,
-                        this));
-        this.craftSlot.setIIcon(-1);
-
-        for (int y = 0; y < 3; y++) {
-            this.addSlotToContainer(
-                    this.outputSlots[y] = new SlotPatternOutputs(output, this, y, 110, -76 + y * 18, 0, 0, 1));
-            this.outputSlots[y].setRenderDisabled(false);
-        }
-        this.updateOrderOfOutputSlots();
-    }
-
-    private void updateOrderOfOutputSlots() {
-        if (!this.isCraftingMode()) {
-            this.craftSlot.xDisplayPosition = -9000;
-            for (int y = 0; y < 3; y++) {
-                this.outputSlots[y].xDisplayPosition = this.outputSlots[y].getX();
-            }
-        } else {
-            this.craftSlot.xDisplayPosition = this.craftSlot.getX();
-            for (int y = 0; y < 3; y++) {
-                this.outputSlots[y].xDisplayPosition = -9000;
-            }
-        }
-    }
-
-    protected boolean validPatternSlot(Slot slot) {
-        return slot instanceof SlotFakeCraftingMatrix || slot instanceof SlotPatternOutputs;
-    }
-
-    @Override
-    public void putStackInSlot(final int par1, final ItemStack par2ItemStack) {
-        super.putStackInSlot(par1, par2ItemStack);
-        this.getAndUpdateOutput();
-    }
-
-    @Override
-    public void putStacksInSlots(final ItemStack[] par1ArrayOfItemStack) {
-        super.putStacksInSlots(par1ArrayOfItemStack);
-        this.getAndUpdateOutput();
-    }
-
-    private ItemStack getAndUpdateOutput() {
-        final InventoryCrafting ic = new InventoryCrafting(this, 3, 3);
-
-        for (int x = 0; x < ic.getSizeInventory(); x++) {
-            ic.setInventorySlotContents(x, this.crafting.getStackInSlot(x));
-        }
-
-        final ItemStack is = CraftingManager.getInstance().findMatchingRecipe(ic, this.getPlayerInv().player.worldObj);
-        this.cOut.setInventorySlotContents(0, is);
-        return is;
-    }
-
-    @Override
-    protected ItemStack[] getOutputs() {
-        if (this.isCraftingMode()) {
-            final ItemStack out = this.getAndUpdateOutput();
-            if (out != null && out.stackSize > 0) {
-                return new ItemStack[] { out };
-            }
-        }
-        return super.getOutputs();
-    }
-
-    @Override
-    public boolean isSlotEnabled(final int idx) {
-        if (idx == 1) {
-            return Platform.isServer() ? !this.patternTerminal.isCraftingRecipe() : !this.isCraftingMode();
-        } else if (idx == 2) {
-            return Platform.isServer() ? this.patternTerminal.isCraftingRecipe() : this.isCraftingMode();
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        super.detectAndSendChanges();
-        if (Platform.isServer()) {
-            if (this.isCraftingMode() != this.patternTerminal.isCraftingRecipe()) {
-                this.setCraftingMode(this.patternTerminal.isCraftingRecipe());
-                this.updateOrderOfOutputSlots();
-            }
-        }
-    }
-
-    @Override
-    public void onUpdate(final String field, final Object oldValue, final Object newValue) {
-        super.onUpdate(field, oldValue, newValue);
-        if (field.equals("craftingMode")) {
-            this.getAndUpdateOutput();
-            this.updateOrderOfOutputSlots();
-        }
-    }
-
-    public void clear() {
-        super.clear();
-        this.getAndUpdateOutput();
-    }
-
-    private void setCraftingMode(final boolean craftingMode) {
-        this.craftingMode = craftingMode;
-    }
-
-    @Override
-    public void doubleStacks(boolean isShift) {
-        if (!isCraftingMode()) {
-            super.doubleStacks(isShift);
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidPatternTerminalEx.java

@@ -1,153 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.Slot;
-
-import com.glodblock.github.client.gui.container.base.FCContainerEncodeTerminal;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.container.slot.IOptionalSlotHost;
-import appeng.container.slot.OptionalSlotFake;
-import appeng.helpers.InventoryAction;
-import appeng.util.Platform;
-
-public class ContainerFluidPatternTerminalEx extends FCContainerEncodeTerminal {
-
-    private static final int CRAFTING_GRID_PAGES = 2;
-    private static final int CRAFTING_GRID_WIDTH = 4;
-    private static final int CRAFTING_GRID_HEIGHT = 4;
-    private static final int CRAFTING_GRID_SLOTS = CRAFTING_GRID_WIDTH * CRAFTING_GRID_HEIGHT;
-
-    public ContainerFluidPatternTerminalEx(final InventoryPlayer ip, final ITerminalHost monitorable) {
-        super(ip, monitorable);
-        this.craftingSlots = new ProcessingSlotFake[CRAFTING_GRID_SLOTS * CRAFTING_GRID_PAGES];
-        this.outputSlots = new ProcessingSlotFake[CRAFTING_GRID_SLOTS * CRAFTING_GRID_PAGES];
-        final IInventory output = this.getPatternTerminal().getInventoryByName("output");
-        for (int page = 0; page < CRAFTING_GRID_PAGES; page++) {
-            for (int y = 0; y < CRAFTING_GRID_HEIGHT; y++) {
-                for (int x = 0; x < CRAFTING_GRID_WIDTH; x++) {
-                    this.addSlotToContainer(
-                            this.craftingSlots[x + y * CRAFTING_GRID_WIDTH
-                                    + page * CRAFTING_GRID_SLOTS] = new ProcessingSlotFake(
-                                            crafting,
-                                            this,
-                                            x + y * CRAFTING_GRID_WIDTH + page * CRAFTING_GRID_SLOTS,
-                                            15,
-                                            -83,
-                                            x,
-                                            y,
-                                            x + 4));
-                }
-            }
-            for (int x = 0; x < CRAFTING_GRID_WIDTH; x++) {
-                for (int y = 0; y < CRAFTING_GRID_HEIGHT; y++) {
-                    this.addSlotToContainer(
-                            this.outputSlots[x * CRAFTING_GRID_HEIGHT + y
-                                    + page * CRAFTING_GRID_SLOTS] = new ProcessingSlotFake(
-                                            output,
-                                            this,
-                                            x * CRAFTING_GRID_HEIGHT + y + page * CRAFTING_GRID_SLOTS,
-                                            112,
-                                            -83,
-                                            -x,
-                                            y,
-                                            x));
-                }
-            }
-        }
-        this.craftingMode = false;
-    }
-
-    @Override
-    public boolean isSlotEnabled(final int idx) {
-        if (idx < 4) // outputs
-        {
-            return inverted || idx == 0;
-        } else {
-            return !inverted || idx == 4;
-        }
-    }
-
-    protected boolean validPatternSlot(Slot slot) {
-        return slot instanceof ProcessingSlotFake;
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        if (Platform.isServer()) {
-            if (inverted != patternTerminal.isInverted() || activePage != patternTerminal.getActivePage()) {
-                inverted = patternTerminal.isInverted();
-                activePage = patternTerminal.getActivePage();
-                offsetSlots();
-            }
-        }
-        super.detectAndSendChanges();
-    }
-
-    private void offsetSlots() {
-        for (int page = 0; page < CRAFTING_GRID_PAGES; page++) {
-            for (int y = 0; y < CRAFTING_GRID_HEIGHT; y++) {
-                for (int x = 0; x < CRAFTING_GRID_WIDTH; x++) {
-                    ((ProcessingSlotFake) this.craftingSlots[x + y * CRAFTING_GRID_WIDTH + page * CRAFTING_GRID_SLOTS])
-                            .setHidden(page != activePage || x > 0 && inverted);
-                    ((ProcessingSlotFake) this.outputSlots[x * CRAFTING_GRID_HEIGHT + y + page * CRAFTING_GRID_SLOTS])
-                            .setHidden(page != activePage || x > 0 && !inverted);
-                }
-            }
-        }
-    }
-
-    @Override
-    public void onUpdate(String field, Object oldValue, Object newValue) {
-        super.onUpdate(field, oldValue, newValue);
-        if (field.equals("inverted") || field.equals("activePage")) {
-            offsetSlots();
-        }
-    }
-
-    @Override
-    public void onSlotChange(final Slot s) {
-        if (s == this.patternSlotOUT && Platform.isServer()) {
-            inverted = patternTerminal.isInverted();
-        }
-        super.onSlotChange(s);
-    }
-
-    @Override
-    public void doAction(EntityPlayerMP player, InventoryAction action, int slotId, long id) {
-        this.craftingMode = false;
-        super.doAction(player, action, slotId, id);
-    }
-
-    @Override
-    public void encode() {
-        this.craftingMode = false;
-        super.encode();
-    }
-
-    @Override
-    public boolean isCraftingMode() {
-        return false;
-    }
-
-    private static class ProcessingSlotFake extends OptionalSlotFake {
-
-        private static final int POSITION_SHIFT = 9000;
-        private boolean hidden = false;
-
-        public ProcessingSlotFake(IInventory inv, IOptionalSlotHost containerBus, int idx, int x, int y, int offX,
-                int offY, int groupNum) {
-            super(inv, containerBus, idx, x, y, offX, offY, groupNum);
-            this.setRenderDisabled(false);
-        }
-
-        public void setHidden(boolean hide) {
-            if (this.hidden != hide) {
-                this.hidden = hide;
-                this.xDisplayPosition += (hide ? -1 : 1) * POSITION_SHIFT;
-            }
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidPatternWireless.java

@@ -1,17 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-
-public class ContainerFluidPatternWireless extends ContainerFluidPatternTerminal {
-
-    public ContainerFluidPatternWireless(InventoryPlayer ip, IWirelessTerminal monitorable) {
-        super(ip, monitorable);
-    }
-
-    @Override
-    protected boolean isWirelessTerminal() {
-        return true;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidPortableCell.java

@@ -1,19 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import com.glodblock.github.inventory.item.IFluidPortableCell;
-
-public class ContainerFluidPortableCell extends ContainerFluidMonitor {
-
-    public ContainerFluidPortableCell(final InventoryPlayer ip, final IFluidPortableCell monitorable) {
-        super(ip, monitorable, false);
-        this.bindPlayerInventory(ip, 0, 0);
-    }
-
-    @Override
-    protected boolean isWirelessTerminal() {
-        return true;
-    }
-
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidStorageBus.java

@@ -1,189 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import java.util.Iterator;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.IInventory;
-
-import com.glodblock.github.client.gui.container.base.FCContainerFluidConfigurable;
-import com.glodblock.github.common.item.ItemFluidPacket;
-import com.glodblock.github.common.parts.PartFluidStorageBus;
-import com.glodblock.github.inventory.slot.OptionalFluidSlotFakeTypeOnly;
-import com.glodblock.github.util.Ae2Reflect;
-
-import appeng.api.AEApi;
-import appeng.api.config.*;
-import appeng.api.storage.IMEInventory;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.api.storage.data.IItemList;
-import appeng.container.guisync.GuiSync;
-import appeng.container.slot.SlotRestrictedInput;
-import appeng.tile.inventory.AppEngInternalAEInventory;
-import appeng.util.Platform;
-import appeng.util.iterators.NullIterator;
-
-public class ContainerFluidStorageBus extends FCContainerFluidConfigurable {
-
-    public final PartFluidStorageBus bus;
-
-    @GuiSync(3)
-    public AccessRestriction rwMode = AccessRestriction.READ_WRITE;
-
-    @GuiSync(4)
-    public StorageFilter storageFilter = StorageFilter.EXTRACTABLE_ONLY;
-
-    public ContainerFluidStorageBus(InventoryPlayer ip, PartFluidStorageBus te) {
-        super(ip, te);
-        this.bus = te;
-    }
-
-    @Override
-    protected int getHeight() {
-        return 251;
-    }
-
-    @Override
-    protected void setupConfig() {
-        final int xo = 8;
-        final int yo = 23 + 6;
-        final IInventory upgrades = Ae2Reflect.getUpgradeList(this).getInventoryByName("upgrades");
-        final IInventory config = Ae2Reflect.getUpgradeList(this).getInventoryByName("config");
-        for (int y = 0; y < 7; y++) {
-            for (int x = 0; x < 9; x++) {
-                this.addSlotToContainer(
-                        new OptionalFluidSlotFakeTypeOnly(config, null, this, y * 9 + x, xo, yo, x, y, y));
-            }
-        }
-        this.addSlotToContainer(
-                (new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.UPGRADES,
-                        upgrades,
-                        0,
-                        187,
-                        8,
-                        this.getInventoryPlayer())).setNotDraggable());
-        this.addSlotToContainer(
-                (new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.UPGRADES,
-                        upgrades,
-                        1,
-                        187,
-                        8 + 18,
-                        this.getInventoryPlayer())).setNotDraggable());
-        this.addSlotToContainer(
-                (new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.UPGRADES,
-                        upgrades,
-                        2,
-                        187,
-                        8 + 18 * 2,
-                        this.getInventoryPlayer())).setNotDraggable());
-        this.addSlotToContainer(
-                (new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.UPGRADES,
-                        upgrades,
-                        3,
-                        187,
-                        8 + 18 * 3,
-                        this.getInventoryPlayer())).setNotDraggable());
-        this.addSlotToContainer(
-                (new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.UPGRADES,
-                        upgrades,
-                        4,
-                        187,
-                        8 + 18 * 4,
-                        this.getInventoryPlayer())).setNotDraggable());
-    }
-
-    @Override
-    protected boolean isValidForConfig(int slot, IAEFluidStack fs) {
-        if (this.supportCapacity()) {
-            final int upgrades = Ae2Reflect.getUpgradeList(this).getInstalledUpgrades(Upgrades.CAPACITY);
-            final int y = slot / 9;
-            return y < upgrades + 2;
-        }
-        return true;
-    }
-
-    @Override
-    protected boolean supportCapacity() {
-        return true;
-    }
-
-    @Override
-    public int availableUpgrades() {
-        return 5;
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        this.verifyPermissions(SecurityPermissions.BUILD, false);
-
-        if (Platform.isServer()) {
-            this.setReadWriteMode(
-                    (AccessRestriction) Ae2Reflect.getUpgradeList(this).getConfigManager().getSetting(Settings.ACCESS));
-            this.setStorageFilter(
-                    (StorageFilter) Ae2Reflect.getUpgradeList(this).getConfigManager()
-                            .getSetting(Settings.STORAGE_FILTER));
-        }
-
-        this.standardDetectAndSendChanges();
-    }
-
-    @Override
-    public boolean isSlotEnabled(final int idx) {
-        if (Ae2Reflect.getUpgradeList(this).getInstalledUpgrades(Upgrades.ORE_FILTER) > 0) return false;
-        final int upgrades = Ae2Reflect.getUpgradeList(this).getInstalledUpgrades(Upgrades.CAPACITY);
-        return upgrades > (idx - 2);
-    }
-
-    public void clear() {
-        AppEngInternalAEInventory h = this.bus.getConfig();
-        for (int i = 0; i < h.getSizeInventory(); ++i) {
-            h.setInventorySlotContents(i, null);
-        }
-        this.detectAndSendChanges();
-    }
-
-    public void partition() {
-        AppEngInternalAEInventory h = this.bus.getConfig();
-        final IMEInventory<IAEFluidStack> cellInv = this.bus.getInternalHandler();
-        Iterator<IAEFluidStack> i = new NullIterator<>();
-        if (cellInv != null) {
-            final IItemList<IAEFluidStack> list = cellInv
-                    .getAvailableItems(AEApi.instance().storage().createFluidList());
-            i = list.iterator();
-        }
-
-        for (int x = 0; x < h.getSizeInventory(); x++) {
-            if (i.hasNext() && this.isSlotEnabled((x / 9) - 2)) {
-                h.setInventorySlotContents(x, ItemFluidPacket.newStack(i.next()));
-            } else {
-                h.setInventorySlotContents(x, null);
-            }
-        }
-        this.detectAndSendChanges();
-    }
-
-    public AccessRestriction getReadWriteMode() {
-        return this.rwMode;
-    }
-
-    public StorageFilter getStorageFilter() {
-        return this.storageFilter;
-    }
-
-    @Override
-    public AppEngInternalAEInventory getFakeFluidInv() {
-        return (AppEngInternalAEInventory) this.bus.getInventoryByName("config");
-    }
-
-    private void setReadWriteMode(final AccessRestriction rwMode) {
-        this.rwMode = rwMode;
-    }
-
-    private void setStorageFilter(final StorageFilter storageFilter) {
-        this.storageFilter = storageFilter;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerInterfaceWireless.java

@@ -1,417 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import java.io.IOException;
-import java.util.*;
-
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.common.util.ForgeDirection;
-
-import com.glodblock.github.client.gui.container.base.FCBaseContainer;
-import com.glodblock.github.common.parts.PartFluidInterface;
-import com.glodblock.github.common.tile.TileFluidInterface;
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-
-import appeng.api.config.*;
-import appeng.api.networking.IGrid;
-import appeng.api.networking.IGridNode;
-import appeng.api.networking.security.IActionHost;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketCompressedNBT;
-import appeng.helpers.DualityInterface;
-import appeng.helpers.IInterfaceHost;
-import appeng.helpers.InventoryAction;
-import appeng.items.misc.ItemEncodedPattern;
-import appeng.parts.AEBasePart;
-import appeng.parts.misc.PartInterface;
-import appeng.parts.p2p.PartP2PInterface;
-import appeng.tile.inventory.AppEngInternalInventory;
-import appeng.tile.misc.TileInterface;
-import appeng.util.InventoryAdaptor;
-import appeng.util.Platform;
-import appeng.util.inv.AdaptorIInventory;
-import appeng.util.inv.AdaptorPlayerHand;
-import appeng.util.inv.ItemSlot;
-import appeng.util.inv.WrapperInvSlot;
-
-public class ContainerInterfaceWireless extends FCBaseContainer {
-
-    /**
-     * this stuff is all server side
-     */
-    private static long autoBase = Long.MIN_VALUE;
-
-    private final Multimap<IInterfaceHost, ContainerInterfaceWireless.InvTracker> diList = HashMultimap.create();
-    private final Map<Long, ContainerInterfaceWireless.InvTracker> byId = new HashMap<>();
-    private IGrid grid;
-    private NBTTagCompound data = new NBTTagCompound();
-
-    public ContainerInterfaceWireless(final InventoryPlayer ip, final IWirelessTerminal monitorable) {
-        super(ip, monitorable);
-        if (Platform.isServer()) {
-            this.grid = monitorable.getActionableNode().getGrid();
-        }
-
-        this.bindPlayerInventory(ip, 14, 0);
-    }
-
-    private Set<IGridNode> getMachineNodes() {
-        Set<IGridNode> union = new HashSet<>();
-        this.grid.getMachines(TileFluidInterface.class).forEach(union::add);
-        this.grid.getMachines(TileInterface.class).forEach(union::add);
-        this.grid.getMachines(PartFluidInterface.class).forEach(union::add);
-        this.grid.getMachines(PartInterface.class).forEach(union::add);
-        this.grid.getMachines(PartP2PInterface.class).forEach(union::add);
-        return union;
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        if (Platform.isClient()) {
-            return;
-        }
-        super.detectAndSendChanges();
-
-        if (this.grid == null) {
-            return;
-        }
-
-        int total = 0;
-        boolean missing = false;
-
-        final IActionHost host = this.getActionHost();
-        if (host != null) {
-            final IGridNode agn = host.getActionableNode();
-            if (agn != null && agn.isActive()) {
-                for (final IGridNode gn : this.getMachineNodes()) {
-                    ContainerInterfaceWireless.InterfaceCheck interfaceCheck = new ContainerInterfaceWireless.InterfaceCheck()
-                            .invoke(gn);
-                    total += interfaceCheck.getTotal();
-                    missing |= interfaceCheck.isMissing();
-                }
-            }
-        }
-
-        if (total != this.diList.size() || missing) {
-            this.regenList(this.data);
-        } else {
-            for (final ContainerInterfaceWireless.InvTracker inv : diList.values()) {
-                for (int x = 0; x < inv.client.getSizeInventory(); x++) {
-                    if (this.isDifferent(inv.server.getStackInSlot(inv.offset + x), inv.client.getStackInSlot(x))) {
-                        this.addItems(this.data, inv, x, 1);
-                    }
-                }
-            }
-        }
-
-        if (!this.data.hasNoTags()) {
-            try {
-                NetworkHandler.instance
-                        .sendTo(new PacketCompressedNBT(this.data), (EntityPlayerMP) this.getPlayerInv().player);
-            } catch (final IOException ignored) {}
-
-            this.data = new NBTTagCompound();
-        }
-    }
-
-    @Override
-    public void doAction(final EntityPlayerMP player, final InventoryAction action, final int slot, final long id) {
-        final ContainerInterfaceWireless.InvTracker inv = this.byId.get(id);
-        if (inv != null) {
-            final ItemStack is = inv.server.getStackInSlot(slot + inv.offset);
-            final boolean hasItemInHand = player.inventory.getItemStack() != null;
-
-            final InventoryAdaptor playerHand = new AdaptorPlayerHand(player);
-
-            final WrapperInvSlot slotInv = new ContainerInterfaceWireless.PatternInvSlot(inv.server);
-
-            final IInventory theSlot = slotInv.getWrapper(slot + inv.offset);
-            final InventoryAdaptor interfaceSlot = new AdaptorIInventory(theSlot);
-
-            IInventory interfaceHandler = inv.server;
-            boolean canInsert = true;
-
-            switch (action) {
-                case PICKUP_OR_SET_DOWN -> {
-                    if (hasItemInHand) {
-                        for (int s = 0; s < interfaceHandler.getSizeInventory(); s++) {
-                            if (Platform.isSameItemPrecise(
-                                    interfaceHandler.getStackInSlot(s),
-                                    player.inventory.getItemStack())) {
-                                canInsert = false;
-                                break;
-                            }
-                        }
-                        if (canInsert) {
-                            ItemStack inSlot = theSlot.getStackInSlot(0);
-                            if (inSlot == null) {
-                                player.inventory.setItemStack(interfaceSlot.addItems(player.inventory.getItemStack()));
-                            } else {
-                                inSlot = inSlot.copy();
-                                final ItemStack inHand = player.inventory.getItemStack().copy();
-
-                                theSlot.setInventorySlotContents(0, null);
-                                player.inventory.setItemStack(null);
-
-                                player.inventory.setItemStack(interfaceSlot.addItems(inHand.copy()));
-
-                                if (player.inventory.getItemStack() == null) {
-                                    player.inventory.setItemStack(inSlot);
-                                } else {
-                                    player.inventory.setItemStack(inHand);
-                                    theSlot.setInventorySlotContents(0, inSlot);
-                                }
-                            }
-                        }
-                    } else {
-                        final IInventory mySlot = slotInv.getWrapper(slot + inv.offset);
-                        mySlot.setInventorySlotContents(0, playerHand.addItems(mySlot.getStackInSlot(0)));
-                    }
-                }
-                case SPLIT_OR_PLACE_SINGLE -> {
-                    if (hasItemInHand) {
-                        for (int s = 0; s < interfaceHandler.getSizeInventory(); s++) {
-                            if (Platform.isSameItemPrecise(
-                                    interfaceHandler.getStackInSlot(s),
-                                    player.inventory.getItemStack())) {
-                                canInsert = false;
-                                break;
-                            }
-                        }
-                        if (canInsert) {
-                            ItemStack extra = playerHand.removeItems(1, null, null);
-                            if (extra != null && !interfaceSlot.containsItems()) {
-                                extra = interfaceSlot.addItems(extra);
-                            }
-                            if (extra != null) {
-                                playerHand.addItems(extra);
-                            }
-                        }
-                    } else if (is != null) {
-                        ItemStack extra = interfaceSlot.removeItems((is.stackSize + 1) / 2, null, null);
-                        if (extra != null) {
-                            extra = playerHand.addItems(extra);
-                        }
-                        if (extra != null) {
-                            interfaceSlot.addItems(extra);
-                        }
-                    }
-                }
-                case SHIFT_CLICK -> {
-                    final IInventory mySlot = slotInv.getWrapper(slot + inv.offset);
-                    final InventoryAdaptor playerInv = InventoryAdaptor.getAdaptor(player, ForgeDirection.UNKNOWN);
-                    mySlot.setInventorySlotContents(0, mergeToPlayerInventory(playerInv, mySlot.getStackInSlot(0)));
-                }
-                case MOVE_REGION -> {
-                    final InventoryAdaptor playerInvAd = InventoryAdaptor.getAdaptor(player, ForgeDirection.UNKNOWN);
-                    for (int x = 0; x < inv.client.getSizeInventory(); x++) {
-                        inv.server.setInventorySlotContents(
-                                x + inv.offset,
-                                mergeToPlayerInventory(playerInvAd, inv.server.getStackInSlot(x + inv.offset)));
-                    }
-                }
-                case CREATIVE_DUPLICATE -> {
-                    if (player.capabilities.isCreativeMode && !hasItemInHand) {
-                        player.inventory.setItemStack(is == null ? null : is.copy());
-                    }
-                }
-                default -> {
-                    return;
-                }
-            }
-
-            this.updateHeld(player);
-        }
-    }
-
-    private ItemStack mergeToPlayerInventory(InventoryAdaptor playerInv, ItemStack stack) {
-        if (stack == null) return null;
-        for (ItemSlot slot : playerInv) {
-            if (Platform.isSameItemPrecise(slot.getItemStack(), stack)) {
-                if (slot.getItemStack().stackSize < slot.getItemStack().getMaxStackSize()) {
-                    ++slot.getItemStack().stackSize;
-                    return null;
-                }
-            }
-        }
-        return playerInv.addItems(stack);
-    }
-
-    private void regenList(final NBTTagCompound data) {
-        this.byId.clear();
-        this.diList.clear();
-
-        final IActionHost host = this.getActionHost();
-        if (host != null) {
-            final IGridNode agn = host.getActionableNode();
-            if (agn != null && agn.isActive()) {
-                for (final IGridNode gn : this.getMachineNodes()) {
-                    final IInterfaceHost ih = (IInterfaceHost) gn.getMachine();
-                    final DualityInterface dual = ih.getInterfaceDuality();
-                    if (gn.isActive() && dual.getConfigManager().getSetting(Settings.INTERFACE_TERMINAL) == YesNo.YES) {
-                        for (int i = 0; i <= dual.getInstalledUpgrades(Upgrades.PATTERN_CAPACITY); ++i) {
-                            this.diList.put(
-                                    ih,
-                                    new ContainerInterfaceWireless.InvTracker(
-                                            dual,
-                                            dual.getPatterns(),
-                                            dual.getTermName(),
-                                            i * 9,
-                                            9));
-                        }
-                    }
-                }
-            }
-        }
-
-        data.setBoolean("clear", true);
-
-        for (final ContainerInterfaceWireless.InvTracker inv : this.diList.values()) {
-            this.byId.put(inv.which, inv);
-            this.addItems(data, inv, 0, inv.client.getSizeInventory());
-        }
-    }
-
-    @Override
-    protected boolean isWirelessTerminal() {
-        return true;
-    }
-
-    private boolean isDifferent(final ItemStack a, final ItemStack b) {
-        if (a == null && b == null) {
-            return false;
-        }
-
-        if (a == null || b == null) {
-            return true;
-        }
-
-        return !ItemStack.areItemStacksEqual(a, b);
-    }
-
-    private void addItems(final NBTTagCompound data, final ContainerInterfaceWireless.InvTracker inv, final int offset,
-            final int length) {
-        final String name = '=' + Long.toString(inv.which, Character.MAX_RADIX);
-        final NBTTagCompound tag = data.getCompoundTag(name);
-
-        if (tag.hasNoTags()) {
-            tag.setLong("sortBy", inv.sortBy);
-            tag.setString("un", inv.unlocalizedName);
-            tag.setInteger("x", inv.X);
-            tag.setInteger("y", inv.Y);
-            tag.setInteger("z", inv.Z);
-            tag.setInteger("dim", inv.dim);
-            tag.setInteger("side", inv.side.ordinal());
-        }
-
-        for (int x = 0; x < length; x++) {
-            final NBTTagCompound itemNBT = new NBTTagCompound();
-
-            final ItemStack is = inv.server.getStackInSlot(x + offset + inv.offset);
-
-            // "update" client side.
-            inv.client.setInventorySlotContents(offset + x, is == null ? null : is.copy());
-
-            if (is != null) {
-                is.writeToNBT(itemNBT);
-            }
-
-            tag.setTag(Integer.toString(x + offset), itemNBT);
-        }
-
-        data.setTag(name, tag);
-    }
-
-    private static class InvTracker {
-
-        private final long sortBy;
-        private final long which = autoBase++;
-        private final String unlocalizedName;
-        private final IInventory client;
-        private final IInventory server;
-        private final int offset;
-        private final int X;
-        private final int Y;
-        private final int Z;
-        private final int dim;
-        private final ForgeDirection side;
-
-        public InvTracker(final DualityInterface dual, final IInventory patterns, final String unlocalizedName,
-                int offset, int size) {
-            this.server = patterns;
-            this.client = new AppEngInternalInventory(null, size);
-            this.unlocalizedName = unlocalizedName;
-            this.sortBy = dual.getSortValue() + offset << 16;
-            this.offset = offset;
-            X = dual.getLocation().x;
-            Y = dual.getLocation().y;
-            Z = dual.getLocation().z;
-            dim = dual.getLocation().getDimension();
-            if (dual.getHost() instanceof AEBasePart) {
-                side = ((AEBasePart) dual.getHost()).getSide();
-            } else {
-                side = ForgeDirection.UNKNOWN;
-            }
-        }
-    }
-
-    private static class PatternInvSlot extends WrapperInvSlot {
-
-        public PatternInvSlot(final IInventory inv) {
-            super(inv);
-        }
-
-        @Override
-        public boolean isItemValid(final ItemStack itemstack) {
-            return itemstack != null && itemstack.getItem() instanceof ItemEncodedPattern;
-        }
-    }
-
-    private class InterfaceCheck {
-
-        int total = 0;
-        boolean missing = false;
-
-        public InterfaceCheck() {}
-
-        public int getTotal() {
-            return total;
-        }
-
-        public boolean isMissing() {
-            return missing;
-        }
-
-        public ContainerInterfaceWireless.InterfaceCheck invoke(IGridNode gn) {
-            if (gn.isActive()) {
-                final IInterfaceHost ih = (IInterfaceHost) gn.getMachine();
-                if (ih.getInterfaceDuality().getConfigManager().getSetting(Settings.INTERFACE_TERMINAL) == YesNo.NO
-                        || ih instanceof PartP2PInterface && ((PartP2PInterface) ih).isOutput()) {
-                    return this;
-                }
-
-                final Collection<ContainerInterfaceWireless.InvTracker> t = ContainerInterfaceWireless.this.diList
-                        .get(ih);
-
-                if (t.isEmpty()) {
-                    missing = true;
-                } else {
-                    final DualityInterface dual = ih.getInterfaceDuality();
-                    for (ContainerInterfaceWireless.InvTracker it : t) {
-                        if (!it.unlocalizedName.equals(dual.getTermName())) {
-                            missing = true;
-                        }
-                    }
-                }
-
-                total += (ih.getInterfaceDuality().getInstalledUpgrades(Upgrades.PATTERN_CAPACITY) + 1);
-            }
-            return this;
-        }
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerItemMonitor.java

@@ -1,152 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.ICrafting;
-import net.minecraftforge.common.util.ForgeDirection;
-
-import com.glodblock.github.client.gui.container.base.FCContainerMonitor;
-import com.glodblock.github.network.SPacketMEUpdateBuffer;
-
-import appeng.api.AEApi;
-import appeng.api.implementations.tiles.IViewCellStorage;
-import appeng.api.networking.IGrid;
-import appeng.api.networking.IGridHost;
-import appeng.api.networking.IGridNode;
-import appeng.api.networking.energy.IEnergyGrid;
-import appeng.api.networking.energy.IEnergySource;
-import appeng.api.networking.security.BaseActionSource;
-import appeng.api.networking.storage.IBaseMonitor;
-import appeng.api.networking.storage.IStorageGrid;
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.api.storage.data.IItemList;
-import appeng.container.slot.SlotRestrictedInput;
-import appeng.me.helpers.ChannelPowerSrc;
-import appeng.util.Platform;
-
-public class ContainerItemMonitor extends FCContainerMonitor<IAEItemStack> {
-
-    private final IItemList<IAEItemStack> items = AEApi.instance().storage().createItemList();
-
-    public ContainerItemMonitor(final InventoryPlayer ip, final ITerminalHost monitorable) {
-        this(ip, monitorable, true);
-    }
-
-    protected ContainerItemMonitor(final InventoryPlayer ip, final ITerminalHost monitorable,
-            final boolean bindInventory) {
-        super(ip, monitorable, bindInventory);
-        if (Platform.isServer()) {
-            this.serverCM = monitorable.getConfigManager();
-            if (monitorable instanceof IGridHost) {
-                final IGridNode node = ((IGridHost) monitorable).getGridNode(ForgeDirection.UNKNOWN);
-                if (node != null) {
-                    this.networkNode = node;
-                    final IGrid g = node.getGrid();
-                    if (g != null) {
-                        this.setPowerSource(new ChannelPowerSrc(this.networkNode, g.getCache(IEnergyGrid.class)));
-                        IStorageGrid storageGrid = g.getCache(IStorageGrid.class);
-                        this.monitor = storageGrid.getItemInventory();
-                        if (this.monitor == null) {
-                            this.setValidContainer(false);
-                        } else {
-                            this.monitor.addListener(this, null);
-                            this.setCellInventory(this.monitor);
-                        }
-                    }
-                } else {
-                    this.setValidContainer(false);
-                }
-            } else {
-                this.monitor = monitorable.getItemInventory();
-                this.monitor.addListener(this, null);
-                this.setCellInventory(this.monitor);
-                this.setPowerSource((IEnergySource) monitorable);
-            }
-        } else {
-            this.monitor = null;
-        }
-
-        this.canAccessViewCells = false;
-        if (monitorable instanceof IViewCellStorage) {
-            for (int y = 0; y < 5; y++) {
-                this.cellView[y] = new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.VIEW_CELL,
-                        ((IViewCellStorage) monitorable).getViewCellStorage(),
-                        y,
-                        206,
-                        y * 18 + 8,
-                        this.getInventoryPlayer());
-                this.cellView[y].setAllowEdit(this.canAccessViewCells);
-                this.addSlotToContainer(this.cellView[y]);
-            }
-        }
-
-        if (bindInventory) {
-            this.bindPlayerInventory(ip, 0, 0);
-        }
-    }
-
-    @Override
-    protected void processItemList() {
-        if (!this.items.isEmpty()) {
-            final IItemList<IAEItemStack> monitorCache = this.monitor.getStorageList();
-            List<IAEItemStack> toSend = new ArrayList<>();
-            for (final IAEItemStack is : this.items) {
-                final IAEItemStack send = monitorCache.findPrecise(is);
-                if (send != null) {
-                    toSend.add(send);
-                } else {
-                    is.setStackSize(0);
-                    toSend.add(is);
-                }
-            }
-            for (final Object c : this.crafters) {
-                if (c instanceof EntityPlayer) {
-                    SPacketMEUpdateBuffer.scheduleItemUpdate((EntityPlayerMP) c, toSend);
-                }
-            }
-            this.items.resetStatus();
-        }
-    }
-
-    @Override
-    protected void queueInventory(final ICrafting c) {
-        if (Platform.isServer() && c instanceof EntityPlayer && this.monitor != null) {
-            final IItemList<IAEItemStack> monitorCache = this.monitor.getStorageList();
-            List<IAEItemStack> toSend = new ArrayList<>();
-            for (final IAEItemStack is : monitorCache) {
-                toSend.add(is);
-            }
-            SPacketMEUpdateBuffer.scheduleItemUpdate((EntityPlayerMP) c, toSend);
-        }
-    }
-
-    @Override
-    public void removeCraftingFromCrafters(final ICrafting c) {
-        super.removeCraftingFromCrafters(c);
-        if (this.crafters.isEmpty() && this.monitor != null) {
-            this.monitor.removeListener(this);
-            if (c instanceof EntityPlayerMP) {
-                SPacketMEUpdateBuffer.clear((EntityPlayerMP) c);
-            }
-        }
-    }
-
-    @Override
-    public void postChange(final IBaseMonitor<IAEItemStack> monitor, final Iterable<IAEItemStack> change,
-            final BaseActionSource source) {
-        for (final IAEItemStack is : change) {
-            this.items.add(is);
-        }
-    }
-
-    @Override
-    protected boolean isWirelessTerminal() {
-        return false;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerLevelMaintainer.java

@@ -1,31 +1,41 @@
 package com.glodblock.github.client.gui.container;
 
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
 import net.minecraft.item.ItemStack;
 
+import com.glodblock.github.FluidCraft;
 import com.glodblock.github.common.tile.TileLevelMaintainer;
-import com.glodblock.github.inventory.AeItemStackHandler;
 import com.glodblock.github.inventory.slot.SlotFluidConvertingFake;
+import com.glodblock.github.network.SPacketLevelMaintainerGuiUpdate;
 
-import appeng.container.AEBaseContainer;
+import appeng.api.config.SecurityPermissions;
+import appeng.api.storage.StorageName;
+import appeng.api.storage.data.IAEStack;
+import appeng.container.ContainerSubGui;
+import appeng.container.interfaces.IVirtualSlotHolder;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketVirtualSlot;
+import appeng.helpers.InventoryAction;
+import appeng.tile.inventory.IAEStackInventory;
+import appeng.util.Platform;
 import appeng.util.item.AEItemStack;
+import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 
-public class ContainerLevelMaintainer extends AEBaseContainer {
+public class ContainerLevelMaintainer extends ContainerSubGui implements IVirtualSlotHolder {
 
     private final TileLevelMaintainer tile;
-    private final SlotFluidConvertingFake[] requestSlots = new SlotFluidConvertingFake[TileLevelMaintainer.REQ_COUNT];
+
+    private static final int UPDATE_INTERVAL = 20;
+    private boolean isFirstUpdate = true;
+    private int updateCount = UPDATE_INTERVAL;
 
     public ContainerLevelMaintainer(InventoryPlayer ipl, TileLevelMaintainer tile) {
         super(ipl, tile);
         this.tile = tile;
-        AeItemStackHandler request = new AeItemStackHandler(tile.getRequestSlots());
-        for (int y = 0; y < TileLevelMaintainer.REQ_COUNT; y++) {
-            SlotFluidConvertingFake slot = new SlotFluidConvertingFake(request, y, 27, 20 + y * 19);
-            addSlotToContainer(slot);
-            requestSlots[y] = slot;
-        }
+
         bindPlayerInventory(ipl, 0, 130);
     }
 
@@ -33,19 +43,92 @@ public class ContainerLevelMaintainer extends AEBaseContainer {
         return tile;
     }
 
-    public SlotFluidConvertingFake[] getRequestSlots() {
-        return this.requestSlots;
+    @Override
+    public void doAction(EntityPlayerMP player, InventoryAction action, int slotId, long id) {
+        if (getSlot(slotId) instanceof SlotFluidConvertingFake slot) {
+            final ItemStack stack = player.inventory.getItemStack();
+            switch (action) {
+                case PICKUP_OR_SET_DOWN, PLACE_SINGLE, SPLIT_OR_PLACE_SINGLE -> {
+                    if (stack == null) {
+                        slot.putStack(null);
+                    } else {
+                        slot.putConvertedStack(stack);
+                    }
+                }
+                default -> {}
+            }
+        } else {
+            super.doAction(player, action, slotId, id);
+        }
     }
 
     @Override
     public ItemStack transferStackInSlot(EntityPlayer player, int idx) {
-        for (SlotFluidConvertingFake slot : this.getRequestSlots()) {
-            if (!slot.getHasStack()) {
-                slot.setAeStack(AEItemStack.create(((Slot) this.inventorySlots.get(idx)).getStack()), true);
-                break;
+        if (Platform.isClient()) {
+            return null;
+        }
+
+        ItemStack clickedStack = this.inventorySlots.get(idx).getStack();
+        if (clickedStack != null) {
+            IAEStackInventory inventory = this.getTile().getAEStackInventory();
+            for (int i = 0; i < inventory.getSizeInventory(); i++) {
+                IAEStack<?> stack = inventory.getAEStackInSlot(i);
+                if (stack == null) {
+                    tile.updateStack(i, AEItemStack.create(clickedStack));
+                    break;
+                }
             }
         }
+
         this.detectAndSendChanges();
         return null;
     }
+
+    @Override
+    public void detectAndSendChanges() {
+        super.detectAndSendChanges();
+        if (Platform.isClient()) {
+            return;
+        }
+
+        this.verifyPermissions(SecurityPermissions.BUILD, false);
+
+        if (this.updateCount++ >= UPDATE_INTERVAL) {
+            this.updateGui();
+        }
+    }
+
+    public void updateGui() {
+        if (this.isFirstUpdate) {
+            Int2ObjectMap<IAEStack<?>> list = new Int2ObjectOpenHashMap<>();
+            for (int i = 0; i < this.tile.requests.length; i++) {
+                TileLevelMaintainer.RequestInfo info = this.tile.requests[i];
+                list.put(i, info != null ? info.getAEStack() : null);
+            }
+            NetworkHandler.instance.sendTo(
+                    new PacketVirtualSlot(StorageName.NONE, list),
+                    (EntityPlayerMP) this.getInventoryPlayer().player);
+        }
+        FluidCraft.proxy.netHandler.sendTo(
+                new SPacketLevelMaintainerGuiUpdate(this.tile.requests, !this.isFirstUpdate, this.tile.isLiteMode()),
+                (EntityPlayerMP) this.getInventoryPlayer().player);
+        this.isFirstUpdate = false;
+        this.updateCount = 0;
+    }
+
+    @Override
+    public void receiveSlotStacks(StorageName invName, Int2ObjectMap<IAEStack<?>> slotStacks) {
+        for (var entry : slotStacks.int2ObjectEntrySet()) {
+            this.tile.updateStack(entry.getIntKey(), entry.getValue());
+        }
+        if (!this.tile.getWorldObj().isRemote) {
+            for (var player : this.crafters) {
+                NetworkHandler.instance
+                        .sendTo(new PacketVirtualSlot(StorageName.NONE, slotStacks), (EntityPlayerMP) player);
+                FluidCraft.proxy.netHandler.sendTo(
+                        new SPacketLevelMaintainerGuiUpdate(this.tile.requests, false, this.tile.isLiteMode()),
+                        (EntityPlayerMP) player);
+            }
+        }
+    }
 }

src/main/java/com/glodblock/github/client/gui/container/ContainerLevelTerminal.java

@@ -0,0 +1,255 @@
+package com.glodblock.github.client.gui.container;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import org.jetbrains.annotations.Nullable;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.container.base.FCBaseContainer;
+import com.glodblock.github.common.parts.PartLevelTerminal;
+import com.glodblock.github.inventory.gui.GuiType;
+import com.glodblock.github.inventory.item.IWirelessTerminal;
+import com.glodblock.github.loader.ItemAndBlockHolder;
+import com.glodblock.github.network.SPacketLevelTerminalUpdate;
+import com.glodblock.github.util.FluidPrimaryGui;
+import com.glodblock.github.util.LevelTerminalRegistry;
+
+import appeng.api.features.ILevelViewable;
+import appeng.api.features.LevelItemInfo;
+import appeng.api.networking.IGrid;
+import appeng.api.networking.IGridHost;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.security.IActionHost;
+import appeng.api.storage.ITerminalHost;
+import appeng.api.util.DimensionalCoord;
+import appeng.container.ContainerOpenContext;
+import appeng.container.PrimaryGui;
+import appeng.util.Platform;
+
+public class ContainerLevelTerminal extends FCBaseContainer {
+
+    /**
+     * this stuff is all server side
+     */
+    private int nextId = 0;
+
+    private final Map<IGridHost, ContainerLevelTerminal.InvTracker> tracked = new HashMap<>();
+    private final Map<Long, ContainerLevelTerminal.InvTracker> trackedById = new HashMap<>();
+
+    private IGrid grid;
+    private SPacketLevelTerminalUpdate updatePacket;
+    private boolean isPacketDirty;
+    private boolean wasOff;
+    private int ticks = 0;
+
+    public ContainerLevelTerminal(final InventoryPlayer ip, final ITerminalHost monitorable) {
+        super(ip, monitorable);
+        if (Platform.isServer()) {
+            if (monitorable instanceof PartLevelTerminal terminal) {
+                grid = terminal.getActionableNode().getGrid();
+            } else if (monitorable instanceof IWirelessTerminal wirelessTerminal) {
+                grid = wirelessTerminal.getActionableNode().getGrid();
+            }
+
+            updatePacket = this.updateList();
+            if (updatePacket != null) {
+                this.isPacketDirty = true;
+            } else {
+                updatePacket = new SPacketLevelTerminalUpdate();
+                this.isPacketDirty = false;
+            }
+        }
+
+        this.bindPlayerInventory(ip, 14, 0);
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        if (Platform.isClient()) {
+            return;
+        }
+
+        super.detectAndSendChanges();
+
+        if (this.grid == null) {
+            return;
+        }
+
+        final IActionHost host = this.getActionHost();
+
+        if (!host.getActionableNode().isActive()) {
+            if (!wasOff) {
+                SPacketLevelTerminalUpdate update = new SPacketLevelTerminalUpdate();
+
+                update.addDisconnectEntry();
+                wasOff = true;
+                FluidCraft.proxy.netHandler.sendTo(update, (EntityPlayerMP) this.getPlayerInv().player);
+            }
+            return;
+        }
+        wasOff = false;
+
+        if (isPacketDirty) {
+            FluidCraft.proxy.netHandler.sendTo(updatePacket, (EntityPlayerMP) this.getPlayerInv().player);
+            updatePacket = new SPacketLevelTerminalUpdate();
+            isPacketDirty = false;
+        } else if (++ticks % 20 == 0) {
+            ticks = 0;
+            SPacketLevelTerminalUpdate updateNew = this.updateList();
+            if (updateNew != null) {
+                FluidCraft.proxy.netHandler.sendTo(updateNew, (EntityPlayerMP) this.getPlayerInv().player);
+            }
+        }
+    }
+
+    @Nullable
+    private SPacketLevelTerminalUpdate updateList() {
+        SPacketLevelTerminalUpdate update = null;
+        var supported = LevelTerminalRegistry.instance().getSupportedClasses();
+        Set<IGridHost> visited = new HashSet<>();
+
+        for (Class<? extends ILevelViewable> clz : supported) {
+            boolean isAdopted = LevelTerminalRegistry.instance().isAdopted(clz);
+            Class<? extends IGridHost> machineClass = isAdopted ? LevelTerminalRegistry.instance().getAdopted(clz)
+                    : clz;
+            for (IGridNode gridNode : grid.getMachines(machineClass)) {
+                final IGridHost gridHost = gridNode.getMachine();
+                final ILevelViewable machine = isAdopted
+                        ? LevelTerminalRegistry.instance().getAdapter(clz).adapt(gridHost)
+                        : (ILevelViewable) gridHost;
+                visited.add(gridHost);
+
+                /* First check if we are already tracking this node */
+                if (tracked.containsKey(gridHost)) {
+                    ContainerLevelTerminal.InvTracker knownTracker = tracked.get(gridHost);
+
+                    /* Name changed? */
+                    String name = machine.getCustomName();
+                    if (!Objects.equals(knownTracker.name, name)) {
+                        knownTracker.name = name;
+                        if (update == null) update = new SPacketLevelTerminalUpdate();
+                        update.addRenameEntry(knownTracker.id, name);
+                    }
+
+                    LevelItemInfo[] prev = knownTracker.infoList;
+                    LevelItemInfo[] curr = machine.getLevelItemInfoList();
+                    if (prev.length == curr.length) {
+                        for (int i = 0; i < prev.length; i++) {
+                            if (prev[i] == null && curr[i] == null) continue;
+
+                            if (prev[i] == null) {
+                                knownTracker.infoList[i] = curr[i];
+                                if (update == null) update = new SPacketLevelTerminalUpdate();
+                                update.addOverwriteSlotEntry(knownTracker.id, i, curr[i]);
+                            } else if (curr[i] == null) {
+                                knownTracker.infoList[i] = null;
+                                if (update == null) update = new SPacketLevelTerminalUpdate();
+                                update.addOverwriteSlotEntry(knownTracker.id, i, null);
+                            } else if (!Platform.isStacksIdentical(prev[i].stack, curr[i].stack)
+                                    || prev[i].quantity != curr[i].quantity
+                                    || prev[i].batchSize != curr[i].batchSize
+                                    || prev[i].state != curr[i].state) {
+                                        knownTracker.infoList[i] = curr[i];
+                                        if (update == null) update = new SPacketLevelTerminalUpdate();
+                                        update.addOverwriteSlotEntry(knownTracker.id, i, curr[i]);
+                                    }
+                        }
+                    } else {
+                        knownTracker.infoList = curr;
+                        if (update == null) update = new SPacketLevelTerminalUpdate();
+                        update.addOverwriteAllSlotEntry(knownTracker.id, curr);
+                    }
+                } else {
+                    /* Add a new entry */
+                    if (update == null) update = new SPacketLevelTerminalUpdate();
+                    ContainerLevelTerminal.InvTracker entry = new ContainerLevelTerminal.InvTracker(nextId++, machine);
+
+                    update.addNewEntry(
+                            entry.id,
+                            entry.x,
+                            entry.y,
+                            entry.z,
+                            entry.dim,
+                            entry.side.ordinal(),
+                            entry.rows,
+                            entry.rowSize,
+                            entry.name,
+                            entry.infoList);
+                    tracked.put(gridHost, entry);
+                    trackedById.put(entry.id, entry);
+                }
+            }
+        }
+
+        /* Now find any entries that we need to remove */
+        Iterator<Map.Entry<IGridHost, ContainerLevelTerminal.InvTracker>> it = tracked.entrySet().iterator();
+        while (it.hasNext()) {
+            var entry = it.next();
+            if (visited.contains(entry.getKey())) {
+                continue;
+            }
+
+            if (update == null) update = new SPacketLevelTerminalUpdate();
+            update.addRemoveEntry(entry.getValue().id);
+            trackedById.remove(entry.getValue().id);
+            it.remove();
+        }
+        return update;
+    }
+
+    @Override
+    protected boolean isWirelessTerminal() {
+        return false;
+    }
+
+    private static class InvTracker {
+
+        private final long id;
+        private String name;
+        private final int rowSize;
+        private final int rows;
+        private final int x;
+        private final int y;
+        private final int z;
+        private final int dim;
+        private final ForgeDirection side;
+
+        private LevelItemInfo[] infoList;
+
+        public InvTracker(long id, ILevelViewable machine) {
+
+            DimensionalCoord location = machine.getLocation();
+
+            this.id = id;
+            this.name = machine.getCustomName();
+            this.rowSize = machine.rowSize();
+            this.rows = machine.rows();
+            this.x = location.x;
+            this.y = location.y;
+            this.z = location.z;
+            this.dim = location.getDimension();
+            this.side = machine.getSide();
+
+            this.infoList = machine.getLevelItemInfoList();
+        }
+    }
+
+    @Override
+    public PrimaryGui createPrimaryGui() {
+        ContainerOpenContext context = getOpenContext();
+        return new FluidPrimaryGui(
+                GuiType.LEVEL_TERMINAL,
+                ItemAndBlockHolder.LEVEL_TERMINAL.stack(),
+                context.getTile(),
+                context.getSide());
+    }
+}

src/main/java/com/glodblock/github/client/gui/container/ContainerLevelWireless.java

@@ -0,0 +1,35 @@
+package com.glodblock.github.client.gui.container;
+
+import net.minecraft.entity.player.InventoryPlayer;
+
+import com.glodblock.github.inventory.gui.GuiType;
+import com.glodblock.github.inventory.item.IWirelessTerminal;
+import com.glodblock.github.loader.ItemAndBlockHolder;
+import com.glodblock.github.util.FluidPrimaryGui;
+
+import appeng.container.ContainerOpenContext;
+import appeng.container.PrimaryGui;
+
+public class ContainerLevelWireless extends ContainerLevelTerminal {
+
+    public ContainerLevelWireless(InventoryPlayer ip, IWirelessTerminal monitorable) {
+        super(ip, monitorable);
+    }
+
+    @Override
+    protected boolean isWirelessTerminal() {
+        return true;
+    }
+
+    @Override
+    public PrimaryGui createPrimaryGui() {
+        ContainerOpenContext context = getOpenContext();
+        PrimaryGui primaryGui = new FluidPrimaryGui(
+                GuiType.WIRELESS_LEVEL_TERMINAL,
+                ItemAndBlockHolder.WIRELESS_LEVEL_TERM.stack(),
+                context.getTile(),
+                context.getSide());
+        primaryGui.setSlotIndex(getTargetSlotIndex());
+        return primaryGui;
+    }
+}

src/main/java/com/glodblock/github/client/gui/container/ContainerMagnetFilter.java

@@ -0,0 +1,103 @@
+package com.glodblock.github.client.gui.container;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+import com.glodblock.github.inventory.item.IWirelessMagnetFilter;
+import com.glodblock.github.inventory.item.WirelessMagnet;
+import com.glodblock.github.inventory.item.WirelessMagnetCardFilterInventory;
+
+import appeng.api.storage.ITerminalHost;
+import appeng.container.ContainerSubGui;
+import appeng.container.guisync.GuiSync;
+import appeng.container.slot.AppEngSlot;
+import appeng.container.slot.IOptionalSlotHost;
+import appeng.container.slot.OptionalSlotFake;
+import appeng.container.slot.SlotFake;
+import appeng.container.slot.SlotPatternOutputs;
+import appeng.util.Platform;
+
+public class ContainerMagnetFilter extends ContainerSubGui implements IOptionalSlotHost {
+
+    @GuiSync(101)
+    public WirelessMagnet.ListMode listMode;
+
+    @GuiSync(102)
+    public boolean nbt;
+
+    @GuiSync(103)
+    public boolean meta;
+
+    @GuiSync(104)
+    public boolean ore;
+
+    @GuiSync(105)
+    public boolean oreDict;
+
+    @GuiSync(106)
+    public String oreDictFilter;
+
+    protected OptionalSlotFake[] filterSlots;
+    protected final IInventory filter;
+    private final IWirelessMagnetFilter object;
+
+    public ContainerMagnetFilter(InventoryPlayer ip, ITerminalHost monitorable) {
+        super(ip, monitorable);
+        this.object = (WirelessMagnetCardFilterInventory) monitorable;
+        this.filter = object.getInventoryByName("config");
+        this.filterSlots = new OptionalSlotFake[27];
+        oreDictFilter = object.getOreDictFilter();
+        for (int y = 0; y < 3; y++) {
+            for (int x = 0; x < 9; x++) {
+                this.addSlotToContainer(
+                        this.filterSlots[x + y * 9] = new SlotPatternOutputs(
+                                this.filter,
+                                this,
+                                x + y * 9,
+                                8 + x * 18,
+                                58 + y * 18,
+                                0,
+                                0,
+                                1));
+                this.filterSlots[x + y * 9].setRenderDisabled(false);
+            }
+        }
+        this.lockPlayerInventorySlot(this.object.getInventorySlot());
+        bindPlayerInventory(ip, 0, 126);
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer p, int idx) {
+        AppEngSlot clickSlot = (AppEngSlot) this.inventorySlots.get(idx);
+        if (clickSlot == null || !clickSlot.getHasStack()) return null;
+        ItemStack tis = clickSlot.getStack();
+        for (SlotFake slot : this.filterSlots) {
+            if (!slot.getHasStack()) {
+                slot.putStack(tis);
+                detectAndSendChanges();
+                break;
+            }
+        }
+        return super.transferStackInSlot(p, idx);
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        if (Platform.isServer()) {
+            this.listMode = this.object.getListMode();
+            this.meta = this.object.getMetaMode();
+            this.nbt = this.object.getNBTMode();
+            this.ore = this.object.getOreMode();
+            this.oreDict = this.object.getOreDictMode();
+            this.oreDictFilter = this.object.getOreDictFilter();
+        }
+        super.detectAndSendChanges();
+    }
+
+    @Override
+    public boolean isSlotEnabled(int idx) {
+        return true;
+    }
+}

src/main/java/com/glodblock/github/client/gui/container/ContainerPatternValueAmount.java

@@ -1,43 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.Slot;
-
-import appeng.api.config.SecurityPermissions;
-import appeng.api.storage.ITerminalHost;
-import appeng.container.AEBaseContainer;
-import appeng.container.guisync.GuiSync;
-import appeng.container.slot.SlotInaccessible;
-import appeng.tile.inventory.AppEngInternalInventory;
-
-public class ContainerPatternValueAmount extends AEBaseContainer {
-
-    private final Slot patternValue;
-
-    @GuiSync(11)
-    public int valueIndex;
-
-    public ContainerPatternValueAmount(final InventoryPlayer ip, final ITerminalHost te) {
-        super(ip, te);
-        this.patternValue = new SlotInaccessible(new AppEngInternalInventory(null, 1), 0, 34, 53);
-        this.addSlotToContainer(patternValue);
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        super.detectAndSendChanges();
-        this.verifyPermissions(SecurityPermissions.CRAFT, false);
-    }
-
-    public Slot getPatternValue() {
-        return patternValue;
-    }
-
-    public int getValueIndex() {
-        return valueIndex;
-    }
-
-    public void setValueIndex(int valueIndex) {
-        this.valueIndex = valueIndex;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerRenamer.java

@@ -1,13 +0,0 @@
-package com.glodblock.github.client.gui.container;
-
-import net.minecraft.entity.player.InventoryPlayer;
-
-import appeng.api.storage.ITerminalHost;
-import appeng.container.AEBaseContainer;
-
-public class ContainerRenamer extends AEBaseContainer {
-
-    public ContainerRenamer(InventoryPlayer ip, ITerminalHost monitorable) {
-        super(ip, monitorable);
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/ContainerSuperStockReplenisher.java

@@ -0,0 +1,190 @@
+package com.glodblock.github.client.gui.container;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.GuiFCImgButton;
+import com.glodblock.github.common.tile.TileSuperStockReplenisher;
+import com.glodblock.github.inventory.gui.GuiType;
+import com.glodblock.github.loader.ItemAndBlockHolder;
+import com.glodblock.github.network.SPacketSuperStockReplenisherUpdate;
+import com.glodblock.github.util.FluidPrimaryGui;
+
+import appeng.api.implementations.items.IStorageCell;
+import appeng.api.storage.StorageName;
+import appeng.api.storage.data.IAEStack;
+import appeng.container.AEBaseContainer;
+import appeng.container.ContainerOpenContext;
+import appeng.container.PrimaryGui;
+import appeng.container.interfaces.IVirtualSlotSource;
+import appeng.container.slot.SlotRestrictedInput;
+import appeng.container.sync.SyncManager;
+import appeng.container.sync.handlers.AEStackInventorySyncHandler;
+import appeng.container.sync.handlers.BooleanSyncHandler;
+import appeng.tile.inventory.IAEStackInventory;
+import appeng.util.Platform;
+import appeng.util.item.AEItemStack;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ContainerSuperStockReplenisher extends AEBaseContainer implements IVirtualSlotSource {
+
+    private final TileSuperStockReplenisher tile;
+
+    private int lastUpdated = 1337;
+
+    private final IAEStackInventory configFluids;
+    public final AEStackInventorySyncHandler configFluidsSlots;
+
+    private final IAEStackInventory configItems;
+    public final AEStackInventorySyncHandler configItemsSlots;
+
+    public final BooleanSyncHandler fullStockModeSync;
+
+    @SideOnly(Side.CLIENT)
+    private GuiFCImgButton modeButton;
+
+    public ContainerSuperStockReplenisher(InventoryPlayer ipl, TileSuperStockReplenisher tile) {
+        super(ipl, tile);
+        this.tile = tile;
+        this.configFluids = tile.getConfigFluids();
+        this.configItems = tile.getConfigItems();
+        final IInventory cell = tile.getCell();
+
+        final SyncManager sm = this.getSyncManager();
+        this.configFluidsSlots = sm.root().aeStackInventory("fluidConfig", this.configFluids);
+        this.configItemsSlots = sm.root().aeStackInventory("itemConfig", this.configItems);
+        this.fullStockModeSync = sm.root().booleanSync("fullstockMode").onClientChange((oldValue, newValue) -> {
+            if (this.modeButton != null) {
+                this.modeButton.set(newValue ? "fullstockMode" : "normalMode");
+            }
+        }).onServerChange((oldValue, newValue) -> this.tile.setFullStockMode(newValue));
+
+        this.addSlotToContainer(
+                new SlotRestrictedInput(
+                        SlotRestrictedInput.PlacableItemType.WORKBENCH_CELL,
+                        cell,
+                        0,
+                        173,
+                        8,
+                        this.getInventoryPlayer()));
+
+        bindPlayerInventory(ipl, 0, 251 - 82);
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void setModeButton(GuiFCImgButton button) {
+        this.modeButton = button;
+    }
+
+    @Override
+    public ItemStack slotClick(int slotId, int clickedButton, int mode, EntityPlayer player) {
+        if (slotId == 0 && player.inventory.getItemStack() == null && isConfigurated()) return null;
+        return super.slotClick(slotId, clickedButton, mode, player);
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        super.detectAndSendChanges();
+        if (Platform.isClient()) return;
+
+        if (this.lastUpdated > 20) {
+            this.lastUpdated = 0;
+            Map<Integer, IAEStack<?>> tmp = new HashMap<>();
+
+            for (int i = 0; i < this.tile.getInternalFluid().getSlots(); i++) {
+                tmp.put(i, this.tile.getInternalFluid().getFluidInSlot(i));
+            }
+
+            for (int i = 0; i < this.tile.getInternalInventory().getSizeInventory(); i++) {
+                tmp.put(i + 100, AEItemStack.create(this.tile.getInternalInventory().getStackInSlot(i)));
+            }
+
+            for (final Object g : this.crafters) {
+                if (g instanceof EntityPlayer) {
+                    FluidCraft.proxy.netHandler.sendTo(new SPacketSuperStockReplenisherUpdate(tmp), (EntityPlayerMP) g);
+                }
+            }
+
+            if (Platform.isServer()) this.setFullStockMode(this.tile.isFullStockMode());
+
+        }
+
+        this.lastUpdated++;
+    }
+
+    private boolean isConfigurated() {
+        for (int i = 0; i < this.configItems.getSizeInventory(); i++)
+            if (this.configItems.getAEStackInSlot(i) != null) return true;
+
+        for (int i = 0; i < this.configFluids.getSizeInventory(); i++)
+            if (this.configFluids.getAEStackInSlot(i) != null) return true;
+        return false;
+    }
+
+    @Override
+    public boolean isValidForSlot(Slot s, ItemStack is) {
+        if (s.slotNumber == 0 && s.getHasStack() && isConfigurated()) {
+            long currentBytes = 0;
+            long newBytes = -1;
+
+            if (s.getStack().getItem() instanceof IStorageCell isc) currentBytes = isc.getBytesLong(is);
+
+            if (is.getItem() instanceof IStorageCell isc) newBytes = isc.getBytesLong(is);
+
+            if (currentBytes > newBytes) {
+                return false;
+            }
+        }
+        return super.isValidForSlot(s, is);
+    }
+
+    @Override
+    public PrimaryGui createPrimaryGui() {
+        ContainerOpenContext context = getOpenContext();
+        return new FluidPrimaryGui(
+                GuiType.GUI_SUPER_STOCK_REPLENISHER,
+                ItemAndBlockHolder.SUPER_STOCK_RERPLENISHER.stack(),
+                context.getTile(),
+                context.getSide());
+    }
+
+    @Override
+    public void updateVirtualSlot(StorageName invName, int slotId, IAEStack<?> aes) {
+        if (aes != null && aes.getStackSize() > Integer.MAX_VALUE) aes.setStackSize(Integer.MAX_VALUE);
+        switch (invName) {
+            case NONE -> {
+                this.configFluids.putAEStackInSlot(slotId, aes);
+                this.configFluidsSlots.markDirty();
+            }
+            case CONFIG -> {
+                this.configItems.putAEStackInSlot(slotId, aes);
+                this.configItemsSlots.markDirty();
+            }
+        }
+    }
+
+    public TileSuperStockReplenisher getTile() {
+        return this.tile;
+    }
+
+    public boolean isFullStockMode() {
+        return this.fullStockModeSync.get();
+    }
+
+    public void setFullStockMode(final boolean fullStockMode) {
+        this.fullStockModeSync.set(fullStockMode);
+    }
+
+    public void markDirty() {
+        this.fullStockModeSync.markDirty();
+    }
+}

src/main/java/com/glodblock/github/client/gui/container/base/FCBaseContainer.java

@@ -3,33 +3,42 @@ package com.glodblock.github.client.gui.container.base;
 import net.minecraft.entity.player.InventoryPlayer;
 
 import com.glodblock.github.inventory.item.IFluidPortableCell;
+import com.glodblock.github.inventory.item.WirelessMagnet;
 import com.glodblock.github.util.Util;
 
 import appeng.api.storage.ITerminalHost;
 import appeng.container.AEBaseContainer;
+import appeng.container.guisync.GuiSync;
+import appeng.util.Platform;
 
 public abstract class FCBaseContainer extends AEBaseContainer {
 
     private int ticks;
     private final double powerMultiplier = 0.5;
-    private IFluidPortableCell host;
+    private ITerminalHost host;
     private int slot = -1;
     private final InventoryPlayer ip;
 
+    @GuiSync(105)
+    public boolean restock = false;
+
+    @GuiSync(106)
+    public WirelessMagnet.Mode mode = WirelessMagnet.Mode.Off;
+
     public FCBaseContainer(InventoryPlayer ip, ITerminalHost monitorable) {
         super(ip, monitorable);
         this.ip = ip;
+        this.host = monitorable;
         if (isWirelessTerminal()) {
-            host = (IFluidPortableCell) monitorable;
             this.slot = lockSlot();
         }
     }
 
     private int lockSlot() {
         if (isWirelessTerminal()) {
-            if (this.host != null) {
-                final int slotIndex = this.host.getInventorySlot();
-                if (Util.GuiHelper.decodeInvType(slotIndex).getLeft() == Util.GuiHelper.InvType.PLAYER_INV) {
+            if (this.host instanceof IFluidPortableCell) {
+                final int slotIndex = ((IFluidPortableCell) this.host).getInventorySlot();
+                if (slotIndex <= Platform.baublesSlotsOffset) {
                     this.lockPlayerInventorySlot(slotIndex);
                 }
                 return slotIndex;
@@ -50,7 +59,7 @@ public abstract class FCBaseContainer extends AEBaseContainer {
                     this.slot,
                     this.ticks,
                     this.getPowerMultiplier(),
-                    this.host);
+                    ((IFluidPortableCell) this.host));
         }
         super.detectAndSendChanges();
     }
@@ -59,4 +68,14 @@ public abstract class FCBaseContainer extends AEBaseContainer {
         return this.powerMultiplier;
     }
 
+    public ITerminalHost getHost() {
+        return this.host;
+    }
+
+    public IFluidPortableCell getPortableCell() {
+        if (this.host instanceof IFluidPortableCell fpc) {
+            return fpc;
+        }
+        return null;
+    }
 }

src/main/java/com/glodblock/github/client/gui/container/base/FCContainerEncodeTerminal.java

@@ -1,550 +0,0 @@
-package com.glodblock.github.client.gui.container.base;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.ICrafting;
-import net.minecraft.inventory.IInventory;
-import net.minecraft.inventory.Slot;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTBase;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraftforge.fluids.FluidContainerRegistry;
-import net.minecraftforge.fluids.FluidStack;
-import net.minecraftforge.fluids.IFluidContainerItem;
-
-import com.glodblock.github.client.gui.container.ContainerItemMonitor;
-import com.glodblock.github.common.item.ItemFluidDrop;
-import com.glodblock.github.common.item.ItemFluidEncodedPattern;
-import com.glodblock.github.common.item.ItemFluidPacket;
-import com.glodblock.github.inventory.IPatternConsumer;
-import com.glodblock.github.inventory.item.IItemPatternTerminal;
-import com.glodblock.github.loader.ItemAndBlockHolder;
-import com.glodblock.github.util.FluidPatternDetails;
-import com.glodblock.github.util.Util;
-
-import appeng.api.AEApi;
-import appeng.api.config.Actionable;
-import appeng.api.definitions.IDefinitions;
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.container.guisync.GuiSync;
-import appeng.container.slot.*;
-import appeng.helpers.IContainerCraftingPacket;
-import appeng.helpers.InventoryAction;
-import appeng.items.misc.ItemEncodedPattern;
-import appeng.tile.inventory.AppEngInternalInventory;
-import appeng.tile.inventory.IAEAppEngInventory;
-import appeng.tile.inventory.InvOperation;
-import appeng.util.Platform;
-import appeng.util.item.AEItemStack;
-
-public abstract class FCContainerEncodeTerminal extends ContainerItemMonitor
-        implements IAEAppEngInventory, IOptionalSlotHost, IContainerCraftingPacket, IPatternConsumer {
-
-    protected final IItemPatternTerminal patternTerminal;
-    protected final AppEngInternalInventory cOut = new AppEngInternalInventory(null, 1);
-    protected final IInventory crafting;
-    protected final SlotRestrictedInput patternSlotIN;
-    protected final SlotRestrictedInput patternSlotOUT;
-    protected SlotFake[] craftingSlots;
-    protected OptionalSlotFake[] outputSlots;
-    protected SlotPatternTerm craftSlot;
-
-    @GuiSync(97)
-    public boolean craftingMode = true;
-
-    @GuiSync(96)
-    public boolean substitute = false;
-
-    @GuiSync(95)
-    public boolean combine = false;
-
-    @GuiSync(94)
-    public boolean beSubstitute = false;
-
-    @GuiSync(93)
-    public boolean inverted;
-
-    @GuiSync(92)
-    public int activePage = 0;
-
-    @GuiSync(91)
-    public boolean prioritize = false;
-
-    @GuiSync(90)
-    public boolean autoFillPattern = false;
-
-    public FCContainerEncodeTerminal(final InventoryPlayer ip, final ITerminalHost monitorable) {
-        super(ip, monitorable);
-        this.patternTerminal = (IItemPatternTerminal) monitorable;
-        this.inverted = patternTerminal.isInverted();
-        final IInventory patternInv = this.patternTerminal.getInventoryByName("pattern");
-        this.crafting = this.patternTerminal.getInventoryByName("crafting");
-        this.addSlotToContainer(
-                this.patternSlotIN = new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.BLANK_PATTERN,
-                        patternInv,
-                        0,
-                        147,
-                        -72 - 9,
-                        this.getInventoryPlayer()));
-        this.addSlotToContainer(
-                this.patternSlotOUT = new SlotRestrictedInput(
-                        SlotRestrictedInput.PlacableItemType.ENCODED_PATTERN,
-                        patternInv,
-                        1,
-                        147,
-                        -72 + 34,
-                        this.getInventoryPlayer()));
-        this.patternSlotOUT.setStackLimit(1);
-    }
-
-    @Override
-    public void doAction(EntityPlayerMP player, InventoryAction action, int slotId, long id) {
-        if (this.isCraftingMode()) {
-            super.doAction(player, action, slotId, id);
-            return;
-        }
-        if (slotId < 0 || slotId >= this.inventorySlots.size()) {
-            super.doAction(player, action, slotId, id);
-            return;
-        }
-        if (action == InventoryAction.MOVE_REGION) {
-            super.doAction(player, InventoryAction.SPLIT_OR_PLACE_SINGLE, slotId, id);
-            return;
-        }
-        if (action == InventoryAction.PICKUP_SINGLE) {
-            super.doAction(player, InventoryAction.PICKUP_OR_SET_DOWN, slotId, id);
-            return;
-        }
-        Slot slot = getSlot(slotId);
-        ItemStack stack = player.inventory.getItemStack();
-        if (Util.getFluidFromItem(stack) == null || Util.getFluidFromItem(stack).amount <= 0) {
-            super.doAction(player, action, slotId, id);
-            return;
-        }
-        if (validPatternSlot(slot)
-                && (stack.getItem() instanceof IFluidContainerItem || FluidContainerRegistry.isContainer(stack))) {
-            FluidStack fluid = null;
-            switch (action) {
-                case PICKUP_OR_SET_DOWN -> {
-                    fluid = Util.getFluidFromItem(stack);
-                    slot.putStack(ItemFluidPacket.newStack(fluid));
-                }
-                case SPLIT_OR_PLACE_SINGLE -> {
-                    fluid = Util.getFluidFromItem(Util.copyStackWithSize(stack, 1));
-                    FluidStack origin = ItemFluidPacket.getFluidStack(slot.getStack());
-                    if (fluid != null && fluid.equals(origin)) {
-                        fluid.amount += origin.amount;
-                        if (fluid.amount <= 0) fluid = null;
-                    }
-                    slot.putStack(ItemFluidPacket.newStack(fluid));
-                }
-            }
-            if (fluid == null) {
-                super.doAction(player, action, slotId, id);
-                return;
-            }
-            return;
-        }
-        super.doAction(player, action, slotId, id);
-    }
-
-    protected abstract boolean validPatternSlot(Slot slot);
-
-    @Override
-    public ItemStack transferStackInSlot(EntityPlayer p, int idx) {
-        Slot clickSlot = (Slot) this.inventorySlots.get(idx);
-        ItemStack is = clickSlot.getStack();
-        if (is != null && !patternSlotOUT.getHasStack()
-                && is.stackSize == 1
-                && (is.getItem() instanceof ItemFluidEncodedPattern || is.getItem() instanceof ItemEncodedPattern)) {
-            ItemStack output = is.copy();
-            patternSlotOUT.putStack(output);
-            p.inventory.setInventorySlotContents(clickSlot.getSlotIndex(), null);
-            this.detectAndSendChanges();
-            return null;
-        } else {
-            return super.transferStackInSlot(p, idx);
-        }
-    }
-
-    public IItemPatternTerminal getPatternTerminal() {
-        return this.patternTerminal;
-    }
-
-    protected static boolean canDoubleStacks(SlotFake[] slots) {
-        List<SlotFake> enabledSlots = Arrays.stream(slots).filter(SlotFake::isEnabled).collect(Collectors.toList());
-        long emptySlots = enabledSlots.stream().filter(s -> s.getStack() == null).count();
-        long fullSlots = enabledSlots.stream().filter(s -> s.getStack() != null && s.getStack().stackSize * 2 > 127)
-                .count();
-        return fullSlots <= emptySlots;
-    }
-
-    protected static void doubleStacksInternal(SlotFake[] slots) {
-        List<ItemStack> overFlowStacks = new ArrayList<>();
-        List<SlotFake> enabledSlots = Arrays.stream(slots).filter(SlotFake::isEnabled).collect(Collectors.toList());
-        for (final Slot s : enabledSlots) {
-            ItemStack st = s.getStack();
-            if (st == null) continue;
-            if (Util.isFluidPacket(st)) {
-                FluidStack fluidStack = ItemFluidPacket.getFluidStack(st);
-                if (fluidStack != null) {
-                    fluidStack = ItemFluidPacket.getFluidStack(st).copy();
-                    if (fluidStack.amount < Integer.MAX_VALUE / 2) fluidStack.amount *= 2;
-                }
-                s.putStack(ItemFluidPacket.newStack(fluidStack));
-            } else if (st.stackSize * 2 > 127) {
-                overFlowStacks.add(st.copy());
-            } else {
-                st.stackSize *= 2;
-                s.putStack(st);
-            }
-        }
-        Iterator<ItemStack> ow = overFlowStacks.iterator();
-        for (final Slot s : enabledSlots) {
-            if (!ow.hasNext()) break;
-            if (s.getStack() != null) continue;
-            s.putStack(ow.next());
-        }
-        assert !ow.hasNext();
-    }
-
-    protected static boolean containsItem(SlotFake[] slots) {
-        List<SlotFake> enabledSlots = Arrays.stream(slots).filter(SlotFake::isEnabled).collect(Collectors.toList());
-        long item = enabledSlots.stream().filter(s -> s.getStack() != null && !Util.isFluidPacket(s.getStack()))
-                .count();
-        return item > 0;
-    }
-
-    protected static boolean containsFluid(SlotFake[] slots) {
-        List<SlotFake> enabledSlots = Arrays.stream(slots).filter(SlotFake::isEnabled).collect(Collectors.toList());
-        long fluid = enabledSlots.stream().filter(s -> Util.isFluidPacket(s.getStack())).count();
-        return fluid > 0;
-    }
-
-    protected static boolean nonNullSlot(SlotFake[] slots) {
-        List<SlotFake> enabledSlots = Arrays.stream(slots).filter(SlotFake::isEnabled).collect(Collectors.toList());
-        long object = enabledSlots.stream().filter(s -> s.getStack() != null).count();
-        return object > 0;
-    }
-
-    protected boolean checkHasFluidPattern() {
-        if (this.craftingMode) {
-            return false;
-        }
-        boolean hasFluid = containsFluid(this.craftingSlots);
-        boolean search = nonNullSlot(this.craftingSlots);
-        if (!search) { // search=false -> inputs were empty
-            return false;
-        }
-        hasFluid |= containsFluid(this.outputSlots);
-        search = nonNullSlot(this.outputSlots);
-        return hasFluid && search; // search=false -> outputs were empty
-    }
-
-    protected void encodeFluidPattern() {
-        ItemStack patternStack = new ItemStack(ItemAndBlockHolder.PATTERN);
-        FluidPatternDetails pattern = new FluidPatternDetails(patternStack);
-        pattern.setInputs(collectInventory(this.craftingSlots));
-        pattern.setOutputs(collectInventory(this.outputSlots));
-        pattern.setCanBeSubstitute(this.beSubstitute ? 1 : 0);
-        patternSlotOUT.putStack(pattern.writeToStack());
-    }
-
-    protected static IAEItemStack[] collectInventory(Slot[] slots) {
-        IAEItemStack[] stacks = new IAEItemStack[slots.length];
-        for (int i = 0; i < stacks.length; i++) {
-            ItemStack stack = slots[i].getStack();
-            if (stack != null) {
-                if (stack.getItem() instanceof ItemFluidPacket) {
-                    IAEItemStack dropStack = ItemFluidDrop.newAeStack(ItemFluidPacket.getFluidStack(stack));
-                    if (dropStack != null) {
-                        stacks[i] = dropStack;
-                        continue;
-                    }
-                }
-            }
-            IAEItemStack aeStack = AEItemStack.create(stack);
-            stacks[i] = aeStack;
-        }
-        return stacks;
-    }
-
-    @Override
-    public void saveChanges() {
-        // NO-OP
-    }
-
-    public void clear() {
-        for (final Slot s : this.craftingSlots) {
-            s.putStack(null);
-        }
-        for (final Slot s : this.outputSlots) {
-            s.putStack(null);
-        }
-        this.detectAndSendChanges();
-    }
-
-    @Override
-    public void onChangeInventory(final IInventory inv, final int slot, final InvOperation mc,
-            final ItemStack removedStack, final ItemStack newStack) {
-        // NO-OP
-    }
-
-    public void encodeAndMoveToInventory() {
-        encode();
-        ItemStack output = this.patternSlotOUT.getStack();
-        if (output != null) {
-            if (!getPlayerInv().addItemStackToInventory(output)) {
-                getPlayerInv().player.entityDropItem(output, 0);
-            }
-            this.patternSlotOUT.putStack(null);
-        }
-        fillPattern();
-    }
-
-    public void encodeAllItemAndMoveToInventory() {
-        encode();
-        ItemStack output = this.patternSlotOUT.getStack();
-        if (output != null) {
-            if (this.patternSlotIN.getStack() != null) output.stackSize += this.patternSlotIN.getStack().stackSize;
-            if (!getPlayerInv().addItemStackToInventory(output)) {
-                getPlayerInv().player.entityDropItem(output, 0);
-            }
-            this.patternSlotOUT.putStack(null);
-            this.patternSlotIN.putStack(null);
-        }
-        fillPattern();
-    }
-
-    private void fillPattern() {
-        if (this.autoFillPattern && this.getHost().getItemInventory() != null) {
-            // try to use me network item to fill pattern input slot
-            final IDefinitions definitions = AEApi.instance().definitions();
-            int fillStackSize = this.patternSlotIN.getHasStack() ? 64 - this.patternSlotIN.getStack().stackSize : 64;
-            if (fillStackSize == 0) return;
-            for (ItemStack blankPattern : definitions.materials().blankPattern().maybeStack(fillStackSize).asSet()) {
-                IAEItemStack iBlankPattern = AEApi.instance().storage().createItemStack(blankPattern);
-                if (this.patternSlotIN.getHasStack() && !iBlankPattern.isSameType(this.patternSlotIN.getStack()))
-                    continue;
-                IAEItemStack out = this.getHost().getItemInventory()
-                        .extractItems(iBlankPattern, Actionable.MODULATE, this.getActionSource());
-                if (out != null) {
-                    ItemStack outPattern;
-                    if (this.patternSlotIN.getHasStack()) {
-                        outPattern = this.patternSlotIN.getStack().copy();
-                        outPattern.stackSize += out.getItemStack().stackSize;
-                    } else {
-                        outPattern = out.getItemStack();
-                    }
-                    this.patternSlotIN.putStack(outPattern);
-                    return;
-                }
-            }
-        }
-    }
-
-    public void encode() {
-        fillPattern();
-        if (!checkHasFluidPattern()) {
-            encodeItemPattern();
-            return;
-        }
-        ItemStack stack = this.patternSlotOUT.getStack();
-        if (stack == null) {
-            stack = this.patternSlotIN.getStack();
-            if (notPattern(stack)) {
-                return;
-            }
-            if (stack.stackSize == 1) {
-                this.patternSlotIN.putStack(null);
-            } else {
-                stack.stackSize--;
-            }
-            encodeFluidPattern();
-        } else if (!notPattern(stack)) {
-            encodeFluidPattern();
-        }
-    }
-
-    public void encodeItemPattern() {
-        ItemStack output = this.patternSlotOUT.getStack();
-        final ItemStack[] in = this.getInputs();
-        final ItemStack[] out = this.getOutputs();
-
-        // if there is no input, this would be silly.
-        if (in == null || out == null) {
-            return;
-        }
-        // first check the output slots, should either be null, or a pattern
-        if (output != null && this.notPattern(output)) {
-            return;
-        } // if nothing is there we should snag a new pattern.
-        else if (output == null) {
-            output = this.patternSlotIN.getStack();
-            if (this.notPattern(output)) {
-                return; // no blanks.
-            }
-
-            // remove one, and clear the input slot.
-            output.stackSize--;
-            if (output.stackSize == 0) {
-                this.patternSlotIN.putStack(null);
-            }
-
-            // add a new encoded pattern.
-            for (final ItemStack encodedPatternStack : AEApi.instance().definitions().items().encodedPattern()
-                    .maybeStack(1).asSet()) {
-                output = encodedPatternStack;
-            }
-        } else if (output.getItem() instanceof ItemFluidEncodedPattern) {
-            for (final ItemStack encodedPatternStack : AEApi.instance().definitions().items().encodedPattern()
-                    .maybeStack(1).asSet()) {
-                output = encodedPatternStack;
-            }
-        }
-
-        // encode the slot.
-        final NBTTagCompound encodedValue = new NBTTagCompound();
-
-        final NBTTagList tagIn = new NBTTagList();
-        final NBTTagList tagOut = new NBTTagList();
-
-        for (final ItemStack i : in) {
-            tagIn.appendTag(this.createItemTag(i));
-        }
-
-        for (final ItemStack i : out) {
-            tagOut.appendTag(this.createItemTag(i));
-        }
-
-        encodedValue.setTag("in", tagIn);
-        encodedValue.setTag("out", tagOut);
-        encodedValue.setBoolean("crafting", this.craftingMode);
-        encodedValue.setBoolean("substitute", this.substitute);
-        encodedValue.setBoolean("beSubstitute", this.beSubstitute);
-        encodedValue.setBoolean("prioritize", this.prioritize);
-        output.setTagCompound(encodedValue);
-        this.patternSlotOUT.putStack(output);
-    }
-
-    protected ItemStack[] getInputs() {
-        final ArrayList<ItemStack> input = new ArrayList<>();
-        for (SlotFake craftingSlot : this.craftingSlots) {
-            input.add(craftingSlot.getStack());
-        }
-        if (input.stream().anyMatch(Objects::nonNull)) {
-            return input.toArray(new ItemStack[0]);
-        }
-        return null;
-    }
-
-    protected ItemStack[] getOutputs() {
-        final ArrayList<ItemStack> output = new ArrayList<>();
-        for (final SlotFake outputSlot : this.outputSlots) {
-            output.add(outputSlot.getStack());
-        }
-        if (output.stream().anyMatch(Objects::nonNull)) {
-            return output.toArray(new ItemStack[0]);
-        }
-        return null;
-    }
-
-    protected boolean notPattern(final ItemStack output) {
-        if (output == null) {
-            return true;
-        }
-        if (output.getItem() instanceof ItemFluidEncodedPattern) {
-            return false;
-        }
-        final IDefinitions definitions = AEApi.instance().definitions();
-
-        boolean isPattern = definitions.items().encodedPattern().isSameAs(output);
-        isPattern |= definitions.materials().blankPattern().isSameAs(output);
-
-        return !isPattern;
-    }
-
-    protected NBTBase createItemTag(final ItemStack i) {
-        final NBTTagCompound c = new NBTTagCompound();
-        if (i != null) {
-            i.writeToNBT(c);
-            c.setInteger("Count", i.stackSize);
-        }
-        return c;
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        super.detectAndSendChanges();
-        if (Platform.isServer()) {
-            this.substitute = this.patternTerminal.isSubstitution();
-            this.combine = this.patternTerminal.shouldCombine();
-            this.beSubstitute = this.patternTerminal.canBeSubstitute();
-            this.prioritize = this.patternTerminal.isPrioritize();
-            this.autoFillPattern = this.patternTerminal.isAutoFillPattern();
-        }
-    }
-
-    @Override
-    public void onSlotChange(final Slot s) {
-        if (s == this.patternSlotOUT && Platform.isServer()) {
-            for (final Object crafter : this.crafters) {
-                final ICrafting icrafting = (ICrafting) crafter;
-
-                for (final Object g : this.inventorySlots) {
-                    if (g instanceof OptionalSlotFake || g instanceof SlotFakeCraftingMatrix) {
-                        final Slot sri = (Slot) g;
-                        icrafting.sendSlotContents(this, sri.slotNumber, sri.getStack());
-                    }
-                }
-                ((EntityPlayerMP) icrafting).isChangingQuantityOnly = false;
-            }
-            this.detectAndSendChanges();
-        }
-    }
-
-    @Override
-    public IInventory getInventoryByName(final String name) {
-        if (name.equals("player")) {
-            return this.getInventoryPlayer();
-        }
-        return this.patternTerminal.getInventoryByName(name);
-    }
-
-    @Override
-    public boolean useRealItems() {
-        return false;
-    }
-
-    public void doubleStacks(boolean isShift) {
-        if (canDoubleStacks(craftingSlots) && canDoubleStacks(outputSlots)) {
-            doubleStacksInternal(this.craftingSlots);
-            doubleStacksInternal(this.outputSlots);
-            if (isShift && (containsItem(outputSlots) || containsItem(craftingSlots))) {
-                while (canDoubleStacks(craftingSlots) && canDoubleStacks(outputSlots)) {
-                    doubleStacksInternal(this.craftingSlots);
-                    doubleStacksInternal(this.outputSlots);
-                }
-            }
-            this.detectAndSendChanges();
-        }
-    }
-
-    @Override
-    public void acceptPattern(IAEItemStack[] inputs, IAEItemStack[] outputs) {
-        if (this.patternTerminal != null) {
-            this.patternTerminal.onChangeCrafting(inputs, outputs);
-        }
-    }
-
-    public boolean isCraftingMode() {
-        return this.craftingMode;
-    }
-}

src/main/java/com/glodblock/github/client/gui/container/base/FCContainerFluidConfigurable.java

@@ -14,7 +14,6 @@ import com.glodblock.github.FluidCraft;
 import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.inventory.slot.OptionalFluidSlotFakeTypeOnly;
 import com.glodblock.github.network.SPacketFluidUpdate;
-import com.glodblock.github.util.Ae2Reflect;
 import com.glodblock.github.util.Util;
 
 import appeng.api.config.Upgrades;
@@ -64,7 +63,7 @@ public abstract class FCContainerFluidConfigurable extends ContainerUpgradeable
     protected void setupConfig() {
         this.setupUpgrades();
 
-        final IInventory inv = Ae2Reflect.getUpgradeList(this).getInventoryByName("config");
+        final IInventory inv = getUpgradeable().getInventoryByName("config");
         final int y = 40;
         final int x = 80;
         this.addSlotToContainer(new OptionalFluidSlotFakeTypeOnly(inv, null, this, 0, x, y, 0, 0, 0));
@@ -84,7 +83,7 @@ public abstract class FCContainerFluidConfigurable extends ContainerUpgradeable
     protected boolean isValidForConfig(int slot, IAEFluidStack fs) {
         if (this.supportCapacity()) {
             // assumes 4 slots per upgrade
-            final int upgrades = Ae2Reflect.getUpgradeList(this).getInstalledUpgrades(Upgrades.CAPACITY);
+            final int upgrades = getUpgradeable().getInstalledUpgrades(Upgrades.CAPACITY);
 
             if (slot > 0 && upgrades < 1) {
                 return false;

src/main/java/com/glodblock/github/client/gui/container/base/FCContainerMonitor.java

@@ -1,229 +0,0 @@
-package com.glodblock.github.client.gui.container.base;
-
-import java.io.IOException;
-
-import javax.annotation.Nonnull;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.entity.player.InventoryPlayer;
-import net.minecraft.inventory.ICrafting;
-import net.minecraft.item.ItemStack;
-
-import com.glodblock.github.inventory.item.IWirelessTerminal;
-import com.glodblock.github.network.SPacketMEUpdateBuffer;
-
-import appeng.api.config.*;
-import appeng.api.networking.IGridNode;
-import appeng.api.networking.energy.IEnergyGrid;
-import appeng.api.storage.IMEMonitor;
-import appeng.api.storage.IMEMonitorHandlerReceiver;
-import appeng.api.storage.ITerminalHost;
-import appeng.api.storage.data.IAEStack;
-import appeng.api.util.IConfigManager;
-import appeng.api.util.IConfigurableObject;
-import appeng.container.guisync.GuiSync;
-import appeng.container.slot.SlotRestrictedInput;
-import appeng.core.AELog;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketValueConfig;
-import appeng.helpers.WirelessTerminalGuiObject;
-import appeng.util.ConfigManager;
-import appeng.util.IConfigManagerHost;
-import appeng.util.Platform;
-
-public abstract class FCContainerMonitor<T extends IAEStack<T>> extends FCBaseContainer
-        implements IConfigManagerHost, IConfigurableObject, IMEMonitorHandlerReceiver<T> {
-
-    protected final SlotRestrictedInput[] cellView = new SlotRestrictedInput[5];
-    protected final IConfigManager clientCM;
-    protected final ITerminalHost host;
-
-    @GuiSync(99)
-    public boolean canAccessViewCells = false;
-
-    @GuiSync(98)
-    public boolean hasPower = false;
-
-    protected IConfigManagerHost gui;
-    protected IConfigManager serverCM;
-    protected IGridNode networkNode;
-    protected IMEMonitor<T> monitor;
-
-    public FCContainerMonitor(final InventoryPlayer ip, final ITerminalHost monitorable) {
-        this(ip, monitorable, true);
-    }
-
-    protected FCContainerMonitor(final InventoryPlayer ip, final ITerminalHost monitorable,
-            final boolean bindInventory) {
-        super(ip, monitorable);
-        this.host = monitorable;
-        this.clientCM = new ConfigManager(this);
-        this.clientCM.registerSetting(Settings.SORT_BY, SortOrder.NAME);
-        this.clientCM.registerSetting(Settings.VIEW_MODE, ViewItems.ALL);
-        this.clientCM.registerSetting(Settings.SORT_DIRECTION, SortDir.ASCENDING);
-        this.clientCM.registerSetting(Settings.TYPE_FILTER, TypeFilter.ALL);
-    }
-
-    public IMEMonitor<T> getMonitor() {
-        return this.monitor;
-    }
-
-    public IGridNode getNetworkNode() {
-        return this.networkNode;
-    }
-
-    @Override
-    public void detectAndSendChanges() {
-        if (Platform.isServer()) {
-            if (isInvalid()) {
-                this.setValidContainer(false);
-            }
-            if (this.serverCM != null) {
-                for (final Settings set : this.serverCM.getSettings()) {
-                    final Enum<?> sideLocal = this.serverCM.getSetting(set);
-                    final Enum<?> sideRemote = this.clientCM.getSetting(set);
-
-                    if (sideLocal != sideRemote) {
-                        this.clientCM.putSetting(set, sideLocal);
-                        for (final Object crafter : this.crafters) {
-                            try {
-                                NetworkHandler.instance.sendTo(
-                                        new PacketValueConfig(set.name(), sideLocal.name()),
-                                        (EntityPlayerMP) crafter);
-                            } catch (final IOException e) {
-                                AELog.debug(e);
-                            }
-                        }
-                    }
-                }
-            }
-            processItemList();
-            this.updatePowerStatus();
-            final boolean oldAccessible = this.canAccessViewCells;
-            this.canAccessViewCells = this.host instanceof WirelessTerminalGuiObject
-                    || this.host instanceof IWirelessTerminal
-                    || this.hasAccess(SecurityPermissions.BUILD, false);
-            if (this.canAccessViewCells != oldAccessible) {
-                for (int y = 0; y < 5; y++) {
-                    if (this.cellView[y] != null) {
-                        this.cellView[y].setAllowEdit(this.canAccessViewCells);
-                    }
-                }
-            }
-            super.detectAndSendChanges();
-        }
-    }
-
-    protected abstract void processItemList();
-
-    protected boolean isInvalid() {
-        return this.monitor == null;
-    }
-
-    protected void updatePowerStatus() {
-        try {
-            if (this.networkNode != null) {
-                this.setPowered(this.networkNode.isActive());
-            } else if (this.getPowerSource() instanceof IEnergyGrid) {
-                this.setPowered(((IEnergyGrid) this.getPowerSource()).isNetworkPowered());
-            } else {
-                this.setPowered(
-                        this.getPowerSource().extractAEPower(1, Actionable.SIMULATE, PowerMultiplier.CONFIG) > 0.8);
-            }
-        } catch (final Throwable ignore) {}
-    }
-
-    @Override
-    public void onUpdate(final String field, final Object oldValue, final Object newValue) {
-        if (field.equals("canAccessViewCells")) {
-            for (int y = 0; y < 5; y++) {
-                if (this.cellView[y] != null) {
-                    this.cellView[y].setAllowEdit(this.canAccessViewCells);
-                }
-            }
-        }
-        super.onUpdate(field, oldValue, newValue);
-    }
-
-    @Override
-    public void addCraftingToCrafters(final ICrafting c) {
-        super.addCraftingToCrafters(c);
-        this.queueInventory(c);
-    }
-
-    protected abstract void queueInventory(final ICrafting c);
-
-    @Override
-    public void onContainerClosed(final EntityPlayer player) {
-        super.onContainerClosed(player);
-        if (this.monitor != null) {
-            this.monitor.removeListener(this);
-            if (player instanceof EntityPlayerMP && Platform.isServer()) {
-                SPacketMEUpdateBuffer.clear((EntityPlayerMP) player);
-            }
-
-        }
-    }
-
-    @Override
-    public IConfigManager getConfigManager() {
-        if (Platform.isServer()) {
-            return this.serverCM;
-        }
-        return this.clientCM;
-    }
-
-    public ItemStack[] getViewCells() {
-        final ItemStack[] list = new ItemStack[this.cellView.length];
-        for (int x = 0; x < this.cellView.length; x++) {
-            list[x] = this.cellView[x].getStack();
-        }
-        return list;
-    }
-
-    public SlotRestrictedInput getCellViewSlot(final int index) {
-        return this.cellView[index];
-    }
-
-    public boolean isPowered() {
-        return this.hasPower;
-    }
-
-    protected void setPowered(final boolean isPowered) {
-        this.hasPower = isPowered;
-    }
-
-    protected IConfigManagerHost getGui() {
-        return this.gui;
-    }
-
-    public void setGui(@Nonnull final IConfigManagerHost gui) {
-        this.gui = gui;
-    }
-
-    @Override
-    public boolean isValid(Object verificationToken) {
-        return true;
-    }
-
-    @Override
-    public void onListUpdate() {
-        for (final Object c : this.crafters) {
-            if (c instanceof final ICrafting cr) {
-                this.queueInventory(cr);
-            }
-        }
-    }
-
-    @Override
-    public void updateSetting(final IConfigManager manager, final Enum settingName, final Enum newValue) {
-        if (this.getGui() != null) {
-            this.getGui().updateSetting(manager, settingName, newValue);
-        }
-    }
-
-    public ITerminalHost getHost() {
-        return this.host;
-    }
-}

src/main/java/com/glodblock/github/client/me/EssentiaRepo.java

@@ -1,126 +0,0 @@
-package com.glodblock.github.client.me;
-
-import java.util.Iterator;
-import java.util.regex.Pattern;
-
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.fluids.Fluid;
-import net.minecraftforge.fluids.FluidStack;
-
-import com.glodblock.github.common.item.ItemFluidDrop;
-import com.glodblock.github.crossmod.thaumcraft.AspectUtil;
-import com.glodblock.github.util.FluidSorters;
-
-import appeng.api.config.SearchBoxMode;
-import appeng.api.config.Settings;
-import appeng.api.config.SortOrder;
-import appeng.api.config.ViewItems;
-import appeng.api.storage.data.IAEFluidStack;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.client.gui.widgets.IScrollSource;
-import appeng.client.gui.widgets.ISortSource;
-import appeng.core.AEConfig;
-
-public class EssentiaRepo extends FluidRepo {
-
-    public EssentiaRepo(final IScrollSource src, final ISortSource sortSrc) {
-        super(src, sortSrc);
-    }
-
-    @Override
-    public void updateView() {
-        this.view.clear();
-        this.dsp.clear();
-
-        this.view.ensureCapacity(this.list.size());
-        this.dsp.ensureCapacity(this.list.size());
-
-        final Enum<?> viewMode = this.sortSrc.getSortDisplay();
-        final Enum<?> searchMode = AEConfig.instance.settings.getSetting(Settings.SEARCH_MODE);
-        if (searchMode == SearchBoxMode.NEI_AUTOSEARCH || searchMode == SearchBoxMode.NEI_MANUAL_SEARCH) {
-            this.updateNEI(this.searchString);
-        }
-
-        String innerSearch = this.searchString;
-
-        if (innerSearch.startsWith("@")) {
-            innerSearch = innerSearch.substring(1);
-        }
-
-        Pattern m;
-        try {
-            m = Pattern.compile(innerSearch.toLowerCase(), Pattern.CASE_INSENSITIVE);
-        } catch (final Throwable ignore) {
-            try {
-                m = Pattern.compile(Pattern.quote(innerSearch.toLowerCase()), Pattern.CASE_INSENSITIVE);
-            } catch (final Throwable __) {
-                return;
-            }
-        }
-
-        for (IAEItemStack is : this.list) {
-            if (this.myPartitionList != null) {
-                if (!this.myPartitionList.isListed(is)) {
-                    continue;
-                }
-            }
-
-            if (viewMode == ViewItems.CRAFTABLE && !is.isCraftable()) {
-                continue;
-            }
-
-            if (viewMode == ViewItems.CRAFTABLE) {
-                is = is.copy();
-                is.setStackSize(0);
-            }
-
-            if (viewMode == ViewItems.STORED && is.getStackSize() == 0) {
-                continue;
-            }
-
-            Fluid fluid = ItemFluidDrop.getAeFluidStack(is).getFluid();
-            if (!AspectUtil.isEssentiaGas(fluid)) {
-                continue;
-            }
-
-            if (m.matcher(fluid.getLocalizedName().toLowerCase()).find()) {
-                this.view.add(is);
-            }
-        }
-
-        final Enum<?> SortBy = this.sortSrc.getSortBy();
-        final Enum<?> SortDir = this.sortSrc.getSortDir();
-
-        FluidSorters.setDirection((appeng.api.config.SortDir) SortDir);
-        FluidSorters.init();
-
-        if (SortBy == SortOrder.MOD) {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_MOD);
-        } else if (SortBy == SortOrder.AMOUNT) {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_SIZE);
-        } else if (SortBy == SortOrder.INVTWEAKS) {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_INV_TWEAKS);
-        } else {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_NAME);
-        }
-
-        for (final IAEItemStack is : this.view) {
-            this.dsp.add(is.getItemStack());
-        }
-        Iterator<IAEItemStack> it1 = this.view.iterator();
-        while (it1.hasNext()) {
-            IAEFluidStack fluid = ItemFluidDrop.getAeFluidStack(it1.next());
-            if (!AspectUtil.isEssentiaGas(fluid)) {
-                it1.remove();
-            }
-        }
-        Iterator<ItemStack> it2 = this.dsp.iterator();
-        while (it2.hasNext()) {
-            FluidStack fluid = ItemFluidDrop.getFluidStack(it2.next());
-            if (!AspectUtil.isEssentiaGas(fluid)) {
-                it2.remove();
-            }
-        }
-    }
-
-}

src/main/java/com/glodblock/github/client/me/FluidRepo.java

@@ -1,244 +0,0 @@
-/*
- * This file is part of Applied Energistics 2. Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. Applied
- * Energistics 2 is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General
- * Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
- * later version. Applied Energistics 2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
- * Public License for more details. You should have received a copy of the GNU Lesser General Public License along with
- * Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
- */
-
-package com.glodblock.github.client.me;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.regex.Pattern;
-
-import javax.annotation.Nonnull;
-
-import net.minecraft.item.ItemStack;
-import net.minecraftforge.fluids.Fluid;
-
-import com.glodblock.github.api.FluidCraftAPI;
-import com.glodblock.github.common.item.ItemFluidDrop;
-import com.glodblock.github.util.FluidSorters;
-import com.glodblock.github.util.Util;
-
-import appeng.api.AEApi;
-import appeng.api.config.*;
-import appeng.api.storage.data.IAEItemStack;
-import appeng.api.storage.data.IDisplayRepo;
-import appeng.api.storage.data.IItemList;
-import appeng.client.gui.widgets.IScrollSource;
-import appeng.client.gui.widgets.ISortSource;
-import appeng.core.AEConfig;
-import appeng.items.storage.ItemViewCell;
-import appeng.util.prioitylist.IPartitionList;
-import cpw.mods.fml.relauncher.ReflectionHelper;
-
-public class FluidRepo implements IDisplayRepo {
-
-    protected final IItemList<IAEItemStack> list = AEApi.instance().storage().createItemList();
-    protected final ArrayList<IAEItemStack> view = new ArrayList<>();
-    protected final ArrayList<ItemStack> dsp = new ArrayList<>();
-    protected final IScrollSource src;
-    protected final ISortSource sortSrc;
-
-    protected int rowSize = 9;
-
-    protected String searchString = "";
-    protected IPartitionList<IAEItemStack> myPartitionList;
-    private String NEIWord = null;
-    private boolean hasPower;
-
-    public FluidRepo(final IScrollSource src, final ISortSource sortSrc) {
-        this.src = src;
-        this.sortSrc = sortSrc;
-    }
-
-    @Override
-    public IAEItemStack getReferenceItem(int idx) {
-        idx += this.src.getCurrentScroll() * this.rowSize;
-
-        if (idx >= this.view.size()) {
-            return null;
-        }
-        return this.view.get(idx);
-    }
-
-    @Override
-    public ItemStack getItem(int idx) {
-        idx += this.src.getCurrentScroll() * this.rowSize;
-
-        if (idx >= this.dsp.size()) {
-            return null;
-        }
-        return this.dsp.get(idx);
-    }
-
-    @Override
-    public void postUpdate(final IAEItemStack is) {
-        final IAEItemStack st = this.list.findPrecise(is);
-        if (st != null) {
-            st.reset();
-            st.add(is);
-        } else {
-            this.list.add(is);
-        }
-    }
-
-    @Override
-    public void setViewCell(final ItemStack[] list) {
-        this.myPartitionList = ItemViewCell.createFilter(list);
-        this.updateView();
-    }
-
-    @Override
-    public void updateView() {
-        this.view.clear();
-        this.dsp.clear();
-
-        this.view.ensureCapacity(this.list.size());
-        this.dsp.ensureCapacity(this.list.size());
-
-        final Enum<?> viewMode = this.sortSrc.getSortDisplay();
-        final Enum<?> searchMode = AEConfig.instance.settings.getSetting(Settings.SEARCH_MODE);
-        if (searchMode == SearchBoxMode.NEI_AUTOSEARCH || searchMode == SearchBoxMode.NEI_MANUAL_SEARCH) {
-            this.updateNEI(this.searchString);
-        }
-
-        String innerSearch = this.searchString;
-
-        boolean searchMod = false;
-        if (innerSearch.startsWith("@")) {
-            searchMod = true;
-            innerSearch = innerSearch.substring(1);
-        }
-
-        Pattern m;
-        try {
-            m = Pattern.compile(innerSearch.toLowerCase(), Pattern.CASE_INSENSITIVE);
-        } catch (final Throwable ignore) {
-            try {
-                m = Pattern.compile(Pattern.quote(innerSearch.toLowerCase()), Pattern.CASE_INSENSITIVE);
-            } catch (final Throwable __) {
-                return;
-            }
-        }
-
-        for (IAEItemStack is : this.list) {
-            if (this.myPartitionList != null) {
-                if (!this.myPartitionList.isListed(is)) {
-                    continue;
-                }
-            }
-
-            if (viewMode == ViewItems.CRAFTABLE && !is.isCraftable()) {
-                continue;
-            }
-
-            if (viewMode == ViewItems.CRAFTABLE) {
-                is = is.copy();
-                is.setStackSize(0);
-            }
-
-            if (viewMode == ViewItems.STORED && is.getStackSize() == 0) {
-                continue;
-            }
-
-            Fluid fluid = ItemFluidDrop.getAeFluidStack(is).getFluid();
-
-            if (FluidCraftAPI.instance().isBlacklistedInDisplay(fluid.getClass())) {
-                continue;
-            }
-
-            if (searchMod) {
-                if (m.matcher(Util.getFluidModID(fluid).toLowerCase()).find()
-                        || m.matcher(Util.getFluidModName(fluid).toLowerCase()).find()) {
-                    this.view.add(is);
-                }
-            } else {
-                if (m.matcher(fluid.getLocalizedName().toLowerCase()).find()) {
-                    this.view.add(is);
-                }
-            }
-        }
-
-        final Enum<?> SortBy = this.sortSrc.getSortBy();
-        final Enum<?> SortDir = this.sortSrc.getSortDir();
-
-        FluidSorters.setDirection((appeng.api.config.SortDir) SortDir);
-        FluidSorters.init();
-
-        if (SortBy == SortOrder.MOD) {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_MOD);
-        } else if (SortBy == SortOrder.AMOUNT) {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_SIZE);
-        } else if (SortBy == SortOrder.INVTWEAKS) {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_INV_TWEAKS);
-        } else {
-            this.view.sort(FluidSorters.CONFIG_BASED_SORT_BY_NAME);
-        }
-
-        for (final IAEItemStack is : this.view) {
-            this.dsp.add(is.getItemStack());
-        }
-    }
-
-    protected void updateNEI(final String filter) {
-        try {
-            if (this.NEIWord == null || !this.NEIWord.equals(filter)) {
-                final Class<?> c = ReflectionHelper
-                        .getClass(this.getClass().getClassLoader(), "codechicken.nei.LayoutManager");
-                final Field fldSearchField = c.getField("searchField");
-                final Object searchField = fldSearchField.get(c);
-
-                final Method a = searchField.getClass().getMethod("setText", String.class);
-                final Method b = searchField.getClass().getMethod("onTextChange", String.class);
-
-                this.NEIWord = filter;
-                a.invoke(searchField, filter);
-                b.invoke(searchField, "");
-            }
-        } catch (final Throwable ignore) {
-
-        }
-    }
-
-    @Override
-    public int size() {
-        return this.view.size();
-    }
-
-    @Override
-    public void clear() {
-        this.list.resetStatus();
-    }
-
-    @Override
-    public boolean hasPower() {
-        return this.hasPower;
-    }
-
-    @Override
-    public void setPowered(final boolean hasPower) {
-        this.hasPower = hasPower;
-    }
-
-    public int getRowSize() {
-        return this.rowSize;
-    }
-
-    public void setRowSize(final int rowSize) {
-        this.rowSize = rowSize;
-    }
-
-    public String getSearchString() {
-        return this.searchString;
-    }
-
-    public void setSearchString(@Nonnull final String searchString) {
-        this.searchString = searchString;
-    }
-}

src/main/java/com/glodblock/github/client/render/ItemCertusQuartzTankRender.java

@@ -17,6 +17,7 @@ import org.lwjgl.opengl.GL11;
 
 import com.glodblock.github.FluidCraft;
 import com.glodblock.github.client.render.tank.ModelCertusTank;
+import com.glodblock.github.common.item.ItemCertusQuartzTank;
 import com.glodblock.github.common.tile.TileCertusQuartzTank;
 import com.glodblock.github.loader.ItemAndBlockHolder;
 
@@ -33,7 +34,7 @@ public class ItemCertusQuartzTankRender implements IItemRenderer {
 
     @Override
     public boolean handleRenderType(ItemStack item, ItemRenderType type) {
-        return type != ItemRenderType.EQUIPPED_FIRST_PERSON;
+        return true;
     }
 
     @Override
@@ -47,28 +48,32 @@ public class ItemCertusQuartzTankRender implements IItemRenderer {
                 .bindTexture(FluidCraft.resource("textures/blocks/certus_quartz_tank/map.png"));
         GL11.glPushMatrix();
         GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
-        GL11.glEnable(GL11.GL_CULL_FACE);
+        GL11.glDisable(GL11.GL_CULL_FACE);
         GL11.glEnable(GL11.GL_LIGHTING);
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        GL11.glEnable(GL11.GL_ALPHA_TEST);
+        GL11.glDisable(GL11.GL_BLEND);
 
-        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
-        GL11.glScalef(1, -1, -1);
-        this.model.render(0.0625f);
-        GL11.glScalef(1, -1, 1);
-        this.model.render(0.0625f);
+        if (type == ItemRenderType.EQUIPPED || type == ItemRenderType.EQUIPPED_FIRST_PERSON) {
+            GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+        }
 
-        if (item != null && item.hasTagCompound()) {
-            FluidStack storedFluid = FluidStack
-                    .loadFluidStackFromNBT(item.getTagCompound().getCompoundTag("tileEntity"));
-            int tankCapacity = 32000;
+        GL11.glRotatef(180F, 1F, 0F, 0F);
+        this.model.render(0.0625f);
+        GL11.glRotatef(180F, 1F, 0F, 0F);
+
+        if (item.getItem() instanceof ItemCertusQuartzTank itemCertusQuartzTank) {
+            FluidStack storedFluid = itemCertusQuartzTank.getFluid(item);
+            int tankCapacity = itemCertusQuartzTank.getCapacity(item);
 
             if (storedFluid != null && storedFluid.getFluid() != null) {
                 IIcon fluidIcon = storedFluid.getFluid().getIcon();
                 if (fluidIcon == null) fluidIcon = FluidRegistry.LAVA.getIcon();
+
                 Tessellator tessellator = Tessellator.instance;
                 RenderBlocks renderer = new RenderBlocks();
-                GL11.glScalef(1, 1, -1);
+                Block waterBlock = FluidRegistry.WATER.getBlock();
+
+                Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);
                 renderer.setRenderBounds(
                         0.08F,
                         0.001F,
@@ -76,9 +81,12 @@ public class ItemCertusQuartzTankRender implements IItemRenderer {
                         0.92F,
                         (float) storedFluid.amount / (float) tankCapacity * 0.999F,
                         0.92F);
-                Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);
                 GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
-                Block waterBlock = FluidRegistry.WATER.getBlock();
+                GL11.glDisable(GL11.GL_LIGHTING);
+                GL11.glEnable(GL11.GL_CULL_FACE);
+                GL11.glEnable(GL11.GL_BLEND);
+                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
                 tessellator.startDrawingQuads();
                 tessellator.setColorRGBA_F(
                         (storedFluid.getFluid().getColor() >> 16 & 0xFF) / 255.0F,

src/main/java/com/glodblock/github/client/render/ItemPacketRender.java

@@ -13,9 +13,7 @@ import org.lwjgl.opengl.GL11;
 
 import com.glodblock.github.common.item.ItemFluidPacket;
 import com.glodblock.github.loader.ItemAndBlockHolder;
-import com.glodblock.github.util.ModAndClassUtil;
 import com.glodblock.github.util.RenderUtil;
-import com.mitchej123.hodgepodge.textures.IPatchedTextureAtlasSprite;
 
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
@@ -44,18 +42,17 @@ public class ItemPacketRender implements IItemRenderer {
         GL11.glEnable(GL11.GL_BLEND);
         GL11.glEnable(GL11.GL_ALPHA_TEST);
         GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        final boolean entity = type.equals(ItemRenderType.ENTITY);
+        if (entity) {
+            GL11.glPushMatrix();
+            GL11.glRotated(90.0D, 0.0D, 1.0D, 0.0D);
+            GL11.glTranslated(-0.5D, -0.6D, 0.0D);
+        }
 
         FluidStack fluid = ItemFluidPacket.getFluidStack(item);
-        int RGB = 0xFFFFFF;
-        if (fluid != null) {
-            RGB = fluid.getFluid().getColor(fluid);
-        }
+        int RGB = fluid == null ? 0xFFFFFF : fluid.getFluid().getColor(fluid);
         IIcon icon = fluid == null ? FluidRegistry.WATER.getStillIcon() : fluid.getFluid().getStillIcon();
 
-        if (ModAndClassUtil.HODGEPODGE && icon instanceof IPatchedTextureAtlasSprite) {
-            ((IPatchedTextureAtlasSprite) icon).markNeedsAnimationUpdate();
-        }
-
         if (RGB != 0xFFFFFF) {
             GL11.glColor3f((RGB >> 16 & 0xFF) / 255.0F, (RGB >> 8 & 0xFF) / 255.0F, (RGB & 0xFF) / 255.0F);
         }
@@ -74,6 +71,9 @@ public class ItemPacketRender implements IItemRenderer {
                     0.0625F);
         }
 
+        if (entity) {
+            GL11.glPopMatrix();
+        }
         GL11.glDisable(GL11.GL_BLEND);
         GL11.glDisable(GL11.GL_ALPHA_TEST);
     }

src/main/java/com/glodblock/github/client/render/ItemWalrusRender.java

@@ -1,17 +1,12 @@
 package com.glodblock.github.client.render;
 
-import net.minecraft.client.Minecraft;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.client.IItemRenderer;
 import net.minecraftforge.client.MinecraftForgeClient;
-import net.minecraftforge.client.model.AdvancedModelLoader;
-import net.minecraftforge.client.model.IModelCustom;
 
 import org.lwjgl.opengl.GL11;
 
-import com.glodblock.github.FluidCraft;
 import com.glodblock.github.common.tile.TileWalrus;
 import com.glodblock.github.loader.ItemAndBlockHolder;
 
@@ -19,9 +14,6 @@ import cpw.mods.fml.client.registry.ClientRegistry;
 
 public class ItemWalrusRender implements IItemRenderer {
 
-    IModelCustom modelWalrus = AdvancedModelLoader.loadModel(FluidCraft.resource("models/walrus.obj"));
-    ResourceLocation textureWalrus = FluidCraft.resource("textures/blocks/walrus.png");
-
     public ItemWalrusRender() {
         ClientRegistry.bindTileEntitySpecialRenderer(TileWalrus.class, new RenderBlockWalrus());
         MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(ItemAndBlockHolder.WALRUS), this);
@@ -34,7 +26,6 @@ public class ItemWalrusRender implements IItemRenderer {
 
     @Override
     public void renderItem(ItemRenderType type, ItemStack item, Object... data) {
-        Minecraft.getMinecraft().renderEngine.bindTexture(this.textureWalrus);
         GL11.glPushMatrix();
         switch (type) {
             case EQUIPPED_FIRST_PERSON -> {
@@ -44,7 +35,7 @@ public class ItemWalrusRender implements IItemRenderer {
             case INVENTORY -> GL11.glTranslatef(-0.5F, -0.5F, -0.1F);
             default -> {}
         }
-        this.modelWalrus.renderAll();
+        WalrusRenderer.render();
         GL11.glPopMatrix();
     }
 

src/main/java/com/glodblock/github/client/render/RenderBlockFluidBuffer.java

@@ -8,8 +8,6 @@ import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidRegistry;
 
-import org.lwjgl.opengl.GL11;
-
 import com.glodblock.github.common.block.BlockFluidBuffer;
 import com.glodblock.github.common.tile.TileFluidBuffer;
 
@@ -38,8 +36,6 @@ public class RenderBlockFluidBuffer extends BaseBlockRender<BlockFluidBuffer, Ti
         if (tileEntity != null && tileEntity.getFluidStack() != null) {
             Fluid storedFluid = tileEntity.getFluidStack().getFluid();
             if (storedFluid != null) {
-                GL11.glEnable(GL11.GL_BLEND);
-                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
                 Block id = Block.getBlockById(FluidRegistry.WATER.getID());
                 IIcon fluidIcon = storedFluid.getIcon();
                 if (fluidIcon == null) fluidIcon = FluidRegistry.LAVA.getIcon();
@@ -60,7 +56,6 @@ public class RenderBlockFluidBuffer extends BaseBlockRender<BlockFluidBuffer, Ti
                 renderer.renderFaceXNeg(id, x, y, z, fluidIcon);
                 tessellator.setNormal(1.0F, 0.0F, 0.0F);
                 renderer.renderFaceXPos(id, x, y, z, fluidIcon);
-                GL11.glDisable(GL11.GL_BLEND);
             }
         }
     }

src/main/java/com/glodblock/github/client/render/RenderBlockFluidInterface.java

@@ -9,6 +9,7 @@ import com.glodblock.github.client.textures.FCPartsTexture;
 import com.glodblock.github.common.block.BlockFluidInterface;
 import com.glodblock.github.common.tile.TileFluidInterface;
 
+import appeng.api.util.AEColor;
 import appeng.client.render.BaseBlockRender;
 import appeng.client.render.BlockRenderInfo;
 import appeng.tile.misc.TileInterface;
@@ -25,15 +26,18 @@ public class RenderBlockFluidInterface extends BaseBlockRender<BlockFluidInterfa
         final TileInterface ti = block.getTileEntity(world, x, y, z);
         final BlockRenderInfo info = block.getRendererInstance();
 
-        if (ti != null && ti.getForward() != ForgeDirection.UNKNOWN) {
-            final IIcon side = FCPartsTexture.BlockFluidInterfaceAlternate_Arrow.getIcon();
-            info.setTemporaryRenderIcons(
-                    FCPartsTexture.BlockInterfaceAlternate.getIcon(),
-                    block.getIcon(0, 0),
-                    side,
-                    side,
-                    side,
-                    side);
+        if (ti != null) {
+            final AEColor color = ti.getProxy().getColor();
+            if (ti.getForward() != ForgeDirection.UNKNOWN) {
+                final IIcon face = color == AEColor.Transparent ? block.getIcon(0, 0)
+                        : block.getColoredTexture(0, color);
+                final IIcon alternate = color == AEColor.Transparent ? FCPartsTexture.BlockInterfaceAlternate.getIcon()
+                        : block.getColoredTexture(1, color);
+                final IIcon side = color == AEColor.Transparent
+                        ? FCPartsTexture.BlockFluidInterfaceAlternate_Arrow.getIcon()
+                        : block.getColoredTexture(2, color);
+                info.setTemporaryRenderIcons(alternate, face, side, side, side, side);
+            }
         }
 
         final boolean fz = super.renderInWorld(block, world, x, y, z, renderer);

src/main/java/com/glodblock/github/client/render/RenderBlockWalrus.java

@@ -1,35 +1,39 @@
 package com.glodblock.github.client.render;
 
-import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
 import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.client.model.AdvancedModelLoader;
-import net.minecraftforge.client.model.IModelCustom;
 
 import org.lwjgl.opengl.GL11;
 
-import com.glodblock.github.FluidCraft;
+import com.glodblock.github.common.tile.TileWalrus;
 
 public class RenderBlockWalrus extends TileEntitySpecialRenderer {
 
-    IModelCustom modelWalrus = AdvancedModelLoader.loadModel(FluidCraft.resource("models/walrus.obj"));
-    ResourceLocation textureWalrus = FluidCraft.resource("textures/blocks/walrus.png");
-
     @Override
     public void renderTileEntityAt(TileEntity tileentity, double x, double y, double z, float partialTickTime) {
-        Minecraft.getMinecraft().renderEngine.bindTexture(this.textureWalrus);
+        if (!(tileentity instanceof TileWalrus Tile)) return;
+        float scale = Tile.getWalrusScale();
         GL11.glPushMatrix();
-        GL11.glTranslated(x + 0.5, y, z + 0.5);
-        int orientation = tileentity.getBlockMetadata();
-        if (orientation == 4) {
-            GL11.glRotatef(90, 0, 1, 0);
-        } else if (orientation == 5) {
-            GL11.glRotatef(-90, 0, 1, 0);
-        } else if (orientation == 3) {
-            GL11.glRotatef(180, 0, 1, 0);
+        int orientation = Tile.getBlockMetadata();
+        switch (orientation) {
+            case 2:
+                GL11.glTranslated(x + 0.5, y, z + 1 - scale * .655); // centering walrus model
+                break;
+            case 3:
+                GL11.glTranslated(x + 0.5, y, z + scale * .655);
+                GL11.glRotatef(180, 0, 1, 0);
+                break;
+            case 4:
+                GL11.glTranslated(x + 1 - scale * .655, y, z + 0.5);
+                GL11.glRotatef(90, 0, 1, 0);
+                break;
+            case 5:
+                GL11.glTranslated(x + scale * .655, y, z + 0.5);
+                GL11.glRotatef(-90, 0, 1, 0);
+                break;
         }
-        this.modelWalrus.renderAll();
+        GL11.glScalef(scale, scale, scale);
+        WalrusRenderer.render();
         GL11.glPopMatrix();
     }
 }