Fix acceleration of gendustry machines (#6)

add compacter classes to network filter

.editorconfig

@@ -0,0 +1,19 @@
+# This is the universal Text Editor Configuration
+# for all GTNewHorizons projects
+# See: https://editorconfig.org/
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{bat,ini}]
+end_of_line = crlf
+
+[*.{dtd,json,info,mcmeta,md,sh,svg,xml,xsd,xsl,yaml,yml}]
+indent_size = 2

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Ignore spotlessApply reformat
+071ca107572c7626deb5c378724e008b8b6a5be5

.gitattributes

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

.github/scripts/test_no_error_reports

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+# bashsupport disable=BP5006 # Global environment variables
+RUNDIR="run" \
+  CRASH="crash-reports" \
+  SERVERLOG="server.log"
+
+# enable nullglob to get 0 results when no match rather than the pattern
+shopt -s nullglob
+
+# store matches in array
+crash_reports=("$RUNDIR/$CRASH/crash"*.txt)
+
+# if array not empty there are crash_reports
+if [ "${#crash_reports[@]}" -gt 0 ]; then
+  # get the latest crash_report from array
+  latest_crash_report="${crash_reports[-1]}"
+  {
+    printf 'Latest crash report detected %s:\n' "${latest_crash_report##*/}"
+    cat "$latest_crash_report"
+  } >&2
+  exit 1
+fi
+
+if grep --quiet --fixed-strings 'Fatal errors were detected' "$SERVERLOG"; then
+  {
+    printf 'Fatal errors detected:\n'
+    cat server.log
+  } >&2
+  exit 1
+fi
+
+if grep --quiet --fixed-strings 'The state engine was in incorrect state ERRORED and forced into state SERVER_STOPPED' \
+  "$SERVERLOG"; then
+  {
+    printf 'Server force stopped:'
+    cat server.log
+  } >&2
+  exit 1
+fi
+
+if ! grep --quiet --perl-regexp --only-matching '.+Done \(.+\)\! For help, type "help" or "\?"' "$SERVERLOG"; then
+  {
+    printf 'Server did not finish startup:'
+    cat server.log
+  } >&2
+  exit 1
+fi
+
+printf 'No crash reports detected'
+exit 0

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

@@ -0,0 +1,13 @@
+
+name: Build and test
+
+on:
+  pull_request:
+    branches: [ master, main ]
+  push:
+    branches: [ master, main ]
+
+jobs:
+  build-and-test:
+    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/build-and-test.yml@master
+    secrets: inherit

.github/workflows/release-tags.yml

@@ -0,0 +1,14 @@
+
+name: Release tagged build
+
+on:
+  push:
+    tags: [ '*' ]
+
+permissions:
+  contents: write
+
+jobs:
+  release-tags:
+    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@master
+    secrets: inherit

.gitignore

@@ -1,10 +1,29 @@
-/bin
-/out
-/build
-/run
-/deps/run
-/eclipse
-/.gradle
-/*.iml
-/*.ipr
-/.idea
+.gradle
+.settings
+/.idea/
+/run/
+/build/
+/eclipse/
+.classpath
+.project
+/bin/
+/config/
+/crash-reports/
+/logs/
+options.txt
+/saves/
+usernamecache.json
+banned-ips.json
+banned-players.json
+eula.txt
+ops.json
+server.properties
+servers.dat
+usercache.json
+whitelist.json
+/out/
+*.iml
+*.ipr
+*.iws
+src/main/resources/mixins.*.json
+*.bat

CODEOWNERS

@@ -0,0 +1,3 @@
+# Any Github changes require admin approval
+/.github/** @GTNewHorizons/admin
+

build.gradle

@@ -1,125 +1,5 @@
-buildscript {
-    configurations.all {
-        resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
-    }
-    repositories {
-        mavenCentral()
-        maven {
-            name = "forge"
-            url = "http://files.minecraftforge.net/maven"
-        }
-        maven {
-            name = "sonatype"
-            url = "https://oss.sonatype.org/content/repositories/snapshots/"
-        }
-    }
-    dependencies {
-        classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT'
-    }
+//version: 1707058017
+
+plugins {
+    id 'com.gtnewhorizons.gtnhconvention'
 }
-
-apply plugin: 'scala'
-apply plugin: 'forge'
-
-file "build.properties" withReader {
-    def prop = new Properties()
-    prop.load(it)
-    ext.config = new ConfigSlurper().parse prop
-}
-
-if (project.hasProperty('forgeOverride')) {
-    config.forge.version = forgeOverride
-}
-
-if (project.hasProperty('buildnum')) {
-    ext.simpleVersion = "${config.bdlib.version}.${project.buildnum}"
-} else {
-    ext.simpleVersion = "${config.bdlib.version}-DEV"
-}
-
-version = simpleVersion + '-mc' + config.minecraft.version
-
-group = "net.bdew"
-archivesBaseName = "bdlib"
-
-minecraft {
-    version = "${config.minecraft.version}-${config.forge.version}"
-    replace("BDLIB_VER", simpleVersion.toString())
-}
-
-import org.apache.tools.ant.filters.ReplaceTokens
-
-
-sourceSets {
-    main {
-        scala {
-            srcDir 'src'
-        }
-        resources {
-            srcDir 'resources'
-        }
-        output.resourcesDir = output.classesDir // Hack for IDEA
-    }
-}
-
-processResources {
-    inputs.property "tokens", minecraft.replacements
-    from(sourceSets.main.resources.srcDirs) {
-        include 'mcmod.info'
-        filter(ReplaceTokens, tokens: minecraft.replacements)
-    }
-
-    from(sourceSets.main.resources.srcDirs) {
-        exclude 'mcmod.info'
-    }
-}
-
-task sourceJar(type: Jar) {
-    classifier "sources"
-}
-
-task deobfJar(type: Jar) {
-    from sourceSets.main.output
-    classifier "dev"
-    duplicatesStrategy "exclude"
-}
-
-afterEvaluate { project ->
-    // Fudge the inputs of source jars so we get the version after replacements
-    tasks.getByPath(":sourceJar").from(tasks.getByPath(":sourceMainScala").outputs.files)
-}
-
-artifacts {
-    archives sourceJar
-    archives deobfJar
-}
-
-apply plugin: 'maven-publish'
-
-publishing {
-    publications {
-        maven(MavenPublication) {
-            artifact deobfJar
-            artifact sourceJar
-        }
-    }
-    repositories {
-        maven {
-            url "file://var/www/maven"
-        }
-    }
-}
-
-apply plugin: 'curseforge'
-
-curse {
-    projectId = config.curseforge.id
-    apiKey = project.hasProperty("curseForgeApiKey") ? project.curseForgeApiKey : ""
-    releaseType = 'alpha'
-
-    artifact = jar
-    changelog = project.hasProperty("changelog") ? project.changelog : "No changelog available"
-
-    additionalArtifact deobfJar
-    additionalArtifact sourceJar
-}

build.properties

@@ -1,5 +0,0 @@
-bdlib.version=1.8.0
-curseforge.id=70496
-
-minecraft.version=1.7.10
-forge.version=10.13.2.1291

dependencies.gradle

@@ -0,0 +1,5 @@
+// Add your dependencies here
+
+dependencies {
+
+}

gradle.properties

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

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,7 @@
-#Wed Jul 02 15:54:47 CDT 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-bin.zip

gradlew

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

gradlew.bat

@@ -1,4 +1,22 @@
-@if "%DEBUG%" == "" @echo off
+@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  Gradle startup script for Windows
@@ -8,26 +26,30 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+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%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -35,54 +57,36 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windowz variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

jitpack.yml

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

repositories.gradle

@@ -0,0 +1,5 @@
+// Add any additional repositiroes for your dependencies here
+
+repositories {
+
+}

settings.gradle

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

src/main/resources/assets/bdlib/config/files.lst

@@ -0,0 +1 @@
+net-filter.cfg

src/main/resources/assets/bdlib/config/net-filter.cfg

@@ -0,0 +1,7 @@
+cfg messageWhitelist {
+    exact = =[
+    ]
+    prefix = =[
+    ]
+    enforce = yes
+}

src/main/resources/assets/bdlib/lang/en_US.lang

@@ -9,6 +9,10 @@ bdlib.multiblock.disabled=Disabled
 bdlib.multiblock.incomplete=This machine is incomplete, it requires at least:
 bdlib.multiblock.notconnected=Not connected to a valid machine
 bdlib.multiblock.toomanyoutputs=Too many outputs connected, unable to attach new connection
+bdlib.multiblock.tip.module=Can be installed in:
+bdlib.multiblock.tip.controller=Possible modules:
+bdlib.multiblock.tip.module.range= * %s (%s - %s)
+bdlib.multiblock.tip.module.max= * %s (up to %s)
 
 bdlib.rsmode.always=Always ON
 bdlib.rsmode.never=Disabled

src/main/resources/assets/bdlib/lang/fr_FR.lang

@@ -8,7 +8,11 @@ bdlib.multiblock.face.down=Dessous
 bdlib.multiblock.disabled=Désactivé
 bdlib.multiblock.incomplete=Cette machine est incomplète, elle exige au moins :
 bdlib.multiblock.notconnected=Pas connecté à une machine valide
-bdlib.multiblock.toomanyoutputs=Trop de soties connectées, Incapable d'ajouter une nouvelle connexion
+bdlib.multiblock.toomanyoutputs=Trop de sorties connectées, impossible d'ajouter une nouvelle connexion
+bdlib.multiblock.tip.module=Peut être installé dans :
+bdlib.multiblock.tip.controller=Modules possibles:
+bdlib.multiblock.tip.module.range= * %s (%s - %s)
+bdlib.multiblock.tip.module.max= * %s (plus de %s)
 
 bdlib.rsmode.always=Toujours actif
 bdlib.rsmode.never=Désactivé

src/main/resources/mcmod.info

@@ -1,9 +1,10 @@
 [
 {
-  "modid": "bdlib",
-  "name": "BD Lib",
+  "modid": "${modId}",
+  "name": "${modName}",
   "description": "",
-  "version": "@BDLIB_VER@",
+  "version": "${modVersion}",
+  "mcversion": "${minecraftVersion}",
   "url": "bdew.net/mods/",
   "updateUrl": "",
   "authorList": [

src/main/scala/net/bdew/lib/ApiReporter.scala

@@ -10,6 +10,7 @@
 package net.bdew.lib
 
 import java.util
+import java.util.Locale
 
 import cpw.mods.fml.common.{ICrashCallable, ModAPIManager, ModContainer}
 
@@ -20,8 +21,10 @@ object ApiReporter extends ICrashCallable {
     val mods = new util.ArrayList[ModContainer]
     val nameLookup = new util.HashMap[String, ModContainer]
     ModAPIManager.INSTANCE.injectAPIModContainers(mods, nameLookup)
-    (for (mod <- mods.sortBy(_.getModId.toLowerCase)) yield
-      "\t\t* %s (%s) from %s".format(mod.getModId, mod.getVersion,
+    (for (mod <- mods.sortBy(_.getModId.toLowerCase(Locale.US)))
+      yield "\t\t* %s (%s) from %s".format(
+        mod.getModId,
+        mod.getVersion,
         if (mod.getSource.isDirectory)
           mod.getSource
         else

src/main/scala/net/bdew/lib/BdLib.scala

@@ -10,22 +10,47 @@
 package net.bdew.lib
 
 import cpw.mods.fml.common.Mod.EventHandler
-import cpw.mods.fml.common.event.{FMLPreInitializationEvent, FMLServerStartingEvent, FMLServerStoppingEvent}
+import cpw.mods.fml.common.event.{
+  FMLPreInitializationEvent,
+  FMLServerStartingEvent,
+  FMLServerStoppingEvent
+}
 import cpw.mods.fml.common.{FMLCommonHandler, Mod}
-import net.bdew.lib.multiblock.network.NetHandler
+import net.bdew.lib.multiblock.data.MsgOutputCfgRSMode
+import net.bdew.lib.multiblock.network.{
+  MsgOutputCfg,
+  MsgOutputCfgSlot,
+  NetHandler
+}
+import net.bdew.lib.network.{
+  BaseMessage,
+  NetworkSecurityLoader,
+  SerializedMessageCodec
+}
+import net.bdew.lib.tooltip.TooltipHandler
 import net.minecraft.command.CommandHandler
 import org.apache.logging.log4j.Logger
 
-@Mod(modid = "bdlib", name = "BD lib", version = "BDLIB_VER", modLanguage = "scala")
+import java.io.File
+
+@Mod(
+  modid = "bdlib",
+  name = "BD lib",
+  version = "GRADLETOKEN_VERSION",
+  modLanguage = "scala"
+)
 object BdLib {
   var log: Logger = null
+  var configDir: File = null
 
   def logDebug(msg: String, args: Any*) = log.debug(msg.format(args: _*))
   def logInfo(msg: String, args: Any*) = log.info(msg.format(args: _*))
   def logWarn(msg: String, args: Any*) = log.warn(msg.format(args: _*))
   def logError(msg: String, args: Any*) = log.error(msg.format(args: _*))
-  def logWarnException(msg: String, t: Throwable, args: Any*) = log.warn(msg.format(args: _*), t)
-  def logErrorException(msg: String, t: Throwable, args: Any*) = log.error(msg.format(args: _*), t)
+  def logWarnException(msg: String, t: Throwable, args: Any*) =
+    log.warn(msg.format(args: _*), t)
+  def logErrorException(msg: String, t: Throwable, args: Any*) =
+    log.error(msg.format(args: _*), t)
 
   val onServerStarting = Event[FMLServerStartingEvent]
   val onServerStopping = Event[FMLServerStoppingEvent]
@@ -33,15 +58,25 @@ object BdLib {
   @EventHandler
   def preInit(ev: FMLPreInitializationEvent) {
     log = ev.getModLog
-    log.info("bdlib BDLIB_VER loaded")
+    log.info("bdlib GRADLETOKEN_VERSION loaded")
     log.debug("List of loaded APIs: " + ApiReporter.APIs)
     FMLCommonHandler.instance().registerCrashCallable(ApiReporter)
+    configDir = new File(ev.getModConfigurationDirectory, "bdlib")
+    SerializedMessageCodec.addValidClass(classOf[BaseMessage[_]])
+    SerializedMessageCodec.addValidClass(classOf[MsgOutputCfgRSMode])
+    SerializedMessageCodec.addValidClass(classOf[MsgOutputCfg])
+    SerializedMessageCodec.addValidClass(classOf[MsgOutputCfgSlot])
+    NetworkSecurityLoader.loadConfigFiles()
     NetHandler.init()
+    if (ev.getSide.isClient) {
+      TooltipHandler.init()
+    }
   }
 
   @EventHandler
   def serverStarting(event: FMLServerStartingEvent) {
-    val commandHandler = event.getServer.getCommandManager.asInstanceOf[CommandHandler]
+    val commandHandler =
+      event.getServer.getCommandManager.asInstanceOf[CommandHandler]
     commandHandler.registerCommand(CommandDumpRegistry)
     commandHandler.registerCommand(CommandOreDistribution)
     onServerStarting.trigger(event)

src/main/scala/net/bdew/lib/Client.scala

@@ -13,9 +13,8 @@ import net.minecraft.client.Minecraft
 import net.minecraft.client.renderer.texture.TextureMap
 import org.lwjgl.input.Keyboard
 
-/**
- * Misc functions and shortcuts for client-side code
- */
+/** Misc functions and shortcuts for client-side code
+  */
 object Client {
   def minecraft = Minecraft.getMinecraft
   def fontRenderer = Minecraft.getMinecraft.fontRenderer
@@ -24,8 +23,14 @@ object Client {
   def player = Minecraft.getMinecraft.thePlayer
   def textureManager = Minecraft.getMinecraft.getTextureManager
 
-  def blockMissingIcon = textureManager.getTexture(TextureMap.locationBlocksTexture).asInstanceOf[TextureMap].getAtlasSprite("missingno")
-  def itemMissingIcon = textureManager.getTexture(TextureMap.locationItemsTexture).asInstanceOf[TextureMap].getAtlasSprite("missingno")
+  def blockMissingIcon = textureManager
+    .getTexture(TextureMap.locationBlocksTexture)
+    .asInstanceOf[TextureMap]
+    .getAtlasSprite("missingno")
+  def itemMissingIcon = textureManager
+    .getTexture(TextureMap.locationItemsTexture)
+    .asInstanceOf[TextureMap]
+    .getAtlasSprite("missingno")
 
   def shiftDown: Boolean = {
     return Keyboard.isKeyDown(42) || Keyboard.isKeyDown(54)

src/main/scala/net/bdew/lib/CommandDumpRegistry.scala

@@ -25,24 +25,47 @@ object CommandDumpRegistry extends CommandBase {
   def getCommandUsage(c: ICommandSender) = "dumpregistry"
 
   def processCommand(sender: ICommandSender, params: Array[String]) {
-    val mcHome = FMLInjectionData.data()(6).asInstanceOf[File] //is there a better way to get this?
+    val mcHome =
+      FMLInjectionData
+        .data()(6)
+        .asInstanceOf[File] // is there a better way to get this?
     val dumpFile = new File(mcHome, "registry.dump")
     val dumpWriter = new BufferedWriter(new FileWriter(dumpFile))
     import scala.collection.JavaConversions._
     try {
       dumpWriter.write("==== BLOCKS ====\n")
-      dumpWriter.write(GameData.getBlockRegistry.map(GameData.getBlockRegistry.getNameForObject).toList.sorted.mkString("\n"))
+      dumpWriter.write(
+        GameData.getBlockRegistry
+          .map(GameData.getBlockRegistry.getNameForObject)
+          .toList
+          .sorted
+          .mkString("\n")
+      )
       dumpWriter.write("\n\n")
 
       dumpWriter.write("==== ITEMS ====\n")
-      dumpWriter.write(GameData.getItemRegistry.map(GameData.getItemRegistry.getNameForObject).toList.sorted.mkString("\n"))
+      dumpWriter.write(
+        GameData.getItemRegistry
+          .map(GameData.getItemRegistry.getNameForObject)
+          .toList
+          .sorted
+          .mkString("\n")
+      )
       dumpWriter.write("\n\n")
 
       dumpWriter.write("==== CUSTOM STACKS ====\n")
       val stacksField = classOf[GameData].getDeclaredField("customItemStacks")
       stacksField.setAccessible(true)
-      val stacksData = stacksField.get(null).asInstanceOf[Table[String, String, ItemStack]]
-      dumpWriter.write(stacksData.cellSet().map(x => x.getRowKey + ":" + x.getColumnKey).toList.sorted.mkString("\n"))
+      val stacksData =
+        stacksField.get(null).asInstanceOf[Table[String, String, ItemStack]]
+      dumpWriter.write(
+        stacksData
+          .cellSet()
+          .map(x => x.getRowKey + ":" + x.getColumnKey)
+          .toList
+          .sorted
+          .mkString("\n")
+      )
       dumpWriter.write("\n\n")
 
       dumpWriter.write("==== ORE DICT ====\n")
@@ -55,16 +78,26 @@ object CommandDumpRegistry extends CommandBase {
       dumpWriter.write("\n\n")
 
       dumpWriter.write("==== FLUIDS ====\n")
-      dumpWriter.write(FluidRegistry.getRegisteredFluids.map(_._1).toList.sorted.mkString("\n"))
+      dumpWriter.write(
+        FluidRegistry.getRegisteredFluids.map(_._1).toList.sorted.mkString("\n")
+      )
       dumpWriter.write("\n\n")
 
-      CommandBase.func_152373_a(sender, this, "Registry dumped to " + dumpFile.getCanonicalPath)
+      CommandBase.func_152373_a(
+        sender,
+        this,
+        "Registry dumped to " + dumpFile.getCanonicalPath
+      )
     } catch {
       case e: Throwable =>
-        CommandBase.func_152373_a(sender, this, "Failed to save registry dump: " + e)
+        CommandBase.func_152373_a(
+          sender,
+          this,
+          "Failed to save registry dump: " + e
+        )
         BdLib.logErrorException("Failed to save registry dump", e)
     } finally {
       dumpWriter.close()
     }
   }
-}
+}

src/main/scala/net/bdew/lib/CommandOreDistribution.scala

@@ -30,10 +30,12 @@ object CommandOreDistribution extends CommandBase {
     try {
       s.toInt
     } catch {
-      case e: NumberFormatException => throw new WrongUsageException("bdlib.oredistribution.usage")
+      case e: NumberFormatException =>
+        throw new WrongUsageException("bdlib.oredistribution.usage")
     }
 
-  def wrapColor(s: String, c: EnumChatFormatting) = c + s + EnumChatFormatting.RESET
+  def wrapColor(s: String, c: EnumChatFormatting) =
+    c + s + EnumChatFormatting.RESET
 
   def processCommand(sender: ICommandSender, baseParams: Array[String]) {
     val (flags, params) = baseParams.partition(_.startsWith("--"))
@@ -44,12 +46,13 @@ object CommandOreDistribution extends CommandBase {
     val (startX, startZ, world) =
       sender match {
         case p: EntityPlayerMP => (p.posX.toInt, p.posZ.toInt, p.worldObj)
-        case _ => (0, 0, sender.getEntityWorld)
+        case _                 => (0, 0, sender.getEntityWorld)
       }
 
     val radius = safeInt(params.head)
     val minY = if (params.length >= 2) safeInt(params(1)) else 0
-    val maxY = if (params.length >= 3) safeInt(params(2)) else world.getHeight - 1
+    val maxY =
+      if (params.length >= 3) safeInt(params(2)) else world.getHeight - 1
 
     if (minY < 0 || radius <= 0 || minY > maxY || maxY > world.getHeight - 1)
       throw new WrongUsageException(getCommandUsage(sender))
@@ -57,25 +60,41 @@ object CommandOreDistribution extends CommandBase {
     val toFile = flags.contains("--file")
 
     // why java, WHY?
-    CommandBase.func_152373_a(sender, this, "bdlib.oredistribution.start1",
-      Array[Integer](startX - radius, minY, startZ - radius, startX + radius, maxY, startZ + radius, world.provider.dimensionId): _*)
+    CommandBase.func_152373_a(
+      sender,
+      this,
+      "bdlib.oredistribution.start1",
+      Array[Integer](
+        startX - radius,
+        minY,
+        startZ - radius,
+        startX + radius,
+        maxY,
+        startZ + radius,
+        world.provider.dimensionId
+      ): _*
+    )
 
     CommandBase.func_152373_a(sender, this, "bdlib.oredistribution.start2")
 
     import scala.collection.JavaConversions._
 
-    val ores = (OreDictionary.getOreNames.filter(x => x.startsWith("ore") || x.startsWith("denseore")) flatMap { name =>
+    val ores = (OreDictionary.getOreNames.filter(x =>
+      x.startsWith("ore") || x.startsWith("denseore")
+    ) flatMap { name =>
       val fixedName =
         if (name.startsWith("ore"))
           name.substring(3)
         else if (name.startsWith("denseore"))
           "Dense " + name.substring(8)
         else name
-      for (s <- OreDictionary.getOres(name)) yield (s.getItem, s.getItemDamage) -> fixedName
+      for (s <- OreDictionary.getOres(name))
+        yield (s.getItem, s.getItemDamage) -> fixedName
     }).toMap
 
     val distribution = mutable.Map.empty[String, Int].withDefaultValue(0)
-    val kinds = mutable.Map.empty[String, Set[(Item, Int)]].withDefaultValue(Set.empty)
+    val kinds =
+      mutable.Map.empty[String, Set[(Item, Int)]].withDefaultValue(Set.empty)
 
     for {
       x <- startX - radius to startX + radius
@@ -83,33 +102,54 @@ object CommandOreDistribution extends CommandBase {
       z <- startZ - radius to startZ + radius
       if !world.isAirBlock(x, y, z)
     } {
-      val key = (Item.getItemFromBlock(world.getBlock(x, y, z)), world.getBlockMetadata(x, y, z))
+      val key = (
+        Item.getItemFromBlock(world.getBlock(x, y, z)),
+        world.getBlockMetadata(x, y, z)
+      )
       for (ore <- ores.get(key)) {
         distribution(ore) += 1
         kinds(ore) += key
       }
     }
 
-    val total = distribution.map(_._2).sum
+    val total = distribution.values.sum
     val warnings = kinds.filter(_._2.size > 1)
 
     if (toFile) {
       // === OUTPUT TO FILE ===
-      val mcHome = FMLInjectionData.data()(6).asInstanceOf[File] //is there a better way to get this?
+      val mcHome =
+        FMLInjectionData
+          .data()(6)
+          .asInstanceOf[File] // is there a better way to get this?
       val dumpFile = new File(mcHome, "ore_distribution.txt")
       val dumpWriter = new BufferedWriter(new FileWriter(dumpFile))
       try {
-        dumpWriter.write("Ore distribution report - (%d,%d,%d) to (%d,%d,%d) dim %d".format(
-          startX - radius, minY, startZ - radius, startX + radius, maxY, startZ + radius, world.provider.dimensionId
-        ))
+        dumpWriter.write(
+          "Ore distribution report - (%d,%d,%d) to (%d,%d,%d) dim %d".format(
+            startX - radius,
+            minY,
+            startZ - radius,
+            startX + radius,
+            maxY,
+            startZ + radius,
+            world.provider.dimensionId
+          )
+        )
         dumpWriter.newLine()
         dumpWriter.newLine()
-        if (warnings.size > 0) {
+        if (warnings.nonEmpty) {
           for ((id, types) <- warnings.toList.sortBy(_._1)) {
-            dumpWriter.write("Warning: %s has multiple variants generated:".format(id))
+            dumpWriter.write(
+              "Warning: %s has multiple variants generated:".format(id)
+            )
             dumpWriter.newLine()
             for ((item, dmg) <- types) {
-              dumpWriter.write(" - %s@%s".format(GameData.getItemRegistry.getNameForObject(item), dmg))
+              dumpWriter.write(
+                " - %s@%s".format(
+                  GameData.getItemRegistry.getNameForObject(item),
+                  dmg
+                )
+              )
               dumpWriter.newLine()
             }
             dumpWriter.newLine()
@@ -119,13 +159,29 @@ object CommandOreDistribution extends CommandBase {
           dumpWriter.newLine()
         }
         for ((id, num) <- distribution.filter(_._2 > 0).toList.sortBy(-_._2)) {
-          dumpWriter.write("%s - %s (%s%%)".format(id, DecFormat.round(num), DecFormat.short(100F * num / total)))
+          dumpWriter.write(
+            "%s - %s (%s%%)".format(
+              id,
+              DecFormat.round(num),
+              DecFormat.short(100f * num / total)
+            )
+          )
           dumpWriter.newLine()
         }
-        CommandBase.func_152373_a(sender, this, "bdlib.oredistribution.saved", dumpFile.getCanonicalPath)
+        CommandBase.func_152373_a(
+          sender,
+          this,
+          "bdlib.oredistribution.saved",
+          dumpFile.getCanonicalPath
+        )
       } catch {
         case e: Throwable =>
-          CommandBase.func_152373_a(sender, this, "bdlib.oredistribution.error", e.toString)
+          CommandBase.func_152373_a(
+            sender,
+            this,
+            "bdlib.oredistribution.error",
+            e.toString
+          )
           BdLib.logErrorException("Failed to save ore distribution dump", e)
       } finally {
         dumpWriter.close()
@@ -133,16 +189,32 @@ object CommandOreDistribution extends CommandBase {
     } else {
       // === OUTPUT TO CHAT ===
       for ((id, types) <- warnings.toList.sortBy(_._1)) {
-        CommandBase.func_152373_a(sender, this, "bdlib.oredistribution.warn",
-          wrapColor(" !", EnumChatFormatting.RED), wrapColor(id, EnumChatFormatting.RED))
+        CommandBase.func_152373_a(
+          sender,
+          this,
+          "bdlib.oredistribution.warn",
+          wrapColor(" !", EnumChatFormatting.RED),
+          wrapColor(id, EnumChatFormatting.RED)
+        )
         for ((item, dmg) <- types)
-          CommandBase.func_152373_a(sender, this, wrapColor(" - ", EnumChatFormatting.RED) + GameData.getItemRegistry.getNameForObject(item) + "@" + dmg)
+          CommandBase.func_152373_a(
+            sender,
+            this,
+            wrapColor(" - ", EnumChatFormatting.RED) + GameData.getItemRegistry
+              .getNameForObject(item) + "@" + dmg
+          )
       }
       for ((id, num) <- distribution.filter(_._2 > 0).toList.sortBy(-_._2)) {
-        CommandBase.func_152373_a(sender, this, "bdlib.oredistribution.entry",
-          " *", wrapColor(id, EnumChatFormatting.YELLOW),
-          DecFormat.round(num), DecFormat.short(100F * num / total))
+        CommandBase.func_152373_a(
+          sender,
+          this,
+          "bdlib.oredistribution.entry",
+          " *",
+          wrapColor(id, EnumChatFormatting.YELLOW),
+          DecFormat.round(num),
+          DecFormat.short(100f * num / total)
+        )
       }
     }
   }
-}
+}

src/main/scala/net/bdew/lib/DecFormat.scala

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) bdew, 2013 - 2014
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib
+
+import java.text.DecimalFormat
+
+object DecFormat {
+  val thousandsFmt = new DecimalFormat("#,##0")
+  val dec2Fmt = new DecimalFormat("#,##0.00")
+  val dec1Fmt = new DecimalFormat("#,##0.0")
+
+  def round(x: Double) = thousandsFmt.format(x).replace('\u00A0', ' ')
+  def round(x: Float) = thousandsFmt.format(x).replace('\u00A0', ' ')
+  def round(x: Int) = thousandsFmt.format(x).replace('\u00A0', ' ')
+
+  def dec2(x: Double) = dec2Fmt.format(x).replace('\u00A0', ' ')
+  def dec2(x: Float) = dec2Fmt.format(x).replace('\u00A0', ' ')
+  def dec2(x: Int) = dec2Fmt.format(x).replace('\u00A0', ' ')
+
+  def short(x: Double) = (if (x > 10) thousandsFmt.format(x)
+                          else if (x > 1) dec1Fmt.format(x)
+                          else dec2Fmt.format(x)).replace('\u00A0', ' ')
+  def short(x: Float) = (if (x > 10) thousandsFmt.format(x)
+                         else if (x > 1) dec1Fmt.format(x)
+                         else dec2Fmt.format(x)).replace('\u00A0', ' ')
+  def short(x: Int) = (if (x > 10) thousandsFmt.format(x)
+                       else if (x > 1) dec1Fmt.format(x)
+                       else dec2Fmt.format(x)).replace('\u00A0', ' ')
+}

src/main/scala/net/bdew/lib/Event.scala

@@ -12,7 +12,7 @@ package net.bdew.lib
 class EventBase[T] extends {
   var listeners = Seq.empty[T]
   def listen(x: T) = listeners :+= x
-  def hasListeners = listeners.size > 0
+  def hasListeners = listeners.nonEmpty
 }
 
 class Event0 extends EventBase[() => Unit] {
@@ -31,4 +31,4 @@ object Event {
   def apply() = new Event0
   def apply[T] = new Event1[T]
   def apply[T, R] = new Event2[T, R]
-}
+}

src/main/scala/net/bdew/lib/Misc.scala

@@ -10,6 +10,7 @@
 package net.bdew.lib
 
 import java.util
+import java.util.Locale
 
 import cpw.mods.fml.common.registry.GameRegistry
 import cpw.mods.fml.common.versioning.VersionParser
@@ -24,15 +25,18 @@ import net.minecraftforge.fluids.{Fluid, FluidStack}
 import net.minecraftforge.oredict.ShapedOreRecipe
 
 object Misc {
-  def getActiveModId = Loader.instance().activeModContainer().getModId
+  def getActiveModId = Option(
+    Loader.instance().activeModContainer().getModId
+  ) getOrElse "<UNKNOWN>"
 
   def toLocal(s: String) = StatCollector.translateToLocal(s)
-  def toLocalF(s: String, params: Any*) = StatCollector.translateToLocal(s).format(params: _*)
+  def toLocalF(s: String, params: Any*) =
+    StatCollector.translateToLocal(s).format(params: _*)
   def hasLocal(s: String) = StatCollector.canTranslate(s)
 
   def flattenRecipe(pattern: Seq[String], items: Map[Char, AnyRef]) =
-    pattern ++ items.flatMap {
-      case (k, v) => Seq(new Character(k), v)
+    pattern ++ items.flatMap { case (k, v) =>
+      Seq(new Character(k), v)
     }
 
   def wrapTag(n: String, f: (NBTTagCompound) => Any)(t: NBTTagCompound) {
@@ -41,23 +45,42 @@ object Misc {
     t.setTag(n, p)
   }
 
-  def addRecipe(result: ItemStack, pattern: Seq[String], items: Map[Char, AnyRef]) =
+  def addRecipe(
+      result: ItemStack,
+      pattern: Seq[String],
+      items: Map[Char, AnyRef]
+  ) =
     GameRegistry.addRecipe(result, flattenRecipe(pattern, items): _*)
 
-  def addRecipeOD(result: ItemStack, pattern: Seq[String], items: Map[Char, AnyRef]) =
-    GameRegistry.addRecipe(new ShapedOreRecipe(result, flattenRecipe(pattern, items): _*))
+  def addRecipeOD(
+      result: ItemStack,
+      pattern: Seq[String],
+      items: Map[Char, AnyRef]
+  ) =
+    GameRegistry.addRecipe(
+      new ShapedOreRecipe(result, flattenRecipe(pattern, items): _*)
+    )
 
   def min[T: Ordering](values: T*) = values.min
   def max[T: Ordering](values: T*) = values.max
 
-  def clamp[T](value: T, min: T, max: T)(implicit o: Ordering[T]): T = if (o.gt(value, max)) max else if (o.lt(value, min)) min else value
+  def clamp[T](value: T, min: T, max: T)(implicit o: Ordering[T]): T =
+    if (o.gt(value, max)) max else if (o.lt(value, min)) min else value
 
-  def iterSome[T](list: Seq[T], indexes: Iterable[Int]): Iterable[T] = for (i <- indexes) yield list(i)
-  def iterSomeEnum[T](list: Seq[T], indexes: Iterable[Int]): Iterable[(Int, T)] = for (i <- indexes) yield i -> list(i)
+  def iterSome[T](list: Seq[T], indexes: Iterable[Int]): Iterable[T] = for (
+    i <- indexes
+  ) yield list(i)
+  def iterSomeEnum[T](
+      list: Seq[T],
+      indexes: Iterable[Int]
+  ): Iterable[(Int, T)] = for (i <- indexes) yield i -> list(i)
 
-  def filterType[T](from: Iterable[_], cls: Class[T]) = from.filter(cls.isInstance).asInstanceOf[Iterable[T]]
+  def filterType[T](from: Iterable[_], cls: Class[T]) =
+    from.filter(cls.isInstance).asInstanceOf[Iterable[T]]
 
-  def getBiomeByName(name: String) = BiomeGenBase.getBiomeGenArray.find(x => x != null && x.biomeName == name).orNull
+  def getBiomeByName(name: String) = BiomeGenBase.getBiomeGenArray
+    .find(x => x != null && x.biomeName == name)
+    .orNull
 
   private lazy val modLookup = {
     val mods = new util.ArrayList[ModContainer]
@@ -72,7 +95,9 @@ object Misc {
 
   def haveModVersion(modId: String) = {
     val spec = VersionParser.parseVersionReference(modId)
-    modLookup.contains(spec.getLabel) && spec.containsVersion(modLookup(spec.getLabel).getProcessedVersion)
+    modLookup.contains(spec.getLabel) && spec.containsVersion(
+      modLookup(spec.getLabel).getProcessedVersion
+    )
   }
 
   def getModVersion(modId: String) =
@@ -94,9 +119,18 @@ object Misc {
   def asInstanceOpt[T](cls: Class[T])(v: Any) =
     if (cls.isInstance(v)) Some(v.asInstanceOf[T]) else None
 
-  def getNeighbourTile[T](origin: TileEntity, dir: ForgeDirection, cls: Class[T]) =
-    Option(origin.getWorldObj.getTileEntity(origin.xCoord + dir.offsetX,
-      origin.yCoord + dir.offsetY, origin.zCoord + dir.offsetZ)) flatMap (asInstanceOpt(_, cls))
+  def getNeighbourTile[T](
+      origin: TileEntity,
+      dir: ForgeDirection,
+      cls: Class[T]
+  ) =
+    Option(
+      origin.getWorldObj.getTileEntity(
+        origin.xCoord + dir.offsetX,
+        origin.yCoord + dir.offsetY,
+        origin.zCoord + dir.offsetZ
+      )
+    ) flatMap (asInstanceOpt(_, cls))
 
   @inline def applyMutator[T](f: (T) => Unit, init: T): T = {
     f(init)
@@ -131,14 +165,45 @@ object Misc {
       Client.blockMissingIcon
 
   def getFluidIcon(f: Fluid): IIcon =
-    if (f != null) getFluidIcon(new FluidStack(f, 1)) else Client.blockMissingIcon
+    if (f != null) getFluidIcon(new FluidStack(f, 1))
+    else Client.blockMissingIcon
 
   def getFluidColor(fs: FluidStack): Int =
-    if (fs != null && fs.getFluid != null) fs.getFluid.getColor(fs) else 0xFFFFFF
+    if (fs != null && fs.getFluid != null) fs.getFluid.getColor(fs)
+    else 0xffffff
 
   def getFluidColor(f: Fluid): Int =
-    if (f != null) getFluidColor(new FluidStack(f, 1)) else 0xFFFFFF
+    if (f != null) getFluidColor(new FluidStack(f, 1)) else 0xffffff
 
   lazy val lineSeparator = System.getProperty("line.separator")
-}
 
+  /** Provides something like java try-with-resources in scala
+    */
+  def withAutoClose[T <: AutoCloseable, R](o: T)(f: T => R): R = {
+    val res =
+      try {
+        f(o)
+      } catch {
+        case t1: Throwable =>
+          if (o != null) {
+            try {
+              o.close()
+            } catch {
+              case t2: Throwable =>
+                t1.addSuppressed(t2)
+            }
+          }
+          throw t1
+      }
+    if (o != null)
+      o.close()
+    res
+  }
+
+  def iconName(domain: String, name: String, path: String*) =
+    if (path.isEmpty)
+      "%s:%s".format(domain, name).toLowerCase(Locale.US)
+    else
+      "%s:%s/%s".format(domain, name, path.mkString("/")).toLowerCase(Locale.US)
+
+}

src/main/scala/net/bdew/lib/async/ServerTickExecutionContext.scala

@@ -40,8 +40,7 @@ object ServerTickExecutionContext extends ExecutionContext {
   override def reportFailure(cause: Throwable): Unit =
     BdLib.logErrorException("Error in execution context", cause)
 
-  @SubscribeEvent
-  def onTick(ev: ServerTickEvent): Unit = {
+  def doSingleLoop(): Unit = {
     for (r <- getNextBatch) {
       try {
         r.run()
@@ -50,4 +49,7 @@ object ServerTickExecutionContext extends ExecutionContext {
       }
     }
   }
+
+  @SubscribeEvent
+  def onTick(ev: ServerTickEvent): Unit = doSingleLoop()
 }

src/main/scala/net/bdew/lib/block/BlockFace.scala

@@ -18,5 +18,6 @@ case class BlockFace(x: Int, y: Int, z: Int, face: ForgeDirection) {
 }
 
 object BlockFace {
-  def apply(bp: BlockRef, face: ForgeDirection) = new BlockFace(bp.x, bp.y, bp.z, face)
+  def apply(bp: BlockRef, face: ForgeDirection) =
+    new BlockFace(bp.x, bp.y, bp.z, face)
 }

src/main/scala/net/bdew/lib/block/BlockRef.scala

@@ -18,16 +18,21 @@ import net.minecraftforge.common.util.ForgeDirection
 import scala.reflect.ClassTag
 
 case class BlockRef(x: Int, y: Int, z: Int) {
-  def isValid(w: IBlockAccess) = y >= 0 && y < 256 // hardcoded because getHeight is unavailable on servers :(
+  def isValid(w: IBlockAccess) =
+    y >= 0 && y < 256 // hardcoded because getHeight is unavailable on servers :(
 
-  def block(w: IBlockAccess) = if (isValid(w)) Option(w.getBlock(x, y, z)) else None
-  def tile(w: IBlockAccess) = if (isValid(w)) Option(w.getTileEntity(x, y, z)) else None
+  def block(w: IBlockAccess) =
+    if (isValid(w)) Option(w.getBlock(x, y, z)) else None
+  def tile(w: IBlockAccess) =
+    if (isValid(w)) Option(w.getTileEntity(x, y, z)) else None
   def meta(w: IBlockAccess) = if (isValid(w)) w.getBlockMetadata(x, y, z) else 0
 
   def blockIs(w: IBlockAccess, other: Block) = block(w).contains(other)
 
-  def neighbour(side: ForgeDirection) = BlockRef(x + side.offsetX, y + side.offsetY, z + side.offsetZ)
-  def neighbours = ForgeDirection.VALID_DIRECTIONS.map(x => x -> neighbour(x)).toMap
+  def neighbour(side: ForgeDirection) =
+    BlockRef(x + side.offsetX, y + side.offsetY, z + side.offsetZ)
+  def neighbours =
+    ForgeDirection.VALID_DIRECTIONS.map(x => x -> neighbour(x)).toMap
 
   override def toString = "(x=%d y=%d z=%d)".format(x, y, z)
 
@@ -58,4 +63,4 @@ object BlockRef {
   def fromTile(te: TileEntity) = BlockRef(te.xCoord, te.yCoord, te.zCoord)
   def fromNBT(tag: NBTTagCompound) =
     BlockRef(tag.getInteger("x"), tag.getInteger("y"), tag.getInteger("z"))
-}
+}

src/main/scala/net/bdew/lib/block/HasItemBlock.scala

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) bdew, 2013 - 2015
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.block
+
+import net.minecraft.block.Block
+import net.minecraft.item.ItemBlock
+
+/** If defined on a block - defines a custom ItemBlock class that will be used
+  * when registering Supported by BlockManager and Machine
+  */
+trait HasItemBlock extends Block {
+  def ItemBlockClass: Class[_ <: ItemBlock]
+}

src/main/scala/net/bdew/lib/block/HasTE.scala

@@ -17,14 +17,21 @@ import net.minecraft.world.{IBlockAccess, World}
 trait HasTE[T] extends Block with ITileEntityProvider {
   val TEClass: Class[_ <: TileEntity]
 
-  def createNewTileEntity(world: World, meta: Int): TileEntity = TEClass.newInstance()
+  def createNewTileEntity(world: World, meta: Int): TileEntity =
+    TEClass.newInstance()
 
   def getTE(w: IBlockAccess, ref: BlockRef): T = getTE(w, ref.x, ref.y, ref.z)
 
   def getTE(w: IBlockAccess, x: Int, y: Int, z: Int): T = {
     var t = w.getTileEntity(x, y, z)
     if ((t == null) || !TEClass.isInstance(t)) {
-      BdLib.logError("Tile entity for block %s at (%d,%d,%d) is corrupt or missing - recreating", this, x, y, z)
+      BdLib.logError(
+        "Tile entity for block %s at (%d,%d,%d) is corrupt or missing - recreating",
+        this,
+        x,
+        y,
+        z
+      )
       w match {
         case ww: World =>
           t = createNewTileEntity(ww, w.getBlockMetadata(x, y, z))

src/main/scala/net/bdew/lib/block/ItemBlockTooltip.scala

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) bdew, 2013 - 2015
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.block
+
+import java.util
+
+import net.minecraft.block.Block
+import net.minecraft.entity.player.EntityPlayer
+import net.minecraft.item.{ItemBlock, ItemStack}
+
+trait BlockTooltip extends Block with HasItemBlock {
+  override val ItemBlockClass: Class[_ <: ItemBlock] = classOf[ItemBlockTooltip]
+  def getTooltip(
+      stack: ItemStack,
+      player: EntityPlayer,
+      advanced: Boolean
+  ): List[String]
+}
+
+class ItemBlockTooltip(b: Block) extends ItemBlock(b) {
+  override def addInformation(
+      stack: ItemStack,
+      player: EntityPlayer,
+      list: util.List[_],
+      advanced: Boolean
+  ): Unit = {
+    import scala.collection.JavaConversions._
+    if (b.isInstanceOf[BlockTooltip])
+      list
+        .asInstanceOf[util.List[String]]
+        .addAll(
+          b.asInstanceOf[BlockTooltip].getTooltip(stack, player, advanced)
+        )
+  }
+}

src/main/scala/net/bdew/lib/block/KeepData.scala

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) bdew, 2013 - 2015
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.block
+
+import java.util
+
+import net.bdew.lib.nbt.NBT
+import net.bdew.lib.tile.TileExtended
+import net.minecraft.block.Block
+import net.minecraft.entity.player.EntityPlayer
+import net.minecraft.item.ItemStack
+import net.minecraft.nbt.NBTTagCompound
+import net.minecraft.util.MovingObjectPosition
+import net.minecraft.world.World
+
+/** Mixin for blocks to keep their data when broken Must have a TileEntity that
+  * extends TileKeepData
+  */
+trait BlockKeepData extends Block with HasItemBlock {
+  this: HasTE[_ <: TileKeepData] =>
+
+  override val ItemBlockClass: Class[_ <: ItemBlockKeepData] =
+    classOf[ItemBlockKeepData]
+
+  def getSavedBlock(world: World, x: Int, y: Int, z: Int, metadata: Int) = {
+    val stack = new ItemStack(
+      getItemDropped(metadata, world.rand, 0),
+      1,
+      damageDropped(metadata)
+    )
+    getTE(world, x, y, z).saveToItem(stack)
+    stack
+  }
+
+  override def getDrops(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      metadata: Int,
+      fortune: Int
+  ): util.ArrayList[ItemStack] = {
+    val drops = new util.ArrayList[ItemStack]()
+    drops.add(getSavedBlock(world, x, y, z, metadata))
+    drops
+  }
+
+  override def removedByPlayer(
+      world: World,
+      player: EntityPlayer,
+      x: Int,
+      y: Int,
+      z: Int,
+      willHarvest: Boolean
+  ): Boolean =
+    if (willHarvest)
+      true
+    else
+      super.removedByPlayer(world, player, x, y, z, willHarvest)
+
+  override def harvestBlock(
+      world: World,
+      player: EntityPlayer,
+      x: Int,
+      y: Int,
+      z: Int,
+      meta: Int
+  ): Unit = {
+    super.harvestBlock(world, player, x, y, z, meta)
+    world.setBlockToAir(x, y, z)
+  }
+
+  override def getPickBlock(
+      target: MovingObjectPosition,
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      player: EntityPlayer
+  ): ItemStack = {
+    getSavedBlock(world, x, y, z, world.getBlockMetadata(x, y, z))
+  }
+
+  /** Override for special actions on placing ItemStack might or might not
+    * contain actual data Called with the TE created and added to world, after
+    * onBlockPlacedBy & co
+    */
+  def restoreTileEntity(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      is: ItemStack,
+      player: EntityPlayer
+  ) = getTE(world, x, y, z).loadFromItem(is)
+}
+
+/** Mixin for tile entities to keep their data when broken Block class has to
+  * extend BlockKeepData
+  */
+trait TileKeepData extends TileExtended {
+
+  /** Override to modify data that will be stored in an item
+    * @param t
+    *   Automatically serialized data
+    * @return
+    *   Modified serialized data
+    */
+  def afterTileBreakSave(t: NBTTagCompound) = t
+
+  /** Override to modify data that will be load from an item After the tile
+    * entity is fully constructed and added to world
+    * @param t
+    *   Automatically serialized data
+    * @return
+    *   Modified serialized data
+    */
+  def beforeTileBreakLoad(t: NBTTagCompound) = t
+
+  final def saveToItem(is: ItemStack): Unit = {
+    if (!is.hasTagCompound) is.setTagCompound(new NBTTagCompound)
+    is.getTagCompound.setTag(
+      "data",
+      afterTileBreakSave(NBT.from(persistSave.trigger))
+    )
+  }
+
+  final def loadFromItem(is: ItemStack): Unit = {
+    if (is.hasTagCompound && is.getTagCompound.hasKey("data")) {
+      persistLoad.trigger(
+        beforeTileBreakLoad(is.getTagCompound.getCompoundTag("data"))
+      )
+    }
+  }
+}
+
+/** Custom ItemBlock that handles loading data to the Tile Entity
+  */
+class ItemBlockKeepData(b: Block) extends ItemBlockTooltip(b) {
+  override def placeBlockAt(
+      stack: ItemStack,
+      player: EntityPlayer,
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      side: Int,
+      hitX: Float,
+      hitY: Float,
+      hitZ: Float,
+      metadata: Int
+  ): Boolean = {
+    if (
+      super.placeBlockAt(
+        stack,
+        player,
+        world,
+        x,
+        y,
+        z,
+        side,
+        hitX,
+        hitY,
+        hitZ,
+        metadata
+      )
+    ) {
+      if (!world.isRemote && b.isInstanceOf[BlockKeepData])
+        b.asInstanceOf[BlockKeepData]
+          .restoreTileEntity(world, x, y, z, stack, player)
+      true
+    } else false
+  }
+}

src/main/scala/net/bdew/lib/block/SimpleBlock.scala

@@ -15,16 +15,20 @@ import net.minecraft.block.Block
 import net.minecraft.block.material.Material
 import net.minecraft.client.renderer.texture.IIconRegister
 
+import scala.language.implicitConversions
+
 trait NamedBlock extends Block {
   def name: String
 }
 
-class SimpleBlock(val name: String, material: Material) extends Block(material) with NamedBlock {
+class SimpleBlock(val name: String, material: Material)
+    extends Block(material)
+    with NamedBlock {
   val modId = Misc.getActiveModId
   setBlockName(modId + "." + name)
 
   @SideOnly(Side.CLIENT)
   override def registerBlockIcons(reg: IIconRegister) {
-    blockIcon = reg.registerIcon(modId + ":" + name.toLowerCase)
+    blockIcon = reg.registerIcon(Misc.iconName(modId, name))
   }
 }

src/main/scala/net/bdew/lib/config/BlockManager.scala

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) bdew, 2013 - 2014
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.config
+
+import cpw.mods.fml.common.ObfuscationReflectionHelper
+import cpw.mods.fml.common.registry.GameRegistry
+import net.bdew.lib.Misc
+import net.bdew.lib.block.{HasItemBlock, HasTE, NamedBlock}
+import net.minecraft.block.Block
+import net.minecraft.creativetab.CreativeTabs
+import net.minecraft.item.{ItemBlock, ItemStack}
+import net.minecraft.tileentity.TileEntity
+
+class BlockManager(creativeTab: CreativeTabs) {
+  def regBlock[T <: NamedBlock](block: T): T = regBlock(block, block.name)
+
+  def regSpecial[T <: NamedBlock](
+      block: T,
+      addStack: Boolean = false,
+      skipTileEntityReg: Boolean = false
+  ): T =
+    regBlock(block, block.name, addStack, skipTileEntityReg)
+
+  def regBlock[T <: Block](
+      block: T,
+      name: String,
+      addStack: Boolean = false,
+      skipTileEntityReg: Boolean = false
+  ): T = {
+    val itemClass: Class[_ <: ItemBlock] =
+      if (block.isInstanceOf[HasItemBlock])
+        block.asInstanceOf[HasItemBlock].ItemBlockClass
+      else
+        classOf[ItemBlock]
+
+    GameRegistry.registerBlock(block, itemClass, name)
+
+    block.setCreativeTab(creativeTab)
+
+    if (addStack)
+      GameRegistry.registerCustomItemStack(name, new ItemStack(block))
+
+    if (block.isInstanceOf[HasTE[_]] && !skipTileEntityReg)
+      GameRegistry.registerTileEntity(
+        block.asInstanceOf[HasTE[_]].TEClass,
+        "%s.%s".format(Misc.getActiveModId, name)
+      )
+
+    return block
+  }
+
+  /** Registers a legacy TE name->class mapping. Stolen from
+    * GameRegistry.registerTileEntityWithAlternatives
+    */
+  def registerLegacyTileEntity(
+      name: String,
+      cls: Class[_ <: TileEntity]
+  ): Unit = {
+    val teMappings: java.util.Map[String, Class[_]] =
+      ObfuscationReflectionHelper.getPrivateValue(
+        classOf[TileEntity],
+        null,
+        "field_" + "145855_i",
+        "nameToClassMap"
+      )
+    if (!teMappings.containsKey(name))
+      teMappings.put(name, cls)
+  }
+
+  def load() {}
+}

src/main/scala/net/bdew/lib/config/ItemManager.scala

@@ -15,11 +15,16 @@ import net.minecraft.creativetab.CreativeTabs
 import net.minecraft.item.{Item, ItemStack}
 
 class ItemManager(creativeTab: CreativeTabs) {
-  def regSimpleItem(name: String): SimpleItem = regItem(new SimpleItem(name), name)
+  def regSimpleItem(name: String): SimpleItem =
+    regItem(new SimpleItem(name), name)
 
   def regItem[T <: NamedItem](item: T): T = regItem[T](item, item.name)
 
-  def regItem[T <: Item](item: T, name: String, addStack: Boolean = false): T = {
+  def regItem[T <: Item](
+      item: T,
+      name: String,
+      addStack: Boolean = false
+  ): T = {
     GameRegistry.registerItem(item, name)
     item.setCreativeTab(creativeTab)
     if (addStack)

src/main/scala/net/bdew/lib/config/MachineManager.scala

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) bdew, 2013 - 2014
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.config
+
+import net.bdew.lib.Misc
+import net.bdew.lib.gui.{GuiHandler, GuiProvider}
+import net.bdew.lib.machine.Machine
+import net.bdew.lib.multiblock.MachineCore
+import net.bdew.lib.multiblock.block.BlockModule
+import net.bdew.lib.recipes.gencfg.ConfigSection
+import net.minecraft.creativetab.CreativeTabs
+
+class MachineManager(
+    val tuning: ConfigSection,
+    guiHandler: GuiHandler,
+    creativeTab: CreativeTabs
+) {
+  def registerMachine[R <: Machine[_]](machine: R): R = {
+    machine.tuning = tuning.getSection(machine.name)
+    if (machine.tuning.getBoolean("Enabled")) {
+      machine.enabled = true
+      machine.regBlock(creativeTab)
+      if (machine.isInstanceOf[GuiProvider])
+        guiHandler.register(machine.asInstanceOf[GuiProvider])
+    }
+    return machine
+  }
+
+  def load() {}
+}
+
+trait MachineManagerMultiblock extends MachineManager {
+  var controllers = Set.empty[MachineCore]
+
+  override def registerMachine[R <: Machine[_]](machine: R): R = {
+    super.registerMachine(machine)
+    if (machine.enabled) {
+      Misc.asInstanceOpt(machine, classOf[MachineCore]) foreach {
+        controllerMachine =>
+          controllers += controllerMachine
+          controllerMachine.getController.machine = controllerMachine
+      }
+    }
+    machine
+  }
+
+  def getMachinesForBlock(b: BlockModule[_]): Map[MachineCore, (Int, Int)] = {
+    (for (machine <- controllers; max <- machine.modules.get(b.kind)) yield {
+      machine -> (machine.required.getOrElse(b.kind, 0), max)
+    }).toMap
+  }
+}

src/main/scala/net/bdew/lib/covers/BlockCoverable.scala

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) bdew, 2013 - 2014
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.covers
+
+import cpw.mods.fml.relauncher.{Side, SideOnly}
+import net.bdew.lib.Misc
+import net.bdew.lib.block.{BlockRef, HasTE}
+import net.bdew.lib.items.ItemUtils
+import net.minecraft.block.Block
+import net.minecraft.entity.player.{EntityPlayer, EntityPlayerMP}
+import net.minecraft.item.ItemStack
+import net.minecraft.util.IIcon
+import net.minecraft.world.{IBlockAccess, World}
+import net.minecraftforge.common.util.ForgeDirection
+
+trait BlockCoverable[T <: TileCoverable] extends HasTE[T] {
+  @SideOnly(Side.CLIENT)
+  override def getRenderType = CoverRenderer.id
+
+  private def getCoverItem(
+      w: IBlockAccess,
+      x: Int,
+      y: Int,
+      z: Int,
+      side: ForgeDirection
+  ): Option[(ItemCover, ItemStack, TileCoverable)] = {
+    val te = getTE(w, x, y, z)
+    for {
+      coverStack <- Option(te.covers(side).value)
+      coverItemMaybe <- Option(coverStack.getItem)
+      coverItem <- Misc.asInstanceOpt(coverItemMaybe, classOf[ItemCover])
+    } yield (coverItem, coverStack, te)
+  }
+
+  override def onBlockActivated(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      player: EntityPlayer,
+      face: Int,
+      xOffs: Float,
+      yOffs: Float,
+      zOffs: Float
+  ): Boolean = {
+    val te = getTE(world, x, y, z)
+    val side = Misc.forgeDirection(face)
+
+    // Shift+RightClick with empty hand should remove cover
+    if (player.getCurrentEquippedItem == null && player.isSneaking) {
+      for {
+        cover <- Option(te.covers(side).value)
+        coverItem <- Misc.asInstanceOpt(cover.getItem, classOf[ItemCover])
+      } {
+        if (!world.isRemote) {
+          te.covers(side) := null
+          te.onCoversChanged()
+          coverChanged(world, x, y, z, side)
+          ItemUtils.dropItemToPlayer(world, player, coverItem.onRemove(cover))
+        }
+        return true
+      }
+    }
+
+    // If held item is cover - try to install it
+    for {
+      activeStack <- Option(player.getCurrentEquippedItem)
+      activeItem <- Option(activeStack.getItem)
+      coverItem <- Misc.asInstanceOpt(activeItem, classOf[ItemCover])
+      if te.isValidCover(side, activeStack) && coverItem.isValidTile(
+        te,
+        activeStack
+      )
+    } {
+      if (!world.isRemote && player.isInstanceOf[EntityPlayerMP]) {
+        for {
+          oldCover <- Option(te.covers(side).value)
+          oldItem <- Misc.asInstanceOpt(oldCover.getItem, classOf[ItemCover])
+        } {
+          ItemUtils.throwItemAt(
+            world,
+            te.xCoord + side.offsetX,
+            te.yCoord + side.offsetY,
+            te.zCoord + side.offsetZ,
+            oldItem.onRemove(oldCover)
+          )
+        }
+
+        te.covers(side) := coverItem.onInstall(
+          te,
+          side,
+          activeStack.splitStack(1),
+          player.asInstanceOf[EntityPlayerMP]
+        )
+
+        if (activeStack.stackSize <= 0)
+          player.inventory.setInventorySlotContents(
+            player.inventory.currentItem,
+            null
+          )
+
+        te.onCoversChanged()
+        coverChanged(world, x, y, z, side)
+      }
+      return true
+    }
+
+    // If has cover - let it handle the click
+    for ((item, stack, te) <- getCoverItem(world, x, y, z, side)) {
+      if (item.clickCover(te, side, stack, player)) return true
+    }
+
+    super.onBlockActivated(world, x, y, z, player, face, xOffs, yOffs, zOffs)
+  }
+
+  override def canProvidePower = true
+
+  override def isProvidingWeakPower(
+      w: IBlockAccess,
+      x: Int,
+      y: Int,
+      z: Int,
+      side: Int
+  ): Int = {
+    val direction = Misc.forgeDirection(side).getOpposite
+    for ((item, stack, te) <- getCoverItem(w, x, y, z, direction)) {
+      if (item.isEmittingSignal(te, direction, stack)) return 15
+    }
+    0
+  }
+
+  def coverChanged(
+      w: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      side: ForgeDirection
+  ): Unit = {
+    val pos = BlockRef(x, y, z).neighbour(side)
+    w.notifyBlockOfNeighborChange(pos.x, pos.y, pos.z, pos.block(w).orNull)
+  }
+
+  def getCoverIcon(
+      w: IBlockAccess,
+      x: Int,
+      y: Int,
+      z: Int,
+      side: ForgeDirection
+  ): Option[IIcon] =
+    for ((item, stack, te) <- getCoverItem(w, x, y, z, side))
+      yield item.getCoverIcon(te, side, stack)
+
+  override def breakBlock(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      block: Block,
+      meta: Int
+  ) {
+    if (!world.isRemote) {
+      val te = getTE(world, x, y, z)
+      for {
+        (dir, covOpt) <- te.covers
+        cover <- Option(covOpt.value)
+        item <- Misc.asInstanceOpt(cover.getItem, classOf[ItemCover])
+      } {
+        te.covers(dir) := null
+        ItemUtils.throwItemAt(world, x, y, z, item.onRemove(cover))
+        coverChanged(world, x, y, z, dir)
+      }
+    }
+    super.breakBlock(world, x, y, z, block, meta)
+  }
+}

src/main/scala/net/bdew/lib/covers/CoverRenderer.scala

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) bdew, 2013 - 2014
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.covers
+
+import net.bdew.lib.Misc
+import net.bdew.lib.render.connected.ConnectedHelper
+import net.bdew.lib.render.{BaseBlockRenderHandler, RenderUtils}
+import net.minecraft.block.Block
+import net.minecraft.client.renderer.RenderBlocks
+import net.minecraft.world.IBlockAccess
+import net.minecraftforge.common.util.ForgeDirection
+
+object CoverRenderer extends BaseBlockRenderHandler {
+  override def renderInventoryBlock(
+      block: Block,
+      metadata: Int,
+      modelId: Int,
+      renderer: RenderBlocks
+  ) =
+    RenderUtils.renderSimpleBlockItem(block, metadata, renderer)
+
+  override def renderWorldBlock(
+      world: IBlockAccess,
+      x: Int,
+      y: Int,
+      z: Int,
+      block: Block,
+      modelId: Int,
+      renderer: RenderBlocks
+  ) = {
+    renderer.renderStandardBlock(block, x, y, z)
+    if (!renderer.hasOverrideBlockTexture)
+      for {
+        blockCov <- Misc.asInstanceOpt(block, classOf[BlockCoverable[_]])
+        face <- ForgeDirection.VALID_DIRECTIONS
+        icon <- blockCov.getCoverIcon(world, x, y, z, face)
+        if block.shouldSideBeRendered(
+          world,
+          x + face.offsetX,
+          y + face.offsetY,
+          z + face.offsetZ,
+          face.ordinal()
+        )
+      } ConnectedHelper
+        .draw(face, 8)
+        .doDraw(ConnectedHelper.Vec3F(x, y, z), icon)
+    true
+  }
+}

src/main/scala/net/bdew/lib/covers/ItemCover.scala

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) bdew, 2013 - 2015
+ * https://github.com/bdew/bdlib
+ *
+ * This mod is distributed under the terms of the Minecraft Mod Public
+ * License 1.0, or MMPL. Please check the contents of the license located in
+ * http://bdew.net/minecraft-mod-public-license/
+ */
+
+package net.bdew.lib.covers
+
+import net.minecraft.entity.player.{EntityPlayer, EntityPlayerMP}
+import net.minecraft.item.{Item, ItemStack}
+import net.minecraft.util.IIcon
+import net.minecraftforge.common.util.ForgeDirection
+
+trait ItemCover extends Item {
+
+  /** @return
+    *   true if tickCover should be called
+    */
+  def isCoverTicking: Boolean
+
+  /** @param te
+    *   Host TileEntity
+    * @param side
+    *   Side the cover is installed on
+    * @param cover
+    *   Cover ItemStack
+    * @return
+    *   Icon to render, MUST be on terrain sprite sheet (0), not item!
+    */
+  def getCoverIcon(
+      te: TileCoverable,
+      side: ForgeDirection,
+      cover: ItemStack
+  ): IIcon
+
+  /** Perform tick, called on server only
+    * @param te
+    *   Host TileEntity
+    * @param side
+    *   Side the cover is installed on
+    * @param cover
+    *   Cover ItemStack
+    */
+  def tickCover(
+      te: TileCoverable,
+      side: ForgeDirection,
+      cover: ItemStack
+  ): Unit = {}
+
+  /** Checks if this cover can be installed on a specific TE
+    * @param te
+    *   Potential host TileEntity
+    * @param cover
+    *   Cover ItemStack
+    * @return
+    *   true if can be installed
+    */
+  def isValidTile(te: TileCoverable, cover: ItemStack): Boolean
+
+  /** Handle click on covered side - called on both client and server
+    * @param te
+    *   Host TileEntity
+    * @param side
+    *   Side the cover is installed on
+    * @param cover
+    *   Cover ItemStack
+    * @param player
+    *   Player clicking the cover
+    * @return
+    *   true if click was handled by cover
+    */
+  def clickCover(
+      te: TileCoverable,
+      side: ForgeDirection,
+      cover: ItemStack,
+      player: EntityPlayer
+  ): Boolean = false
+
+  /** Check if cover is emitting RS signal
+    * @param te
+    *   Host TileEntity
+    * @param side
+    *   Side the cover is installed on
+    * @param cover
+    *   Cover ItemStack
+    * @return
+    *   true if cover is emitting RS signal
+    */
+  def isEmittingSignal(
+      te: TileCoverable,
+      side: ForgeDirection,
+      cover: ItemStack
+  ): Boolean = false
+
+  /** Called when cover is installed on a block - called only on server
+    * @param te
+    *   Host TileEntity
+    * @param side
+    *   Side the cover is installed on
+    * @param cover
+    *   Cover ItemStack - do not modify!
+    * @param player
+    *   Player entity doing the installation
+    * @return
+    *   cover ItemStack - copy if modified
+    */
+  def onInstall(
+      te: TileCoverable,
+      side: ForgeDirection,
+      cover: ItemStack,
+      player: EntityPlayerMP
+  ): ItemStack = cover
+
+  /** Called when cover is removed from block or block is destroyed - called
+    * only on server
+    * @param cover
+    *   Cover ItemStack - do not modify!
+    * @return
+    *   cover ItemStack - copy if modified
+    */
+  def onRemove(cover: ItemStack): ItemStack = cover
+}

src/main/scala/net/bdew/lib/covers/TileCoverable.scala

@@ -9,6 +9,8 @@
 
 package net.bdew.lib.covers
 
+import java.util.Locale
+
 import net.bdew.lib.Misc
 import net.bdew.lib.data.DataSlotItemStack
 import net.bdew.lib.data.base.{TileDataSlots, UpdateKind}
@@ -17,24 +19,26 @@ import net.minecraftforge.common.util.ForgeDirection
 
 trait TileCoverable extends TileDataSlots {
   val covers = (ForgeDirection.VALID_DIRECTIONS map { x =>
-    x -> DataSlotItemStack("cover_" + x.toString.toLowerCase, this).setUpdate(UpdateKind.SAVE, UpdateKind.WORLD, UpdateKind.RENDER)
+    x -> DataSlotItemStack("cover_" + x.toString.toLowerCase(Locale.US), this)
+      .setUpdate(UpdateKind.SAVE, UpdateKind.WORLD, UpdateKind.RENDER)
   }).toMap
 
-  /**
-   * Checks if a specific cover can be installed here
-   */
+  /** Checks if a specific cover can be installed here
+    */
   def isValidCover(side: ForgeDirection, cover: ItemStack): Boolean
 
-  /**
-   * Called when new covers are installed
-   */
+  /** Called when new covers are installed
+    */
   def onCoversChanged() {}
 
   def tickCovers() =
     for {
       (dir, coverSlot) <- covers
       coverStack <- Option(coverSlot.value)
-      coverItem <- Option(coverStack.getItem) flatMap (Misc.asInstanceOpt(_, classOf[ItemCover]))
+      coverItem <- Option(coverStack.getItem) flatMap (Misc.asInstanceOpt(
+        _,
+        classOf[ItemCover]
+      ))
     } {
       coverItem.tickCover(this, dir, coverStack)
     }

src/main/scala/net/bdew/lib/data/DataSlotBoolean.scala

@@ -12,8 +12,14 @@ package net.bdew.lib.data
 import net.bdew.lib.data.base.{DataSlotContainer, DataSlotVal, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 
-case class DataSlotBoolean(name: String, parent: DataSlotContainer, default: Boolean = false) extends DataSlotVal[Boolean] {
+case class DataSlotBoolean(
+    name: String,
+    parent: DataSlotContainer,
+    default: Boolean = false
+) extends DataSlotVal[Boolean] {
   var value = default
-  def save(t: NBTTagCompound, kind: UpdateKind.Value) = t.setBoolean(name, value)
-  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value = t.getBoolean(name)
+  def save(t: NBTTagCompound, kind: UpdateKind.Value) =
+    t.setBoolean(name, value)
+  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value =
+    t.getBoolean(name)
 }

src/main/scala/net/bdew/lib/data/DataSlotDirection.scala

@@ -13,8 +13,11 @@ import net.bdew.lib.data.base.{DataSlotContainer, DataSlotVal, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.util.ForgeDirection
 
-case class DataSlotDirection(name: String, parent: DataSlotContainer) extends DataSlotVal[ForgeDirection] {
+case class DataSlotDirection(name: String, parent: DataSlotContainer)
+    extends DataSlotVal[ForgeDirection] {
   var value = ForgeDirection.UP
-  def save(t: NBTTagCompound, kind: UpdateKind.Value) = t.setByte(name, value.ordinal().toByte)
-  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value = ForgeDirection.getOrientation(t.getByte(name))
+  def save(t: NBTTagCompound, kind: UpdateKind.Value) =
+    t.setByte(name, value.ordinal().toByte)
+  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value =
+    ForgeDirection.getOrientation(t.getByte(name))
 }

src/main/scala/net/bdew/lib/data/DataSlotDouble.scala

@@ -12,7 +12,12 @@ package net.bdew.lib.data
 import net.bdew.lib.data.base.{DataSlotContainer, DataSlotNumeric, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 
-case class DataSlotDouble(name: String, parent: DataSlotContainer, default: Double = 0) extends DataSlotNumeric[Double](default) {
+case class DataSlotDouble(
+    name: String,
+    parent: DataSlotContainer,
+    default: Double = 0
+) extends DataSlotNumeric[Double](default) {
   def save(t: NBTTagCompound, kind: UpdateKind.Value) = t.setDouble(name, value)
-  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value = t.getDouble(name)
+  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value =
+    t.getDouble(name)
 }

src/main/scala/net/bdew/lib/data/DataSlotFloat.scala

@@ -12,7 +12,11 @@ package net.bdew.lib.data
 import net.bdew.lib.data.base.{DataSlotContainer, DataSlotNumeric, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 
-case class DataSlotFloat(name: String, parent: DataSlotContainer, default: Float = 0) extends DataSlotNumeric[Float](default) {
+case class DataSlotFloat(
+    name: String,
+    parent: DataSlotContainer,
+    default: Float = 0
+) extends DataSlotNumeric[Float](default) {
   def save(t: NBTTagCompound, kind: UpdateKind.Value) = t.setFloat(name, value)
   def load(t: NBTTagCompound, kind: UpdateKind.Value) = value = t.getFloat(name)
 }

src/main/scala/net/bdew/lib/data/DataSlotFluidOption.scala

@@ -13,11 +13,12 @@ import net.bdew.lib.data.base.{DataSlotContainer, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.fluids.{Fluid, FluidRegistry}
 
-case class DataSlotFluidOption(name: String, parent: DataSlotContainer) extends DataSlotOption[Fluid] {
+case class DataSlotFluidOption(name: String, parent: DataSlotContainer)
+    extends DataSlotOption[Fluid] {
   setUpdate(UpdateKind.SAVE, UpdateKind.GUI)
 
   override def save(t: NBTTagCompound, kind: UpdateKind.Value) {
-    value map { x => t.setString(name, x.getName) }
+    value foreach { x => t.setString(name, x.getName) }
   }
 
   override def load(t: NBTTagCompound, kind: UpdateKind.Value): Unit = {

src/main/scala/net/bdew/lib/data/DataSlotGameProfile.scala

@@ -16,21 +16,29 @@ import net.bdew.lib.data.base.{DataSlotContainer, DataSlotVal, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 import org.apache.commons.lang3.StringUtils
 
-case class DataSlotGameProfile(name: String, parent: DataSlotContainer) extends DataSlotVal[GameProfile] {
+case class DataSlotGameProfile(name: String, parent: DataSlotContainer)
+    extends DataSlotVal[GameProfile] {
   override var value: GameProfile = null
 
   override def load(t: NBTTagCompound, kind: UpdateKind.Value) = {
     value = if (t.hasKey(name + "_uid") || t.hasKey(name + "_name")) {
-      val uId = if (t.hasKey(name + "_uid")) UUID.fromString(t.getString(name + "_uid")) else null
-      val uName = if (t.hasKey(name + "_name")) t.getString(name + "_name") else null
+      val uId =
+        if (t.hasKey(name + "_uid")) UUID.fromString(t.getString(name + "_uid"))
+        else null
+      val uName =
+        if (t.hasKey(name + "_name")) t.getString(name + "_name") else null
       new GameProfile(uId, uName)
     } else null
   }
 
   override def save(t: NBTTagCompound, kind: UpdateKind.Value) = {
     if (value != null) {
-      Option(value.getId) map (id => t.setString(name + "_uid", id.toString))
-      Option(value.getName) filterNot (name => StringUtils.isBlank(name)) map (name => t.setString(name + "_name", name))
+      Option(value.getId) foreach (id =>
+        t.setString(name + "_uid", id.toString)
+      )
+      Option(value.getName) filterNot (name =>
+        StringUtils.isBlank(name)
+      ) foreach (name => t.setString(name + "_name", name))
     }
   }
 }

src/main/scala/net/bdew/lib/data/DataSlotInt.scala

@@ -12,7 +12,13 @@ package net.bdew.lib.data
 import net.bdew.lib.data.base.{DataSlotContainer, DataSlotNumeric, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 
-case class DataSlotInt(name: String, parent: DataSlotContainer, default: Int = 0) extends DataSlotNumeric[Int](default) {
-  def save(t: NBTTagCompound, kind: UpdateKind.Value) = t.setInteger(name, value)
-  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value = t.getInteger(name)
+case class DataSlotInt(
+    name: String,
+    parent: DataSlotContainer,
+    default: Int = 0
+) extends DataSlotNumeric[Int](default) {
+  def save(t: NBTTagCompound, kind: UpdateKind.Value) =
+    t.setInteger(name, value)
+  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value =
+    t.getInteger(name)
 }

src/main/scala/net/bdew/lib/data/DataSlotInventory.scala

@@ -14,7 +14,9 @@ import net.bdew.lib.tile.inventory.BaseInventory
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.{NBTTagCompound, NBTTagList}
 
-case class DataSlotInventory(name: String, parent: DataSlotContainer, size: Int) extends DataSlot with BaseInventory {
+case class DataSlotInventory(name: String, parent: DataSlotContainer, size: Int)
+    extends DataSlot
+    with BaseInventory {
   setUpdate(UpdateKind.SAVE)
 
   override def getSizeInventory = size
@@ -42,5 +44,3 @@ case class DataSlotInventory(name: String, parent: DataSlotContainer, size: Int)
     t.setTag(name, itemList)
   }
 }
-
-

src/main/scala/net/bdew/lib/data/DataSlotItemStack.scala

@@ -13,7 +13,8 @@ import net.bdew.lib.data.base.{DataSlotContainer, DataSlotVal, UpdateKind}
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.NBTTagCompound
 
-case class DataSlotItemStack(name: String, parent: DataSlotContainer) extends DataSlotVal[ItemStack] {
+case class DataSlotItemStack(name: String, parent: DataSlotContainer)
+    extends DataSlotVal[ItemStack] {
   var value: ItemStack = null
 
   override def update(v: ItemStack) = {
@@ -28,5 +29,6 @@ case class DataSlotItemStack(name: String, parent: DataSlotContainer) extends Da
     if (value != null) value.writeToNBT(tag)
     t.setTag(name, tag)
   }
-  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value = ItemStack.loadItemStackFromNBT(t.getCompoundTag(name))
+  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value =
+    ItemStack.loadItemStackFromNBT(t.getCompoundTag(name))
 }

src/main/scala/net/bdew/lib/data/DataSlotMovingAverage.scala

@@ -9,14 +9,23 @@
 
 package net.bdew.lib.data
 
-import java.io.{ByteArrayInputStream, ByteArrayOutputStream, DataInputStream, DataOutputStream}
+import java.io.{
+  ByteArrayInputStream,
+  ByteArrayOutputStream,
+  DataInputStream,
+  DataOutputStream
+}
 
 import net.bdew.lib.data.base.{DataSlot, DataSlotContainer, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 
 import scala.collection.mutable
 
-case class DataSlotMovingAverage(name: String, parent: DataSlotContainer, size: Int) extends DataSlot {
+case class DataSlotMovingAverage(
+    name: String,
+    parent: DataSlotContainer,
+    size: Int
+) extends DataSlot {
   val values = mutable.Queue.empty[Double]
   var average: Double = 0
 
@@ -53,7 +62,9 @@ case class DataSlotMovingAverage(name: String, parent: DataSlotContainer, size:
     } else {
       values.clear()
       if (t.hasKey(name)) {
-        val i = new DataInputStream(new ByteArrayInputStream(t.getByteArray(name)))
+        val i = new DataInputStream(
+          new ByteArrayInputStream(t.getByteArray(name))
+        )
         val len = i.readByte()
         values ++= (for (x <- 0 until Math.min(len, size)) yield i.readDouble())
         i.close()

src/main/scala/net/bdew/lib/data/DataSlotString.scala

@@ -12,8 +12,14 @@ package net.bdew.lib.data
 import net.bdew.lib.data.base.{DataSlotContainer, DataSlotVal, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 
-case class DataSlotString(name: String, parent: DataSlotContainer, default: String = null) extends DataSlotVal[String] {
+case class DataSlotString(
+    name: String,
+    parent: DataSlotContainer,
+    default: String = null
+) extends DataSlotVal[String] {
   var value: String = default
-  def save(t: NBTTagCompound, kind: UpdateKind.Value) = if (value != null) t.setString(name, value)
-  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value = if (t.hasKey(name)) t.getString(name) else null
+  def save(t: NBTTagCompound, kind: UpdateKind.Value) =
+    if (value != null) t.setString(name, value)
+  def load(t: NBTTagCompound, kind: UpdateKind.Value) = value =
+    if (t.hasKey(name)) t.getString(name) else null
 }

src/main/scala/net/bdew/lib/data/DataSlotTank.scala

@@ -13,7 +13,10 @@ import net.bdew.lib.data.base.{DataSlot, DataSlotContainer, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.fluids._
 
-abstract class DataSlotTankBase(sz: Int) extends FluidTank(sz) with IFluidTank with DataSlot {
+abstract class DataSlotTankBase(sz: Int)
+    extends FluidTank(sz)
+    with IFluidTank
+    with DataSlot {
   var oldStack: FluidStack = null
 
   parent.onServerTick(checkUpdate)
@@ -51,12 +54,19 @@ abstract class DataSlotTankBase(sz: Int) extends FluidTank(sz) with IFluidTank w
       setCapacity(tag.getInteger("size"))
   }
 
-  override def setFluid(fluid: FluidStack) = execWithChangeNotify(super.setFluid(fluid))
-  override def setCapacity(capacity: Int) = execWithChangeNotify(super.setCapacity(capacity))
+  override def setFluid(fluid: FluidStack) = execWithChangeNotify(
+    super.setFluid(fluid)
+  )
+  override def setCapacity(capacity: Int) = execWithChangeNotify(
+    super.setCapacity(capacity)
+  )
 
   override def drain(maxDrain: Int, doDrain: Boolean) =
     if (doDrain)
-      execWithChangeNotifyConditional[FluidStack](super.drain(maxDrain, true), _ != null)
+      execWithChangeNotifyConditional[FluidStack](
+        super.drain(maxDrain, true),
+        _ != null
+      )
     else
       super.drain(maxDrain, false)
 
@@ -67,10 +77,17 @@ abstract class DataSlotTankBase(sz: Int) extends FluidTank(sz) with IFluidTank w
       super.fill(resource, false)
 }
 
-case class DataSlotTank(name: String, parent: DataSlotContainer, size: Int) extends DataSlotTankBase(size)
+case class DataSlotTank(name: String, parent: DataSlotContainer, size: Int)
+    extends DataSlotTankBase(size)
 
-case class DataSlotTankRestricted(name: String, parent: DataSlotContainer, var size: Int, filterFluid: Fluid) extends DataSlotTankBase(size) {
-  def fill(amount: Int, doFill: Boolean) = super.fill(new FluidStack(filterFluid, amount), doFill)
+case class DataSlotTankRestricted(
+    name: String,
+    parent: DataSlotContainer,
+    var size: Int,
+    filterFluid: Fluid
+) extends DataSlotTankBase(size) {
+  def fill(amount: Int, doFill: Boolean) =
+    super.fill(new FluidStack(filterFluid, amount), doFill)
 
   override def fill(resource: FluidStack, doFill: Boolean): Int = {
     if ((resource != null) && (resource.getFluid != filterFluid)) return 0

src/main/scala/net/bdew/lib/data/base/ContainerDataSlots.scala

@@ -21,14 +21,19 @@ trait ContainerDataSlots extends NoInvContainer {
     super.addCraftingToCrafters(crafter)
     if (crafter.isInstanceOf[EntityPlayerMP]) {
       val pkt = dataSource.getDataSlotPacket
-      crafter.asInstanceOf[EntityPlayerMP].playerNetServerHandler.sendPacket(pkt)
+      crafter
+        .asInstanceOf[EntityPlayerMP]
+        .playerNetServerHandler
+        .sendPacket(pkt)
     }
   }
 
   override def detectAndSendChanges() {
     super.detectAndSendChanges()
     // only send updates every 10 ticks
-    if (dataSource.lastChange >= lastSentChange + 10 || (dataSource.lastChange > lastSentChange && lastSentChange + 10 < dataSource.getWorldObj.getTotalWorldTime)) {
+    if (
+      dataSource.lastChange >= lastSentChange + 10 || (dataSource.lastChange > lastSentChange && lastSentChange + 10 < dataSource.getWorldObj.getTotalWorldTime)
+    ) {
       lastSentChange = dataSource.lastChange
       val pkt = dataSource.getDataSlotPacket
 

src/main/scala/net/bdew/lib/data/base/DataSlot.scala

@@ -11,20 +11,18 @@ package net.bdew.lib.data.base
 
 import net.minecraft.nbt.NBTTagCompound
 
-/**
- * Base trait for all data slots
- */
+/** Base trait for all data slots
+  */
 trait DataSlot {
-  /**
-   * Tile Entity that owns this slot
-   * Accessed in constructor, so should be in parameters or a lazy val, otherwise will crash
-   */
+
+  /** Tile Entity that owns this slot Accessed in constructor, so should be in
+    * parameters or a lazy val, otherwise will crash
+    */
   val parent: DataSlotContainer
 
-  /**
-   * Unique name
-   * Accessed in constructor, so should be in parameters or a lazy val, otherwise will crash
-   */
+  /** Unique name Accessed in constructor, so should be in parameters or a lazy
+    * val, otherwise will crash
+    */
   val name: String
 
   parent.dataSlots += (name -> this)
@@ -41,7 +39,10 @@ trait DataSlot {
     v
   }
 
-  def execWithChangeNotifyConditional[T](f: => T, condition: T => Boolean): T = {
+  def execWithChangeNotifyConditional[T](
+      f: => T,
+      condition: T => Boolean
+  ): T = {
     val v = f
     if (condition(v))
       parent.dataSlotChanged(this)

src/main/scala/net/bdew/lib/data/base/DataSlotContainer.scala

@@ -14,37 +14,32 @@ import net.minecraft.world.World
 
 import scala.collection.mutable
 
-/**
- * Base Trait for objects that can contain Data Slots, this allows implementing them on things that aren't TEs
- */
+/** Base Trait for objects that can contain Data Slots, this allows implementing
+  * them on things that aren't TEs
+  */
 trait DataSlotContainer {
 
   // Can't use getWorldObj - it fails to get remapped and stuff breaks in obfuscated environment
   def getWorldObject: World
 
-  /**
-   * Called when a dataslot value changes
-   */
+  /** Called when a dataslot value changes
+    */
   def dataSlotChanged(slot: DataSlot): Unit
 
-  /**
-   * Register a function to run on every server tick
-   */
+  /** Register a function to run on every server tick
+    */
   def onServerTick(f: () => Unit): Unit
 
-  /**
-   * List of dataslots in this container
-   */
+  /** List of dataslots in this container
+    */
   val dataSlots = mutable.HashMap.empty[String, DataSlot]
 
-  /**
-   * The value of getTotalWorldTime when the last change happened
-   */
+  /** The value of getTotalWorldTime when the last change happened
+    */
   var lastChange = 0L
 
-  /**
-   * The value of getTotalWorldTime when the last GUI packet was sent happened
-   */
+  /** The value of getTotalWorldTime when the last GUI packet was sent happened
+    */
   var lastGuiPacket = 0L
 
   final val TRACE = false
@@ -73,5 +68,3 @@ trait DataSlotContainer {
     }
   }
 }
-
-

src/main/scala/net/bdew/lib/data/base/DataSlotNumeric.scala

@@ -9,12 +9,12 @@
 
 package net.bdew.lib.data.base
 
-/**
- * Base class for data slots that hold numeric values
- * adds convenience operators to modify the value
- */
+/** Base class for data slots that hold numeric values adds convenience
+  * operators to modify the value
+  */
 
-abstract class DataSlotNumeric[T](default: T)(implicit n: Numeric[T]) extends DataSlotVal[T] {
+abstract class DataSlotNumeric[T](default: T)(implicit n: Numeric[T])
+    extends DataSlotVal[T] {
   var value = default
   def +=(that: T) = update(n.plus(value, that))
   def -=(that: T) = update(n.minus(value, that))

src/main/scala/net/bdew/lib/data/base/DataSlotOrdered.scala

@@ -9,11 +9,12 @@
 
 package net.bdew.lib.data.base
 
-/**
- * Base class for data slots that hold values with ordering operators, adds more convenience operators
- * TODO: Do i need this? normal operators can be used with the implicit conversion
- */
-abstract class DataSlotOrdered[T](implicit n: Ordering[T]) extends DataSlotVal[T] {
+/** Base class for data slots that hold values with ordering operators, adds
+  * more convenience operators TODO: Do i need this? normal operators can be
+  * used with the implicit conversion
+  */
+abstract class DataSlotOrdered[T](implicit n: Ordering[T])
+    extends DataSlotVal[T] {
   def :>(that: T) = n.compare(value, that) > 0
   def :<(that: T) = n.compare(value, that) < 0
   def :>=(that: T) = n.compare(value, that) >= 0

src/main/scala/net/bdew/lib/data/base/DataSlotVal.scala

@@ -11,10 +11,10 @@ package net.bdew.lib.data.base
 
 import scala.language.implicitConversions
 
-/**
- * Base trait for data slots that hold primitive values
- * Defines some convenience operators to access the value and an implicit conversion to the value
- */
+/** Base trait for data slots that hold primitive values Defines some
+  * convenience operators to access the value and an implicit conversion to the
+  * value
+  */
 
 trait DataSlotVal[T] extends DataSlot {
   var value: T
@@ -36,4 +36,4 @@ trait DataSlotVal[T] extends DataSlot {
 
 object DataSlotVal {
   implicit def slot2val[T](slot: DataSlotVal[T]): T = slot.value
-}
+}

src/main/scala/net/bdew/lib/data/base/TileDataSlots.scala

@@ -21,7 +21,14 @@ trait TileDataSlots extends TileExtended with DataSlotContainer {
   handleClientUpdate.listen { tag =>
     doLoad(UpdateKind.WORLD, tag)
     if (dataSlots.values.exists(_.updateKind.contains(UpdateKind.RENDER)))
-      getWorldObj.markBlockRangeForRenderUpdate(xCoord, yCoord, zCoord, xCoord, yCoord, zCoord)
+      getWorldObj.markBlockRangeForRenderUpdate(
+        xCoord,
+        yCoord,
+        zCoord,
+        xCoord,
+        yCoord,
+        zCoord
+      )
   }
 
   override def getWorldObject = getWorldObj
@@ -32,7 +39,7 @@ trait TileDataSlots extends TileExtended with DataSlotContainer {
     if (getWorldObj != null) {
       if (slot.updateKind.contains(UpdateKind.GUI))
         lastChange = getWorldObj.getTotalWorldTime
-      if (slot.updateKind.contains(UpdateKind.WORLD))
+      if (!getWorldObj.isRemote && slot.updateKind.contains(UpdateKind.WORLD))
         getWorldObj.markBlockForUpdate(xCoord, yCoord, zCoord)
       if (slot.updateKind.contains(UpdateKind.SAVE))
         getWorldObj.markTileEntityChunkModified(xCoord, yCoord, zCoord, this)

src/main/scala/net/bdew/lib/data/base/UpdateKind.scala

@@ -14,4 +14,4 @@ object UpdateKind extends Enumeration {
   val GUI = Value("GUI")
   val SAVE = Value("SAVE")
   val RENDER = Value("RENDER")
-}
+}

src/main/scala/net/bdew/lib/gui/BaseContainer.scala

@@ -15,20 +15,30 @@ import net.minecraft.inventory.IInventory
 import net.minecraft.item.ItemStack
 
 abstract class BaseContainer(te: IInventory) extends NoInvContainer {
-  override def transferStackInSlot(player: EntityPlayer, slot: Int): ItemStack = {
+  override def transferStackInSlot(
+      player: EntityPlayer,
+      slot: Int
+  ): ItemStack = {
     var stack = getSlot(slot).getStack
     if (getSlot(slot).inventory == player.inventory) {
-      stack = ItemUtils.addStackToSlots(stack, te, 0 until te.getSizeInventory, true)
+      stack =
+        ItemUtils.addStackToSlots(stack, te, 0 until te.getSizeInventory, true)
     } else {
-      stack = ItemUtils.addStackToSlots(stack, player.inventory, 9 until player.inventory.mainInventory.length, true)
+      stack = ItemUtils.addStackToSlots(
+        stack,
+        player.inventory,
+        9 until player.inventory.mainInventory.length,
+        true
+      )
       // Only put in hotbar if the rest is full
       if (stack != null)
-        stack = ItemUtils.addStackToSlots(stack, player.inventory, 0 until 9, true)
+        stack =
+          ItemUtils.addStackToSlots(stack, player.inventory, 0 until 9, true)
     }
     getSlot(slot).putStack(stack)
     return null
   }
 
-  override def canInteractWith(player: EntityPlayer) = te.isUseableByPlayer(player)
+  override def canInteractWith(player: EntityPlayer) =
+    te.isUseableByPlayer(player)
 }
-

src/main/scala/net/bdew/lib/gui/BaseRect.scala

@@ -16,7 +16,8 @@ case class BaseRect[T: Numeric](x: T, y: T, w: T, h: T) {
 
   def this(p: BasePoint[T], w: T, h: T) = this(p.x, p.y, w, h)
 
-  def contains(p: BasePoint[T]) = n.gteq(p.x, x) && n.gteq(p.y, y) && n.lt(p.x, x2) && n.lt(p.y, y2)
+  def contains(p: BasePoint[T]) =
+    n.gteq(p.x, x) && n.gteq(p.y, y) && n.lt(p.x, x2) && n.lt(p.y, y2)
 
   def origin = BasePoint(x, y)
 

src/main/scala/net/bdew/lib/gui/BaseScreen.scala

@@ -16,7 +16,8 @@ import org.lwjgl.opengl.GL11
 
 import scala.collection.mutable
 
-abstract class BaseScreen(cont: Container, xSz: Int, ySz: Int) extends GuiContainer(cont) {
+abstract class BaseScreen(cont: Container, xSz: Int, ySz: Int)
+    extends GuiContainer(cont) {
   xSize = xSz
   ySize = ySz
 
@@ -56,7 +57,7 @@ abstract class BaseScreen(cont: Container, xSz: Int, ySz: Int) extends GuiContai
 
     import scala.collection.JavaConversions._
 
-    if (tip.size > 0)
+    if (tip.nonEmpty)
       drawHoveringText(tip, x, y, getFontRenderer)
   }
 

src/main/scala/net/bdew/lib/gui/BaseSlot.scala

@@ -12,7 +12,8 @@ package net.bdew.lib.gui
 import net.minecraft.inventory.{IInventory, Slot}
 import org.lwjgl.opengl.GL11
 
-class BaseSlot(inv: IInventory, slot: Int, x: Int, y: Int) extends Slot(inv, slot, x, y) {
+class BaseSlot(inv: IInventory, slot: Int, x: Int, y: Int)
+    extends Slot(inv, slot, x, y) {
   override def getBackgroundIconIndex = {
     // Workaround for bug in GuiContainer, color isn't reset if previous slot had an item with color.
     GL11.glColor4d(1, 1, 1, 1)

src/main/scala/net/bdew/lib/gui/Color.scala

@@ -28,11 +28,12 @@ case class Color(r: Float, g: Float, b: Float, a: Float = 1) {
 }
 
 object Color {
-  def fromRGB(r: Int, g: Int, b: Int, a: Int = 255) = Color(r / 255F, g / 255F, b / 255F, a / 255F)
+  def fromRGB(r: Int, g: Int, b: Int, a: Int = 255) =
+    Color(r / 255f, g / 255f, b / 255f, a / 255f)
   def fromInt(v: Int) = Color(
-    ((v >> 16) & 0xFF) / 255F,
-    ((v >> 8) & 0xFF) / 255F,
-    (v & 0xFF) / 255F
+    ((v >> 16) & 0xff) / 255f,
+    ((v >> 8) & 0xff) / 255f,
+    (v & 0xff) / 255f
   )
   final val white = Color(1, 1, 1)
   final val black = Color(0, 0, 0)
@@ -43,7 +44,7 @@ object Color {
   final val cyan = Color(0, 1, 1)
   final val magenta = Color(1, 0, 1)
 
-  final val gray = Color(0.5F, 0.5F, 0.5F)
-  final val lightGray = Color(0.75F, 0.75F, 0.75F)
-  final val darkGray = Color(0.25F, 0.25F, 0.25F)
+  final val gray = Color(0.5f, 0.5f, 0.5f)
+  final val lightGray = Color(0.75f, 0.75f, 0.75f)
+  final val darkGray = Color(0.25f, 0.25f, 0.25f)
 }

src/main/scala/net/bdew/lib/gui/DrawTarget.scala

@@ -19,8 +19,20 @@ trait DrawTarget {
   def drawText(text: String, p: Point, color: Color, shadow: Boolean)
   def drawTextMultiline(text: String, r: Rect, color: Color)
 
-  def drawTextureInterpolate(r: Rect, t: Texture, x1: Float, y1: Float, x2: Float, y2: Float, color: Color = Color.white) =
-    drawTexture(r.interpolate(x1, y1, x2, y2), Texture.interpolate(t, x1, y1, x2, y2), color)
+  def drawTextureInterpolate(
+      r: Rect,
+      t: Texture,
+      x1: Float,
+      y1: Float,
+      x2: Float,
+      y2: Float,
+      color: Color = Color.white
+  ) =
+    drawTexture(
+      r.interpolate(x1, y1, x2, y2),
+      Texture.interpolate(t, x1, y1, x2, y2),
+      color
+    )
 }
 
 trait SimpleDrawTarget extends DrawTarget {
@@ -42,5 +54,11 @@ trait SimpleDrawTarget extends DrawTarget {
     getFontRenderer.drawString(text, p.x.round, p.y.round, color.asARGB, shadow)
 
   def drawTextMultiline(text: String, r: Rect, color: Color) =
-    getFontRenderer.drawSplitString(text, r.x.round, r.y.round, r.w.round, color.asARGB)
+    getFontRenderer.drawSplitString(
+      text,
+      r.x.round,
+      r.y.round,
+      r.w.round,
+      color.asARGB
+    )
 }

src/main/scala/net/bdew/lib/gui/GuiHandler.scala

@@ -20,13 +20,30 @@ class GuiHandler extends IGuiHandler {
 
   def register(p: GuiProvider) = {
     if (GUIs.isDefinedAt(p.guiId))
-      sys.error("GUI ID Collision - %d was registered for %s and attempted to register by %s".format(p.guiId, GUIs(p.guiId), p))
+      sys.error(
+        "GUI ID Collision - %d was registered for %s and attempted to register by %s"
+          .format(p.guiId, GUIs(p.guiId), p)
+      )
     GUIs += (p.guiId -> p)
   }
 
-  def getServerGuiElement(ID: Int, player: EntityPlayer, world: World, x: Int, y: Int, z: Int): AnyRef =
+  def getServerGuiElement(
+      ID: Int,
+      player: EntityPlayer,
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int
+  ): AnyRef =
     GUIs(ID).getContainer(world.getTileEntity(x, y, z), player)
 
-  def getClientGuiElement(ID: Int, player: EntityPlayer, world: World, x: Int, y: Int, z: Int): AnyRef =
+  def getClientGuiElement(
+      ID: Int,
+      player: EntityPlayer,
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int
+  ): AnyRef =
     GUIs(ID).getGui(world.getTileEntity(x, y, z), player)
 }

src/main/scala/net/bdew/lib/gui/GuiProvider.scala

@@ -23,6 +23,13 @@ trait GuiProvider {
   def getContainer(te: TEClass, player: EntityPlayer): AnyRef
 
   @SideOnly(Side.CLIENT)
-  def getGui(te: TileEntity, player: EntityPlayer): AnyRef = getGui(te.asInstanceOf[TEClass], player)
-  def getContainer(te: TileEntity, player: EntityPlayer): AnyRef = getContainer(te.asInstanceOf[TEClass], player)
+  def getGui(te: TileEntity, player: EntityPlayer): AnyRef =
+    if (te != null)
+      getGui(te.asInstanceOf[TEClass], player)
+    else null
+
+  def getContainer(te: TileEntity, player: EntityPlayer): AnyRef =
+    if (te != null)
+      getContainer(te.asInstanceOf[TEClass], player)
+    else null
 }

src/main/scala/net/bdew/lib/gui/NoInvContainer.scala

@@ -10,7 +10,11 @@
 package net.bdew.lib.gui
 
 import net.bdew.lib.Misc
-import net.minecraft.entity.player.{EntityPlayer, EntityPlayerMP, InventoryPlayer}
+import net.minecraft.entity.player.{
+  EntityPlayer,
+  EntityPlayerMP,
+  InventoryPlayer
+}
 import net.minecraft.inventory.{Container, Slot}
 import net.minecraft.item.ItemStack
 
@@ -20,22 +24,37 @@ abstract class NoInvContainer extends Container {
 
   def players = Misc.filterType(crafters, classOf[EntityPlayerMP])
 
-  protected def bindPlayerInventory(inv: InventoryPlayer, xOffs: Int, yOffsInv: Int, yOffsHotbar: Int) {
+  protected def bindPlayerInventory(
+      inv: InventoryPlayer,
+      xOffs: Int,
+      yOffsInv: Int,
+      yOffsHotbar: Int
+  ) {
     for (i <- 0 until 3; j <- 0 until 9)
-      addSlotToContainer(new Slot(inv, j + i * 9 + 9, xOffs + j * 18, yOffsInv + i * 18))
+      addSlotToContainer(
+        new Slot(inv, j + i * 9 + 9, xOffs + j * 18, yOffsInv + i * 18)
+      )
 
     for (i <- 0 until 9)
       addSlotToContainer(new Slot(inv, i, xOffs + i * 18, yOffsHotbar))
   }
 
-  override def slotClick(slotNum: Int, button: Int, modifiers: Int, player: EntityPlayer): ItemStack = {
+  override def slotClick(
+      slotNum: Int,
+      button: Int,
+      modifiers: Int,
+      player: EntityPlayer
+  ): ItemStack = {
     if (inventorySlots.isDefinedAt(slotNum)) {
       val slot = getSlot(slotNum)
       if (slot != null && slot.isInstanceOf[SlotClickable])
-        return slot.asInstanceOf[SlotClickable].onClick(button, modifiers, player)
+        return slot
+          .asInstanceOf[SlotClickable]
+          .onClick(button, modifiers, player)
     }
     return super.slotClick(slotNum, button, modifiers, player)
   }
 
-  override def transferStackInSlot(player: EntityPlayer, slot: Int): ItemStack = null
+  override def transferStackInSlot(player: EntityPlayer, slot: Int): ItemStack =
+    null
 }

src/main/scala/net/bdew/lib/gui/SlotValidating.scala

@@ -12,6 +12,8 @@ package net.bdew.lib.gui
 import net.minecraft.inventory.IInventory
 import net.minecraft.item.ItemStack
 
-class SlotValidating(inv: IInventory, slot: Int, x: Int, y: Int) extends BaseSlot(inv, slot, x, y) {
-  override def isItemValid(stack: ItemStack) = inventory.isItemValidForSlot(getSlotIndex, stack)
-}
+class SlotValidating(inv: IInventory, slot: Int, x: Int, y: Int)
+    extends BaseSlot(inv, slot, x, y) {
+  override def isItemValid(stack: ItemStack) =
+    inventory.isItemValidForSlot(getSlotIndex, stack)
+}

src/main/scala/net/bdew/lib/gui/Texture.scala

@@ -30,7 +30,8 @@ class InterpolatedTexture(val texture: Texture, rect: Rect) extends Texture {
   def v2 = rect.y2 * (texture.v2 - texture.v1) + texture.v1
 }
 
-class IconWrapper(val resource: ResourceLocation, aIcon: IIcon) extends Texture {
+class IconWrapper(val resource: ResourceLocation, aIcon: IIcon)
+    extends Texture {
   val icon = if (aIcon == null) {
     if (resource == Texture.ITEMS) Client.itemMissingIcon
     else if (resource == Texture.BLOCKS) Client.blockMissingIcon
@@ -44,7 +45,8 @@ class IconWrapper(val resource: ResourceLocation, aIcon: IIcon) extends Texture
   def bind() = Minecraft.getMinecraft.renderEngine.bindTexture(resource)
 }
 
-class Sprite(val resource: ResourceLocation, r: Rect, scale: Int = 256) extends Texture {
+class Sprite(val resource: ResourceLocation, r: Rect, scale: Int = 256)
+    extends Texture {
   val rect = Rect(r.x / scale, r.y / scale, r.w / scale, r.h / scale)
   def u1 = rect.x1
   def u2 = rect.x2
@@ -53,8 +55,10 @@ class Sprite(val resource: ResourceLocation, r: Rect, scale: Int = 256) extends
   def bind() = Minecraft.getMinecraft.renderEngine.bindTexture(resource)
 }
 
-class ScaledResourceLocation(path: String, val scale: Int = 256) extends ResourceLocation(path) {
-  def this(domain: String, path: String, scale: Int) = this(domain + ":" + path, scale)
+class ScaledResourceLocation(path: String, val scale: Int = 256)
+    extends ResourceLocation(path) {
+  def this(domain: String, path: String, scale: Int) =
+    this(domain + ":" + path, scale)
   def this(domain: String, path: String) = this(domain + ":" + path, 256)
 }
 
@@ -67,27 +71,76 @@ object Texture {
 
   // From a ResourceLocation and position, scale optional
   def apply(res: ResourceLocation, r: Rect) = new Sprite(res, r)
-  def apply(res: ResourceLocation, r: Rect, scale: Int) = new Sprite(res, r, scale)
-  def apply(res: ResourceLocation, u1: Float, v1: Float, w: Float, h: Float) = new Sprite(res, Rect(u1, v1, w, h))
-  def apply(res: ResourceLocation, u1: Float, v1: Float, w: Float, h: Float, scale: Int) = new Sprite(res, Rect(u1, v1, w, h), scale)
+  def apply(res: ResourceLocation, r: Rect, scale: Int) =
+    new Sprite(res, r, scale)
+  def apply(res: ResourceLocation, u1: Float, v1: Float, w: Float, h: Float) =
+    new Sprite(res, Rect(u1, v1, w, h))
+  def apply(
+      res: ResourceLocation,
+      u1: Float,
+      v1: Float,
+      w: Float,
+      h: Float,
+      scale: Int
+  ) = new Sprite(res, Rect(u1, v1, w, h), scale)
 
   // From a path (with optional domain) and position, no scale
   def apply(path: String, r: Rect) = new Sprite(new ResourceLocation(path), r)
-  def apply(path: String, u1: Float, v1: Float, w: Float, h: Float) = new Sprite(new ResourceLocation(path), Rect(u1, v1, w, h))
-  def apply(domain: String, path: String, r: Rect) = new Sprite(new ResourceLocation(domain, path), r)
-  def apply(domain: String, path: String, u1: Float, v1: Float, w: Float, h: Float) = new Sprite(new ResourceLocation(domain, path), Rect(u1, v1, w, h))
+  def apply(path: String, u1: Float, v1: Float, w: Float, h: Float) =
+    new Sprite(new ResourceLocation(path), Rect(u1, v1, w, h))
+  def apply(domain: String, path: String, r: Rect) =
+    new Sprite(new ResourceLocation(domain, path), r)
+  def apply(
+      domain: String,
+      path: String,
+      u1: Float,
+      v1: Float,
+      w: Float,
+      h: Float
+  ) = new Sprite(new ResourceLocation(domain, path), Rect(u1, v1, w, h))
 
   // From a path (with optional domain), position and scale
-  def apply(path: String, r: Rect, scale: Int) = new Sprite(new ResourceLocation(path), r, scale)
-  def apply(path: String, u1: Float, v1: Float, w: Float, h: Float, scale: Int) = new Sprite(new ResourceLocation(path), Rect(u1, v1, w, h), scale)
-  def apply(domain: String, path: String, r: Rect, scale: Int) = new Sprite(new ResourceLocation(domain, path), r, scale)
-  def apply(domain: String, path: String, u1: Float, v1: Float, w: Float, h: Float, scale: Int) = new Sprite(new ResourceLocation(domain, path), Rect(u1, v1, w, h), scale)
+  def apply(path: String, r: Rect, scale: Int) =
+    new Sprite(new ResourceLocation(path), r, scale)
+  def apply(
+      path: String,
+      u1: Float,
+      v1: Float,
+      w: Float,
+      h: Float,
+      scale: Int
+  ) = new Sprite(new ResourceLocation(path), Rect(u1, v1, w, h), scale)
+  def apply(domain: String, path: String, r: Rect, scale: Int) =
+    new Sprite(new ResourceLocation(domain, path), r, scale)
+  def apply(
+      domain: String,
+      path: String,
+      u1: Float,
+      v1: Float,
+      w: Float,
+      h: Float,
+      scale: Int
+  ) = new Sprite(new ResourceLocation(domain, path), Rect(u1, v1, w, h), scale)
 
   // From a ScaledResourceLocation and position
-  def apply(res: ScaledResourceLocation, r: Rect) = new Sprite(res, r, res.scale)
-  def apply(res: ScaledResourceLocation, u1: Float, v1: Float, w: Float, h: Float) = new Sprite(res, Rect(u1, v1, w, h), res.scale)
+  def apply(res: ScaledResourceLocation, r: Rect) =
+    new Sprite(res, r, res.scale)
+  def apply(
+      res: ScaledResourceLocation,
+      u1: Float,
+      v1: Float,
+      w: Float,
+      h: Float
+  ) = new Sprite(res, Rect(u1, v1, w, h), res.scale)
 
   // A fraction of another Texture, parameters should be between 0 and 1
-  def interpolate(texture: Texture, rect: Rect) = new InterpolatedTexture(texture, rect)
-  def interpolate(texture: Texture, u1: Float, v1: Float, u2: Float, v2: Float) = new InterpolatedTexture(texture, Rect(u1, v1, u2 - u1, v2 - v1))
+  def interpolate(texture: Texture, rect: Rect) =
+    new InterpolatedTexture(texture, rect)
+  def interpolate(
+      texture: Texture,
+      u1: Float,
+      v1: Float,
+      u2: Float,
+      v2: Float
+  ) = new InterpolatedTexture(texture, Rect(u1, v1, u2 - u1, v2 - v1))
 }

src/main/scala/net/bdew/lib/gui/WidgetContainer.scala

@@ -78,7 +78,9 @@ trait WidgetContainer extends DrawTarget {
   def getOffsetFromWindow: Point
 }
 
-class WidgetContainerWindow(val parent: BaseScreen, xSz: Int, ySz: Int) extends WidgetContainer with SimpleDrawTarget {
+class WidgetContainerWindow(val parent: BaseScreen, xSz: Int, ySz: Int)
+    extends WidgetContainer
+    with SimpleDrawTarget {
   def getZLevel = parent.getZLevel
   def getFontRenderer = parent.getFontRenderer
   def getOffsetFromWindow = Point(0, 0)

src/main/scala/net/bdew/lib/gui/package.scala

@@ -15,19 +15,25 @@ package object gui {
 
   import scala.language.implicitConversions
 
-  implicit def awt2point(p: java.awt.Point): BasePoint[Int] = BasePoint(p.x, p.y)
-  implicit def point2awt(p: BasePoint[Int]): java.awt.Point = new java.awt.Point(p.x, p.y)
-  implicit def tuple2point[T: Numeric](p: (T, T)): BasePoint[T] = BasePoint(p._1, p._2)
+  implicit def awt2point(p: java.awt.Point): BasePoint[Int] =
+    BasePoint(p.x, p.y)
+  implicit def point2awt(p: BasePoint[Int]): java.awt.Point =
+    new java.awt.Point(p.x, p.y)
+  implicit def tuple2point[T: Numeric](p: (T, T)): BasePoint[T] =
+    BasePoint(p._1, p._2)
 
   // Converts different kinds of Point/Rect as long as there's an implicit for the underlying type
 
-  implicit def pointConvert[T, R](a: BasePoint[R])(implicit f: R => T, n: Numeric[T]): BasePoint[T] =
+  implicit def pointConvert[T, R](
+      a: BasePoint[R]
+  )(implicit f: R => T, n: Numeric[T]): BasePoint[T] =
     BasePoint[T](f(a.x), f(a.y))
 
-  implicit def rectConvert[T, R](a: BaseRect[R])(implicit f: R => T, n: Numeric[T]): BaseRect[T] =
+  implicit def rectConvert[T, R](
+      a: BaseRect[R]
+  )(implicit f: R => T, n: Numeric[T]): BaseRect[T] =
     BaseRect[T](f(a.x), f(a.y), f(a.w), f(a.h))
 
   def Rect(x: Float, y: Float, w: Float, h: Float) = BaseRect(x, y, w, h)
   def Point(x: Float, y: Float) = BasePoint(x, y)
 }
-

src/main/scala/net/bdew/lib/gui/widgets/WidgetButton.scala

@@ -16,12 +16,26 @@ import net.minecraft.client.gui.GuiButton
 import net.minecraft.util.ResourceLocation
 
 class WidgetButton(val rect: Rect, text: String, clicked: WidgetButton => Unit)
-  extends GuiButton(0, rect.x.round, rect.y.round, rect.w.round, rect.h.round, text) with Widget {
+    extends GuiButton(
+      0,
+      rect.x.round,
+      rect.y.round,
+      rect.w.round,
+      rect.h.round,
+      text
+    )
+    with Widget {
 
   override def mouseClicked(p: Point, button: Int) {
-    Minecraft.getMinecraft.getSoundHandler.playSound(PositionedSoundRecord.func_147674_a(new ResourceLocation("gui.button.press"), 1.0F))
+    Minecraft.getMinecraft.getSoundHandler.playSound(
+      PositionedSoundRecord.func_147674_a(
+        new ResourceLocation("gui.button.press"),
+        1.0f
+      )
+    )
     clicked(this)
   }
 
-  override def draw(mouse: Point) = drawButton(Minecraft.getMinecraft, mouse.x.round, mouse.y.round)
+  override def draw(mouse: Point) =
+    drawButton(Minecraft.getMinecraft, mouse.x.round, mouse.y.round)
 }

src/main/scala/net/bdew/lib/gui/widgets/WidgetButtonIcon.scala

@@ -16,9 +16,14 @@ import net.minecraft.util.ResourceLocation
 
 import scala.collection.mutable
 
-class WidgetButtonIcon(p: Point, clicked: WidgetButtonIcon => Unit, baseTex: Texture, hoverTex: Texture) extends Widget {
+class WidgetButtonIcon(
+    p: Point,
+    clicked: WidgetButtonIcon => Unit,
+    baseTex: Texture,
+    hoverTex: Texture
+) extends Widget {
   val rect = new Rect(p, 16, 16)
-  val iconRect = new Rect(p +(1, 1), 14, 14)
+  val iconRect = new Rect(p + (1, 1), 14, 14)
 
   var icon: Texture = null
   var hover: String = null
@@ -39,7 +44,12 @@ class WidgetButtonIcon(p: Point, clicked: WidgetButtonIcon => Unit, baseTex: Tex
   }
 
   override def mouseClicked(p: Point, button: Int) {
-    Minecraft.getMinecraft.getSoundHandler.playSound(PositionedSoundRecord.func_147674_a(new ResourceLocation("gui.button.press"), 1.0F))
+    Minecraft.getMinecraft.getSoundHandler.playSound(
+      PositionedSoundRecord.func_147674_a(
+        new ResourceLocation("gui.button.press"),
+        1.0f
+      )
+    )
     clicked(this)
   }
 }

src/main/scala/net/bdew/lib/gui/widgets/WidgetDynLabel.scala

@@ -11,7 +11,8 @@ package net.bdew.lib.gui.widgets
 
 import net.bdew.lib.gui.{Color, Point, Rect}
 
-class WidgetDynLabel(text: => String, x: Int, y: Int, color: Color) extends Widget {
+class WidgetDynLabel(text: => String, x: Int, y: Int, color: Color)
+    extends Widget {
   val rect = new Rect(x, y, 0, 0)
   override def draw(mouse: Point) {
     parent.drawText(text, rect.origin, color, false)

src/main/scala/net/bdew/lib/gui/widgets/WidgetFillDataslot.scala

@@ -12,7 +12,14 @@ package net.bdew.lib.gui.widgets
 import net.bdew.lib.data.base.DataSlotNumeric
 import net.bdew.lib.gui._
 
-class WidgetFillDataSlot[T](val rect: Rect, val texture: Texture, dir: Direction.Direction, dSlot: DataSlotNumeric[T], maxVal: T)(implicit num: Numeric[T]) extends Widget {
+class WidgetFillDataSlot[T](
+    val rect: Rect,
+    val texture: Texture,
+    dir: Direction.Direction,
+    dSlot: DataSlotNumeric[T],
+    maxVal: T
+)(implicit num: Numeric[T])
+    extends Widget {
 
   import num.mkNumericOps
 
@@ -30,5 +37,3 @@ class WidgetFillDataSlot[T](val rect: Rect, val texture: Texture, dir: Direction
     }
   }
 }
-
-

src/main/scala/net/bdew/lib/gui/widgets/WidgetFluidGauge.scala

@@ -16,11 +16,18 @@ import org.lwjgl.opengl.GL11
 
 import scala.collection.mutable
 
-class WidgetFluidGauge(val rect: Rect, overlay: Texture, dSlot: DataSlotTankBase) extends Widget {
+class WidgetFluidGauge(
+    val rect: Rect,
+    overlay: Texture,
+    dSlot: DataSlotTankBase
+) extends Widget {
   override def handleTooltip(p: Point, tip: mutable.MutableList[String]) {
     if (dSlot.getFluid != null) {
       tip += dSlot.getFluid.getFluid.getLocalizedName(dSlot.getFluid)
-      tip += "%s/%s mB".format(DecFormat.round(dSlot.getFluidAmount), DecFormat.round(dSlot.getCapacity))
+      tip += "%s/%s mB".format(
+        DecFormat.round(dSlot.getFluidAmount),
+        DecFormat.round(dSlot.getCapacity)
+      )
     } else {
       tip += Misc.toLocal("bdlib.label.empty")
     }
@@ -34,15 +41,29 @@ class WidgetFluidGauge(val rect: Rect, overlay: Texture, dSlot: DataSlotTankBase
     if (fStack != null) {
       val color = Color.fromInt(Misc.getFluidColor(fStack))
       val icon = Texture(Texture.BLOCKS, Misc.getFluidIcon(fStack))
-      var fillHeight = if (dSlot.getCapacity > 0) rect.h * fStack.amount / dSlot.getCapacity else 0
+      var fillHeight =
+        if (dSlot.getCapacity > 0) rect.h * fStack.amount / dSlot.getCapacity
+        else 0
       var yStart: Int = 0
 
       while (fillHeight > 0) {
         if (fillHeight > 16) {
-          parent.drawTexture(new Rect(rect.x, rect.y2 - 16 - yStart, rect.w, 16), icon, color)
+          parent.drawTexture(
+            new Rect(rect.x, rect.y2 - 16 - yStart, rect.w, 16),
+            icon,
+            color
+          )
           fillHeight -= 16
         } else {
-          parent.drawTextureInterpolate(new Rect(rect.x, rect.y2 - 16 - yStart, rect.w, 16), icon, 0, 1 - fillHeight / 16, 1, 1, color)
+          parent.drawTextureInterpolate(
+            new Rect(rect.x, rect.y2 - 16 - yStart, rect.w, 16),
+            icon,
+            0,
+            1 - fillHeight / 16,
+            1,
+            1,
+            color
+          )
           fillHeight = 0
         }
         yStart = yStart + 16