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-crash-reports.sh

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

.github/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

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

.github/workflows/release-tags.yml

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

.gitignore

@@ -26,3 +26,4 @@ whitelist.json
 *.ipr
 *.iws
 src/main/resources/mixins.*.json
+*.bat

build.gradle

@@ -1,594 +1,5 @@
-//version: 1642484596
-/*
-DO NOT CHANGE THIS FILE!
-
-Also, you may replace this file at any time if there is an update available.
-Please check https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/build.gradle for updates.
- */
-
-
-import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-
-import java.util.concurrent.TimeUnit
-
-buildscript {
-    repositories {
-        maven {
-            name = "forge"
-            url = "https://maven.minecraftforge.net"
-        }
-        maven {
-            name = "sonatype"
-            url = "https://oss.sonatype.org/content/repositories/snapshots/"
-        }
-        maven {
-            name = "Scala CI dependencies"
-            url = "https://repo1.maven.org/maven2/"
-        }
-        maven {
-            name = "jitpack"
-            url = "https://jitpack.io"
-        }
-    }
-    dependencies {
-        classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.5'
-    }
-}
+//version: 1707058017
 
 plugins {
-    id 'idea'
-    id 'scala'
-    id("org.ajoberstar.grgit") version("3.1.1")
-    id("com.github.johnrengelman.shadow") version("4.0.4")
-    id("com.palantir.git-version") version("0.12.3")
-    id("maven-publish")
-}
-
-apply plugin: 'forge'
-
-def projectJavaVersion = JavaLanguageVersion.of(8)
-
-java {
-    toolchain {
-        languageVersion.set(projectJavaVersion)
-    }
-}
-
-idea {
-    module {
-        inheritOutputDirs = true
-        downloadJavadoc = true
-        downloadSources = true
-    }
-}
-
-if(JavaVersion.current() != JavaVersion.VERSION_1_8) {
-    throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current())
-}
-
-checkPropertyExists("modName")
-checkPropertyExists("modId")
-checkPropertyExists("modGroup")
-checkPropertyExists("autoUpdateBuildScript")
-checkPropertyExists("minecraftVersion")
-checkPropertyExists("forgeVersion")
-checkPropertyExists("replaceGradleTokenInFile")
-checkPropertyExists("gradleTokenModId")
-checkPropertyExists("gradleTokenModName")
-checkPropertyExists("gradleTokenVersion")
-checkPropertyExists("gradleTokenGroupName")
-checkPropertyExists("apiPackage")
-checkPropertyExists("accessTransformersFile")
-checkPropertyExists("usesMixins")
-checkPropertyExists("mixinPlugin")
-checkPropertyExists("mixinsPackage")
-checkPropertyExists("coreModClass")
-checkPropertyExists("containsMixinsAndOrCoreModOnly")
-checkPropertyExists("usesShadowedDependencies")
-checkPropertyExists("developmentEnvironmentUserName")
-
-boolean noPublishedSources = project.findProperty("noPublishedSources") ? project.noPublishedSources.toBoolean() : false
-
-String javaSourceDir = "src/main/java/"
-String scalaSourceDir = "src/main/scala/"
-
-String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/")
-String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/")
-if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
-    throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
-}
-
-if(apiPackage) {
-    targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
-    targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
-    if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
-        throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
-    }
-}
-
-if(accessTransformersFile) {
-    String targetFile = "src/main/resources/META-INF/" + accessTransformersFile
-    if(getFile(targetFile).exists() == false) {
-        throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile)
-    }
-}
-
-if(usesMixins.toBoolean()) {
-    if(mixinsPackage.isEmpty() || mixinPlugin.isEmpty()) {
-        throw new GradleException("\"mixinPlugin\" requires \"mixinsPackage\" and \"mixinPlugin\" to be set!")
-    }
-
-    targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
-    targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
-    if((getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists()) == false) {
-        throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala)
-    }
-
-    String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
-    String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".scala"
-    String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
-    if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
-        throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
-    }
-}
-
-if(coreModClass) {
-    String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
-    String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".scala"
-    String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
-    if((getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists()) == false) {
-        throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava)
-    }
-}
-
-configurations.all {
-    resolutionStrategy.cacheChangingModulesFor(0, TimeUnit.SECONDS)
-
-    // Make sure GregTech build won't time out
-    System.setProperty("org.gradle.internal.http.connectionTimeout", 120000 as String)
-    System.setProperty("org.gradle.internal.http.socketTimeout", 120000 as String)
-}
-
-// Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version
-'git config core.fileMode false'.execute()
-
-// Pulls version first from the VERSION env and then git tag
-String identifiedVersion
-try {
-    String versionOverride = System.getenv("VERSION") ?: null
-    identifiedVersion = versionOverride == null ? gitVersion() : versionOverride
-    version = minecraftVersion + "-" + identifiedVersion
-}
-catch (Exception e) {
-    throw new IllegalStateException("This mod must be version controlled by Git AND the repository must provide at least one tag, or the VERSION override must be set!");
-}
-
-group = modGroup
-if(project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
-    archivesBaseName = customArchiveBaseName
-}
-else {
-    archivesBaseName = modId
-}
-
-minecraft {
-    version = minecraftVersion + "-" + forgeVersion + "-" + minecraftVersion
-    runDir = "run"
-
-    if (replaceGradleTokenInFile) {
-        replaceIn replaceGradleTokenInFile
-        if(gradleTokenModId) {
-            replace gradleTokenModId, modId
-        }
-        if(gradleTokenModName) {
-            replace gradleTokenModName, modName
-        }
-        if(gradleTokenVersion) {
-            replace gradleTokenVersion, versionDetails().lastTag
-        }
-        if(gradleTokenGroupName) {
-            replace gradleTokenGroupName, modGroup
-        }
-    }
-}
-
-if(file("addon.gradle").exists()) {
-    apply from: "addon.gradle"
-}
-
-apply from: 'repositories.gradle'
-
-configurations {
-    implementation.extendsFrom(shadowImplementation)  // TODO: remove after all uses are refactored
-    implementation.extendsFrom(shadowCompile)
-    implementation.extendsFrom(shadeCompile)
-}
-
-repositories {
-    maven {
-        name = "Overmind forge repo mirror"
-        url = "https://gregtech.overminddl1.com/"
-    }
-    if(usesMixins.toBoolean()) {
-        maven {
-            name = "sponge"
-            url = "https://repo.spongepowered.org/repository/maven-public"
-        }
-        maven {
-            url = "https://jitpack.io"
-        }
-    }
-}
-
-dependencies {
-    if(usesMixins.toBoolean()) {
-        annotationProcessor("org.ow2.asm:asm-debug-all:5.0.3")
-        annotationProcessor("com.google.guava:guava:24.1.1-jre")
-        annotationProcessor("com.google.code.gson:gson:2.8.6")
-        annotationProcessor("org.spongepowered:mixin:0.8-SNAPSHOT")
-        // using 0.8 to workaround a issue in 0.7 which fails mixin application
-        compile("com.github.GTNewHorizons:SpongePoweredMixin:0.7.12-GTNH") {
-            // Mixin includes a lot of dependencies that are too up-to-date
-            exclude module: "launchwrapper"
-            exclude module: "guava"
-            exclude module: "gson"
-            exclude module: "commons-io"
-            exclude module: "log4j-core"
-        }
-        compile("com.github.GTNewHorizons:SpongeMixins:1.5.0")
-    }
-}
-
-apply from: 'dependencies.gradle'
-
-def mixingConfigRefMap = "mixins." + modId + ".refmap.json"
-def refMap = "${tasks.compileJava.temporaryDir}" + File.separator + mixingConfigRefMap
-def mixinSrg = "${tasks.reobf.temporaryDir}" + File.separator + "mixins.srg"
-
-task generateAssets {
-    if(usesMixins.toBoolean()) {
-        getFile("/src/main/resources/mixins." + modId + ".json").text = """{
-  "required": true,
-  "minVersion": "0.7.11",
-  "package": "${modGroup}.${mixinsPackage}",
-  "plugin": "${modGroup}.${mixinPlugin}",
-  "refmap": "${mixingConfigRefMap}",
-  "target": "@env(DEFAULT)",
-  "compatibilityLevel": "JAVA_8"
-}
-
-"""
-    }
-}
-
-task relocateShadowJar(type: ConfigureShadowRelocation) {
-    target = tasks.shadowJar
-    prefix = modGroup + ".shadow"
-}
-
-shadowJar {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    manifest {
-        attributes(getManifestAttributes())
-    }
-
-    minimize()  // This will only allow shading for actually used classes
-    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
-    dependsOn(relocateShadowJar)
-}
-
-jar {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    manifest {
-        attributes(getManifestAttributes())
-    }
-
-    if(usesShadowedDependencies.toBoolean()) {
-        dependsOn(shadowJar)
-        enabled = false
-    }
-}
-
-reobf {
-    if(usesMixins.toBoolean()) {
-        addExtraSrgFile mixinSrg
-    }
-}
-
-afterEvaluate {
-    if(usesMixins.toBoolean()) {
-        tasks.compileJava {
-            options.compilerArgs += [
-                    "-AreobfSrgFile=${tasks.reobf.srg}",
-                    "-AoutSrgFile=${mixinSrg}",
-                    "-AoutRefMapFile=${refMap}",
-                    // Elan: from what I understand they are just some linter configs so you get some warning on how to properly code
-                    "-XDenableSunApiLintControl",
-                    "-XDignore.symbol.file"
-            ]
-        }
-    }
-}
-
-runClient {
-    def arguments = []
-
-    if(usesMixins.toBoolean()) {
-        arguments += [
-                "--mods=../build/libs/$modId-${version}.jar",
-                "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
-        ]
-    }
-
-    if(developmentEnvironmentUserName) {
-        arguments += [
-                "--username",
-                developmentEnvironmentUserName
-        ]
-    }
-
-    args(arguments)
-}
-
-runServer {
-    def arguments = []
-
-    if (usesMixins.toBoolean()) {
-        arguments += [
-                "--mods=../build/libs/$modId-${version}.jar",
-                "--tweakClass org.spongepowered.asm.launch.MixinTweaker"
-        ]
-    }
-
-    args(arguments)
-}
-
-tasks.withType(JavaExec).configureEach {
-    javaLauncher.set(
-            javaToolchains.launcherFor {
-                languageVersion = projectJavaVersion
-            }
-    )
-}
-
-processResources
-{
-    // this will ensure that this task is redone when the versions change.
-    inputs.property "version", project.version
-    inputs.property "mcversion", project.minecraft.version
-
-    // replace stuff in mcmod.info, nothing else
-    from(sourceSets.main.resources.srcDirs) {
-        include 'mcmod.info'
-
-        // replace version and mcversion
-        expand "minecraftVersion": project.minecraft.version,
-                "modVersion": versionDetails().lastTag,
-                "modId": modId,
-                "modName": modName
-    }
-
-    if(usesMixins.toBoolean()) {
-        from refMap
-    }
-
-    // copy everything else, thats not the mcmod.info
-    from(sourceSets.main.resources.srcDirs) {
-        exclude 'mcmod.info'
-    }
-}
-
-def getManifestAttributes() {
-    def manifestAttributes = [:]
-    if(containsMixinsAndOrCoreModOnly.toBoolean() == false && (usesMixins.toBoolean() || coreModClass)) {
-        manifestAttributes += ["FMLCorePluginContainsFMLMod": true]
-    }
-
-    if(accessTransformersFile) {
-        manifestAttributes += ["FMLAT" : accessTransformersFile.toString()]
-    }
-
-    if(coreModClass) {
-        manifestAttributes += ["FMLCorePlugin": modGroup + "." + coreModClass]
-    }
-
-    if(usesMixins.toBoolean()) {
-        manifestAttributes += [
-                "TweakClass" : "org.spongepowered.asm.launch.MixinTweaker",
-                "MixinConfigs" : "mixins." + modId + ".json",
-                "ForceLoadAsMod" : containsMixinsAndOrCoreModOnly.toBoolean() == false
-        ]
-    }
-    return manifestAttributes
-}
-
-task sourcesJar(type: Jar) {
-    from (sourceSets.main.allJava)
-    from (file("$projectDir/LICENSE"))
-    getArchiveClassifier().set('sources')
-}
-
-task shadowDevJar(type: ShadowJar) {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    from sourceSets.main.output
-    getArchiveClassifier().set("dev")
-
-    manifest {
-        attributes(getManifestAttributes())
-    }
-
-    minimize()  // This will only allow shading for actually used classes
-    configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
-}
-
-task relocateShadowDevJar(type: ConfigureShadowRelocation) {
-    target = tasks.shadowDevJar
-    prefix = modGroup + ".shadow"
-}
-
-task circularResolverJar(type: Jar) {
-    dependsOn(relocateShadowDevJar)
-    dependsOn(shadowDevJar)
-    enabled = false
-}
-
-task devJar(type: Jar) {
-    project.configurations.shadeCompile.each { dep ->
-        from(project.zipTree(dep)) {
-            exclude 'META-INF', 'META-INF/**'
-        }
-    }
-
-    from sourceSets.main.output
-    getArchiveClassifier().set("dev")
-
-    manifest {
-        attributes(getManifestAttributes())
-    }
-
-    if(usesShadowedDependencies.toBoolean()) {
-        dependsOn(circularResolverJar)
-        enabled = false
-    }
-}
-
-task apiJar(type: Jar) {
-    from (sourceSets.main.allJava) {
-        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
-    }
-
-    from (sourceSets.main.output) {
-        include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
-    }
-
-    from (sourceSets.main.resources.srcDirs) {
-        include("LICENSE")
-    }
-
-    getArchiveClassifier().set('api')
-}
-
-artifacts {
-    if(!noPublishedSources) {
-        archives sourcesJar
-    }
-    archives devJar
-    if(apiPackage) {
-        archives apiJar
-    }
-}
-
-// publishing
-publishing {
-    publications {
-        maven(MavenPublication) {
-            artifact source: usesShadowedDependencies.toBoolean() ? shadowJar : jar, classifier: ""
-            if(!noPublishedSources) {
-                artifact source: sourcesJar, classifier: "src"
-            }
-            artifact source: usesShadowedDependencies.toBoolean() ? shadowDevJar : devJar, classifier: "dev"
-            if (apiPackage) {
-                artifact source: apiJar, classifier: "api"
-            }
-
-            groupId = System.getenv("ARTIFACT_GROUP_ID") ?: "com.github.GTNewHorizons"
-            artifactId = System.getenv("ARTIFACT_ID") ?: project.name
-            // Using the identified version, not project.version as it has the prepended 1.7.10
-            version = System.getenv("RELEASE_VERSION") ?: identifiedVersion
-        }
-    }
-
-    repositories {
-        maven {
-            url = "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases"
-            credentials {
-                username = System.getenv("MAVEN_USER") ?: "NONE"
-                password = System.getenv("MAVEN_PASSWORD") ?: "NONE"
-            }
-        }
-    }
-}
-
-// Updating
-task updateBuildScript {
-    doLast {
-        if (performBuildScriptUpdate(projectDir.toString())) return
-
-        print("Build script already up-to-date!")
-    }
-}
-
-if (isNewBuildScriptVersionAvailable(projectDir.toString())) {
-    if (autoUpdateBuildScript.toBoolean()) {
-        performBuildScriptUpdate(projectDir.toString())
-    } else {
-        println("Build script update available! Run 'gradle updateBuildScript'")
-    }
-}
-
-static URL availableBuildScriptUrl() {
-    new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/main/build.gradle")
-}
-
-boolean performBuildScriptUpdate(String projectDir) {
-    if (isNewBuildScriptVersionAvailable(projectDir)) {
-        def buildscriptFile = getFile("build.gradle")
-        availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } }
-        print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
-        return true
-    }
-    return false
-}
-
-boolean isNewBuildScriptVersionAvailable(String projectDir) {
-    Map parameters = ["connectTimeout": 2000, "readTimeout": 2000]
-
-    String currentBuildScript = getFile("build.gradle").getText()
-    String currentBuildScriptHash = getVersionHash(currentBuildScript)
-    String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText()
-    String availableBuildScriptHash = getVersionHash(availableBuildScript)
-
-    boolean isUpToDate = currentBuildScriptHash.empty || availableBuildScriptHash.empty || currentBuildScriptHash == availableBuildScriptHash
-    return !isUpToDate
-}
-
-static String getVersionHash(String buildScriptContent) {
-    String versionLine = buildScriptContent.find("^//version: [a-z0-9]*")
-    if(versionLine != null) {
-        return versionLine.split(": ").last()
-    }
-    return ""
-}
-
-configure(updateBuildScript) {
-    group = 'forgegradle'
-    description = 'Updates the build script to the latest version'
-}
-
-// Helper methods
-
-def checkPropertyExists(String propertyName) {
-    if (project.hasProperty(propertyName) == false) {
-        throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/gradle.properties")
-    }
-}
-
-def getFile(String relativePath) {
-    return new File(projectDir, relativePath)
+    id 'com.gtnewhorizons.gtnhconvention'
 }

gradle.properties

@@ -1,60 +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
 
-# This is a case-sensitive string to identify your mod. Convention is to use lower case.
+# Case-sensitive identifier string, available for mcmod.info population and used for automatic mixin JSON generation.
+# Conventionally lowercase.
 modId = 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
 
-# WHY is there no version field?
-# The build script relies on git to provide a version via tags. It is super easy and will enable you to always know the
-# code base or your binary. Check out this tutorial: https://blog.mattclemente.com/2017/10/13/versioning-with-git-tags/
+# Whether to use modGroup as the maven publishing group.
+# When false, com.github.GTNewHorizons is used.
+useModGroupForPublishing = false
 
-# Will update your build.gradle automatically whenever an update is available
+# Updates your build.gradle and settings.gradle automatically whenever an update is available.
 autoUpdateBuildScript = false
 
+# Version of Minecraft to target
 minecraftVersion = 1.7.10
+
+# Version of Minecraft Forge to target
 forgeVersion = 10.13.4.1614
 
-# Select a username for testing your mod with breakpoints. You may leave this empty for a random user name each time you
-# restart Minecraft in development. Choose this dependent on your mod:
-# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
-# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
-developmentEnvironmentUserName = "Developer"
+# Specify an MCP channel for dependency deobfuscation and the deobfParams task.
+channel = stable
 
-# Define a source file of your project with:
-# public static final String VERSION = "GRADLETOKEN_VERSION";
-# The string's content will be replaced with your mods version when compiled. You should use this to specify your mod's
-# version in @Mod([...], version = VERSION, [...])
-# Leave these properties empty to skip individual token replacements
-replaceGradleTokenInFile = BdLib.scala
-gradleTokenModId =
-gradleTokenModName =
+# 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 =
 
-# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise you can
+# [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
+# Example value: (apiPackage = api) + (modGroup = com.myname.mymodid) -> com.myname.mymodid.api
 apiPackage =
 
-# Specify the configuration file for Forge's access transformers here. I must be placed into /src/main/resources/META-INF/
-# Example value: mymodid_at.cfg
+# 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 compatability only
-# Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
+# 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
 
-# If enabled, you may use 'shadowImplementation' for dependencies. They will be integrated in your jar. It is your
-# responsibility check the licence and request permission for distribution, if required.
+# Enables Mixins even if this mod doesn't use them, useful if one of the dependencies uses mixins.
+forceEnableMixins = false
+
+# If enabled, you may use 'shadowCompile' for dependencies. They will be integrated into your jar. It is your
+# responsibility to check the license and request permission for distribution if required.
 usesShadowedDependencies = false
+
+# 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,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.9.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

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

gradlew.bat

@@ -13,8 +13,10 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,10 +27,14 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
@@ -37,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -51,48 +57,36 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

settings.gradle

@@ -0,0 +1,23 @@
+
+pluginManagement {
+    repositories {
+        maven {
+            // RetroFuturaGradle
+            name "GTNH Maven"
+            url "https://nexus.gtnewhorizons.com/repository/public/"
+            mavenContent {
+                includeGroup("com.gtnewhorizons")
+                includeGroupByRegex("com\\.gtnewhorizons\\..+")
+            }
+        }
+        gradlePluginPortal()
+        mavenCentral()
+        mavenLocal()
+    }
+}
+
+plugins {
+    id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.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/scala/net/bdew/lib/ApiReporter.scala

@@ -21,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(Locale.US))) 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,23 +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 = "GRADLETOKEN_VERSION", 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]
@@ -37,6 +61,12 @@ object BdLib {
     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()
@@ -45,7 +75,8 @@ object BdLib {
 
   @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,7 +102,10 @@ 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
@@ -95,21 +117,39 @@ object CommandOreDistribution extends CommandBase {
 
     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.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

@@ -24,7 +24,13 @@ object DecFormat {
   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', ' ')
+  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

@@ -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

@@ -25,15 +25,18 @@ import net.minecraftforge.fluids.{Fluid, FluidStack}
 import net.minecraftforge.oredict.ShapedOreRecipe
 
 object Misc {
-  def getActiveModId = Option(Loader.instance().activeModContainer().getModId) getOrElse "<UNKNOWN>"
+  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) {
@@ -42,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]
@@ -73,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) =
@@ -95,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)
@@ -132,34 +165,36 @@ 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
-   */
+  /** 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)
+    val res =
+      try {
+        f(o)
+      } catch {
+        case t1: Throwable =>
+          if (o != null) {
+            try {
+              o.close()
+            } catch {
+              case t2: Throwable =>
+                t1.addSuppressed(t2)
+            }
           }
-        }
-        throw t1
-    }
+          throw t1
+      }
     if (o != null)
       o.close()
     res
@@ -172,4 +207,3 @@ object Misc {
       "%s:%s/%s".format(domain, name, path.mkString("/")).toLowerCase(Locale.US)
 
 }
-

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

@@ -12,10 +12,9 @@ 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
- */
+/** 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

@@ -17,13 +17,26 @@ 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]
+  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 = {
+  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))
+      list
+        .asInstanceOf[util.List[String]]
+        .addAll(
+          b.asInstanceOf[BlockTooltip].getTooltip(stack, player, advanced)
+        )
   }
 }

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

@@ -20,91 +20,162 @@ 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
- */
+/** 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]
+  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))
+    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] = {
+  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 =
+  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 = {
+  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 = {
+  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)
+  /** 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
- */
+/** 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
-   */
+
+  /** 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
-   */
+  /** 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)))
+    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")))
+      persistLoad.trigger(
+        beforeTileBreakLoad(is.getTagCompound.getCompoundTag("data"))
+      )
     }
   }
 }
 
-/**
- * Custom ItemBlock that handles loading data to the Tile Entity
- */
+/** 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)) {
+  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)
+        b.asInstanceOf[BlockKeepData]
+          .restoreTileEntity(world, x, y, z, stack, player)
       true
     } else false
   }
-}
+}

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

@@ -21,7 +21,9 @@ 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)
 

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

@@ -21,14 +21,24 @@ 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 =
+  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]
+  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)
 
@@ -38,17 +48,28 @@ class BlockManager(creativeTab: CreativeTabs) {
       GameRegistry.registerCustomItemStack(name, new ItemStack(block))
 
     if (block.isInstanceOf[HasTE[_]] && !skipTileEntityReg)
-      GameRegistry.registerTileEntity(block.asInstanceOf[HasTE[_]].TEClass,
-        "%s.%s".format(Misc.getActiveModId, name))
+      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")
+  /** 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)
   }

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

@@ -17,7 +17,11 @@ 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) {
+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")) {
@@ -38,9 +42,10 @@ trait MachineManagerMultiblock extends MachineManager {
   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
+      Misc.asInstanceOpt(machine, classOf[MachineCore]) foreach {
+        controllerMachine =>
+          controllers += controllerMachine
+          controllerMachine.getController.machine = controllerMachine
       }
     }
     machine
@@ -48,7 +53,7 @@ trait MachineManagerMultiblock extends MachineManager {
 
   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)
+      machine -> (machine.required.getOrElse(b.kind, 0), max)
     }).toMap
   }
-}
+}

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

@@ -24,7 +24,13 @@ 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)] = {
+  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)
@@ -33,7 +39,17 @@ trait BlockCoverable[T <: TileCoverable] extends HasTE[T] {
     } 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 = {
+  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)
 
@@ -58,20 +74,37 @@ trait BlockCoverable[T <: TileCoverable] extends HasTE[T] {
       activeStack <- Option(player.getCurrentEquippedItem)
       activeItem <- Option(activeStack.getItem)
       coverItem <- Misc.asInstanceOpt(activeItem, classOf[ItemCover])
-      if te.isValidCover(side, activeStack) && coverItem.isValidTile(te, activeStack)
+      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))
+          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])
+        te.covers(side) := coverItem.onInstall(
+          te,
+          side,
+          activeStack.splitStack(1),
+          player.asInstanceOf[EntityPlayerMP]
+        )
 
         if (activeStack.stackSize <= 0)
-          player.inventory.setInventorySlotContents(player.inventory.currentItem, null)
+          player.inventory.setInventorySlotContents(
+            player.inventory.currentItem,
+            null
+          )
 
         te.onCoversChanged()
         coverChanged(world, x, y, z, side)
@@ -89,7 +122,13 @@ trait BlockCoverable[T <: TileCoverable] extends HasTE[T] {
 
   override def canProvidePower = true
 
-  override def isProvidingWeakPower(w: IBlockAccess, x: Int, y: Int, z: Int, side: Int): Int = {
+  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
@@ -97,16 +136,35 @@ trait BlockCoverable[T <: TileCoverable] extends HasTE[T] {
     0
   }
 
-  def coverChanged(w: World, x: Int, y: Int, z: Int, side: ForgeDirection): Unit = {
+  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] =
+  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) {
+  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 {

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

@@ -18,18 +18,39 @@ 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) =
+  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) = {
+  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)
+        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

@@ -15,68 +15,111 @@ import net.minecraft.util.IIcon
 import net.minecraftforge.common.util.ForgeDirection
 
 trait ItemCover extends Item {
-  /**
-   * @return true if tickCover should be called
-   */
+
+  /** @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
+  /** @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 = {}
+  /** 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
-   */
+  /** 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
+  /** 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
+  /** 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 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
-   */
+  /** 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

@@ -19,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(Locale.US), 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,7 +13,8 @@ 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) {

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) foreach (id => t.setString(name + "_uid", id.toString))
-      Option(value.getName) filterNot (name => StringUtils.isBlank(name)) foreach (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

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
 

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/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

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

@@ -14,6 +14,14 @@ import net.bdew.lib.gui._
 
 import scala.collection.mutable
 
-class WidgetProgressBar(rect: Rect, texture: Texture, dSlot: DataSlotFloat) extends WidgetFillDataSlot[Float](rect, texture, Direction.RIGHT, dSlot, 1) {
-  override def handleTooltip(p: Point, tip: mutable.MutableList[String]) = tip += "%.0f".format(dSlot.value * 100) + "%"
+class WidgetProgressBar(rect: Rect, texture: Texture, dSlot: DataSlotFloat)
+    extends WidgetFillDataSlot[Float](
+      rect,
+      texture,
+      Direction.RIGHT,
+      dSlot,
+      1
+    ) {
+  override def handleTooltip(p: Point, tip: mutable.MutableList[String]) =
+    tip += "%.0f".format(dSlot.value * 100) + "%"
 }

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

@@ -11,7 +11,10 @@ package net.bdew.lib.gui.widgets
 
 import net.bdew.lib.gui._
 
-class WidgetSubContainer(val rect: Rect) extends BaseWidget with WidgetContainer with SimpleDrawTarget {
+class WidgetSubContainer(val rect: Rect)
+    extends BaseWidget
+    with WidgetContainer
+    with SimpleDrawTarget {
   def getZLevel = parent.getZLevel
   def getFontRenderer = parent.getFontRenderer
   def getOffsetFromWindow = parent.getOffsetFromWindow + rect.origin

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

@@ -12,7 +12,15 @@ package net.bdew.lib.gui.widgets
 import net.bdew.lib.gui.{Point, Rect}
 import net.minecraft.client.gui.{FontRenderer, GuiTextField}
 
-class WidgetTextEdit(val rect: Rect, fr: FontRenderer) extends GuiTextField(fr, rect.x.round, rect.y.round, rect.w.round, rect.h.round) with Widget {
+class WidgetTextEdit(val rect: Rect, fr: FontRenderer)
+    extends GuiTextField(
+      fr,
+      rect.x.round,
+      rect.y.round,
+      rect.w.round,
+      rect.h.round
+    )
+    with Widget {
 
   override def mouseClicked(p: Point, button: Int) = {
     val pp = p + rect.origin

src/main/scala/net/bdew/lib/helpers/ChatHelper.scala

@@ -52,9 +52,13 @@ object ChatHelper {
   }
 
   implicit def str2chat(s: String): ChatComponentText = new ChatComponentText(s)
-  implicit def str2rich(s: String): RichChatComponent = new RichChatComponent(new ChatComponentText(s))
-  implicit def pimpIChatComponent(v: IChatComponent): RichChatComponent = new RichChatComponent(v)
+  implicit def str2rich(s: String): RichChatComponent = new RichChatComponent(
+    new ChatComponentText(s)
+  )
+  implicit def pimpIChatComponent(v: IChatComponent): RichChatComponent =
+    new RichChatComponent(v)
 
   def C(s: String) = new ChatComponentText(s)
-  def L(s: String, params: IChatComponent*) = new ChatComponentTranslation(s, params: _*)
+  def L(s: String, params: IChatComponent*) =
+    new ChatComponentTranslation(s, params: _*)
 }

src/main/scala/net/bdew/lib/items/IStack.scala

@@ -12,9 +12,8 @@ package net.bdew.lib.items
 import net.minecraft.block.Block
 import net.minecraft.item.{Item, ItemBlock, ItemStack}
 
-/**
- * Allows matching Items in ItemStacks in scala pattern matches
- */
+/** Allows matching Items in ItemStacks in scala pattern matches
+  */
 object IStack {
   def unapply(x: ItemStack): Option[Item] =
     if (x == null || x.getItem == null)
@@ -23,9 +22,8 @@ object IStack {
       Some(x.getItem)
 }
 
-/**
- * Allows matching Blocks in ItemStacks in scala pattern matches
- */
+/** Allows matching Blocks in ItemStacks in scala pattern matches
+  */
 object IStackBlock {
   def unapply(x: ItemStack): Option[Block] =
     if (x == null || x.getItem == null || !x.getItem.isInstanceOf[ItemBlock])

src/main/scala/net/bdew/lib/items/ItemUtils.scala

@@ -34,7 +34,9 @@ object ItemUtils {
 
   def dropItemToPlayer(world: World, player: EntityPlayer, stack: ItemStack) {
     if ((stack == null) || world.isRemote) return
-    world.spawnEntityInWorld(new EntityItem(world, player.posX, player.posY, player.posZ, stack))
+    world.spawnEntityInWorld(
+      new EntityItem(world, player.posX, player.posY, player.posZ, stack)
+    )
   }
 
   def isSameItem(stack1: ItemStack, stack2: ItemStack): Boolean = {
@@ -47,13 +49,28 @@ object ItemUtils {
     return ItemStack.areItemStackTagsEqual(stack2, stack1)
   }
 
-  def addStackToSlots(stack: ItemStack, inv: IInventory, slots: Iterable[Int], checkValid: Boolean): ItemStack = {
+  def addStackToSlots(
+      stack: ItemStack,
+      inv: IInventory,
+      slots: Iterable[Int],
+      checkValid: Boolean
+  ): ItemStack = {
     if (stack == null) return null
 
     // Try merging into existing slots
-    for (slot <- slots if (!checkValid || inv.isItemValidForSlot(slot, stack)) && isSameItem(stack, inv.getStackInSlot(slot))) {
+    for (
+      slot <- slots
+      if (!checkValid || inv.isItemValidForSlot(slot, stack)) && isSameItem(
+        stack,
+        inv.getStackInSlot(slot)
+      )
+    ) {
       val target = inv.getStackInSlot(slot)
-      val toAdd = Misc.min(target.getMaxStackSize - target.stackSize, inv.getInventoryStackLimit - target.stackSize, stack.stackSize)
+      val toAdd = Misc.min(
+        target.getMaxStackSize - target.stackSize,
+        inv.getInventoryStackLimit - target.stackSize,
+        stack.stackSize
+      )
       if (toAdd >= stack.stackSize) {
         target.stackSize += stack.stackSize
         stack.stackSize = 0
@@ -67,9 +84,16 @@ object ItemUtils {
     }
 
     // Now find empty slots and stick any leftovers there
-    for (slot <- slots if (!checkValid || inv.isItemValidForSlot(slot, stack)) && inv.getStackInSlot(slot) == null) {
+    for (
+      slot <- slots
+      if (!checkValid || inv.isItemValidForSlot(slot, stack)) && inv
+        .getStackInSlot(slot) == null
+    ) {
       if (inv.getInventoryStackLimit < stack.stackSize) {
-        inv.setInventorySlotContents(slot, stack.splitStack(inv.getInventoryStackLimit))
+        inv.setInventorySlotContents(
+          slot,
+          stack.splitStack(inv.getInventoryStackLimit)
+        )
       } else {
         inv.setInventorySlotContents(slot, stack.copy())
         stack.stackSize = 0
@@ -86,7 +110,8 @@ object ItemUtils {
       getOrElse (0 until inv.getSizeInventory))
 
   def findItemInInventory(inv: IInventory, item: Item) =
-    Range(0, inv.getSizeInventory).map(x => x -> inv.getStackInSlot(x))
+    Range(0, inv.getSizeInventory)
+      .map(x => x -> inv.getStackInSlot(x))
       .find({ case (slot, stack) => stack != null && stack.getItem == item })
       .map({ case (slot, stack) => slot })
 
@@ -102,4 +127,4 @@ object ItemUtils {
         newSize
     newStack
   }
-}
+}

src/main/scala/net/bdew/lib/items/inventory/ContainerItemInventory.scala

@@ -14,8 +14,14 @@ import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.inventory.Slot
 import net.minecraft.item.ItemStack
 
-class ContainerItemInventory(inv: InventoryItemAdapter, player: EntityPlayer) extends BaseContainer(inv) {
-  override def slotClick(slotNum: Int, button: Int, modifiers: Int, player: EntityPlayer): ItemStack = {
+class ContainerItemInventory(inv: InventoryItemAdapter, player: EntityPlayer)
+    extends BaseContainer(inv) {
+  override def slotClick(
+      slotNum: Int,
+      button: Int,
+      modifiers: Int,
+      player: EntityPlayer
+  ): ItemStack = {
     if (slotNum > 0 && slotNum < inventorySlots.size()) {
       val slot = inventorySlots.asInstanceOf[java.util.List[Slot]].get(slotNum)
       if (slot.isSlotInInventory(inv.player.inventory, inv.slot))

src/main/scala/net/bdew/lib/items/inventory/InventoryItemAdapter.scala

@@ -14,7 +14,12 @@ import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.{NBTTagCompound, NBTTagList}
 
-class InventoryItemAdapter(val player: EntityPlayer, val slot: Int, val size: Int, val tagName: String) extends BaseInventory {
+class InventoryItemAdapter(
+    val player: EntityPlayer,
+    val slot: Int,
+    val size: Int,
+    val tagName: String
+) extends BaseInventory {
   def getSizeInventory = size
   def getStack = player.inventory.getStackInSlot(slot)
 

src/main/scala/net/bdew/lib/items/inventory/ItemInventory.scala

@@ -17,10 +17,9 @@ import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.Item
 import net.minecraft.world.World
 
-/**
- * Mixin for items that have an internal inventory
- * Subclasses are responsible for registering themselves with the GuiHandler of their mod
- */
+/** Mixin for items that have an internal inventory Subclasses are responsible
+  * for registering themselves with the GuiHandler of their mod
+  */
 trait ItemInventory extends Item with GuiProvider {
   type TEClass = Any
   def guiId: Int
@@ -30,9 +29,17 @@ trait ItemInventory extends Item with GuiProvider {
 
   @SideOnly(Side.CLIENT)
   def makeGui(inv: InventoryItemAdapter, player: EntityPlayer): AnyRef
-  def makeContainer(inv: InventoryItemAdapter, player: EntityPlayer): ContainerItemInventory
+  def makeContainer(
+      inv: InventoryItemAdapter,
+      player: EntityPlayer
+  ): ContainerItemInventory
 
-  def makeAdaptor(player: EntityPlayer) = new InventoryItemAdapter(player, player.inventory.currentItem, invSize, invTagName)
+  def makeAdaptor(player: EntityPlayer) = new InventoryItemAdapter(
+    player,
+    player.inventory.currentItem,
+    invSize,
+    invTagName
+  )
 
   @SideOnly(Side.CLIENT)
   def getGui(te: TEClass, player: EntityPlayer) = {
@@ -40,7 +47,10 @@ trait ItemInventory extends Item with GuiProvider {
     if (stack.getItem == this) {
       makeGui(makeAdaptor(player), player)
     } else {
-      BdLib.logWarn("Attempt to open item container GUI without active item (%s)", this)
+      BdLib.logWarn(
+        "Attempt to open item container GUI without active item (%s)",
+        this
+      )
       null
     }
   }
@@ -50,12 +60,23 @@ trait ItemInventory extends Item with GuiProvider {
     if (stack.getItem == this) {
       makeContainer(makeAdaptor(player), player)
     } else {
-      BdLib.logWarn("Attempt to open item container GUI without active item by '%s' (%s)", player.getCommandSenderName, this)
+      BdLib.logWarn(
+        "Attempt to open item container GUI without active item by '%s' (%s)",
+        player.getCommandSenderName,
+        this
+      )
       null
     }
   }
 
   def doOpenGui(player: EntityPlayer, world: World) {
-    player.openGui(modObj, guiId, world, player.posX.toInt, player.posY.toInt, player.posZ.toInt)
+    player.openGui(
+      modObj,
+      guiId,
+      world,
+      player.posX.toInt,
+      player.posY.toInt,
+      player.posZ.toInt
+    )
   }
 }

src/main/scala/net/bdew/lib/machine/Machine.scala

@@ -26,16 +26,20 @@ abstract class Machine[T <: Block](val name: String, blockConstruct: => T) {
   def regBlock(creativeTab: CreativeTabs) {
     block = blockConstruct
 
-    val itemClass: Class[_ <: ItemBlock] = if (block.isInstanceOf[HasItemBlock])
-      block.asInstanceOf[HasItemBlock].ItemBlockClass
-    else
-      classOf[ItemBlock]
+    val itemClass: Class[_ <: ItemBlock] =
+      if (block.isInstanceOf[HasItemBlock])
+        block.asInstanceOf[HasItemBlock].ItemBlockClass
+      else
+        classOf[ItemBlock]
 
     GameRegistry.registerBlock(block, itemClass, name)
 
     block.setCreativeTab(creativeTab)
     if (block.isInstanceOf[HasTE[_]]) {
-      GameRegistry.registerTileEntity(block.asInstanceOf[HasTE[_]].TEClass, "%s.%s".format(modId, name))
+      GameRegistry.registerTileEntity(
+        block.asInstanceOf[HasTE[_]].TEClass,
+        "%s.%s".format(modId, name)
+      )
     }
 
   }

src/main/scala/net/bdew/lib/multiblock/MachineCore.scala

@@ -19,10 +19,17 @@ trait MachineCore extends {
 
   def getController: BlockController[_] = block
 
-  def cfgSectionToMap(name: String) = tuning.getSection(name).map({
-    case (n, EntryDouble(v)) => n -> v.toInt
-    case (n, x) => sys.error("Invalid config value in section %s%s.%s = %s".format(tuning.pfx, name, n, x))
-  }).toMap
+  def cfgSectionToMap(name: String) = tuning
+    .getSection(name)
+    .map({
+      case (n, EntryDouble(v)) => n -> v.toInt
+      case (n, x) =>
+        sys.error(
+          "Invalid config value in section %s%s.%s = %s"
+            .format(tuning.pfx, name, n, x)
+        )
+    })
+    .toMap
 
   lazy val modules = cfgSectionToMap("Modules")
   lazy val required = cfgSectionToMap("Required")

src/main/scala/net/bdew/lib/multiblock/Tools.scala

@@ -24,13 +24,18 @@ object Tools {
   def findConnections(world: World, start: BlockRef, kind: String) =
     (start.neighbours.values flatMap { case pos =>
       (pos.tile(world) flatMap {
-        case t: TileModule => t.connected.value
+        case t: TileModule     => t.connected.value
         case t: TileController => Some(pos)
-        case _ => None
+        case _                 => None
       }) filter (x => canConnect(world, x, kind))
     }).toList.distinct
 
-  def getConnectedNeighbours(w: World, core: BlockRef, pos: BlockRef, seen: mutable.Set[BlockRef]) =
+  def getConnectedNeighbours(
+      w: World,
+      core: BlockRef,
+      pos: BlockRef,
+      seen: mutable.Set[BlockRef]
+  ) =
     pos.neighbours.values
       .filterNot(seen.contains)
       .flatMap(_.getTile[TileModule](w))

src/main/scala/net/bdew/lib/multiblock/block/BlockController.scala

@@ -21,8 +21,14 @@ import net.minecraft.item.ItemStack
 import net.minecraft.util.EnumChatFormatting
 import net.minecraft.world.{IBlockAccess, World}
 
-abstract class BlockController[T <: TileController](val name: String, material: Material, val TEClass: Class[T])
-  extends Block(material) with HasTE[T] with ConnectedTextureBlock with BlockTooltip {
+abstract class BlockController[T <: TileController](
+    val name: String,
+    material: Material,
+    val TEClass: Class[T]
+) extends Block(material)
+    with HasTE[T]
+    with ConnectedTextureBlock
+    with BlockTooltip {
 
   var machine: MachineCore = null
 
@@ -30,37 +36,67 @@ abstract class BlockController[T <: TileController](val name: String, material:
 
   override def edgeIcon = resources.edge
 
-  override def breakBlock(world: World, x: Int, y: Int, z: Int, block: Block, meta: Int) {
+  override def breakBlock(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      block: Block,
+      meta: Int
+  ) {
     getTE(world, x, y, z).onBreak()
     super.breakBlock(world, x, y, z, block, meta)
   }
 
-  override def canConnect(world: IBlockAccess, origin: BlockRef, target: BlockRef) =
+  override def canConnect(
+      world: IBlockAccess,
+      origin: BlockRef,
+      target: BlockRef
+  ) =
     getTE(world, origin).modules.contains(target)
 
-  override def onBlockActivated(world: World, x: Int, y: Int, z: Int, player: EntityPlayer, meta: Int, xOffs: Float, yOffs: Float, zOffs: Float): Boolean = {
+  override def onBlockActivated(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      player: EntityPlayer,
+      meta: Int,
+      xOffs: Float,
+      yOffs: Float,
+      zOffs: Float
+  ): Boolean = {
     if (player.isSneaking) return false
     if (world.isRemote) return true
     getTE(world, x, y, z).onClick(player)
     return true
   }
 
-  override def getTooltip(stack: ItemStack, player: EntityPlayer, advanced: Boolean): List[String] = {
-    List(Misc.toLocal("bdlib.multiblock.tip.controller")) ++ (
-      for ((kind, max) <- machine.modules) yield {
-        val name = Misc.toLocalF(resources.getModuleName(kind))
-        if (machine.required.getOrElse(kind, 0) > 0) {
-          Misc.toLocalF("bdlib.multiblock.tip.module.range",
-            EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
-            EnumChatFormatting.YELLOW + machine.required(kind).toString + EnumChatFormatting.RESET,
-            EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET)
-        } else {
-          Misc.toLocalF("bdlib.multiblock.tip.module.max",
-            EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
-            EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET)
-        }
-      })
+  override def getTooltip(
+      stack: ItemStack,
+      player: EntityPlayer,
+      advanced: Boolean
+  ): List[String] = {
+    List(Misc.toLocal("bdlib.multiblock.tip.controller")) ++ (for (
+      (kind, max) <- machine.modules
+    ) yield {
+      val name = Misc.toLocalF(resources.getModuleName(kind))
+      if (machine.required.getOrElse(kind, 0) > 0) {
+        Misc.toLocalF(
+          "bdlib.multiblock.tip.module.range",
+          EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
+          EnumChatFormatting.YELLOW + machine
+            .required(kind)
+            .toString + EnumChatFormatting.RESET,
+          EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET
+        )
+      } else {
+        Misc.toLocalF(
+          "bdlib.multiblock.tip.module.max",
+          EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
+          EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET
+        )
+      }
+    })
   }
 }
-
-

src/main/scala/net/bdew/lib/multiblock/block/BlockModule.scala

@@ -23,8 +23,16 @@ import net.minecraft.item.ItemStack
 import net.minecraft.util.{ChatComponentTranslation, EnumChatFormatting}
 import net.minecraft.world.{IBlockAccess, World}
 
-abstract class BlockModule[T <: TileModule](val name: String, val kind: String, material: Material, val TEClass: Class[T], val machines: MachineManagerMultiblock)
-  extends Block(material) with HasTE[T] with ConnectedTextureBlock with BlockTooltip {
+abstract class BlockModule[T <: TileModule](
+    val name: String,
+    val kind: String,
+    material: Material,
+    val TEClass: Class[T],
+    val machines: MachineManagerMultiblock
+) extends Block(material)
+    with HasTE[T]
+    with ConnectedTextureBlock
+    with BlockTooltip {
 
   def resources: ResourceProvider
 
@@ -33,28 +41,62 @@ abstract class BlockModule[T <: TileModule](val name: String, val kind: String,
   override def canPlaceBlockAt(world: World, x: Int, y: Int, z: Int): Boolean =
     Tools.findConnections(world, BlockRef(x, y, z), kind).size <= 1
 
-  override def onBlockPlacedBy(world: World, x: Int, y: Int, z: Int, player: EntityLivingBase, stack: ItemStack) {
+  override def onBlockPlacedBy(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      player: EntityLivingBase,
+      stack: ItemStack
+  ) {
     getTE(world, x, y, z).tryConnect()
   }
 
-  override def onNeighborBlockChange(world: World, x: Int, y: Int, z: Int, block: Block) {
+  override def onNeighborBlockChange(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      block: Block
+  ) {
     getTE(world, x, y, z).tryConnect()
   }
 
-  override def breakBlock(world: World, x: Int, y: Int, z: Int, block: Block, meta: Int) {
+  override def breakBlock(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      block: Block,
+      meta: Int
+  ) {
     getTE(world, x, y, z).onBreak()
     super.breakBlock(world, x, y, z, block, meta)
   }
 
-  override def canConnect(world: IBlockAccess, origin: BlockRef, target: BlockRef) = {
+  override def canConnect(
+      world: IBlockAccess,
+      origin: BlockRef,
+      target: BlockRef
+  ) = {
     val me = getTE(world, origin)
     me.connected.contains(target) ||
-      (target.getTile[TileModule](world) exists { other =>
-        me.getCore.isDefined && other.getCore == me.getCore
-      })
+    (target.getTile[TileModule](world) exists { other =>
+      me.getCore.isDefined && other.getCore == me.getCore
+    })
   }
 
-  override def onBlockActivated(world: World, x: Int, y: Int, z: Int, player: EntityPlayer, meta: Int, xOffs: Float, yOffs: Float, zOffs: Float): Boolean = {
+  override def onBlockActivated(
+      world: World,
+      x: Int,
+      y: Int,
+      z: Int,
+      player: EntityPlayer,
+      meta: Int,
+      xOffs: Float,
+      yOffs: Float,
+      zOffs: Float
+  ): Boolean = {
     if (player.isSneaking) return false
     if (world.isRemote) return true
     val te = getTE(world, x, y, z)
@@ -62,27 +104,38 @@ abstract class BlockModule[T <: TileModule](val name: String, val kind: String,
       p <- te.connected.value
       bl <- p.block(world)
     } yield {
-        bl.onBlockActivated(world, p.x, p.y, p.z, player, meta, 0, 0, 0)
-      }) getOrElse {
-      player.addChatMessage(new ChatComponentTranslation("bdlib.multiblock.notconnected"))
+      bl.onBlockActivated(world, p.x, p.y, p.z, player, meta, 0, 0, 0)
+    }) getOrElse {
+      player.addChatMessage(
+        new ChatComponentTranslation("bdlib.multiblock.notconnected")
+      )
     }
     true
   }
 
-  override def getTooltip(stack: ItemStack, player: EntityPlayer, advanced: Boolean): List[String] = {
-    List(Misc.toLocal("bdlib.multiblock.tip.module")) ++ (
-      for ((machine, (min, max)) <- machines.getMachinesForBlock(this)) yield {
-        val name = machine.getController.getLocalizedName
-        if (min > 0) {
-          Misc.toLocalF("bdlib.multiblock.tip.module.range",
-            EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
-            EnumChatFormatting.YELLOW + min.toString + EnumChatFormatting.RESET,
-            EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET)
-        } else {
-          Misc.toLocalF("bdlib.multiblock.tip.module.max",
-            EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
-            EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET)
-        }
-      })
+  override def getTooltip(
+      stack: ItemStack,
+      player: EntityPlayer,
+      advanced: Boolean
+  ): List[String] = {
+    List(Misc.toLocal("bdlib.multiblock.tip.module")) ++ (for (
+      (machine, (min, max)) <- machines.getMachinesForBlock(this)
+    ) yield {
+      val name = machine.getController.getLocalizedName
+      if (min > 0) {
+        Misc.toLocalF(
+          "bdlib.multiblock.tip.module.range",
+          EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
+          EnumChatFormatting.YELLOW + min.toString + EnumChatFormatting.RESET,
+          EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET
+        )
+      } else {
+        Misc.toLocalF(
+          "bdlib.multiblock.tip.module.max",
+          EnumChatFormatting.YELLOW + name + EnumChatFormatting.RESET,
+          EnumChatFormatting.YELLOW + max.toString + EnumChatFormatting.RESET
+        )
+      }
+    })
   }
 }

src/main/scala/net/bdew/lib/multiblock/block/BlockOutput.scala

@@ -11,11 +11,17 @@ package net.bdew.lib.multiblock.block
 
 import net.bdew.lib.block.{BlockFace, BlockRef}
 import net.bdew.lib.multiblock.tile.TileOutput
-import net.bdew.lib.render.connected.{BlockAdditionalRender, ConnectedHelper, FaceOverlay}
+import net.bdew.lib.render.connected.{
+  BlockAdditionalRender,
+  ConnectedHelper,
+  FaceOverlay
+}
 import net.minecraft.world.IBlockAccess
 import net.minecraftforge.common.util.ForgeDirection
 
-trait BlockOutput[T <: TileOutput[_]] extends BlockModule[T] with BlockAdditionalRender {
+trait BlockOutput[T <: TileOutput[_]]
+    extends BlockModule[T]
+    with BlockAdditionalRender {
   def getNeighbourFaces(face: ForgeDirection, bp: BlockRef) = {
     val sides = ConnectedHelper.neighbourFaces(face)
     Seq(
@@ -26,15 +32,27 @@ trait BlockOutput[T <: TileOutput[_]] extends BlockModule[T] with BlockAdditiona
     )
   }
 
-  def getFaceOverlays(world: IBlockAccess, x: Int, y: Int, z: Int, face: ForgeDirection): List[FaceOverlay] = {
+  def getFaceOverlays(
+      world: IBlockAccess,
+      x: Int,
+      y: Int,
+      z: Int,
+      face: ForgeDirection
+  ): List[FaceOverlay] = {
     var result = List.empty[FaceOverlay]
     Option(getTE(world, x, y, z)) flatMap (_.getCore) foreach { core =>
       val bf = BlockFace(x, y, z, face)
       if (core.outputFaces.contains(bf))
-        result :+= FaceOverlay(resources.output, resources.outputColors(core.outputFaces(bf)))
+        result :+= FaceOverlay(
+          resources.output,
+          resources.outputColors(core.outputFaces(bf))
+        )
       for ((bf, icon) <- getNeighbourFaces(face, bf.origin)) {
         if (core.outputFaces.contains(bf))
-          result :+= FaceOverlay(icon, resources.outputColors(core.outputFaces(bf)))
+          result :+= FaceOverlay(
+            icon,
+            resources.outputColors(core.outputFaces(bf))
+          )
       }
     }
     return result

src/main/scala/net/bdew/lib/multiblock/data/DataSlotBlockFaceMap.scala

@@ -16,15 +16,18 @@ import net.minecraftforge.common.util.ForgeDirection
 
 import scala.collection.mutable
 
-case class DataSlotBlockFaceMap(name: String, parent: DataSlotContainer) extends DataSlot {
+case class DataSlotBlockFaceMap(name: String, parent: DataSlotContainer)
+    extends DataSlot {
   val map = collection.mutable.Map.empty[BlockFace, Int]
 
   setUpdate(UpdateKind.SAVE, UpdateKind.WORLD)
 
   def inverted = map.map(_.swap)
 
-  def ent2arr(x: (BlockFace, Int)) = Array(x._2, x._1.x, x._1.y, x._1.z, x._1.face.ordinal())
-  def arr2ent(x: Array[Int]) = BlockFace(x(1), x(2), x(3), ForgeDirection.values()(x(4))) -> x(0)
+  def ent2arr(x: (BlockFace, Int)) =
+    Array(x._2, x._1.x, x._1.y, x._1.z, x._1.face.ordinal())
+  def arr2ent(x: Array[Int]) =
+    BlockFace(x(1), x(2), x(3), ForgeDirection.values()(x(4))) -> x(0)
 
   import net.bdew.lib.nbt._
 
@@ -44,5 +47,7 @@ object DataSlotBlockFaceMap {
 
   import scala.language.implicitConversions
 
-  implicit def dataSlotBlockFaceMap2map(v: DataSlotBlockFaceMap): mutable.Map[BlockFace, Int] = v.map
+  implicit def dataSlotBlockFaceMap2map(
+      v: DataSlotBlockFaceMap
+  ): mutable.Map[BlockFace, Int] = v.map
 }

src/main/scala/net/bdew/lib/multiblock/data/DataSlotOutputConfig.scala

@@ -14,7 +14,11 @@ import net.minecraft.nbt.NBTTagCompound
 
 import scala.collection.mutable
 
-case class DataSlotOutputConfig(name: String, parent: DataSlotContainer, slots: Int) extends DataSlot {
+case class DataSlotOutputConfig(
+    name: String,
+    parent: DataSlotContainer,
+    slots: Int
+) extends DataSlot {
   val map = collection.mutable.Map.empty[Int, OutputConfig]
 
   setUpdate(UpdateKind.SAVE, UpdateKind.GUI)
@@ -49,5 +53,7 @@ object DataSlotOutputConfig {
 
   import scala.language.implicitConversions
 
-  implicit def dataSlotOutputConfig2map(v: DataSlotOutputConfig): mutable.Map[Int, OutputConfig] = v.map
+  implicit def dataSlotOutputConfig2map(
+      v: DataSlotOutputConfig
+  ): mutable.Map[Int, OutputConfig] = v.map
 }

src/main/scala/net/bdew/lib/multiblock/data/DataSlotPos.scala

@@ -15,17 +15,21 @@ import net.bdew.lib.data.DataSlotOption
 import net.bdew.lib.data.base.{DataSlotContainer, UpdateKind}
 import net.minecraft.nbt.NBTTagCompound
 
-case class DataSlotPos(name: String, parent: DataSlotContainer) extends DataSlotOption[BlockRef] {
+case class DataSlotPos(name: String, parent: DataSlotContainer)
+    extends DataSlotOption[BlockRef] {
   setUpdate(UpdateKind.SAVE, UpdateKind.WORLD)
 
   def save(t: NBTTagCompound, kind: UpdateKind.Value) {
-    value foreach (x => t.setTag(name, Misc.applyMutator(x.writeToNBT, new NBTTagCompound)))
+    value foreach (x =>
+      t.setTag(name, Misc.applyMutator(x.writeToNBT, new NBTTagCompound))
+    )
   }
 
   def load(t: NBTTagCompound, kind: UpdateKind.Value) {
-    value = if (t.hasKey(name))
-      Some(BlockRef.fromNBT(t.getCompoundTag(name)))
-    else
-      None
+    value =
+      if (t.hasKey(name))
+        Some(BlockRef.fromNBT(t.getCompoundTag(name)))
+      else
+        None
   }
 }

src/main/scala/net/bdew/lib/multiblock/data/DataSlotPosSet.scala

@@ -16,7 +16,8 @@ import net.minecraft.nbt.NBTTagCompound
 
 import scala.collection.mutable
 
-case class DataSlotPosSet(name: String, parent: DataSlotContainer) extends DataSlot {
+case class DataSlotPosSet(name: String, parent: DataSlotContainer)
+    extends DataSlot {
   val set = collection.mutable.Set.empty[BlockRef]
 
   setUpdate(UpdateKind.SAVE, UpdateKind.WORLD)
@@ -24,7 +25,10 @@ case class DataSlotPosSet(name: String, parent: DataSlotContainer) extends DataS
   import net.bdew.lib.nbt._
 
   def save(t: NBTTagCompound, kind: UpdateKind.Value) {
-    t.setList(name, set.map(x => Misc.applyMutator(x.writeToNBT, new NBTTagCompound)))
+    t.setList(
+      name,
+      set.map(x => Misc.applyMutator(x.writeToNBT, new NBTTagCompound))
+    )
   }
 
   def load(t: NBTTagCompound, kind: UpdateKind.Value) {
@@ -39,5 +43,6 @@ object DataSlotPosSet {
 
   import scala.language.implicitConversions
 
-  implicit def dataSlotPosSet2set(v: DataSlotPosSet): mutable.Set[BlockRef] = v.set
+  implicit def dataSlotPosSet2set(v: DataSlotPosSet): mutable.Set[BlockRef] =
+    v.set
 }

src/main/scala/net/bdew/lib/multiblock/data/OutputConfig.scala

@@ -30,8 +30,9 @@ class OutputConfigInvalid extends OutputConfig {
 object OutputConfigManager {
   var loaders = Map.empty[String, () => OutputConfig]
   def register(id: String, loader: () => OutputConfig) = loaders += id -> loader
-  def create(id: String) = loaders.get(id).map(_.apply()).getOrElse(new OutputConfigInvalid)
+  def create(id: String) =
+    loaders.get(id).map(_.apply()).getOrElse(new OutputConfigInvalid)
 
   register("fluid", () => new OutputConfigFluid)
   register("power", () => new OutputConfigPower)
-}
+}

src/main/scala/net/bdew/lib/multiblock/data/OutputConfigFluid.scala

@@ -45,6 +45,7 @@ class OutputConfigFluid extends OutputConfig with OutputConfigRSControllable {
 
   def handleConfigPacket(m: MsgOutputCfg) = m match {
     case MsgOutputCfgRSMode(_, r) => rsMode = r
-    case _ => sys.error("Invalid output config packet %s to config %s".format(m, this))
+    case _ =>
+      sys.error("Invalid output config packet %s to config %s".format(m, this))
   }
 }

src/main/scala/net/bdew/lib/multiblock/data/OutputConfigFluidSlots.scala

@@ -17,7 +17,9 @@ trait OutputConfigSlots {
   var slot = slotsDef.default
 }
 
-class OutputConfigFluidSlots(val slotsDef: SlotSet) extends OutputConfigFluid with OutputConfigSlots {
+class OutputConfigFluidSlots(val slotsDef: SlotSet)
+    extends OutputConfigFluid
+    with OutputConfigSlots {
   override def id = slotsDef.outputConfigId
   override def read(t: NBTTagCompound) {
     super.read(t)
@@ -29,6 +31,6 @@ class OutputConfigFluidSlots(val slotsDef: SlotSet) extends OutputConfigFluid wi
   }
   override def handleConfigPacket(m: MsgOutputCfg) = m match {
     case MsgOutputCfgSlot(n, id) => slot = slotsDef.get(id)
-    case _ => super.handleConfigPacket(m)
+    case _                       => super.handleConfigPacket(m)
   }
 }

src/main/scala/net/bdew/lib/multiblock/data/OutputConfigItems.scala

@@ -26,7 +26,8 @@ class OutputConfigItems extends OutputConfig with OutputConfigRSControllable {
 
   def handleConfigPacket(m: MsgOutputCfg) = m match {
     case MsgOutputCfgRSMode(_, r) => rsMode = r
-    case _ => sys.error("Invalid output config packet %s to config %s".format(m, this))
+    case _ =>
+      sys.error("Invalid output config packet %s to config %s".format(m, this))
   }
 
 }

src/main/scala/net/bdew/lib/multiblock/data/OutputConfigPower.scala

@@ -12,7 +12,9 @@ package net.bdew.lib.multiblock.data
 import net.bdew.lib.multiblock.network.MsgOutputCfg
 import net.minecraft.nbt.NBTTagCompound
 
-class OutputConfigPower(var unit: String = "MJ") extends OutputConfig with OutputConfigRSControllable {
+class OutputConfigPower(var unit: String = "MJ")
+    extends OutputConfig
+    with OutputConfigRSControllable {
   override val id = "power"
   var avg = 0.0
   var rsMode = RSMode.ALWAYS
@@ -37,6 +39,7 @@ class OutputConfigPower(var unit: String = "MJ") extends OutputConfig with Outpu
 
   def handleConfigPacket(m: MsgOutputCfg) = m match {
     case MsgOutputCfgRSMode(_, r) => rsMode = r
-    case _ => sys.error("Invalid output config packet %s to config %s".format(m, this))
+    case _ =>
+      sys.error("Invalid output config packet %s to config %s".format(m, this))
   }
 }