refactor AutoRotatingModel

* Channel Config Test

* Update AEConfig.java

* userDefinedChannelAmounts

config option added for the dense and normal channel amounts - will need to be refined to match everything but not sure what I would need to do to make it match the other config options

rebound all hard coded checks for channel amounts and linked them to the config options

redefined how the channel amounts are noted in all applicable api integrations

.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: Build mod
+
+on: [ push, pull_request, workflow_dispatch ]
+
+jobs:
+  build:
+    name: Build mod
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK 1.8
+      uses: actions/setup-java@v2
+      with:
+        distribution: 'adopt'
+        java-version: '8'
+    - name: Grant execute permission for gradlew
+      run: chmod +x gradlew
+    - name: Build with Gradle
+      run: ./gradlew -Pnet.minecraftforge.gradle.disableUpdateChecker=true build
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: appliedenergistics2
+        path: build/libs

.github/workflows/lock.yml

@@ -1,15 +0,0 @@
-name: 'Lock threads'
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  lock:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: dessant/lock-threads@v2
-        with:
-          github-token: ${{ github.token }}
-          issue-lock-inactive-days: '180'
-          pr-lock-inactive-days: '180'

.gitignore

@@ -8,6 +8,7 @@
 !gradlew.bat
 !build.gradle
 !gradle.properties
+!settings.gradle
 !.travis.yml
 
 # include markdowns

README.md

@@ -1,17 +1,21 @@
 This is a fork of AE2 i made for trying to solve issues for the [Omnifactory](https://www.curseforge.com/minecraft/modpacks/omnifactory) modpack.
 
-See https://github.com/PrototypeTrousers/Applied-Energistics-2/tree/AE2-Omnifactory branch for commits
+See [AE2-Omnifactory](https://github.com/PrototypeTrousers/Applied-Energistics-2/tree/AE2-Omnifactory) branch for commits and [Releases](https://github.com/PrototypeTrousers/Applied-Energistics-2/releases) for the compiled jars.
-and
-https://github.com/PrototypeTrousers/Applied-Energistics-2/releases for the compiled jars.
 
 # Applied Energistics 2 (PrototypeTrousers fork for Omnifactory)
 
 ## About
+A Mod about Matter, Energy and using them to conquer the world.
 
-A Mod about Matter, Energy and using them to conquer the world..
+## RecipeStages
+You need to add the following into a CraftTweaker script:
+```
+mods.recipestages.Recipes.setPackageStage("appeng", allStages);
+```
+
+The second argument allows you to customize which stages exactly you want to be craftable with AE2. Idk why would you like to restrict any, but you can.
 
 ## License
-
 * Applied Energistics 2 API
   - (c) 2013 - 2018 AlgorithmX2 et al
   - [![License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](http://opensource.org/licenses/MIT)
@@ -25,7 +29,6 @@ A Mod about Matter, Energy and using them to conquer the world..
   - [![License](https://img.shields.io/badge/License-No%20Restriction-green.svg?style=flat-square)](https://creativecommons.org/publicdomain/zero/1.0/)
 
 ## Credits
-
 Thanks to
  
 * Notch et al for Minecraft

gradle.properties

@@ -3,20 +3,16 @@ aechannel=stable
 aebuild=7
 aegroup=appeng
 aebasename=appliedenergistics2
-trousers=trousers_edition
-trousersversion=v49t
 #########################################################
 # Versions                                              #
 #########################################################
 minecraft_version=1.12.2
 mcp_mappings=snapshot_20171003
 forge_version=14.23.5.2847
-
 #########################################################
 # Installable                                           #
 #########################################################
 hwyla_version=1.8.26-B41_1.12.2
-
 #########################################################
 # Provided APIs                                         #
 #########################################################
@@ -24,13 +20,129 @@ jei_version=4.16.1.302
 tesla_version=1.0.63
 ic2_version=2.8.73-ex112
 top_version=1.12-1.4.23-16
-cofhcore_version=1.12.2-4.5.2.19
+crafttweaker_version=4.1.20.684
-crafttweaker_version=4.1.8.9
-inventorytweaks_version=1.63
 ctm_version=MC1.12.2-0.3.1.16
-
+forestry_version=5.8.2.387
 #########################################################
 # Deployment                                            #
 #########################################################
 website_version=1.12.2
 curse_versions=1.12.2
+mapping_channel=snapshot
+mapping_version=20171003
+# Run Configurations
+minecraft_username=Developer
+extra_jvm_args=
+modName=Applied Energistics 2
+# This is a case-sensitive string to identify your mod. Convention is to use lower case.
+modId=appliedenergistics2
+modGroup=appeng
+# Version of your mod.
+# This field can be left empty if you want your mod's version to be determined by the latest git tag instead.
+modVersion=rv6-stable-7-extended_life-v0.55.21
+# Whether to use the old jar naming structure (modid-mcversion-version) instead of the new version (modid-version)
+includeMCVersionJar=false
+# The name of your jar when you produce builds, not including any versioning info
+modArchivesBaseName=appliedenergistics2
+# Will update your build.gradle automatically whenever an update is available
+autoUpdateBuildScript=false
+minecraftVersion=1.12.2
+# Select a username for testing your mod with breakpoints. You may leave this empty for a random username each time you
+# restart Minecraft in development. Choose this dependent on your mod:
+# Do you need consistent player progressing (for example Thaumcraft)? -> Select a name
+# Do you need to test how your custom blocks interacts with a player that is not the owner? -> leave name empty
+# Alternatively this can be set with the 'DEV_USERNAME' environment variable.
+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.
+# Using this requires that you use a Java 17 JDK for development.
+enableModernJavaSyntax=true
+# Generate a class with String fields for the mod id, name and version named with the fields below
+generateGradleTokenClass=appeng.Tags
+gradleTokenModId=
+gradleTokenModName=
+gradleTokenVersion=VERSION
+# In case your mod provides an API for other mods to implement you may declare its package here. Otherwise, you can
+# leave this property empty.
+# Example value: apiPackage = api + modGroup = com.myname.mymodid -> com.myname.mymodid.api
+apiPackage=api
+# Specify the configuration file for Forge's access transformers here. It must be placed into /src/main/resources/
+# There can be multiple files in a comma-separated list.
+# Example value: mymodid_at.cfg,jei_at.cfg
+accessTransformersFile=appliedenergistics2_at.cfg
+# Provides setup for Mixins if enabled. If you don't know what mixins are: Keep it disabled!
+usesMixins=false
+# 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!
+# Example value: coreModClass = asm.FMLPlugin + modGroup = com.myname.mymodid -> com.myname.mymodid.asm.FMLPlugin
+coreModClass=core.AE2ELCore
+# If your project is only a consolidation of mixins or a core mod and does NOT contain a 'normal' mod (meaning that
+# there is no class annotated with @Mod) you want this to be true. When in doubt: leave it on false!
+containsMixinsAndOrCoreModOnly=false
+# Enables Mixins even if this mod doesn't use them, useful if one of the dependencies uses mixins.
+forceEnableMixins=false
+# Adds CurseMaven, Modrinth Maven, BlameJared maven, and some more well-known 1.12.2 repositories
+includeWellKnownRepositories=true
+# Adds JEI and TheOneProbe to your development environment. Adds them as 'implementation', meaning they will
+# be available at compiletime and runtime for your mod (in-game and in-code).
+# Overrides the above setting to be always true, as these repositories are needed to fetch the mods
+includeCommonDevEnvMods=true
+# If enabled, you may use 'shadowCompile' for dependencies. They will be integrated in your jar. It is your
+# responsibility check the licence and request permission for distribution, if required.
+usesShadowedDependencies=false
+# If disabled, won't remove unused classes from shaded 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
+# Publishing to modrinth requires you to set the MODRINTH_API_KEY 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 on Modrinth.
+# Alternatively this can be set with the 'MODRINTH_PROJECT_ID' environment variable.
+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:jei;optional-project:top;incompatible-project:gregtech
+modrinthRelations=
+# Publishing to CurseForge requires you to set the CURSEFORGE_API_KEY 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.
+# Alternatively this can be set with the 'CURSEFORGE_PROJECT_ID' environment variable.
+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
+curseForgeRelations=
+# This project's release type on CurseForge and/or Modrinth
+# Allowed types: release, beta, alpha
+releaseType=beta
+# Generate a default changelog for releases. Requires git to be installed, as it uses it to generate a changelog of
+# commits since the last tagged release.
+generateDefaultChangelog=false
+# Prevent the source code from being published
+noPublishedSources=false
+# Enable spotless checks
+# Enforces code formatting on your source code
+# By default this will use the files found here: https://github.com/GregTechCEu/Buildscripts/tree/master/spotless
+# to format your code. However, you can create your own version of these files and place them in your project's
+# root directory to apply your own formatting options instead.
+enableSpotless=false
+# Enable JUnit testing platform used for testing your code.
+# Uses JUnit 5. See guide and documentation here: https://junit.org/junit5/docs/current/user-guide/
+enableJUnit=true
+# Deployment debug setting
+# Uncomment this to test deployments to CurseForge and Modrinth
+# Alternatively, you can set the 'DEPLOYMENT_DEBUG' environment variable.
+deploymentDebug=false
+# Gradle Settings
+# Effectively applies the '--stacktrace' flag by default
+org.gradle.logging.stacktrace=all
+# Sets default memory used for gradle commands. Can be overridden by user or command line properties.
+# This is required to provide enough memory for the Minecraft decompilation process.
+org.gradle.jvmargs=-Xmx3G

gradle/scripts/artifacts.gradle

@@ -1,67 +0,0 @@
-/*
- * This file is part of Applied Energistics 2.
- * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
- *
- * Applied Energistics 2 is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Applied Energistics 2 is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
- */
- 
-// Suppresses warnings/errors when building javadocs
-allprojects {
-	tasks.withType(Javadoc) {
-		options.addStringOption('Xdoclint:none', '-quiet')
-	}
-}
-
-javadoc {
-	options.encoding = 'UTF-8'
-	options.charSet = 'UTF-8'
-}
-
-task javadocs(type: Javadoc) {
-	source = sourceSets.api.java
-	include "appeng/api/**"
-
-	// Due to ForgeGradle having to be a special snowflake,
-	// we have to add some custom configurations to the normal compile configuration and hope it does not break.
-	classpath = configurations.compile + configurations.forgeGradleMc + configurations.forgeGradleMcDeps 
-}
-
-task javadocJar(type: Jar, dependsOn: javadocs) {
-	from javadoc.destinationDir
-
-	classifier = 'javadoc'
-}
-
-task apiJar(type: Jar) {
-	from sourceSets.api.java
-	include "appeng/api/**"
-
-	from sourceSets.api.output
-	include "appeng/api/**"
-
-	classifier = 'api'
-}
-
-task sourceJar(type: Jar, overwrite: true) {
-	from sourceSets.api.allSource
-	from sourceSets.main.allSource
-
-	classifier = 'sources'
-}
-
-artifacts {
-	archives apiJar
-	archives javadocJar
-	archives sourceJar
-}

gradle/scripts/dependencies.gradle

@@ -19,6 +19,15 @@
 repositories {
     mavenLocal()
 
+    maven {
+        url "https://cursemaven.com"
+    }
+
+    maven {
+        name = "CurseForge"
+        url = "https://minecraft.curseforge.com/api/maven/"
+    }
+
     maven {
         name "Mobius"
         url "http://mobiusstrip.eu/maven"
@@ -29,11 +38,6 @@ repositories {
         url "http://dvs1.progwml6.com/files/maven"
     }
 
-    maven {
-        name = "Tesla repo"
-        url "https://maven.mcmoddev.com"
-    }
-
     maven {
         name "Ellpeck"
         url "https://maven.ellpeck.de"
@@ -68,11 +72,6 @@ repositories {
     //    name 'modmaven'
     //    url "https://modmaven.k-4u.nl/"
     //}
-
-    maven {
-		name = "CurseForge"
-		url = "https://minecraft.curseforge.com/api/maven/"
-	}
 }
 
 configurations {
@@ -80,28 +79,42 @@ configurations {
 }
 
 dependencies {
-    compileOnly "gregtechce:gregtech:1.12.2:1.15.1.735"
+    // deobfCompile "gregtechce:gregtech:1.12.2:1.15.1.735"
-
     // installable runtime dependencies
-    mods "mcp.mobius.waila:Hwyla:${hwyla_version}"
+    implementation rfg.deobf("curse.maven:gregtechceu-557242:4429261")
+
+    compileOnly "curse.maven:chisel-235279:2915375"
+
+    implementation rfg.deobf("curse.maven:baubles-227083:2518667")
+    //mods "mcp.mobius.waila:Hwyla:${hwyla_version}"
+    mods "curse.maven:hwyla-253449:2568751"
     mods "net.industrial-craft:industrialcraft-2:${ic2_version}:dev"
     mods "mcjty.theoneprobe:TheOneProbe-${minecraft_version}:${top_version}"
 
     // compile against provided APIs
     compileOnly "mezz.jei:jei_${minecraft_version}:${jei_version}:api"
-    compileOnly "mcp.mobius.waila:Hwyla:${hwyla_version}"
+    //compileOnly "mcp.mobius.waila:Hwyla:${hwyla_version}"
+    compileOnly "curse.maven:hwyla-253449:2568751"
+    //Code chicken lib, GTCE dependency
+    implementation rfg.deobf("curse.maven:CCL-242818:2779848")
+
+    compileOnly "curse.maven:recipe-stages-280554:3405072"
+    compileOnly "curse.maven:item-stages-280316:2696769"
+    compileOnly "curse.maven:game-stages-268655:2951844"
     compileOnly "net.darkhax.tesla:Tesla-1.12.2:${tesla_version}"
     compileOnly "net.industrial-craft:industrialcraft-2:${ic2_version}:api"
     compileOnly "mcjty.theoneprobe:TheOneProbe-1.12:${top_version}:api"
-    compileOnly "cofh:CoFHCore:${cofhcore_version}:deobf"
+    compileOnly "curse.maven:CoFHCore-69162:2920433"
     compileOnly "CraftTweaker2:CraftTweaker2-API:${crafttweaker_version}"
-	compileOnly "inventory-tweaks:InventoryTweaks:${inventorytweaks_version}:api"
+    compileOnly "curse.maven:inventory-tweaks-223094:2482482"
+    compileOnly "curse.maven:inventory-bogo-sorter-632327:4399738"
     compileOnly "team.chisel.ctm:CTM:${ctm_version}"
     compileOnly "de.ellpeck.actuallyadditions:ActuallyAdditions:1.12.2-r152.16:api"
+    implementation rfg.deobf("net.sengir.forestry:forestry_${minecraft_version}:$forestry_version")
 
     // at runtime, use the full JEI jar
-    runtime "mezz.jei:jei_${minecraft_version}:${jei_version}"
+    runtimeOnly "mezz.jei:jei_${minecraft_version}:${jei_version}"
 
     // unit test dependencies
-    testCompile "junit:junit:4.12"
+    testImplementation "junit:junit:4.12"
 }

gradle/scripts/optional.gradle

@@ -16,40 +16,39 @@
  * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
  */
 
-task wrapper(type: Wrapper) {
-    gradleVersion = "2.14"
-}
-
 // HWYLA
-task installHwyla(type: Copy, dependsOn: "deinstallHwyla") {
+tasks.register('installHwyla', Copy) {
+    dependsOn "deinstallHwyla"
     from { configurations.mods }
     include "**/*Hwyla*.jar"
-    into file(minecraft.runDir + "/mods")
+    into file("/run/mods")
 }
 
-task deinstallHwyla(type: Delete) {
+tasks.register('deinstallHwyla', Delete) {
-    delete fileTree(dir: minecraft.runDir + "/mods", include: "*Hwyla*.jar")
+    delete fileTree(dir: "/run/mods", include: "*Hwyla*.jar")
 }
 
 // IC2
-task installIC2(type: Copy, dependsOn: "deinstallIC2") {
+tasks.register('installIC2', Copy) {
+    dependsOn "deinstallIC2"
     from { configurations.mods }
     include "**/*industrialcraft-2*.jar"
-    into file(minecraft.runDir + "/mods")
+    into file("/run/mods")
 }
 
-task deinstallIC2(type: Delete) {
+tasks.register('deinstallIC2', Delete) {
-    delete fileTree(dir: minecraft.runDir + "/mods", include: "*industrialcraft-2*.jar")
+    delete fileTree(dir: "/run/mods", include: "*industrialcraft-2*.jar")
 }
 
 // TOP
-task installTop(type: Copy, dependsOn: ["deinstallTop"]) {
+tasks.register('installTop', Copy) {
+    dependsOn["deinstallTop"]
     from { configurations.mods }
     include "**/*TheOneProbe*.jar"
-    into file(minecraft.runDir + "/mods")
+    into file("/run/mods")
 }
 
-task deinstallTop(type: Delete) {
+tasks.register('deinstallTop', Delete) {
-    delete fileTree(dir: minecraft.runDir + "/mods", include: "*TheOneProbe*.jar")
+    delete fileTree(dir: "/run/mods", include: "*TheOneProbe*.jar")
 }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-all.zip
+networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.8-bin.zip

gradlew

@@ -1,78 +1,129 @@
-#!/usr/bin/env sh
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
 
 ##############################################################################
-##
+#
-##  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/subprojects/plugins/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
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
+# Resolve links: $0 may be a link
-APP_BASE_NAME=`basename "$0"`
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # 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
+case "$( uname )" in                #(
-  CYGWIN* )
+  CYGWIN* )         cygwin=true  ;; #(
-    cygwin=true
+  Darwin* )         darwin=true  ;; #(
-    ;;
+  MSYS* | MINGW* )  msys=true    ;; #(
-  Darwin* )
+  NONSTOP* )        nonstop=true ;;
-    darwin=true
-    ;;
-  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
@@ -81,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    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.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -89,84 +140,105 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
+    case $MAX_FD in #(
-    if [ $? -eq 0 ] ; then
+      max*)
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-            MAX_FD="$MAX_FD_LIMIT"
+        # shellcheck disable=SC3045
-        fi
+        MAX_FD=$( ulimit -H -n ) ||
-        ulimit -n $MAX_FD
+            warn "Could not query maximum file descriptor limit"
-        if [ $? -ne 0 ] ; then
+    esac
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
+    case $MAX_FD in  #(
-        fi
+      '' | soft) :;; #(
-    else
+      *)
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-    fi
+        # shellcheck disable=SC3045
-fi
+        ulimit -n "$MAX_FD" ||
-
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    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" ;;
     esac
 fi
 
-# Escape application args
+# Collect all arguments for the java command, stacking in reverse order:
-save () {
+#   * args from the command line
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+#   * the main class name
-    echo " "
+#   * -classpath
-}
+#   * -D...appname settings
-APP_ARGS=$(save "$@")
+#   * --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
+# For Cygwin or MSYS, switch paths to Windows format before running java
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+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
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+
-  cd "$(dirname "$0")"
+    # 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
 
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+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" "$@"

settings.gradle

@@ -0,0 +1,26 @@
+pluginManagement {
+    repositories {
+        maven {
+            // RetroFuturaGradle
+            name 'GTNH Maven'
+            //noinspection HttpUrlsUsage
+            url 'http://jenkins.usrv.eu:8081/nexus/content/groups/public/'
+            allowInsecureProtocol = true
+            //noinspection GroovyAssignabilityCheck
+            mavenContent {
+                includeGroup 'com.gtnewhorizons'
+                includeGroup 'com.gtnewhorizons.retrofuturagradle'
+            }
+        }
+        gradlePluginPortal()
+        mavenCentral()
+        mavenLocal()
+    }
+}
+
+plugins {
+    // Automatic toolchain provisioning
+    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.4.0'
+}
+
+rootProject.name = rootProject.projectDir.getName()

src/api/java/appeng/api/config/PowerUnits.java

@@ -28,7 +28,8 @@ public enum PowerUnits
 {
 	AE( "gui.appliedenergistics2.units.appliedenergstics" ), // Native Units - AE Energy
 	EU( "gui.appliedenergistics2.units.ic2" ), // IndustrialCraft 2 - Energy Units
-	RF( "gui.appliedenergistics2.units.rf" ); // RF - Redstone Flux
+	RF( "gui.appliedenergistics2.units.rf" ), // RF - Redstone Flux
+	GTEU( "gui.appliedenergistics2.units.gteu" ); // RF - Redstone Flux
 
 	/**
 	 * unlocalized name for the power unit.
@@ -46,14 +47,13 @@ public enum PowerUnits
 
 	/**
 	 * do power conversion using AE's conversion rates.
-	 *
+	 * <p>
 	 * Example: PowerUnits.EU.convertTo( PowerUnits.AE, 32 );
-	 *
+	 * <p>
 	 * will normally returns 64, as it will convert the EU, to AE with AE's power settings.
 	 *
 	 * @param target target power unit
 	 * @param value  value
-	 *
 	 * @return value converted to target units, from this units.
 	 */
 	public double convertTo( final PowerUnits target, final double value )

src/api/java/appeng/api/config/TunnelType.java

@@ -29,6 +29,7 @@ public enum TunnelType
 	ME, // Network Tunnel
 	IC2_POWER, // EU Tunnel
 	FE_POWER, // Forge Energy tunnel
+	GTEU_POWER, // Forge Energy tunnel
 	REDSTONE, // Redstone Tunnel
 	FLUID, // Fluid Tunnel
 	ITEM, // Item Tunnel

src/api/java/appeng/api/config/Upgrades.java

@@ -32,36 +32,35 @@ import net.minecraft.item.ItemStack;
 import appeng.api.definitions.IItemDefinition;
 
 
-public enum Upgrades
+public enum Upgrades {
-{
     /**
      * Gold Tier Upgrades.
      */
-	CAPACITY( 0 ),
+    CAPACITY(0),
-	REDSTONE( 0 ),
+    REDSTONE(0),
-	CRAFTING( 0 ),
+    CRAFTING(0),
+    MAGNET(0),
 
     /**
      * Diamond Tier Upgrades.
      */
-	FUZZY( 1 ),
+    FUZZY(1),
-	SPEED( 1 ),
+    SPEED(1),
-	INVERTER( 1 ),
+    INVERTER(1),
-	PATTERN_EXPANSION(1);
+    PATTERN_EXPANSION(1),
+    QUANTUM_LINK(1);
 
     private final int tier;
     private final Map<ItemStack, Integer> supportedMax = new HashMap<>();
 
-	Upgrades( final int tier )
+    Upgrades(final int tier) {
-	{
         this.tier = tier;
     }
 
     /**
      * @return list of Items/Blocks that support this upgrade, and how many it supports.
      */
-	public Map<ItemStack, Integer> getSupported()
+    public Map<ItemStack, Integer> getSupported() {
-	{
         return this.supportedMax;
     }
 
@@ -71,9 +70,8 @@ public enum Upgrades
      * @param item         machine in which this upgrade can be installed
      * @param maxSupported amount how many upgrades can be installed
      */
-	public void registerItem( final IItemDefinition item, final int maxSupported )
+    public void registerItem(final IItemDefinition item, final int maxSupported) {
-	{
+        item.maybeStack(1).ifPresent(is -> this.registerItem(is, maxSupported));
-		item.maybeStack( 1 ).ifPresent( is -> this.registerItem( is, maxSupported ) );
     }
 
     /**
@@ -82,16 +80,13 @@ public enum Upgrades
      * @param stack        machine in which this upgrade can be installed
      * @param maxSupported amount how many upgrades can be installed
      */
-	public void registerItem( final ItemStack stack, final int maxSupported )
+    public void registerItem(final ItemStack stack, final int maxSupported) {
-	{
+        if (stack != null) {
-		if( stack != null )
+            this.supportedMax.put(stack, maxSupported);
-		{
-			this.supportedMax.put( stack, maxSupported );
         }
     }
 
-	public int getTier()
+    public int getTier() {
-	{
         return this.tier;
     }
 }

src/api/java/appeng/api/definitions/IItems.java

@@ -30,8 +30,7 @@ import appeng.api.util.AEColoredItemDefinition;
 /**
  * A list of all items in AE
  */
-public interface IItems
+public interface IItems {
-{
 	IItemDefinition certusQuartzAxe();
 
 	IItemDefinition certusQuartzHoe();
@@ -64,6 +63,12 @@ public interface IItems
 
 	IItemDefinition wirelessTerminal();
 
+	IItemDefinition wirelessCraftingTerminal();
+
+	IItemDefinition wirelessPatternTerminal();
+
+	IItemDefinition wirelessFluidTerminal();
+
 	IItemDefinition biometricCard();
 
 	IItemDefinition chargedStaff();

src/api/java/appeng/api/definitions/IMaterials.java

@@ -27,8 +27,7 @@ package appeng.api.definitions;
 /**
  * A list of all materials in AE
  */
-public interface IMaterials
+public interface IMaterials {
-{
     IItemDefinition cell2SpatialPart();
 
     IItemDefinition cell16SpatialPart();
@@ -91,6 +90,10 @@ public interface IMaterials
 
     IItemDefinition cardPatternExpansion();
 
+    IItemDefinition cardQuantumLink();
+
+    IItemDefinition cardMagnet();
+
     IItemDefinition cardFuzzy();
 
     IItemDefinition cardInverter();

src/api/java/appeng/api/definitions/IParts.java

@@ -30,8 +30,7 @@ import appeng.api.util.AEColoredItemDefinition;
 /**
  * A list of all parts in AE
  */
-public interface IParts
+public interface IParts {
-{
     AEColoredItemDefinition cableSmart();
 
     AEColoredItemDefinition cableCovered();
@@ -88,6 +87,8 @@ public interface IParts
 
     IItemDefinition p2PTunnelFE();
 
+    IItemDefinition p2PTunnelGTEU();
+
     IItemDefinition p2PTunnelLight();
 
     // IItemDefinition p2PTunnelOpenComputers();
@@ -106,6 +107,10 @@ public interface IParts
 
     IItemDefinition expandedProcessingPatternTerminal();
 
+    IItemDefinition interfaceConfigurationTerminal();
+
+    IItemDefinition fluidInterfaceConfigurationTerminal();
+
     IItemDefinition craftingTerminal();
 
     IItemDefinition terminal();

src/api/java/appeng/api/features/IWirelessTermHandler.java

@@ -28,20 +28,19 @@ import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 
 import appeng.api.util.IConfigManager;
+import net.minecraftforge.fml.common.network.IGuiHandler;
 
 
 /**
  * A handler for a wireless terminal.
  */
-public interface IWirelessTermHandler extends INetworkEncodable
+public interface IWirelessTermHandler extends INetworkEncodable {
-{
 
     /**
      * @param is wireless terminal
-	 *
      * @return true, if usePower, hasPower, etc... can be called for the provided item
      */
-	boolean canHandle( ItemStack is );
+    boolean canHandle(ItemStack is);
 
     /**
      * use an amount of power, in AE units
@@ -49,26 +48,25 @@ public interface IWirelessTermHandler extends INetworkEncodable
      * @param amount is in AE units ( 5 per MJ ), if you return false, the item should be dead and return false for
      *               hasPower
      * @param is     wireless terminal
-	 *
      * @return true if wireless terminal uses power
      */
-	boolean usePower( EntityPlayer player, double amount, ItemStack is );
+    boolean usePower(EntityPlayer player, double amount, ItemStack is);
 
     /**
      * gets the power status of the item.
      *
      * @param is wireless terminal
-	 *
      * @return returns true if there is any power left.
      */
-	boolean hasPower( EntityPlayer player, double amount, ItemStack is );
+    boolean hasPower(EntityPlayer player, double amount, ItemStack is);
 
     /**
      * Return the config manager for the wireless terminal.
      *
      * @param is wireless terminal
-	 *
      * @return config manager of wireless terminal
      */
-	IConfigManager getConfigManager( ItemStack is );
+    IConfigManager getConfigManager(ItemStack is);
+
+    IGuiHandler getGuiHandler(ItemStack is);
 }

src/api/java/appeng/api/implementations/IUpgradeableCellContainer.java

@@ -0,0 +1,7 @@
+package appeng.api.implementations;
+
+public interface IUpgradeableCellContainer {
+    int availableUpgrades();
+
+    void setupUpgrades();
+}

src/api/java/appeng/api/implementations/IUpgradeableCellHost.java

@@ -0,0 +1,41 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013 AlgorithmX2
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package appeng.api.implementations;
+
+
+import appeng.api.config.Upgrades;
+import appeng.api.implementations.tiles.ISegmentedInventory;
+import appeng.api.util.IConfigurableObject;
+
+
+public interface IUpgradeableCellHost extends IConfigurableObject, ISegmentedInventory {
+
+    /**
+     * determine how many of an upgrade are installed.
+     */
+    default int getInstalledUpgrades(Upgrades u) {
+        return 0;
+    }
+
+}

src/api/java/appeng/api/networking/crafting/ICraftingCPU.java

@@ -28,6 +28,8 @@ import appeng.api.networking.security.IActionSource;
 import appeng.api.networking.storage.IBaseMonitor;
 import appeng.api.storage.data.IAEItemStack;
 
+import javax.annotation.Nullable;
+
 
 public interface ICraftingCPU extends IBaseMonitor<IAEItemStack>
 {
@@ -56,4 +58,30 @@ public interface ICraftingCPU extends IBaseMonitor<IAEItemStack>
 	 * @return an empty string or the name of the cpu.
 	 */
 	String getName();
+
+
+	/**
+	 * @return final output of the current crafting operation, or null if not crafting
+	 */
+	@Nullable
+	default IAEItemStack getFinalOutput()
+	{
+		return null;
+	}
+
+	/**
+	 * @return remaining count of items (or other units of processing) for the current crafting job
+	 */
+	default long getRemainingItemCount()
+	{
+		return 0;
+	}
+
+	/**
+	 * @return total count of items (or other units of processing) for the current crafting job
+	 */
+	default long getStartItemCount()
+	{
+		return 0;
+	}
 }

src/api/java/appeng/api/package-info.java

@@ -22,7 +22,7 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-@API( apiVersion = "@aeversion@", owner = "appliedenergistics2", provides = "appliedenergistics2|API" )
+@API(apiVersion = "rv6", owner = "appliedenergistics2", provides = "appliedenergistics2|API")
 package appeng.api;
 
 

src/api/java/appeng/api/storage/data/IAEItemStack.java

@@ -119,10 +119,10 @@ public interface IAEItemStack extends IAEStack<IAEItemStack>
 	 *
 	 * @param is An item stack
 	 */
-	boolean equals(ItemStack is);
+	boolean equals( ItemStack is );
 
-	ItemStack getCachedItemStack();
+	ItemStack getCachedItemStack( long stackSize );
 
-	void setCachedItemStack(ItemStack is);
+	void setCachedItemStack( ItemStack is );
 
 }

src/api/java/com/enderio/core/common/interfaces/IOverlayRenderAware.java

@@ -0,0 +1,11 @@
+package com.enderio.core.common.interfaces;
+
+import net.minecraft.item.ItemStack;
+
+import javax.annotation.Nonnull;
+
+public interface IOverlayRenderAware {
+
+    public void renderItemOverlayIntoGUI(@Nonnull ItemStack stack, int xPosition, int yPosition);
+
+}

src/main/java/appeng/block/AEBaseBlock.java

@@ -19,11 +19,12 @@
 package appeng.block;
 
 
-import java.util.ArrayList;
+import appeng.api.util.IOrientable;
-import java.util.List;
+import appeng.api.util.IOrientableBlock;
-
+import appeng.helpers.AEGlassMaterial;
-import javax.annotation.Nullable;
+import appeng.helpers.ICustomCollision;
-
+import appeng.util.LookDirection;
+import appeng.util.Platform;
 import net.minecraft.block.Block;
 import net.minecraft.block.SoundType;
 import net.minecraft.block.material.Material;
@@ -46,16 +47,12 @@ import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.IOrientable;
+import javax.annotation.Nullable;
-import appeng.api.util.IOrientableBlock;
+import java.util.ArrayList;
-import appeng.helpers.AEGlassMaterial;
+import java.util.List;
-import appeng.helpers.ICustomCollision;
-import appeng.util.LookDirection;
-import appeng.util.Platform;
 
 
-public abstract class AEBaseBlock extends Block
+public abstract class AEBaseBlock extends Block {
-{
 
     private boolean isOpaque = true;
     private boolean isFullSize = true;
@@ -64,292 +61,238 @@ public abstract class AEBaseBlock extends Block
 
     protected AxisAlignedBB boundingBox = FULL_BLOCK_AABB;
 
-	protected AEBaseBlock( final Material mat )
+    protected AEBaseBlock(final Material mat) {
-	{
+        super(mat);
-		super( mat );
 
-		if( mat == AEGlassMaterial.INSTANCE || mat == Material.GLASS )
+        if (mat == AEGlassMaterial.INSTANCE || mat == Material.GLASS) {
-		{
+            this.setSoundType(SoundType.GLASS);
-			this.setSoundType( SoundType.GLASS );
+        } else if (mat == Material.ROCK) {
-		}
+            this.setSoundType(SoundType.STONE);
-		else if( mat == Material.ROCK )
+        } else if (mat == Material.WOOD) {
-		{
+            this.setSoundType(SoundType.WOOD);
-			this.setSoundType( SoundType.STONE );
+        } else {
-		}
+            this.setSoundType(SoundType.METAL);
-		else if( mat == Material.WOOD )
-		{
-			this.setSoundType( SoundType.WOOD );
-		}
-		else
-		{
-			this.setSoundType( SoundType.METAL );
         }
 
-		this.setLightOpacity( 255 );
+        this.setLightOpacity(255);
-		this.setLightLevel( 0 );
+        this.setLightLevel(0);
-		this.setHardness( 2.2F );
+        this.setHardness(2.2F);
-		this.setHarvestLevel( "pickaxe", 0 );
+        this.setHarvestLevel("pickaxe", 0);
 
         // Workaround as vanilla sets it way too early.
         this.fullBlock = this.isFullSize();
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new BlockStateContainer(this, this.getAEStates());
-		return new BlockStateContainer( this, this.getAEStates() );
     }
 
     @Override
-	public final boolean isNormalCube( IBlockState state )
+    public final boolean isNormalCube(IBlockState state) {
-	{
         return this.isFullSize() && this.isOpaque();
     }
 
     @Override
-	public AxisAlignedBB getBoundingBox( IBlockState state, IBlockAccess source, BlockPos pos )
+    public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos) {
-	{
         return this.boundingBox;
     }
 
-	@SuppressWarnings( "deprecation" )
+    @SuppressWarnings("deprecation")
     @Override
-	public void addCollisionBoxToList( final IBlockState state, final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, @Nullable final Entity e, boolean p_185477_7_ )
+    public void addCollisionBoxToList(final IBlockState state, final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, @Nullable final Entity e, boolean p_185477_7_) {
-	{
+        final ICustomCollision collisionHandler = this.getCustomCollision(w, pos);
-		final ICustomCollision collisionHandler = this.getCustomCollision( w, pos );
 
-		if( collisionHandler != null && bb != null )
+        if (collisionHandler != null && bb != null) {
-		{
             final List<AxisAlignedBB> tmp = new ArrayList<>();
-			collisionHandler.addCollidingBlockToList( w, pos, bb, tmp, e );
+            collisionHandler.addCollidingBlockToList(w, pos, bb, tmp, e);
-			for( final AxisAlignedBB b : tmp )
+            for (final AxisAlignedBB b : tmp) {
-			{
+                final AxisAlignedBB offset = b.offset(pos.getX(), pos.getY(), pos.getZ());
-				final AxisAlignedBB offset = b.offset( pos.getX(), pos.getY(), pos.getZ() );
+                if (bb.intersects(offset)) {
-				if( bb.intersects( offset ) )
+                    out.add(offset);
-				{
-					out.add( offset );
                 }
             }
-		}
+        } else {
-		else
+            super.addCollisionBoxToList(state, w, pos, bb, out, e, p_185477_7_);
-		{
-			super.addCollisionBoxToList( state, w, pos, bb, out, e, p_185477_7_ );
         }
     }
 
-	@SuppressWarnings( "deprecation" )
+    @SuppressWarnings("deprecation")
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public AxisAlignedBB getSelectedBoundingBox( IBlockState state, final World w, final BlockPos pos )
+    public AxisAlignedBB getSelectedBoundingBox(IBlockState state, final World w, final BlockPos pos) {
-	{
+        final ICustomCollision collisionHandler = this.getCustomCollision(w, pos);
-		final ICustomCollision collisionHandler = this.getCustomCollision( w, pos );
 
-		if( collisionHandler != null )
+        if (collisionHandler != null) {
-		{
+            if (Platform.isClient()) {
-			if( Platform.isClient() )
-			{
                 final EntityPlayer player = Minecraft.getMinecraft().player;
-				final LookDirection ld = Platform.getPlayerRay( player, Platform.getEyeOffset( player ) );
+                final LookDirection ld = Platform.getPlayerRay(player, Platform.getEyeOffset(player));
 
-				final Iterable<AxisAlignedBB> bbs = collisionHandler.getSelectedBoundingBoxesFromPool( w, pos, Minecraft.getMinecraft().player, true );
+                final Iterable<AxisAlignedBB> bbs = collisionHandler.getSelectedBoundingBoxesFromPool(w, pos, Minecraft.getMinecraft().player, true);
                 AxisAlignedBB br = null;
 
                 double lastDist = 0;
 
-				for( final AxisAlignedBB bb : bbs )
+                for (final AxisAlignedBB bb : bbs) {
-				{
                     this.boundingBox = bb;
 
-					final RayTraceResult r = super.collisionRayTrace( state, w, pos, ld.getA(), ld.getB() );
+                    final RayTraceResult r = super.collisionRayTrace(state, w, pos, ld.getA(), ld.getB());
 
                     this.boundingBox = FULL_BLOCK_AABB;
 
-					if( r != null )
+                    if (r != null) {
-					{
+                        final double xLen = (ld.getA().x - r.hitVec.x);
-						final double xLen = ( ld.getA().x - r.hitVec.x );
+                        final double yLen = (ld.getA().y - r.hitVec.y);
-						final double yLen = ( ld.getA().y - r.hitVec.y );
+                        final double zLen = (ld.getA().z - r.hitVec.z);
-						final double zLen = ( ld.getA().z - r.hitVec.z );
 
                         final double thisDist = xLen * xLen + yLen * yLen + zLen * zLen;
 
-						if( br == null || lastDist > thisDist )
+                        if (br == null || lastDist > thisDist) {
-						{
                             lastDist = thisDist;
                             br = bb;
                         }
                     }
                 }
 
-				if( br != null )
+                if (br != null) {
-				{
+                    br = new AxisAlignedBB(br.minX + pos.getX(), br.minY + pos.getY(), br.minZ + pos.getZ(), br.maxX + pos.getX(), br.maxY + pos
-					br = new AxisAlignedBB( br.minX + pos.getX(), br.minY + pos.getY(), br.minZ + pos.getZ(), br.maxX + pos.getX(), br.maxY + pos
+                            .getY(), br.maxZ + pos.getZ());
-							.getY(), br.maxZ + pos.getZ() );
                     return br;
                 }
             }
 
             AxisAlignedBB b = null; // new AxisAlignedBB( 16d, 16d, 16d, 0d, 0d, 0d );
 
-			for( final AxisAlignedBB bx : collisionHandler.getSelectedBoundingBoxesFromPool( w, pos, null, false ) )
+            for (final AxisAlignedBB bx : collisionHandler.getSelectedBoundingBoxesFromPool(w, pos, null, false)) {
-			{
+                if (b == null) {
-				if( b == null )
-				{
                     b = bx;
                     continue;
                 }
 
-				final double minX = Math.min( b.minX, bx.minX );
+                final double minX = Math.min(b.minX, bx.minX);
-				final double minY = Math.min( b.minY, bx.minY );
+                final double minY = Math.min(b.minY, bx.minY);
-				final double minZ = Math.min( b.minZ, bx.minZ );
+                final double minZ = Math.min(b.minZ, bx.minZ);
-				final double maxX = Math.max( b.maxX, bx.maxX );
+                final double maxX = Math.max(b.maxX, bx.maxX);
-				final double maxY = Math.max( b.maxY, bx.maxY );
+                final double maxY = Math.max(b.maxY, bx.maxY);
-				final double maxZ = Math.max( b.maxZ, bx.maxZ );
+                final double maxZ = Math.max(b.maxZ, bx.maxZ);
 
-				b = new AxisAlignedBB( minX, minY, minZ, maxX, maxY, maxZ );
+                b = new AxisAlignedBB(minX, minY, minZ, maxX, maxY, maxZ);
             }
 
-			if( b == null )
+            if (b == null) {
-			{
+                b = new AxisAlignedBB(16d, 16d, 16d, 0d, 0d, 0d);
-				b = new AxisAlignedBB( 16d, 16d, 16d, 0d, 0d, 0d );
+            } else {
-			}
+                b = new AxisAlignedBB(b.minX + pos.getX(), b.minY + pos.getY(), b.minZ + pos.getZ(), b.maxX + pos.getX(), b.maxY + pos.getY(), b.maxZ + pos
-			else
+                        .getZ());
-			{
-				b = new AxisAlignedBB( b.minX + pos.getX(), b.minY + pos.getY(), b.minZ + pos.getZ(), b.maxX + pos.getX(), b.maxY + pos.getY(), b.maxZ + pos
-						.getZ() );
             }
 
             return b;
         }
 
-		return super.getSelectedBoundingBox( state, w, pos );
+        return super.getSelectedBoundingBox(state, w, pos);
     }
 
     @Override
-	public final boolean isOpaqueCube( IBlockState state )
+    public final boolean isOpaqueCube(IBlockState state) {
-	{
         return this.isOpaque();
     }
 
-	@SuppressWarnings( "deprecation" )
+    @SuppressWarnings("deprecation")
     @Override
-	public RayTraceResult collisionRayTrace( final IBlockState state, final World w, final BlockPos pos, final Vec3d a, final Vec3d b )
+    public RayTraceResult collisionRayTrace(final IBlockState state, final World w, final BlockPos pos, final Vec3d a, final Vec3d b) {
-	{
+        final ICustomCollision collisionHandler = this.getCustomCollision(w, pos);
-		final ICustomCollision collisionHandler = this.getCustomCollision( w, pos );
 
-		if( collisionHandler != null )
+        if (collisionHandler != null) {
-		{
+            final Iterable<AxisAlignedBB> bbs = collisionHandler.getSelectedBoundingBoxesFromPool(w, pos, null, true);
-			final Iterable<AxisAlignedBB> bbs = collisionHandler.getSelectedBoundingBoxesFromPool( w, pos, null, true );
             RayTraceResult br = null;
 
             double lastDist = 0;
 
-			for( final AxisAlignedBB bb : bbs )
+            for (final AxisAlignedBB bb : bbs) {
-			{
                 this.boundingBox = bb;
 
-				final RayTraceResult r = super.collisionRayTrace( state, w, pos, a, b );
+                final RayTraceResult r = super.collisionRayTrace(state, w, pos, a, b);
 
                 this.boundingBox = FULL_BLOCK_AABB;
 
-				if( r != null )
+                if (r != null) {
-				{
+                    final double xLen = (a.x - r.hitVec.x);
-					final double xLen = ( a.x - r.hitVec.x );
+                    final double yLen = (a.y - r.hitVec.y);
-					final double yLen = ( a.y - r.hitVec.y );
+                    final double zLen = (a.z - r.hitVec.z);
-					final double zLen = ( a.z - r.hitVec.z );
 
                     final double thisDist = xLen * xLen + yLen * yLen + zLen * zLen;
-					if( br == null || lastDist > thisDist )
+                    if (br == null || lastDist > thisDist) {
-					{
                         lastDist = thisDist;
                         br = r;
                     }
                 }
             }
 
-			if( br != null )
-			{
             return br;
         }
 
-			return null;
-		}
-
         this.boundingBox = FULL_BLOCK_AABB;
-		return super.collisionRayTrace( state, w, pos, a, b );
+        return super.collisionRayTrace(state, w, pos, a, b);
     }
 
     @Override
-	public boolean hasComparatorInputOverride( IBlockState state )
+    public boolean hasComparatorInputOverride(IBlockState state) {
-	{
         return this.isInventory();
     }
 
     @Override
-	public int getComparatorInputOverride( IBlockState state, final World worldIn, final BlockPos pos )
+    public int getComparatorInputOverride(IBlockState state, final World worldIn, final BlockPos pos) {
-	{
         return 0;
     }
 
     @Override
-	public final boolean isNormalCube( IBlockState state, final IBlockAccess world, final BlockPos pos )
+    public final boolean isNormalCube(IBlockState state, final IBlockAccess world, final BlockPos pos) {
-	{
         return this.isFullSize();
     }
 
     @Override
-	public boolean rotateBlock( final World w, final BlockPos pos, final EnumFacing axis )
+    public boolean rotateBlock(final World w, final BlockPos pos, final EnumFacing axis) {
-	{
+        final IOrientable rotatable = this.getOrientable(w, pos);
-		final IOrientable rotatable = this.getOrientable( w, pos );
 
-		if( rotatable != null && rotatable.canBeRotated() )
+        if (rotatable != null && rotatable.canBeRotated()) {
-		{
+            if (this.hasCustomRotation()) {
-			if( this.hasCustomRotation() )
+                this.customRotateBlock(rotatable, axis);
-			{
-				this.customRotateBlock( rotatable, axis );
                 return true;
-			}
+            } else {
-			else
-			{
                 EnumFacing forward = rotatable.getForward();
                 EnumFacing up = rotatable.getUp();
 
-				for( int rs = 0; rs < 4; rs++ )
+                for (int rs = 0; rs < 4; rs++) {
-				{
+                    forward = Platform.rotateAround(forward, axis);
-					forward = Platform.rotateAround( forward, axis );
+                    up = Platform.rotateAround(up, axis);
-					up = Platform.rotateAround( up, axis );
 
-					if( this.isValidOrientation( w, pos, forward, up ) )
+                    if (this.isValidOrientation(w, pos, forward, up)) {
-					{
+                        rotatable.setOrientation(forward, up);
-						rotatable.setOrientation( forward, up );
                         return true;
                     }
                 }
             }
         }
 
-		return super.rotateBlock( w, pos, axis );
+        return super.rotateBlock(w, pos, axis);
     }
 
     @Override
-	public EnumFacing[] getValidRotations( final World w, final BlockPos pos )
+    public EnumFacing[] getValidRotations(final World w, final BlockPos pos) {
-	{
         return new EnumFacing[0];
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public void addInformation( final ItemStack is, final World world, final List<String> lines, final ITooltipFlag advancedItemTooltips )
+    public void addInformation(final ItemStack is, final World world, final List<String> lines, final ITooltipFlag advancedItemTooltips) {
-	{
 
     }
 
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
         return false;
     }
 
-	public final EnumFacing mapRotation( final IOrientable ori, final EnumFacing dir )
+    public final EnumFacing mapRotation(final IOrientable ori, final EnumFacing dir) {
-	{
         // case DOWN: return bottomIcon;
         // case UP: return blockIcon;
         // case NORTH: return northIcon;
@@ -360,8 +303,7 @@ public abstract class AEBaseBlock extends Block
         final EnumFacing forward = ori.getForward();
         final EnumFacing up = ori.getUp();
 
-		if( forward == null || up == null )
+        if (forward == null || up == null) {
-		{
             return dir;
         }
 
@@ -370,43 +312,34 @@ public abstract class AEBaseBlock extends Block
         final int west_z = forward.getFrontOffsetX() * up.getFrontOffsetY() - forward.getFrontOffsetY() * up.getFrontOffsetX();
 
         EnumFacing west = null;
-		for( final EnumFacing dx : EnumFacing.VALUES )
+        for (final EnumFacing dx : EnumFacing.VALUES) {
-		{
+            if (dx.getFrontOffsetX() == west_x && dx.getFrontOffsetY() == west_y && dx.getFrontOffsetZ() == west_z) {
-			if( dx.getFrontOffsetX() == west_x && dx.getFrontOffsetY() == west_y && dx.getFrontOffsetZ() == west_z )
-			{
                 west = dx;
             }
         }
 
-		if( west == null )
+        if (west == null) {
-		{
             return dir;
         }
 
-		if( dir == forward )
+        if (dir == forward) {
-		{
             return EnumFacing.SOUTH;
         }
-		if( dir == forward.getOpposite() )
+        if (dir == forward.getOpposite()) {
-		{
             return EnumFacing.NORTH;
         }
 
-		if( dir == up )
+        if (dir == up) {
-		{
             return EnumFacing.UP;
         }
-		if( dir == up.getOpposite() )
+        if (dir == up.getOpposite()) {
-		{
             return EnumFacing.DOWN;
         }
 
-		if( dir == west )
+        if (dir == west) {
-		{
             return EnumFacing.WEST;
         }
-		if( dir == west.getOpposite() )
+        if (dir == west.getOpposite()) {
-		{
             return EnumFacing.EAST;
         }
 
@@ -414,95 +347,77 @@ public abstract class AEBaseBlock extends Block
     }
 
     @Override
-	public String toString()
+    public String toString() {
-	{
         String regName = this.getRegistryName() != null ? this.getRegistryName().getResourcePath() : "unregistered";
         return this.getClass().getSimpleName() + "[" + regName + "]";
     }
 
-	protected String getUnlocalizedName( final ItemStack is )
+    protected String getUnlocalizedName(final ItemStack is) {
-	{
         return this.getUnlocalizedName();
     }
 
-	protected boolean hasCustomRotation()
+    protected boolean hasCustomRotation() {
-	{
         return false;
     }
 
-	protected void customRotateBlock( final IOrientable rotatable, final EnumFacing axis )
+    protected void customRotateBlock(final IOrientable rotatable, final EnumFacing axis) {
-	{
 
     }
 
-	protected IOrientable getOrientable( final IBlockAccess w, final BlockPos pos )
+    protected IOrientable getOrientable(final IBlockAccess w, final BlockPos pos) {
-	{
+        if (this instanceof IOrientableBlock) {
-		if( this instanceof IOrientableBlock )
-		{
             IOrientableBlock orientable = (IOrientableBlock) this;
-			return orientable.getOrientable( w, pos );
+            return orientable.getOrientable(w, pos);
         }
         return null;
     }
 
-	protected boolean isValidOrientation( final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up )
+    protected boolean isValidOrientation(final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up) {
-	{
         return true;
     }
 
-	protected ICustomCollision getCustomCollision( final World w, final BlockPos pos )
+    protected ICustomCollision getCustomCollision(final World w, final BlockPos pos) {
-	{
+        if (this instanceof ICustomCollision) {
-		if( this instanceof ICustomCollision )
-		{
             return (ICustomCollision) this;
         }
         return null;
     }
 
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
         return new IProperty[0];
     }
 
-	protected boolean isOpaque()
+    protected boolean isOpaque() {
-	{
         return this.isOpaque;
     }
 
-	protected boolean setOpaque( final boolean isOpaque )
+    protected boolean setOpaque(final boolean isOpaque) {
-	{
         this.isOpaque = isOpaque;
         return isOpaque;
     }
 
-	protected boolean hasSubtypes()
+    protected boolean hasSubtypes() {
-	{
         return this.hasSubtypes;
     }
 
-	protected void setHasSubtypes( final boolean hasSubtypes )
+    protected void setHasSubtypes(final boolean hasSubtypes) {
-	{
         this.hasSubtypes = hasSubtypes;
     }
 
-	protected boolean isFullSize()
+    protected boolean isFullSize() {
-	{
         return this.isFullSize;
     }
 
-	protected boolean setFullSize( final boolean isFullSize )
+    protected boolean setFullSize(final boolean isFullSize) {
-	{
         this.isFullSize = isFullSize;
         return isFullSize;
     }
 
-	protected boolean isInventory()
+    protected boolean isInventory() {
-	{
         return this.isInventory;
     }
 
-	protected void setInventory( final boolean isInventory )
+    protected void setInventory(final boolean isInventory) {
-	{
         this.isInventory = isInventory;
     }
 

src/main/java/appeng/block/AEBaseItemBlock.java

@@ -19,8 +19,13 @@
 package appeng.block;
 
 
-import java.util.List;
+import appeng.api.util.IOrientable;
-
+import appeng.api.util.IOrientableBlock;
+import appeng.block.misc.BlockLightDetector;
+import appeng.block.misc.BlockSkyCompass;
+import appeng.block.networking.BlockWireless;
+import appeng.me.helpers.IGridProxyable;
+import appeng.tile.AEBaseTile;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.util.ITooltipFlag;
@@ -34,102 +39,74 @@ import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.IOrientable;
+import java.util.List;
-import appeng.api.util.IOrientableBlock;
-import appeng.block.misc.BlockLightDetector;
-import appeng.block.misc.BlockSkyCompass;
-import appeng.block.networking.BlockWireless;
-import appeng.me.helpers.IGridProxyable;
-import appeng.tile.AEBaseTile;
 
 
-public class AEBaseItemBlock extends ItemBlock
+public class AEBaseItemBlock extends ItemBlock {
-{
 
     private final AEBaseBlock blockType;
 
-	public AEBaseItemBlock( final Block id )
+    public AEBaseItemBlock(final Block id) {
-	{
+        super(id);
-		super( id );
         this.blockType = (AEBaseBlock) id;
         this.hasSubtypes = this.blockType.hasSubtypes();
     }
 
     @Override
-	public int getMetadata( final int dmg )
+    public int getMetadata(final int dmg) {
-	{
+        if (this.hasSubtypes) {
-		if( this.hasSubtypes )
-		{
             return dmg;
         }
         return 0;
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public final void addInformation( final ItemStack itemStack, final World world, final List<String> toolTip, final ITooltipFlag advancedTooltips )
+    public final void addInformation(final ItemStack itemStack, final World world, final List<String> toolTip, final ITooltipFlag advancedTooltips) {
-	{
+        this.addCheckedInformation(itemStack, world, toolTip, advancedTooltips);
-		this.addCheckedInformation( itemStack, world, toolTip, advancedTooltips );
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void addCheckedInformation( final ItemStack itemStack, final World world, final List<String> toolTip, final ITooltipFlag advancedTooltips )
+    public void addCheckedInformation(final ItemStack itemStack, final World world, final List<String> toolTip, final ITooltipFlag advancedTooltips) {
-	{
+        this.blockType.addInformation(itemStack, world, toolTip, advancedTooltips);
-		this.blockType.addInformation( itemStack, world, toolTip, advancedTooltips );
     }
 
     @Override
-	public boolean isBookEnchantable( final ItemStack itemstack1, final ItemStack itemstack2 )
+    public boolean isBookEnchantable(final ItemStack itemstack1, final ItemStack itemstack2) {
-	{
         return false;
     }
 
     @Override
-	public String getUnlocalizedName( final ItemStack is )
+    public String getUnlocalizedName(final ItemStack is) {
-	{
+        return this.blockType.getUnlocalizedName(is);
-		return this.blockType.getUnlocalizedName( is );
     }
 
     @Override
-	public boolean placeBlockAt( final ItemStack stack, final EntityPlayer player, final World w, final BlockPos pos, final EnumFacing side, final float hitX, final float hitY, final float hitZ, final IBlockState newState )
+    public boolean placeBlockAt(final ItemStack stack, final EntityPlayer player, final World w, final BlockPos pos, final EnumFacing side, final float hitX, final float hitY, final float hitZ, final IBlockState newState) {
-	{
         EnumFacing up = null;
         EnumFacing forward = null;
 
-		if( this.blockType instanceof AEBaseTileBlock )
+        if (this.blockType instanceof AEBaseTileBlock) {
-		{
+            if (this.blockType instanceof BlockLightDetector) {
-			if( this.blockType instanceof BlockLightDetector )
-			{
                 up = side;
-				if( up == EnumFacing.UP || up == EnumFacing.DOWN )
+                if (up == EnumFacing.UP || up == EnumFacing.DOWN) {
-				{
                     forward = EnumFacing.SOUTH;
-				}
+                } else {
-				else
-				{
                     forward = EnumFacing.UP;
                 }
-			}
+            } else if (this.blockType instanceof BlockWireless || this.blockType instanceof BlockSkyCompass) {
-			else if( this.blockType instanceof BlockWireless || this.blockType instanceof BlockSkyCompass )
-			{
                 forward = side;
-				if( forward == EnumFacing.UP || forward == EnumFacing.DOWN )
+                if (forward == EnumFacing.UP || forward == EnumFacing.DOWN) {
-				{
                     up = EnumFacing.SOUTH;
-				}
+                } else {
-				else
-				{
                     up = EnumFacing.UP;
                 }
-			}
+            } else {
-			else
-			{
                 up = EnumFacing.UP;
 
-				final byte rotation = (byte) ( MathHelper.floor( ( player.rotationYaw * 4F ) / 360F + 2.5D ) & 3 );
+                final byte rotation = (byte) (MathHelper.floor((player.rotationYaw * 4F) / 360F + 2.5D) & 3);
 
-				switch( rotation )
+                switch (rotation) {
-				{
                     default:
                     case 0:
                         forward = EnumFacing.SOUTH;
@@ -145,13 +122,10 @@ public class AEBaseItemBlock extends ItemBlock
                         break;
                 }
 
-				if( player.rotationPitch > 65 )
+                if (player.rotationPitch > 65) {
-				{
                     up = forward.getOpposite();
                     forward = EnumFacing.UP;
-				}
+                } else if (player.rotationPitch < -65) {
-				else if( player.rotationPitch < -65 )
-				{
                     up = forward.getOpposite();
                     forward = EnumFacing.DOWN;
                 }
@@ -159,49 +133,39 @@ public class AEBaseItemBlock extends ItemBlock
         }
 
         IOrientable ori = null;
-		if( this.blockType instanceof IOrientableBlock )
+        if (this.blockType instanceof IOrientableBlock) {
-		{
+            ori = ((IOrientableBlock) this.blockType).getOrientable(w, pos);
-			ori = ( (IOrientableBlock) this.blockType ).getOrientable( w, pos );
             up = side;
             forward = EnumFacing.SOUTH;
-			if( up.getFrontOffsetY() == 0 )
+            if (up.getFrontOffsetY() == 0) {
-			{
                 forward = EnumFacing.UP;
             }
         }
 
-		if( !this.blockType.isValidOrientation( w, pos, forward, up ) )
+        if (!this.blockType.isValidOrientation(w, pos, forward, up)) {
-		{
             return false;
         }
 
-		if( super.placeBlockAt( stack, player, w, pos, side, hitX, hitY, hitZ, newState ) )
+        if (super.placeBlockAt(stack, player, w, pos, side, hitX, hitY, hitZ, newState)) {
-		{
+            if (this.blockType instanceof AEBaseTileBlock && !(this.blockType instanceof BlockLightDetector)) {
-			if( this.blockType instanceof AEBaseTileBlock && !( this.blockType instanceof BlockLightDetector ) )
+                final AEBaseTile tile = ((AEBaseTileBlock) this.blockType).getTileEntity(w, pos);
-			{
-				final AEBaseTile tile = ( (AEBaseTileBlock) this.blockType ).getTileEntity( w, pos );
                 ori = tile;
 
-				if( tile == null )
+                if (tile == null) {
-				{
                     return true;
                 }
 
-				if( ori.canBeRotated() && !this.blockType.hasCustomRotation() )
+                if (ori.canBeRotated() && !this.blockType.hasCustomRotation()) {
-				{
+                    ori.setOrientation(forward, up);
-					ori.setOrientation( forward, up );
                 }
 
-				if( tile instanceof IGridProxyable )
+                if (tile instanceof IGridProxyable) {
-				{
+                    ((IGridProxyable) tile).getProxy().setOwner(player);
-					( (IGridProxyable) tile ).getProxy().setOwner( player );
                 }
 
-				tile.onPlacement( stack, player, side );
+                tile.onPlacement(stack, player, side);
-			}
+            } else if (this.blockType instanceof IOrientableBlock) {
-			else if( this.blockType instanceof IOrientableBlock )
+                ori.setOrientation(forward, up);
-			{
-				ori.setOrientation( forward, up );
             }
 
             return true;

src/main/java/appeng/block/AEBaseItemBlockChargeable.java

@@ -19,17 +19,6 @@
 package appeng.block;
 
 
-import java.text.MessageFormat;
-import java.util.List;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.util.ITooltipFlag;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.world.World;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.api.config.AccessRestriction;
 import appeng.api.config.Actionable;
 import appeng.api.config.PowerUnits;
@@ -38,118 +27,110 @@ import appeng.api.implementations.items.IAEItemPowerStorage;
 import appeng.core.Api;
 import appeng.core.localization.GuiText;
 import appeng.util.Platform;
+import net.minecraft.block.Block;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.text.MessageFormat;
+import java.util.List;
 
 
-public class AEBaseItemBlockChargeable extends AEBaseItemBlock implements IAEItemPowerStorage
+public class AEBaseItemBlockChargeable extends AEBaseItemBlock implements IAEItemPowerStorage {
-{
 
-	public AEBaseItemBlockChargeable( final Block id )
+    public AEBaseItemBlockChargeable(final Block id) {
-	{
+        super(id);
-		super( id );
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void addCheckedInformation( final ItemStack stack, final World world, final List<String> lines, final ITooltipFlag advancedTooltips )
+    public void addCheckedInformation(final ItemStack stack, final World world, final List<String> lines, final ITooltipFlag advancedTooltips) {
-	{
         final NBTTagCompound tag = stack.getTagCompound();
         double internalCurrentPower = 0;
         final double internalMaxPower = this.getMaxEnergyCapacity();
 
-		if( internalMaxPower > 0 )
+        if (internalMaxPower > 0) {
-		{
+            if (tag != null) {
-			if( tag != null )
+                internalCurrentPower = tag.getDouble("internalCurrentPower");
-			{
-				internalCurrentPower = tag.getDouble( "internalCurrentPower" );
             }
 
             final double percent = internalCurrentPower / internalMaxPower;
 
-			lines.add( GuiText.StoredEnergy.getLocal() + ':' + MessageFormat.format( " {0,number,#} ", internalCurrentPower ) + Platform
+            lines.add(GuiText.StoredEnergy.getLocal() + ':' + MessageFormat.format(" {0,number,#} ", internalCurrentPower) + Platform
-					.gui_localize( PowerUnits.AE.unlocalizedName ) + " - " + MessageFormat.format( " {0,number,#.##%} ", percent ) );
+                    .gui_localize(PowerUnits.AE.unlocalizedName) + " - " + MessageFormat.format(" {0,number,#.##%} ", percent));
         }
     }
 
     @Override
-	public double injectAEPower( final ItemStack is, double amount, Actionable mode )
+    public double injectAEPower(final ItemStack is, double amount, Actionable mode) {
-	{
+        final double internalCurrentPower = this.getInternal(is);
-		final double internalCurrentPower = this.getInternal( is );
+        final double internalMaxPower = this.getAEMaxPower(is);
-		final double internalMaxPower = this.getAEMaxPower( is );
         final double required = internalMaxPower - internalCurrentPower;
-		final double overflow = Math.max( 0, amount - required );
+        final double overflow = Math.max(0, amount - required);
 
-		if( mode == Actionable.MODULATE )
+        if (mode == Actionable.MODULATE) {
-		{
+            final double toAdd = Math.min(required, amount);
-			final double toAdd = Math.min( required, amount );
             final double newPowerStored = internalCurrentPower + toAdd;
 
-			this.setInternal( is, newPowerStored );
+            this.setInternal(is, newPowerStored);
         }
 
         return overflow;
     }
 
     @Override
-	public double extractAEPower( final ItemStack is, double amount, Actionable mode )
+    public double extractAEPower(final ItemStack is, double amount, Actionable mode) {
-	{
+        final double internalCurrentPower = this.getInternal(is);
-		final double internalCurrentPower = this.getInternal( is );
+        final double fulfillable = Math.min(amount, internalCurrentPower);
-		final double fulfillable = Math.min( amount, internalCurrentPower );
 
-		if( mode == Actionable.MODULATE )
+        if (mode == Actionable.MODULATE) {
-		{
             final double newPowerStored = internalCurrentPower - fulfillable;
 
-			this.setInternal( is, newPowerStored );
+            this.setInternal(is, newPowerStored);
         }
 
         return fulfillable;
     }
 
     @Override
-	public double getAEMaxPower( final ItemStack is )
+    public double getAEMaxPower(final ItemStack is) {
-	{
         return this.getMaxEnergyCapacity();
     }
 
     @Override
-	public double getAECurrentPower( final ItemStack is )
+    public double getAECurrentPower(final ItemStack is) {
-	{
+        return this.getInternal(is);
-		return this.getInternal( is );
     }
 
     @Override
-	public AccessRestriction getPowerFlow( final ItemStack is )
+    public AccessRestriction getPowerFlow(final ItemStack is) {
-	{
         return AccessRestriction.WRITE;
     }
 
-	private double getMaxEnergyCapacity()
+    private double getMaxEnergyCapacity() {
-	{
+        final Block blockID = Block.getBlockFromItem(this);
-		final Block blockID = Block.getBlockFromItem( this );
         final IBlockDefinition energyCell = Api.INSTANCE.definitions().blocks().energyCell();
 
-		return energyCell.maybeBlock().map( block ->
+        return energyCell.maybeBlock().map(block ->
-		{
-			if( blockID == block )
         {
+            if (blockID == block) {
                 return 200000;
-			}
+            } else {
-			else
-			{
                 return 8 * 200000;
             }
-		} ).orElse( 0 );
+        }).orElse(0);
     }
 
-	private double getInternal( final ItemStack is )
+    private double getInternal(final ItemStack is) {
-	{
+        final NBTTagCompound nbt = Platform.openNbtData(is);
-		final NBTTagCompound nbt = Platform.openNbtData( is );
+        return nbt.getDouble("internalCurrentPower");
-		return nbt.getDouble( "internalCurrentPower" );
     }
 
-	private void setInternal( final ItemStack is, final double amt )
+    private void setInternal(final ItemStack is, final double amt) {
-	{
+        final NBTTagCompound nbt = Platform.openNbtData(is);
-		final NBTTagCompound nbt = Platform.openNbtData( is );
+        nbt.setDouble("internalCurrentPower", amt);
-		nbt.setDouble( "internalCurrentPower", amt );
     }
 }

src/main/java/appeng/block/AEBaseStairBlock.java

@@ -20,31 +20,38 @@ package appeng.block;
 
 
 import com.google.common.base.Preconditions;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockStairs;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IBlockAccess;
+
+import javax.annotation.Nonnull;
 
 
-public abstract class AEBaseStairBlock extends BlockStairs
+public abstract class AEBaseStairBlock extends BlockStairs {
-{
 
-	protected AEBaseStairBlock( final Block block, final String type )
+    protected AEBaseStairBlock(final Block block, final String type) {
-	{
+        super(block.getDefaultState());
-		super( block.getDefaultState() );
 
-		Preconditions.checkNotNull( block );
+        Preconditions.checkNotNull(block);
-		Preconditions.checkNotNull( block.getUnlocalizedName() );
+        Preconditions.checkNotNull(block.getUnlocalizedName());
-		Preconditions.checkArgument( block.getUnlocalizedName().length() > 0 );
+        Preconditions.checkArgument(block.getUnlocalizedName().length() > 0);
 
-		this.setUnlocalizedName( "stair." + type );
+        this.setUnlocalizedName("stair." + type);
-		this.setLightOpacity( 0 );
+        this.setLightOpacity(0);
     }
 
     @Override
-	public String toString()
+    public String toString() {
-	{
         String regName = this.getRegistryName() != null ? this.getRegistryName().getResourcePath() : "unregistered";
         return this.getClass().getSimpleName() + "[" + regName + "]";
     }
 
+    @Override
+    public boolean doesSideBlockChestOpening(@Nonnull IBlockState blockState, @Nonnull IBlockAccess world, @Nonnull BlockPos pos, @Nonnull EnumFacing side) {
+        return false;
+    }
+
 }

src/main/java/appeng/block/AEBaseTileBlock.java

@@ -19,14 +19,23 @@
 package appeng.block;
 
 
-import java.util.ArrayList;
+import appeng.api.implementations.items.IMemoryCard;
-import java.util.List;
+import appeng.api.implementations.items.MemoryCardMessages;
-
+import appeng.api.implementations.tiles.IColorableTile;
-import javax.annotation.Nonnull;
+import appeng.api.util.AEColor;
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.api.util.IOrientable;
+import appeng.block.networking.BlockCableBus;
+import appeng.core.sync.GuiBridge;
+import appeng.helpers.ICustomCollision;
+import appeng.items.tools.quartz.ToolQuartzCuttingKnife;
+import appeng.tile.AEBaseInvTile;
+import appeng.tile.AEBaseTile;
+import appeng.tile.networking.TileCableBus;
+import appeng.tile.storage.TileSkyChest;
+import appeng.util.Platform;
+import appeng.util.SettingsFrom;
 import com.google.common.collect.Lists;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.ITileEntityProvider;
 import net.minecraft.block.material.Material;
@@ -46,111 +55,88 @@ import net.minecraft.world.World;
 import net.minecraftforge.common.property.ExtendedBlockState;
 import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.common.property.IUnlistedProperty;
+import net.minecraftforge.event.ForgeEventFactory;
 import net.minecraftforge.items.ItemHandlerHelper;
 
-import appeng.api.implementations.items.IMemoryCard;
+import javax.annotation.Nonnull;
-import appeng.api.implementations.items.MemoryCardMessages;
+import javax.annotation.Nullable;
-import appeng.api.implementations.tiles.IColorableTile;
+import java.util.ArrayList;
-import appeng.api.util.AEColor;
+import java.util.List;
-import appeng.api.util.IOrientable;
-import appeng.block.networking.BlockCableBus;
-import appeng.helpers.ICustomCollision;
-import appeng.tile.AEBaseInvTile;
-import appeng.tile.AEBaseTile;
-import appeng.tile.networking.TileCableBus;
-import appeng.tile.storage.TileSkyChest;
-import appeng.util.Platform;
-import appeng.util.SettingsFrom;
 
 
-public abstract class AEBaseTileBlock extends AEBaseBlock implements ITileEntityProvider
+public abstract class AEBaseTileBlock extends AEBaseBlock implements ITileEntityProvider {
-{
 
     @Nonnull
     private Class<? extends AEBaseTile> tileEntityType;
 
-	public AEBaseTileBlock( final Material mat )
+    public AEBaseTileBlock(final Material mat) {
-	{
+        super(mat);
-		super( mat );
     }
 
-	public static final UnlistedDirection FORWARD = new UnlistedDirection( "forward" );
+    public static final UnlistedDirection FORWARD = new UnlistedDirection("forward");
-	public static final UnlistedDirection UP = new UnlistedDirection( "up" );
+    public static final UnlistedDirection UP = new UnlistedDirection("up");
 
     @Override
-	public IBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         // A subclass may decide it doesn't want extended block state for whatever reason
-		if( !( state instanceof IExtendedBlockState ) )
+        if (!(state instanceof IExtendedBlockState)) {
-		{
             return state;
         }
 
-		AEBaseTile tile = this.getTileEntity( world, pos );
+        AEBaseTile tile = this.getTileEntity(world, pos);
-		if( tile == null )
+        if (tile == null) {
-		{
             return state; // No info available
         }
 
         IExtendedBlockState extState = (IExtendedBlockState) state;
-		return extState.withProperty( FORWARD, tile.getForward() ).withProperty( UP, tile.getUp() );
+        return extState.withProperty(FORWARD, tile.getForward()).withProperty(UP, tile.getUp());
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, this.getAEStates(), new IUnlistedProperty[]{
-		return new ExtendedBlockState( this, this.getAEStates(), new IUnlistedProperty[] {
                 FORWARD,
                 UP
-		} );
+        });
     }
 
     @Override
-	public int getMetaFromState( IBlockState state )
+    public int getMetaFromState(IBlockState state) {
-	{
         return 0;
     }
 
     // TODO : Was this change needed?
-	public void setTileEntity( final Class<? extends AEBaseTile> c )
+    public void setTileEntity(final Class<? extends AEBaseTile> c) {
-	{
         this.tileEntityType = c;
-		this.setInventory( AEBaseInvTile.class.isAssignableFrom( c ) );
+        this.setInventory(AEBaseInvTile.class.isAssignableFrom(c));
     }
 
     @Override
-	public boolean hasTileEntity( IBlockState state )
+    public boolean hasTileEntity(IBlockState state) {
-	{
         return this.hasBlockTileEntity();
     }
 
-	private boolean hasBlockTileEntity()
+    private boolean hasBlockTileEntity() {
-	{
         return this.tileEntityType != null;
     }
 
-	public Class<? extends AEBaseTile> getTileEntityClass()
+    public Class<? extends AEBaseTile> getTileEntityClass() {
-	{
         return this.tileEntityType;
     }
 
     @Nullable
-	public <T extends AEBaseTile> T getTileEntity( final IBlockAccess w, final int x, final int y, final int z )
+    public <T extends AEBaseTile> T getTileEntity(final IBlockAccess w, final int x, final int y, final int z) {
-	{
+        return this.getTileEntity(w, new BlockPos(x, y, z));
-		return this.getTileEntity( w, new BlockPos( x, y, z ) );
     }
 
     @Nullable
-	public <T extends AEBaseTile> T getTileEntity( final IBlockAccess w, final BlockPos pos )
+    public <T extends AEBaseTile> T getTileEntity(final IBlockAccess w, final BlockPos pos) {
-	{
+        if (!this.hasBlockTileEntity()) {
-		if( !this.hasBlockTileEntity() )
-		{
             return null;
         }
 
-		final TileEntity te = w.getTileEntity( pos );
+        final TileEntity te = w.getTileEntity(pos);
-		if( this.tileEntityType.isInstance( te ) )
+        if (this.tileEntityType.isInstance(te)) {
-		{
             return (T) te;
         }
 
@@ -158,21 +144,14 @@ public abstract class AEBaseTileBlock extends AEBaseBlock implements ITileEntity
     }
 
     @Override
-	public final TileEntity createNewTileEntity( final World var1, final int var2 )
+    public final TileEntity createNewTileEntity(final World var1, final int var2) {
-	{
+        if (this.hasBlockTileEntity()) {
-		if( this.hasBlockTileEntity() )
+            try {
-		{
-			try
-			{
                 return this.tileEntityType.newInstance();
-			}
+            } catch (final InstantiationException e) {
-			catch( final InstantiationException e )
+                throw new IllegalStateException("Failed to create a new instance of an illegal class " + this.tileEntityType, e);
-			{
+            } catch (final IllegalAccessException e) {
-				throw new IllegalStateException( "Failed to create a new instance of an illegal class " + this.tileEntityType, e );
+                throw new IllegalStateException("Failed to create a new instance of " + this.tileEntityType + ", because lack of permissions", e);
-			}
-			catch( final IllegalAccessException e )
-			{
-				throw new IllegalStateException( "Failed to create a new instance of " + this.tileEntityType + ", because lack of permissions", e );
             }
         }
 
@@ -180,214 +159,183 @@ public abstract class AEBaseTileBlock extends AEBaseBlock implements ITileEntity
     }
 
     @Override
-	public void breakBlock( final World w, final BlockPos pos, final IBlockState state )
+    public void breakBlock(final World w, final BlockPos pos, final IBlockState state) {
-	{
+        final AEBaseTile te = this.getTileEntity(w, pos);
-		final AEBaseTile te = this.getTileEntity( w, pos );
+        if (te != null) {
-		if( te != null )
-		{
             final ArrayList<ItemStack> drops = new ArrayList<>();
-			if( te.dropItems() )
+            if (te.dropItems()) {
-			{
+                te.getDrops(w, pos, drops);
-				te.getDrops( w, pos, drops );
+            } else {
-			}
+                te.getNoDrops(w, pos, drops);
-			else
-			{
-				te.getNoDrops( w, pos, drops );
             }
 
             // Cry ;_; ...
-			Platform.spawnDrops( w, pos, drops );
+            Platform.spawnDrops(w, pos, drops);
         }
 
         // super will remove the TE, as it is not an instance of BlockContainer
-		super.breakBlock( w, pos, state );
+        super.breakBlock(w, pos, state);
     }
 
     @Override
-	public final EnumFacing[] getValidRotations( final World w, final BlockPos pos )
+    public final EnumFacing[] getValidRotations(final World w, final BlockPos pos) {
-	{
+        final AEBaseTile obj = this.getTileEntity(w, pos);
-		final AEBaseTile obj = this.getTileEntity( w, pos );
+        if (obj != null && obj.canBeRotated()) {
-		if( obj != null && obj.canBeRotated() )
-		{
             return EnumFacing.VALUES;
         }
 
-		return super.getValidRotations( w, pos );
+        return super.getValidRotations(w, pos);
     }
 
     @Override
-	public boolean recolorBlock( final World world, final BlockPos pos, final EnumFacing side, final EnumDyeColor color )
+    public boolean recolorBlock(final World world, final BlockPos pos, final EnumFacing side, final EnumDyeColor color) {
-	{
+        final TileEntity te = this.getTileEntity(world, pos);
-		final TileEntity te = this.getTileEntity( world, pos );
 
-		if( te instanceof IColorableTile )
+        if (te instanceof IColorableTile) {
-		{
             final IColorableTile ct = (IColorableTile) te;
             final AEColor c = ct.getColor();
             final AEColor newColor = AEColor.values()[color.getMetadata()];
 
-			if( c != newColor )
+            if (c != newColor) {
-			{
+                ct.recolourBlock(side, newColor, null);
-				ct.recolourBlock( side, newColor, null );
                 return true;
             }
             return false;
         }
 
-		return super.recolorBlock( world, pos, side, color );
+        return super.recolorBlock(world, pos, side, color);
     }
 
     @Override
-	public int getComparatorInputOverride( IBlockState state, final World w, final BlockPos pos )
+    public int getComparatorInputOverride(IBlockState state, final World w, final BlockPos pos) {
-	{
+        final TileEntity te = this.getTileEntity(w, pos);
-		final TileEntity te = this.getTileEntity( w, pos );
+        if (te instanceof AEBaseInvTile) {
-		if( te instanceof AEBaseInvTile )
-		{
             AEBaseInvTile invTile = (AEBaseInvTile) te;
-			if( invTile.getInternalInventory().getSlots() > 0 )
+            if (invTile.getInternalInventory().getSlots() > 0) {
-			{
+                return ItemHandlerHelper.calcRedstoneFromInventory(invTile.getInternalInventory());
-				return ItemHandlerHelper.calcRedstoneFromInventory( invTile.getInternalInventory() );
             }
         }
         return 0;
     }
 
     @Override
-	public boolean eventReceived( final IBlockState state, final World worldIn, final BlockPos pos, final int eventID, final int eventParam )
+    public boolean eventReceived(final IBlockState state, final World worldIn, final BlockPos pos, final int eventID, final int eventParam) {
-	{
+        super.eventReceived(state, worldIn, pos, eventID, eventParam);
-		super.eventReceived( state, worldIn, pos, eventID, eventParam );
+        final TileEntity tileentity = worldIn.getTileEntity(pos);
-		final TileEntity tileentity = worldIn.getTileEntity( pos );
+        return tileentity != null && tileentity.receiveClientEvent(eventID, eventParam);
-		return tileentity != null ? tileentity.receiveClientEvent( eventID, eventParam ) : false;
     }
 
     @Override
-	public void onBlockPlacedBy( final World w, final BlockPos pos, final IBlockState state, final EntityLivingBase placer, final ItemStack is )
+    public void onBlockPlacedBy(final World w, final BlockPos pos, final IBlockState state, final EntityLivingBase placer, final ItemStack is) {
-	{
+        if (is.hasDisplayName()) {
-		if( is.hasDisplayName() )
+            final TileEntity te = this.getTileEntity(w, pos);
-		{
+            if (te instanceof AEBaseTile) {
-			final TileEntity te = this.getTileEntity( w, pos );
+                ((AEBaseTile) w.getTileEntity(pos)).setName(is.getDisplayName());
-			if( te instanceof AEBaseTile )
-			{
-				( (AEBaseTile) w.getTileEntity( pos ) ).setName( is.getDisplayName() );
             }
         }
     }
 
     @Override
-	public boolean onBlockActivated( World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ )
+    public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
-	{
         ItemStack heldItem;
-		if( player != null && !player.getHeldItem( hand ).isEmpty() )
+        if (player != null && !player.getHeldItem(hand).isEmpty()) {
-		{
+            heldItem = player.getHeldItem(hand);
-			heldItem = player.getHeldItem( hand );
 
-			if( Platform.isWrench( player, heldItem, pos ) && player.isSneaking() )
+            if (Platform.isWrench(player, heldItem, pos) && player.isSneaking()) {
-			{
+                final IBlockState blockState = world.getBlockState(pos);
-				final IBlockState blockState = world.getBlockState( pos );
                 final Block block = blockState.getBlock();
 
-				if( block == null )
+                if (block == null) {
-				{
                     return false;
                 }
 
-				final AEBaseTile tile = this.getTileEntity( world, pos );
+                final AEBaseTile tile = this.getTileEntity(world, pos);
 
-				if( tile == null )
+                if (tile == null) {
-				{
                     return false;
                 }
 
-				if( tile instanceof TileCableBus || tile instanceof TileSkyChest )
+                if (tile instanceof TileCableBus || tile instanceof TileSkyChest) {
-				{
                     return false;
                 }
 
-				final ItemStack[] itemDropCandidates = Platform.getBlockDrops( world, pos );
+                final ItemStack[] itemDropCandidates = Platform.getBlockDrops(world, pos);
-				final ItemStack op = new ItemStack( this );
+                final ItemStack op = new ItemStack(this);
 
-				for( final ItemStack ol : itemDropCandidates )
+                for (final ItemStack ol : itemDropCandidates) {
-				{
+                    if (Platform.itemComparisons().isEqualItemType(ol, op)) {
-					if( Platform.itemComparisons().isEqualItemType( ol, op ) )
+                        final NBTTagCompound tag = tile.downloadSettings(SettingsFrom.DISMANTLE_ITEM);
-					{
+                        if (tag != null) {
-						final NBTTagCompound tag = tile.downloadSettings( SettingsFrom.DISMANTLE_ITEM );
+                            ol.setTagCompound(tag);
-						if( tag != null )
-						{
-							ol.setTagCompound( tag );
                         }
                     }
                 }
 
-				if( block.removedByPlayer( blockState, world, pos, player, false ) )
+                if (block.removedByPlayer(blockState, world, pos, player, false)) {
-				{
+                    final List<ItemStack> itemsToDrop = Lists.newArrayList(itemDropCandidates);
-					final List<ItemStack> itemsToDrop = Lists.newArrayList( itemDropCandidates );
+                    Platform.spawnDrops(world, pos, itemsToDrop);
-					Platform.spawnDrops( world, pos, itemsToDrop );
+                    world.setBlockToAir(pos);
-					world.setBlockToAir( pos );
                 }
 
                 return false;
             }
 
-			if( heldItem.getItem() instanceof IMemoryCard && !( this instanceof BlockCableBus ) )
+            if (heldItem.getItem() instanceof IMemoryCard && !(this instanceof BlockCableBus)) {
-			{
                 final IMemoryCard memoryCard = (IMemoryCard) heldItem.getItem();
-				final AEBaseTile tileEntity = this.getTileEntity( world, pos );
+                final AEBaseTile tileEntity = this.getTileEntity(world, pos);
 
-				if( tileEntity == null )
+                if (tileEntity == null) {
-				{
                     return false;
                 }
 
                 final String name = this.getUnlocalizedName();
 
-				if( player.isSneaking() )
+                if (player.isSneaking()) {
-				{
+                    final NBTTagCompound data = tileEntity.downloadSettings(SettingsFrom.MEMORY_CARD);
-					final NBTTagCompound data = tileEntity.downloadSettings( SettingsFrom.MEMORY_CARD );
+                    if (data != null) {
-					if( data != null )
+                        memoryCard.setMemoryCardContents(heldItem, name, data);
-					{
+                        memoryCard.notifyUser(player, MemoryCardMessages.SETTINGS_SAVED);
-						memoryCard.setMemoryCardContents( heldItem, name, data );
-						memoryCard.notifyUser( player, MemoryCardMessages.SETTINGS_SAVED );
                     }
-				}
+                } else {
-				else
+                    final String savedName = memoryCard.getSettingsName(heldItem);
-				{
+                    final NBTTagCompound data = memoryCard.getData(heldItem);
-					final String savedName = memoryCard.getSettingsName( heldItem );
-					final NBTTagCompound data = memoryCard.getData( heldItem );
 
-					if( this.getUnlocalizedName().equals( savedName ) )
+                    if (this.getUnlocalizedName().equals(savedName)) {
-					{
+                        tileEntity.uploadSettings(SettingsFrom.MEMORY_CARD, data, player);
-						tileEntity.uploadSettings( SettingsFrom.MEMORY_CARD, data );
+                        memoryCard.notifyUser(player, MemoryCardMessages.SETTINGS_LOADED);
-						memoryCard.notifyUser( player, MemoryCardMessages.SETTINGS_LOADED );
+                    } else {
-					}
+                        memoryCard.notifyUser(player, MemoryCardMessages.INVALID_MACHINE);
-					else
-					{
-						memoryCard.notifyUser( player, MemoryCardMessages.INVALID_MACHINE );
                     }
                 }
 
                 return true;
             }
+
+            if (heldItem.getItem() instanceof ToolQuartzCuttingKnife && !(this instanceof BlockCableBus)) {
+                if (ForgeEventFactory.onItemUseStart(player, heldItem, 1) <= 0) return false;
+                final AEBaseTile tile = this.getTileEntity(world, pos);
+                if (tile == null) return false;
+                Platform.openGUI(player, tile, AEPartLocation.fromFacing(facing), GuiBridge.GUI_RENAMER);
+                return true;
+            }
         }
 
-		return this.onActivated( world, pos, player, hand, player.getHeldItem( hand ), facing, hitX, hitY, hitZ );
+        return this.onActivated(world, pos, player, hand, player.getHeldItem(hand), facing, hitX, hitY, hitZ);
     }
 
     @Override
-	public IOrientable getOrientable( final IBlockAccess w, final BlockPos pos )
+    public IOrientable getOrientable(final IBlockAccess w, final BlockPos pos) {
-	{
+        return this.getTileEntity(w, pos);
-		return this.getTileEntity( w, pos );
     }
 
     @Override
-	public ICustomCollision getCustomCollision( final World w, final BlockPos pos )
+    public ICustomCollision getCustomCollision(final World w, final BlockPos pos) {
-	{
+        final AEBaseTile te = this.getTileEntity(w, pos);
-		final AEBaseTile te = this.getTileEntity( w, pos );
+        if (te instanceof ICustomCollision) {
-		if( te instanceof ICustomCollision )
-		{
             return (ICustomCollision) te;
         }
 
-		return super.getCustomCollision( w, pos );
+        return super.getCustomCollision(w, pos);
     }
 
 }

src/main/java/appeng/block/AEDecorativeBlock.java

@@ -22,10 +22,8 @@ package appeng.block;
 import net.minecraft.block.material.Material;
 
 
-public abstract class AEDecorativeBlock extends AEBaseBlock
+public abstract class AEDecorativeBlock extends AEBaseBlock {
-{
+    public AEDecorativeBlock(final Material mat) {
-	public AEDecorativeBlock( final Material mat )
+        super(mat);
-	{
-		super( mat );
     }
 }

src/main/java/appeng/block/UnlistedBlockAccess.java

@@ -23,29 +23,24 @@ import net.minecraft.world.IBlockAccess;
 import net.minecraftforge.common.property.IUnlistedProperty;
 
 
-public final class UnlistedBlockAccess implements IUnlistedProperty<IBlockAccess>
+public final class UnlistedBlockAccess implements IUnlistedProperty<IBlockAccess> {
-{
     @Override
-	public String getName()
+    public String getName() {
-	{
         return "ba";
     }
 
     @Override
-	public boolean isValid( final IBlockAccess value )
+    public boolean isValid(final IBlockAccess value) {
-	{
         return true;
     }
 
     @Override
-	public Class<IBlockAccess> getType()
+    public Class<IBlockAccess> getType() {
-	{
         return IBlockAccess.class;
     }
 
     @Override
-	public String valueToString( final IBlockAccess value )
+    public String valueToString(final IBlockAccess value) {
-	{
         return null;
     }
 }

src/main/java/appeng/block/UnlistedBlockPos.java

@@ -23,29 +23,24 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraftforge.common.property.IUnlistedProperty;
 
 
-public final class UnlistedBlockPos implements IUnlistedProperty<BlockPos>
+public final class UnlistedBlockPos implements IUnlistedProperty<BlockPos> {
-{
     @Override
-	public String getName()
+    public String getName() {
-	{
         return "pos";
     }
 
     @Override
-	public boolean isValid( final BlockPos value )
+    public boolean isValid(final BlockPos value) {
-	{
         return true;
     }
 
     @Override
-	public Class<BlockPos> getType()
+    public Class<BlockPos> getType() {
-	{
         return BlockPos.class;
     }
 
     @Override
-	public String valueToString( final BlockPos value )
+    public String valueToString(final BlockPos value) {
-	{
         return null;
     }
 }

src/main/java/appeng/block/UnlistedDirection.java

@@ -23,37 +23,31 @@ import net.minecraft.util.EnumFacing;
 import net.minecraftforge.common.property.IUnlistedProperty;
 
 
-public class UnlistedDirection implements IUnlistedProperty<EnumFacing>
+public class UnlistedDirection implements IUnlistedProperty<EnumFacing> {
-{
 
     private final String name;
 
-	public UnlistedDirection( String name )
+    public UnlistedDirection(String name) {
-	{
         this.name = name;
     }
 
     @Override
-	public String getName()
+    public String getName() {
-	{
         return this.name;
     }
 
     @Override
-	public boolean isValid( EnumFacing value )
+    public boolean isValid(EnumFacing value) {
-	{
         return value != null;
     }
 
     @Override
-	public Class<EnumFacing> getType()
+    public Class<EnumFacing> getType() {
-	{
         return EnumFacing.class;
     }
 
     @Override
-	public String valueToString( EnumFacing value )
+    public String valueToString(EnumFacing value) {
-	{
         return value.getName();
     }
 

src/main/java/appeng/block/crafting/BlockCraftingMonitor.java

@@ -19,6 +19,9 @@
 package appeng.block.crafting;
 
 
+import appeng.api.util.AEColor;
+import appeng.client.UnlistedProperty;
+import appeng.tile.crafting.TileCraftingMonitorTile;
 import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.creativetab.CreativeTabs;
@@ -33,57 +36,47 @@ import net.minecraftforge.common.property.IUnlistedProperty;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.AEColor;
-import appeng.client.UnlistedProperty;
-import appeng.tile.crafting.TileCraftingMonitorTile;
 
+public class BlockCraftingMonitor extends BlockCraftingUnit {
 
-public class BlockCraftingMonitor extends BlockCraftingUnit
+    public static final UnlistedProperty<AEColor> COLOR = new UnlistedProperty<>("color", AEColor.class);
-{
 
-	public static final UnlistedProperty<AEColor> COLOR = new UnlistedProperty<>( "color", AEColor.class );
+    public BlockCraftingMonitor() {
-
+        super(CraftingUnitType.MONITOR);
-	public BlockCraftingMonitor()
-	{
-		super( CraftingUnitType.MONITOR );
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, this.getAEStates(), new IUnlistedProperty[]{
-		return new ExtendedBlockState( this, this.getAEStates(), new IUnlistedProperty[] {
                 STATE,
                 COLOR,
                 FORWARD,
                 UP
-		} );
+        });
     }
 
     @Override
-	public IExtendedBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IExtendedBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         AEColor color = AEColor.TRANSPARENT;
         EnumFacing forward = EnumFacing.NORTH;
         EnumFacing up = EnumFacing.UP;
 
-		TileCraftingMonitorTile te = this.getTileEntity( world, pos );
+        TileCraftingMonitorTile te = this.getTileEntity(world, pos);
-		if( te != null )
+        if (te != null) {
-		{
             color = te.getColor();
             forward = te.getForward();
             up = te.getUp();
         }
 
-		return super.getExtendedState( state, world, pos )
+        return super.getExtendedState(state, world, pos)
-				.withProperty( COLOR, color )
+                .withProperty(COLOR, color)
-				.withProperty( FORWARD, forward )
+                .withProperty(FORWARD, forward)
-				.withProperty( UP, up );
+                .withProperty(UP, up);
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void getSubBlocks( final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks )
+    public void getSubBlocks(final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks) {
-	{
+        itemStacks.add(new ItemStack(this, 1, 0));
-		itemStacks.add( new ItemStack( this, 1, 0 ) );
     }
 }

src/main/java/appeng/block/crafting/BlockCraftingStorage.java

@@ -19,12 +19,10 @@
 package appeng.block.crafting;
 
 
-public class BlockCraftingStorage extends BlockCraftingUnit
+public class BlockCraftingStorage extends BlockCraftingUnit {
-{
 
-	public BlockCraftingStorage( final CraftingUnitType type )
+    public BlockCraftingStorage(final CraftingUnitType type) {
-	{
+        super(type);
-		super( type );
     }
 
 }

src/main/java/appeng/block/crafting/BlockCraftingUnit.java

@@ -19,8 +19,13 @@
 package appeng.block.crafting;
 
 
-import java.util.EnumSet;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.client.UnlistedProperty;
+import appeng.client.render.crafting.CraftingCubeState;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.crafting.TileCraftingTile;
+import appeng.util.Platform;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
@@ -38,130 +43,105 @@ import net.minecraftforge.common.property.ExtendedBlockState;
 import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.common.property.IUnlistedProperty;
 
-import appeng.api.util.AEPartLocation;
+import java.util.EnumSet;
-import appeng.block.AEBaseTileBlock;
-import appeng.client.UnlistedProperty;
-import appeng.client.render.crafting.CraftingCubeState;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.crafting.TileCraftingTile;
-import appeng.util.Platform;
 
 
-public class BlockCraftingUnit extends AEBaseTileBlock
+public class BlockCraftingUnit extends AEBaseTileBlock {
-{
+    public static final PropertyBool FORMED = PropertyBool.create("formed");
-	public static final PropertyBool FORMED = PropertyBool.create( "formed" );
+    public static final PropertyBool POWERED = PropertyBool.create("powered");
-	public static final PropertyBool POWERED = PropertyBool.create( "powered" );
+    public static final UnlistedProperty<CraftingCubeState> STATE = new UnlistedProperty<>("state", CraftingCubeState.class);
-	public static final UnlistedProperty<CraftingCubeState> STATE = new UnlistedProperty<>( "state", CraftingCubeState.class );
 
     public final CraftingUnitType type;
 
-	public BlockCraftingUnit( final CraftingUnitType type )
+    public BlockCraftingUnit(final CraftingUnitType type) {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
 
         this.type = type;
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{POWERED, FORMED};
-		return new IProperty[] { POWERED, FORMED };
     }
 
     @Override
-	public IExtendedBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IExtendedBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
 
-		EnumSet<EnumFacing> connections = EnumSet.noneOf( EnumFacing.class );
+        EnumSet<EnumFacing> connections = EnumSet.noneOf(EnumFacing.class);
 
-		for( EnumFacing facing : EnumFacing.values() )
+        for (EnumFacing facing : EnumFacing.values()) {
-		{
+            if (this.isConnected(world, pos, facing)) {
-			if( this.isConnected( world, pos, facing ) )
+                connections.add(facing);
-			{
-				connections.add( facing );
             }
         }
 
         IExtendedBlockState extState = (IExtendedBlockState) state;
 
-		return extState.withProperty( STATE, new CraftingCubeState( connections ) );
+        return extState.withProperty(STATE, new CraftingCubeState(connections));
     }
 
-	private boolean isConnected( IBlockAccess world, BlockPos pos, EnumFacing side )
+    private boolean isConnected(IBlockAccess world, BlockPos pos, EnumFacing side) {
-	{
+        BlockPos adjacentPos = pos.offset(side);
-		BlockPos adjacentPos = pos.offset( side );
+        return world.getBlockState(adjacentPos).getBlock() instanceof BlockCraftingUnit;
-		return world.getBlockState( adjacentPos ).getBlock() instanceof BlockCraftingUnit;
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, this.getAEStates(), new IUnlistedProperty[]{STATE});
-		return new ExtendedBlockState( this, this.getAEStates(), new IUnlistedProperty[] { STATE } );
     }
 
     @Override
-	public IBlockState getStateFromMeta( final int meta )
+    public IBlockState getStateFromMeta(final int meta) {
-	{
+        return this.getDefaultState().withProperty(POWERED, (meta & 1) == 1).withProperty(FORMED, (meta & 2) == 2);
-		return this.getDefaultState().withProperty( POWERED, ( meta & 1 ) == 1 ).withProperty( FORMED, ( meta & 2 ) == 2 );
     }
 
     @Override
-	public int getMetaFromState( final IBlockState state )
+    public int getMetaFromState(final IBlockState state) {
-	{
+        boolean p = state.getValue(POWERED);
-		boolean p = state.getValue( POWERED );
+        boolean f = state.getValue(FORMED);
-		boolean f = state.getValue( FORMED );
+        return (p ? 1 : 0) | (f ? 2 : 0);
-		return ( p ? 1 : 0 ) | ( f ? 2 : 0 );
     }
 
     @Override
-	public void neighborChanged( final IBlockState state, final World worldIn, final BlockPos pos, final Block blockIn, final BlockPos fromPos )
+    public void neighborChanged(final IBlockState state, final World worldIn, final BlockPos pos, final Block blockIn, final BlockPos fromPos) {
-	{
+        final TileCraftingTile cp = this.getTileEntity(worldIn, pos);
-		final TileCraftingTile cp = this.getTileEntity( worldIn, pos );
+        if (cp != null) {
-		if( cp != null )
-		{
             cp.updateMultiBlock();
         }
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	public void breakBlock( final World w, final BlockPos pos, final IBlockState state )
+    public void breakBlock(final World w, final BlockPos pos, final IBlockState state) {
-	{
+        final TileCraftingTile cp = this.getTileEntity(w, pos);
-		final TileCraftingTile cp = this.getTileEntity( w, pos );
+        if (cp != null) {
-		if( cp != null )
-		{
             cp.breakCluster();
         }
 
-		super.breakBlock( w, pos, state );
+        super.breakBlock(w, pos, state);
     }
 
     @Override
-	public boolean onBlockActivated( final World w, final BlockPos pos, final IBlockState state, final EntityPlayer p, final EnumHand hand, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onBlockActivated(final World w, final BlockPos pos, final IBlockState state, final EntityPlayer p, final EnumHand hand, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        final TileCraftingTile tg = this.getTileEntity(w, pos);
-		final TileCraftingTile tg = this.getTileEntity( w, pos );
 
-		if( tg != null && !p.isSneaking() && tg.isFormed() && tg.isActive() )
+        if (tg != null && !p.isSneaking() && tg.isFormed() && tg.isActive()) {
-		{
+            if (Platform.isClient()) {
-			if( Platform.isClient() )
-			{
                 return true;
             }
 
-			Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_CRAFTING_CPU );
+            Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_CRAFTING_CPU);
             return true;
         }
 
-		return super.onBlockActivated( w, pos, state, p, hand, side, hitX, hitY, hitZ );
+        return super.onBlockActivated(w, pos, state, p, hand, side, hitX, hitY, hitZ);
     }
 
-	public enum CraftingUnitType
+    public enum CraftingUnitType {
-	{
         UNIT, ACCELERATOR, STORAGE_1K, STORAGE_4K, STORAGE_16K, STORAGE_64K, MONITOR
     }
 }

src/main/java/appeng/block/crafting/BlockMolecularAssembler.java

@@ -19,6 +19,11 @@
 package appeng.block.crafting;
 
 
+import appeng.api.util.AEPartLocation;
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.crafting.TileMolecularAssembler;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.properties.PropertyBool;
@@ -33,79 +38,71 @@ import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.AEPartLocation;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.crafting.TileMolecularAssembler;
-import appeng.util.Platform;
 
+public class BlockMolecularAssembler extends AEBaseTileBlock {
 
-public class BlockMolecularAssembler extends AEBaseTileBlock
+    public static final PropertyBool POWERED = PropertyBool.create("powered");
-{
 
-	public static final PropertyBool POWERED = PropertyBool.create( "powered" );
+    public BlockMolecularAssembler() {
+        super(Material.IRON);
 
-	public BlockMolecularAssembler()
+        this.setOpaque(false);
-	{
-		super( Material.IRON );
-
-		this.setOpaque( false );
         this.lightOpacity = 1;
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{POWERED};
-		return new IProperty[] { POWERED };
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess worldIn, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
-	{
         boolean powered = false;
-		TileMolecularAssembler te = this.getTileEntity( worldIn, pos );
+        TileMolecularAssembler te = this.getTileEntity(worldIn, pos);
-		if( te != null )
+        if (te != null) {
-		{
             powered = te.isPowered();
         }
 
-		return super.getActualState( state, worldIn, pos ).withProperty( POWERED, powered );
+        return super.getActualState(state, worldIn, pos).withProperty(POWERED, powered);
     }
 
     /**
      * NOTE: This is only used to determine how to render an item being held in hand.
      * For determining block rendering, the method below is used (canRenderInLayer).
      */
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public boolean canRenderInLayer( IBlockState state, BlockRenderLayer layer )
+    public boolean canRenderInLayer(IBlockState state, BlockRenderLayer layer) {
-	{
         return layer == BlockRenderLayer.CUTOUT || layer == BlockRenderLayer.TRANSLUCENT;
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 
     @Override
-	public boolean onBlockActivated( final World w, final BlockPos pos, final IBlockState state, final EntityPlayer p, final EnumHand hand, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onBlockActivated(final World w, final BlockPos pos, final IBlockState state, final EntityPlayer p, final EnumHand hand, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        final TileMolecularAssembler tg = this.getTileEntity(w, pos);
-		final TileMolecularAssembler tg = this.getTileEntity( w, pos );
+        if (tg != null && !p.isSneaking()) {
-		if( tg != null && !p.isSneaking() )
+            Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_MAC);
-		{
-			Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_MAC );
             return true;
         }
 
-		return super.onBlockActivated( w, pos, state, p, hand, side, hitX, hitY, hitZ );
+        return super.onBlockActivated(w, pos, state, p, hand, side, hitX, hitY, hitZ);
+    }
+
+    @Override
+    public void onNeighborChange(IBlockAccess world, BlockPos pos, BlockPos neighbor) {
+        final TileMolecularAssembler tg = this.getTileEntity(world, pos);
+        if (tg != null) {
+            tg.updateNeighbors(world, pos, neighbor);
+        }
     }
 }

src/main/java/appeng/block/crafting/ItemCraftingStorage.java

@@ -19,32 +19,27 @@
 package appeng.block.crafting;
 
 
-import net.minecraft.block.Block;
-import net.minecraft.item.ItemStack;
-
 import appeng.api.AEApi;
 import appeng.block.AEBaseItemBlock;
 import appeng.core.AEConfig;
 import appeng.core.features.AEFeature;
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemStack;
 
 
-public class ItemCraftingStorage extends AEBaseItemBlock
+public class ItemCraftingStorage extends AEBaseItemBlock {
-{
 
-	public ItemCraftingStorage( final Block id )
+    public ItemCraftingStorage(final Block id) {
-	{
+        super(id);
-		super( id );
     }
 
     @Override
-	public ItemStack getContainerItem( final ItemStack itemStack )
+    public ItemStack getContainerItem(final ItemStack itemStack) {
-	{
+        return AEApi.instance().definitions().blocks().craftingUnit().maybeStack(1).orElse(ItemStack.EMPTY);
-		return AEApi.instance().definitions().blocks().craftingUnit().maybeStack( 1 ).orElse( ItemStack.EMPTY );
     }
 
     @Override
-	public boolean hasContainerItem( final ItemStack stack )
+    public boolean hasContainerItem(final ItemStack stack) {
-	{
+        return AEConfig.instance().isFeatureEnabled(AEFeature.ENABLE_DISASSEMBLY_CRAFTING);
-		return AEConfig.instance().isFeatureEnabled( AEFeature.ENABLE_DISASSEMBLY_CRAFTING );
     }
 }

src/main/java/appeng/block/grindstone/BlockCrank.java

@@ -19,8 +19,11 @@
 package appeng.block.grindstone;
 
 
-import javax.annotation.Nullable;
+import appeng.api.implementations.tiles.ICrankable;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.stats.Stats;
+import appeng.tile.AEBaseTile;
+import appeng.tile.grindstone.TileCrank;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.BlockFaceShape;
@@ -37,144 +40,113 @@ import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.FakePlayer;
 
-import appeng.api.implementations.tiles.ICrankable;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.stats.Stats;
-import appeng.tile.AEBaseTile;
-import appeng.tile.grindstone.TileCrank;
 
 
-public class BlockCrank extends AEBaseTileBlock
+public class BlockCrank extends AEBaseTileBlock {
-{
 
-	public BlockCrank()
+    public BlockCrank() {
-	{
+        super(Material.WOOD);
-		super( Material.WOOD );
 
-		this.setLightOpacity( 0 );
+        this.setLightOpacity(0);
-		this.setHarvestLevel( "axe", 0 );
+        this.setHarvestLevel("axe", 0);
-		this.setFullSize( this.setOpaque( false ) );
+        this.setFullSize(this.setOpaque(false));
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (player instanceof FakePlayer || player == null) {
-		if( player instanceof FakePlayer || player == null )
+            this.dropCrank(w, pos);
-		{
-			this.dropCrank( w, pos );
             return true;
         }
 
-		final AEBaseTile tile = this.getTileEntity( w, pos );
+        final AEBaseTile tile = this.getTileEntity(w, pos);
-		if( tile instanceof TileCrank )
+        if (tile instanceof TileCrank) {
-		{
+            if (((TileCrank) tile).power()) {
-			if( ( (TileCrank) tile ).power() )
+                Stats.TurnedCranks.addToPlayer(player, 1);
-			{
-				Stats.TurnedCranks.addToPlayer( player, 1 );
             }
         }
 
         return true;
     }
 
-	private void dropCrank( final World world, final BlockPos pos )
+    private void dropCrank(final World world, final BlockPos pos) {
-	{
+        world.destroyBlock(pos, true); // w.destroyBlock( x, y, z, true );
-		world.destroyBlock( pos, true ); // w.destroyBlock( x, y, z, true );
+        world.notifyBlockUpdate(pos, this.getDefaultState(), world.getBlockState(pos), 3);
-		world.notifyBlockUpdate( pos, this.getDefaultState(), world.getBlockState( pos ), 3 );
     }
 
     @Override
-	public void onBlockPlacedBy( final World world, final BlockPos pos, final IBlockState state, final EntityLivingBase placer, final ItemStack stack )
+    public void onBlockPlacedBy(final World world, final BlockPos pos, final IBlockState state, final EntityLivingBase placer, final ItemStack stack) {
-	{
+        final AEBaseTile tile = this.getTileEntity(world, pos);
-		final AEBaseTile tile = this.getTileEntity( world, pos );
+        if (tile != null) {
-		if( tile != null )
+            final EnumFacing mnt = this.findCrankable(world, pos);
-		{
-			final EnumFacing mnt = this.findCrankable( world, pos );
             EnumFacing forward = EnumFacing.UP;
-			if( mnt == EnumFacing.UP || mnt == EnumFacing.DOWN )
+            if (mnt == EnumFacing.UP || mnt == EnumFacing.DOWN) {
-			{
                 forward = EnumFacing.SOUTH;
             }
-			tile.setOrientation( forward, mnt.getOpposite() );
+            tile.setOrientation(forward, mnt.getOpposite());
-		}
+        } else {
-		else
+            this.dropCrank(world, pos);
-		{
-			this.dropCrank( world, pos );
         }
     }
 
     @Override
-	public boolean isValidOrientation( final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up )
+    public boolean isValidOrientation(final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up) {
-	{
+        final TileEntity te = w.getTileEntity(pos);
-		final TileEntity te = w.getTileEntity( pos );
+        return !(te instanceof TileCrank) || this.isCrankable(w, pos, up.getOpposite());
-		return !( te instanceof TileCrank ) || this.isCrankable( w, pos, up.getOpposite() );
     }
 
-	private EnumFacing findCrankable( final World world, final BlockPos pos )
+    private EnumFacing findCrankable(final World world, final BlockPos pos) {
-	{
+        for (final EnumFacing dir : EnumFacing.VALUES) {
-		for( final EnumFacing dir : EnumFacing.VALUES )
+            if (this.isCrankable(world, pos, dir)) {
-		{
-			if( this.isCrankable( world, pos, dir ) )
-			{
                 return dir;
             }
         }
         return null;
     }
 
-	private boolean isCrankable( final World world, final BlockPos pos, final EnumFacing offset )
+    private boolean isCrankable(final World world, final BlockPos pos, final EnumFacing offset) {
-	{
+        final BlockPos o = pos.offset(offset);
-		final BlockPos o = pos.offset( offset );
+        final TileEntity te = world.getTileEntity(o);
-		final TileEntity te = world.getTileEntity( o );
 
-		return te instanceof ICrankable && ( (ICrankable) te ).canCrankAttach( offset.getOpposite() );
+        return te instanceof ICrankable && ((ICrankable) te).canCrankAttach(offset.getOpposite());
     }
 
     @Override
-	public EnumBlockRenderType getRenderType( IBlockState state )
+    public EnumBlockRenderType getRenderType(IBlockState state) {
-	{
         return EnumBlockRenderType.ENTITYBLOCK_ANIMATED;
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
 
-		final AEBaseTile tile = this.getTileEntity( world, pos );
+        final AEBaseTile tile = this.getTileEntity(world, pos);
-		if( tile != null )
+        if (tile != null) {
-		{
+            if (!this.isCrankable(world, pos, tile.getUp().getOpposite())) {
-			if( !this.isCrankable( world, pos, tile.getUp().getOpposite() ) )
+                this.dropCrank(world, pos);
-			{
-				this.dropCrank( world, pos );
             }
-		}
+        } else {
-		else
+            this.dropCrank(world, pos);
-		{
-			this.dropCrank( world, pos );
         }
     }
 
     @Override
-	public boolean canPlaceBlockAt( final World world, final BlockPos pos )
+    public boolean canPlaceBlockAt(final World world, final BlockPos pos) {
-	{
+        return this.findCrankable(world, pos) != null;
-		return this.findCrankable( world, pos ) != null;
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 
     @Override
-	public boolean canPlaceTorchOnTop( IBlockState state, IBlockAccess world, BlockPos pos )
+    public boolean canPlaceTorchOnTop(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         return false;
     }
 
     @Override
-	public BlockFaceShape getBlockFaceShape( IBlockAccess worldIn, IBlockState state, BlockPos pos, EnumFacing face )
+    public BlockFaceShape getBlockFaceShape(IBlockAccess worldIn, IBlockState state, BlockPos pos, EnumFacing face) {
-	{
         return BlockFaceShape.UNDEFINED;
     }
 

src/main/java/appeng/block/grindstone/BlockGrinder.java

@@ -19,8 +19,11 @@
 package appeng.block.grindstone;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.grindstone.TileGrinder;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -29,30 +32,22 @@ import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.grindstone.TileGrinder;
-import appeng.util.Platform;
 
 
-public class BlockGrinder extends AEBaseTileBlock
+public class BlockGrinder extends AEBaseTileBlock {
-{
 
-	public BlockGrinder()
+    public BlockGrinder() {
-	{
+        super(Material.ROCK);
-		super( Material.ROCK );
 
-		this.setHardness( 3.2F );
+        this.setHardness(3.2F);
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        final TileGrinder tg = this.getTileEntity(w, pos);
-		final TileGrinder tg = this.getTileEntity( w, pos );
+        if (tg != null && !p.isSneaking()) {
-		if( tg != null && !p.isSneaking() )
+            Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_GRINDER);
-		{
-			Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_GRINDER );
             return true;
         }
         return false;

src/main/java/appeng/block/grindstone/CrankRendering.java

@@ -19,22 +19,19 @@
 package appeng.block.grindstone;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.tesr.CrankTESR;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class CrankRendering extends BlockRenderingCustomizer
+public class CrankRendering extends BlockRenderingCustomizer {
-{
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.tesr(new CrankTESR());
-		rendering.tesr( new CrankTESR() );
     }
 }

src/main/java/appeng/block/misc/BlockCellWorkbench.java

@@ -19,8 +19,11 @@
 package appeng.block.misc;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.misc.TileCellWorkbench;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -29,35 +32,25 @@ import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.misc.TileCellWorkbench;
-import appeng.util.Platform;
 
 
-public class BlockCellWorkbench extends AEBaseTileBlock
+public class BlockCellWorkbench extends AEBaseTileBlock {
-{
 
-	public BlockCellWorkbench()
+    public BlockCellWorkbench() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileCellWorkbench tg = this.getTileEntity( w, pos );
+        final TileCellWorkbench tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_CELL_WORKBENCH);
-			{
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_CELL_WORKBENCH );
             }
             return true;
         }

src/main/java/appeng/block/misc/BlockCharger.java

@@ -19,17 +19,18 @@
 package appeng.block.misc;
 
 
-import java.util.Collections;
+import appeng.api.AEApi;
-import java.util.List;
+import appeng.api.util.AEAxisAlignedBB;
-import java.util.Random;
+import appeng.block.AEBaseTileBlock;
-
+import appeng.client.render.effects.LightningFX;
-import javax.annotation.Nullable;
+import appeng.client.render.renderable.ItemRenderable;
-
+import appeng.client.render.tesr.ModularTESR;
-import org.apache.commons.lang3.tuple.ImmutablePair;
+import appeng.core.AEConfig;
-import org.apache.commons.lang3.tuple.Pair;
+import appeng.core.AppEng;
-import org.lwjgl.util.vector.Matrix4f;
+import appeng.helpers.ICustomCollision;
-import org.lwjgl.util.vector.Vector3f;
+import appeng.tile.AEBaseTile;
-
+import appeng.tile.misc.TileCharger;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
@@ -44,46 +45,36 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+import org.lwjgl.util.vector.Matrix4f;
+import org.lwjgl.util.vector.Vector3f;
 
-import appeng.api.AEApi;
+import javax.annotation.Nullable;
-import appeng.api.util.AEAxisAlignedBB;
+import java.util.Collections;
-import appeng.block.AEBaseTileBlock;
+import java.util.List;
-import appeng.client.render.effects.LightningFX;
+import java.util.Random;
-import appeng.client.render.renderable.ItemRenderable;
-import appeng.client.render.tesr.ModularTESR;
-import appeng.core.AEConfig;
-import appeng.core.AppEng;
-import appeng.helpers.ICustomCollision;
-import appeng.tile.AEBaseTile;
-import appeng.tile.misc.TileCharger;
-import appeng.util.Platform;
 
 
-public class BlockCharger extends AEBaseTileBlock implements ICustomCollision
+public class BlockCharger extends AEBaseTileBlock implements ICustomCollision {
-{
 
-	public BlockCharger()
+    public BlockCharger() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
 
-		this.setLightOpacity( 2 );
+        this.setLightOpacity(2);
-		this.setFullSize( this.setOpaque( false ) );
+        this.setFullSize(this.setOpaque(false));
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (player.isSneaking()) {
-		if( player.isSneaking() )
-		{
             return false;
         }
 
-		if( Platform.isServer() )
+        if (Platform.isServer()) {
-		{
+            final TileCharger tc = this.getTileEntity(w, pos);
-			final TileCharger tc = this.getTileEntity( w, pos );
+            if (tc != null) {
-			if( tc != null )
+                tc.activate(player);
-			{
-				tc.activate( player );
             }
         }
 
@@ -91,37 +82,30 @@ public class BlockCharger extends AEBaseTileBlock implements ICustomCollision
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void randomDisplayTick( final IBlockState state, final World w, final BlockPos pos, final Random r )
+    public void randomDisplayTick(final IBlockState state, final World w, final BlockPos pos, final Random r) {
-	{
+        if (!AEConfig.instance().isEnableEffects()) {
-		if( !AEConfig.instance().isEnableEffects() )
-		{
             return;
         }
 
-		if( r.nextFloat() < 0.98 )
+        if (r.nextFloat() < 0.98) {
-		{
             return;
         }
 
-		final AEBaseTile tile = this.getTileEntity( w, pos );
+        final AEBaseTile tile = this.getTileEntity(w, pos);
-		if( tile instanceof TileCharger )
+        if (tile instanceof TileCharger) {
-		{
             final TileCharger tc = (TileCharger) tile;
 
-			if( AEApi.instance().definitions().materials().certusQuartzCrystalCharged().isSameAs( tc.getInternalInventory().getStackInSlot( 0 ) ) )
+            if (AEApi.instance().definitions().materials().certusQuartzCrystalCharged().isSameAs(tc.getInternalInventory().getStackInSlot(0))) {
-			{
                 final double xOff = 0.0;
                 final double yOff = 0.0;
                 final double zOff = 0.0;
 
-				for( int bolts = 0; bolts < 3; bolts++ )
+                for (int bolts = 0; bolts < 3; bolts++) {
-				{
+                    if (AppEng.proxy.shouldAddParticles(r)) {
-					if( AppEng.proxy.shouldAddParticles( r ) )
+                        final LightningFX fx = new LightningFX(w, xOff + 0.5 + pos.getX(), yOff + 0.5 + pos.getY(), zOff + 0.5 + pos
-					{
+                                .getZ(), 0.0D, 0.0D, 0.0D);
-						final LightningFX fx = new LightningFX( w, xOff + 0.5 + pos.getX(), yOff + 0.5 + pos.getY(), zOff + 0.5 + pos
+                        Minecraft.getMinecraft().effectRenderer.addEffect(fx);
-								.getZ(), 0.0D, 0.0D, 0.0D );
-						Minecraft.getMinecraft().effectRenderer.addEffect( fx );
                     }
                 }
             }
@@ -129,34 +113,28 @@ public class BlockCharger extends AEBaseTileBlock implements ICustomCollision
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
+        final TileCharger tile = this.getTileEntity(w, pos);
-		final TileCharger tile = this.getTileEntity( w, pos );
+        if (tile != null) {
-		if( tile != null )
-		{
             final double twoPixels = 2.0 / 16.0;
             final EnumFacing up = tile.getUp();
             final EnumFacing forward = tile.getForward();
-			final AEAxisAlignedBB bb = new AEAxisAlignedBB( twoPixels, twoPixels, twoPixels, 1.0 - twoPixels, 1.0 - twoPixels, 1.0 - twoPixels );
+            final AEAxisAlignedBB bb = new AEAxisAlignedBB(twoPixels, twoPixels, twoPixels, 1.0 - twoPixels, 1.0 - twoPixels, 1.0 - twoPixels);
 
-			if( up.getFrontOffsetX() != 0 )
+            if (up.getFrontOffsetX() != 0) {
-			{
                 bb.minX = 0;
                 bb.maxX = 1;
             }
-			if( up.getFrontOffsetY() != 0 )
+            if (up.getFrontOffsetY() != 0) {
-			{
                 bb.minY = 0;
                 bb.maxY = 1;
             }
-			if( up.getFrontOffsetZ() != 0 )
+            if (up.getFrontOffsetZ() != 0) {
-			{
                 bb.minZ = 0;
                 bb.maxZ = 1;
             }
 
-			switch( forward )
+            switch (forward) {
-			{
                 case DOWN:
                     bb.maxY = 1;
                     break;
@@ -179,29 +157,26 @@ public class BlockCharger extends AEBaseTileBlock implements ICustomCollision
                     break;
             }
 
-			return Collections.singletonList( bb.getBoundingBox() );
+            return Collections.singletonList(bb.getBoundingBox());
         }
-		return Collections.singletonList( new AxisAlignedBB( 0.0, 0, 0.0, 1.0, 1.0, 1.0 ) );
+        return Collections.singletonList(new AxisAlignedBB(0.0, 0, 0.0, 1.0, 1.0, 1.0));
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
+        out.add(new AxisAlignedBB(0.0, 0.0, 0.0, 1.0, 1.0, 1.0));
-		out.add( new AxisAlignedBB( 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ) );
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public static TileEntitySpecialRenderer<TileCharger> createTesr()
+    public static TileEntitySpecialRenderer<TileCharger> createTesr() {
-	{
+        return new ModularTESR<>(new ItemRenderable<>(BlockCharger::getRenderedItem));
-		return new ModularTESR<>( new ItemRenderable<>( BlockCharger::getRenderedItem ) );
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	private static Pair<ItemStack, Matrix4f> getRenderedItem( TileCharger tile )
+    private static Pair<ItemStack, Matrix4f> getRenderedItem(TileCharger tile) {
-	{
         Matrix4f transform = new Matrix4f();
-		transform.translate( new Vector3f( 0.5f, 0.4f, 0.5f ) );
+        transform.translate(new Vector3f(0.5f, 0.4f, 0.5f));
-		return new ImmutablePair<>( tile.getInternalInventory().getStackInSlot( 0 ), transform );
+        return new ImmutablePair<>(tile.getInternalInventory().getStackInSlot(0), transform);
     }
 
 }

src/main/java/appeng/block/misc/BlockCondenser.java

@@ -19,8 +19,11 @@
 package appeng.block.misc;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.misc.TileCondenser;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
@@ -29,35 +32,25 @@ import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.misc.TileCondenser;
-import appeng.util.Platform;
 
 
-public class BlockCondenser extends AEBaseTileBlock
+public class BlockCondenser extends AEBaseTileBlock {
-{
 
-	public BlockCondenser()
+    public BlockCondenser() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (player.isSneaking()) {
-		if( player.isSneaking() )
-		{
             return false;
         }
 
-		if( Platform.isServer() )
+        if (Platform.isServer()) {
-		{
+            final TileCondenser tc = this.getTileEntity(w, pos);
-			final TileCondenser tc = this.getTileEntity( w, pos );
+            if (tc != null && !player.isSneaking()) {
-			if( tc != null && !player.isSneaking() )
+                Platform.openGUI(player, tc, AEPartLocation.fromFacing(side), GuiBridge.GUI_CONDENSER);
-			{
-				Platform.openGUI( player, tc, AEPartLocation.fromFacing( side ), GuiBridge.GUI_CONDENSER );
                 return true;
             }
         }

src/main/java/appeng/block/misc/BlockInscriber.java

@@ -19,8 +19,11 @@
 package appeng.block.misc;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.misc.TileInscriber;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.player.EntityPlayer;
@@ -31,38 +34,28 @@ import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.misc.TileInscriber;
-import appeng.util.Platform;
 
 
-public class BlockInscriber extends AEBaseTileBlock
+public class BlockInscriber extends AEBaseTileBlock {
-{
 
-	public BlockInscriber()
+    public BlockInscriber() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
 
-		this.setLightOpacity( 2 );
+        this.setLightOpacity(2);
-		this.setFullSize( this.setOpaque( false ) );
+        this.setFullSize(this.setOpaque(false));
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileInscriber tg = this.getTileEntity( w, pos );
+        final TileInscriber tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_INSCRIBER);
-			{
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_INSCRIBER );
             }
             return true;
         }
@@ -70,14 +63,12 @@ public class BlockInscriber extends AEBaseTileBlock
     }
 
     @Override
-	public EnumBlockRenderType getRenderType( IBlockState state )
+    public EnumBlockRenderType getRenderType(IBlockState state) {
-	{
         return EnumBlockRenderType.MODEL;
     }
 
     @Override
-	public String getUnlocalizedName( final ItemStack is )
+    public String getUnlocalizedName(final ItemStack is) {
-	{
+        return super.getUnlocalizedName(is);
-		return super.getUnlocalizedName( is );
     }
 }

src/main/java/appeng/block/misc/BlockInterface.java

@@ -19,8 +19,12 @@
 package appeng.block.misc;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.api.util.IOrientable;
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.misc.TileInterface;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.properties.PropertyBool;
@@ -33,59 +37,45 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.api.util.IOrientable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.misc.TileInterface;
-import appeng.util.Platform;
 
 
-public class BlockInterface extends AEBaseTileBlock
+public class BlockInterface extends AEBaseTileBlock {
-{
 
-	private static final PropertyBool OMNIDIRECTIONAL = PropertyBool.create( "omnidirectional" );
+    private static final PropertyBool OMNIDIRECTIONAL = PropertyBool.create("omnidirectional");
 
-	public BlockInterface()
+    public BlockInterface() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{OMNIDIRECTIONAL};
-		return new IProperty[] { OMNIDIRECTIONAL };
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         // Determine whether the interface is omni-directional or not
-		TileInterface te = this.getTileEntity( world, pos );
+        TileInterface te = this.getTileEntity(world, pos);
         boolean omniDirectional = true; // The default
-		if( te != null )
+        if (te != null) {
-		{
             omniDirectional = te.isOmniDirectional();
         }
 
-		return super.getActualState( state, world, pos )
+        return super.getActualState(state, world, pos)
-				.withProperty( OMNIDIRECTIONAL, omniDirectional );
+                .withProperty(OMNIDIRECTIONAL, omniDirectional);
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileInterface tg = this.getTileEntity( w, pos );
+        final TileInterface tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_INTERFACE);
-			{
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_INTERFACE );
             }
             return true;
         }
@@ -93,17 +83,14 @@ public class BlockInterface extends AEBaseTileBlock
     }
 
     @Override
-	protected boolean hasCustomRotation()
+    protected boolean hasCustomRotation() {
-	{
         return true;
     }
 
     @Override
-	protected void customRotateBlock( final IOrientable rotatable, final EnumFacing axis )
+    protected void customRotateBlock(final IOrientable rotatable, final EnumFacing axis) {
-	{
+        if (rotatable instanceof TileInterface) {
-		if( rotatable instanceof TileInterface )
+            ((TileInterface) rotatable).setSide(axis);
-		{
-			( (TileInterface) rotatable ).setSide( axis );
         }
     }
 }

src/main/java/appeng/block/misc/BlockLightDetector.java

@@ -19,10 +19,12 @@
 package appeng.block.misc;
 
 
-import java.util.Collections;
+import appeng.api.util.IOrientable;
-import java.util.List;
+import appeng.api.util.IOrientableBlock;
-import java.util.Random;
+import appeng.block.AEBaseTileBlock;
-
+import appeng.helpers.ICustomCollision;
+import appeng.helpers.MetaRotation;
+import appeng.tile.misc.TileLightDetector;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
@@ -39,105 +41,88 @@ import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.IOrientable;
+import java.util.Collections;
-import appeng.api.util.IOrientableBlock;
+import java.util.List;
-import appeng.block.AEBaseTileBlock;
+import java.util.Random;
-import appeng.helpers.ICustomCollision;
-import appeng.helpers.MetaRotation;
-import appeng.tile.misc.TileLightDetector;
 
 
-public class BlockLightDetector extends AEBaseTileBlock implements IOrientableBlock, ICustomCollision
+public class BlockLightDetector extends AEBaseTileBlock implements IOrientableBlock, ICustomCollision {
-{
 
     // Cannot use the vanilla FACING property here because it excludes facing DOWN
-	public static final PropertyDirection FACING = PropertyDirection.create( "facing" );
+    public static final PropertyDirection FACING = PropertyDirection.create("facing");
 
     // Used to alternate between two variants of the fixture on adjacent blocks
-	public static final PropertyBool ODD = PropertyBool.create( "odd" );
+    public static final PropertyBool ODD = PropertyBool.create("odd");
 
-	public BlockLightDetector()
+    public BlockLightDetector() {
-	{
+        super(Material.CIRCUITS);
-		super( Material.CIRCUITS );
 
-		this.setDefaultState( this.blockState.getBaseState().withProperty( FACING, EnumFacing.UP ).withProperty( ODD, false ) );
+        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.UP).withProperty(ODD, false));
-		this.setLightOpacity( 0 );
+        this.setLightOpacity(0);
-		this.setFullSize( false );
+        this.setFullSize(false);
-		this.setOpaque( false );
+        this.setOpaque(false);
     }
 
     @Override
-	public int getMetaFromState( final IBlockState state )
+    public int getMetaFromState(final IBlockState state) {
-	{
+        return state.getValue(FACING).ordinal();
-		return state.getValue( FACING ).ordinal();
     }
 
     @Override
-	public IBlockState getStateFromMeta( final int meta )
+    public IBlockState getStateFromMeta(final int meta) {
-	{
         EnumFacing facing = EnumFacing.values()[meta];
-		return this.getDefaultState().withProperty( FACING, facing );
+        return this.getDefaultState().withProperty(FACING, facing);
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{FACING, ODD};
-		return new IProperty[] { FACING, ODD };
     }
 
     @Override
-	public int getWeakPower( final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side )
+    public int getWeakPower(final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side) {
-	{
+        if (w instanceof World && ((TileLightDetector) this.getTileEntity(w, pos)).isReady()) {
-		if( w instanceof World && ( (TileLightDetector) this.getTileEntity( w, pos ) ).isReady() )
+            return ((World) w).getLightFromNeighbors(pos) - 6;
-		{
-			return ( (World) w ).getLightFromNeighbors( pos ) - 6;
         }
 
         return 0;
     }
 
     @Override
-	public void onNeighborChange( final IBlockAccess world, final BlockPos pos, final BlockPos neighbor )
+    public void onNeighborChange(final IBlockAccess world, final BlockPos pos, final BlockPos neighbor) {
-	{
+        super.onNeighborChange(world, pos, neighbor);
-		super.onNeighborChange( world, pos, neighbor );
 
-		final TileLightDetector tld = this.getTileEntity( world, pos );
+        final TileLightDetector tld = this.getTileEntity(world, pos);
-		if( tld != null )
+        if (tld != null) {
-		{
             tld.updateLight();
         }
     }
 
     @Override
-	public void randomDisplayTick( final IBlockState state, final World worldIn, final BlockPos pos, final Random rand )
+    public void randomDisplayTick(final IBlockState state, final World worldIn, final BlockPos pos, final Random rand) {
-	{
         // cancel out lightning
     }
 
     @Override
-	public boolean isValidOrientation( final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up )
+    public boolean isValidOrientation(final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up) {
-	{
+        return this.canPlaceAt(w, pos, up.getOpposite());
-		return this.canPlaceAt( w, pos, up.getOpposite() );
     }
 
-	private boolean canPlaceAt( final World w, final BlockPos pos, final EnumFacing dir )
+    private boolean canPlaceAt(final World w, final BlockPos pos, final EnumFacing dir) {
-	{
+        return w.isSideSolid(pos.offset(dir), dir.getOpposite(), false);
-		return w.isSideSolid( pos.offset( dir ), dir.getOpposite(), false );
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
+        final EnumFacing up = this.getOrientable(w, pos).getUp();
-		final EnumFacing up = this.getOrientable( w, pos ).getUp();
         final double xOff = -0.3 * up.getFrontOffsetX();
         final double yOff = -0.3 * up.getFrontOffsetY();
         final double zOff = -0.3 * up.getFrontOffsetZ();
-		return Collections.singletonList( new AxisAlignedBB( xOff + 0.3, yOff + 0.3, zOff + 0.3, xOff + 0.7, yOff + 0.7, zOff + 0.7 ) );
+        return Collections.singletonList(new AxisAlignedBB(xOff + 0.3, yOff + 0.3, zOff + 0.3, xOff + 0.7, yOff + 0.7, zOff + 0.7));
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {/*
-	{/*
      * double xOff = -0.15 * getUp().offsetX; double yOff = -0.15 *
      * getUp().offsetY; double zOff = -0.15 * getUp().offsetZ; out.add(
      * AxisAlignedBB.getBoundingBox( xOff + (double) x + 0.15, yOff +
@@ -147,29 +132,23 @@ public class BlockLightDetector extends AEBaseTileBlock implements IOrientableBl
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final EnumFacing up = this.getOrientable(world, pos).getUp();
-		final EnumFacing up = this.getOrientable( world, pos ).getUp();
+        if (!this.canPlaceAt(world, pos, up.getOpposite())) {
-		if( !this.canPlaceAt( world, pos, up.getOpposite() ) )
+            this.dropTorch(world, pos);
-		{
-			this.dropTorch( world, pos );
         }
     }
 
-	private void dropTorch( final World w, final BlockPos pos )
+    private void dropTorch(final World w, final BlockPos pos) {
-	{
+        final IBlockState prev = w.getBlockState(pos);
-		final IBlockState prev = w.getBlockState( pos );
+        w.destroyBlock(pos, true);
-		w.destroyBlock( pos, true );
+        w.notifyBlockUpdate(pos, prev, w.getBlockState(pos), 3);
-		w.notifyBlockUpdate( pos, prev, w.getBlockState( pos ), 3 );
     }
 
     @Override
-	public boolean canPlaceBlockAt( final World w, final BlockPos pos )
+    public boolean canPlaceBlockAt(final World w, final BlockPos pos) {
-	{
+        for (final EnumFacing dir : EnumFacing.VALUES) {
-		for( final EnumFacing dir : EnumFacing.VALUES )
+            if (this.canPlaceAt(w, pos, dir)) {
-		{
-			if( this.canPlaceAt( w, pos, dir ) )
-			{
                 return true;
             }
         }
@@ -177,28 +156,24 @@ public class BlockLightDetector extends AEBaseTileBlock implements IOrientableBl
     }
 
     @Override
-	public boolean usesMetadata()
+    public boolean usesMetadata() {
-	{
         return false;
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	public IOrientable getOrientable( final IBlockAccess w, final BlockPos pos )
+    public IOrientable getOrientable(final IBlockAccess w, final BlockPos pos) {
-	{
+        return new MetaRotation(w, pos, FACING);
-		return new MetaRotation( w, pos, FACING );
     }
 
 }

src/main/java/appeng/block/misc/BlockQuartzFixture.java

@@ -19,10 +19,14 @@
 package appeng.block.misc;
 
 
-import java.util.Collections;
+import appeng.api.util.IOrientable;
-import java.util.List;
+import appeng.api.util.IOrientableBlock;
-import java.util.Random;
+import appeng.block.AEBaseBlock;
-
+import appeng.client.render.effects.LightningFX;
+import appeng.core.AEConfig;
+import appeng.core.AppEng;
+import appeng.helpers.ICustomCollision;
+import appeng.helpers.MetaRotation;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
@@ -40,92 +44,77 @@ import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.IOrientable;
+import java.util.Collections;
-import appeng.api.util.IOrientableBlock;
+import java.util.List;
-import appeng.block.AEBaseBlock;
+import java.util.Random;
-import appeng.client.render.effects.LightningFX;
-import appeng.core.AEConfig;
-import appeng.core.AppEng;
-import appeng.helpers.ICustomCollision;
-import appeng.helpers.MetaRotation;
 
 
-public class BlockQuartzFixture extends AEBaseBlock implements IOrientableBlock, ICustomCollision
+public class BlockQuartzFixture extends AEBaseBlock implements IOrientableBlock, ICustomCollision {
-{
 
     // Cannot use the vanilla FACING property here because it excludes facing DOWN
-	public static final PropertyDirection FACING = PropertyDirection.create( "facing" );
+    public static final PropertyDirection FACING = PropertyDirection.create("facing");
 
     // Used to alternate between two variants of the fixture on adjacent blocks
-	public static final PropertyBool ODD = PropertyBool.create( "odd" );
+    public static final PropertyBool ODD = PropertyBool.create("odd");
 
-	public BlockQuartzFixture()
+    public BlockQuartzFixture() {
-	{
+        super(Material.CIRCUITS);
-		super( Material.CIRCUITS );
 
-		this.setDefaultState( this.blockState.getBaseState().withProperty( FACING, EnumFacing.UP ).withProperty( ODD, false ) );
+        this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.UP).withProperty(ODD, false));
-		this.setLightLevel( 0.9375F );
+        this.setLightLevel(0.9375F);
-		this.setLightOpacity( 0 );
+        this.setLightOpacity(0);
-		this.setFullSize( false );
+        this.setFullSize(false);
-		this.setOpaque( false );
+        this.setOpaque(false);
     }
 
     /**
      * Sets the "ODD" property of the block state according to the placement of the block.
      */
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess worldIn, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
-	{
+        boolean oddPlacement = ((pos.getX() + pos.getY() + pos.getZ()) % 2) != 0;
-		boolean oddPlacement = ( ( pos.getX() + pos.getY() + pos.getZ() ) % 2 ) != 0;
 
-		return super.getActualState( state, worldIn, pos )
+        return super.getActualState(state, worldIn, pos)
-				.withProperty( ODD, oddPlacement );
+                .withProperty(ODD, oddPlacement);
     }
 
     @Override
-	public int getMetaFromState( final IBlockState state )
+    public int getMetaFromState(final IBlockState state) {
-	{
+        return state.getValue(FACING).ordinal();
-		return state.getValue( FACING ).ordinal();
     }
 
     @Override
-	public IBlockState getStateFromMeta( final int meta )
+    public IBlockState getStateFromMeta(final int meta) {
-	{
         EnumFacing facing = EnumFacing.values()[meta];
-		return this.getDefaultState().withProperty( FACING, facing );
+        return this.getDefaultState().withProperty(FACING, facing);
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{FACING, ODD};
-		return new IProperty[] { FACING, ODD };
     }
 
     @Override
-	public boolean isValidOrientation( final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up )
+    public boolean isValidOrientation(final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up) {
-	{
+        return this.canPlaceAt(w, pos, up.getOpposite());
-		return this.canPlaceAt( w, pos, up.getOpposite() );
     }
 
-	private boolean canPlaceAt( final World w, final BlockPos pos, final EnumFacing dir )
+    private boolean canPlaceAt(final World w, final BlockPos pos, final EnumFacing dir) {
-	{
+        final BlockPos test = pos.offset(dir);
-		final BlockPos test = pos.offset( dir );
+        return w.isSideSolid(test, dir.getOpposite(), false);
-		return w.isSideSolid( test, dir.getOpposite(), false );
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity e, final boolean isVisual )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity e, final boolean isVisual) {
-	{
+        final EnumFacing up = this.getOrientable(w, pos).getUp();
-		final EnumFacing up = this.getOrientable( w, pos ).getUp();
         final double xOff = -0.3 * up.getFrontOffsetX();
         final double yOff = -0.3 * up.getFrontOffsetY();
         final double zOff = -0.3 * up.getFrontOffsetZ();
-		return Collections.singletonList( new AxisAlignedBB( xOff + 0.3, yOff + 0.3, zOff + 0.3, xOff + 0.7, yOff + 0.7, zOff + 0.7 ) );
+        return Collections.singletonList(new AxisAlignedBB(xOff + 0.3, yOff + 0.3, zOff + 0.3, xOff + 0.7, yOff + 0.7, zOff + 0.7));
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List out, final Entity e) {/*
-	{/*
      * double xOff = -0.15 * getUp().offsetX; double yOff = -0.15 * getUp().offsetY; double zOff = -0.15 *
      * getUp().offsetZ; out.add( AxisAlignedBB.getBoundingBox( xOff + (double) x + 0.15, yOff + (double) y + 0.15,
      * zOff
@@ -134,58 +123,47 @@ public class BlockQuartzFixture extends AEBaseBlock implements IOrientableBlock,
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void randomDisplayTick( final IBlockState state, final World w, final BlockPos pos, final Random r )
+    public void randomDisplayTick(final IBlockState state, final World w, final BlockPos pos, final Random r) {
-	{
+        if (!AEConfig.instance().isEnableEffects()) {
-		if( !AEConfig.instance().isEnableEffects() )
-		{
             return;
         }
 
-		if( r.nextFloat() < 0.98 )
+        if (r.nextFloat() < 0.98) {
-		{
             return;
         }
 
-		final EnumFacing up = this.getOrientable( w, pos ).getUp();
+        final EnumFacing up = this.getOrientable(w, pos).getUp();
         final double xOff = -0.3 * up.getFrontOffsetX();
         final double yOff = -0.3 * up.getFrontOffsetY();
         final double zOff = -0.3 * up.getFrontOffsetZ();
-		for( int bolts = 0; bolts < 3; bolts++ )
+        for (int bolts = 0; bolts < 3; bolts++) {
-		{
+            if (AppEng.proxy.shouldAddParticles(r)) {
-			if( AppEng.proxy.shouldAddParticles( r ) )
+                final LightningFX fx = new LightningFX(w, xOff + 0.5 + pos.getX(), yOff + 0.5 + pos.getY(), zOff + 0.5 + pos.getZ(), 0.0D, 0.0D, 0.0D);
-			{
-				final LightningFX fx = new LightningFX( w, xOff + 0.5 + pos.getX(), yOff + 0.5 + pos.getY(), zOff + 0.5 + pos.getZ(), 0.0D, 0.0D, 0.0D );
 
-				Minecraft.getMinecraft().effectRenderer.addEffect( fx );
+                Minecraft.getMinecraft().effectRenderer.addEffect(fx);
             }
         }
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final EnumFacing up = this.getOrientable(world, pos).getUp();
-		final EnumFacing up = this.getOrientable( world, pos ).getUp();
+        if (!this.canPlaceAt(world, pos, up.getOpposite())) {
-		if( !this.canPlaceAt( world, pos, up.getOpposite() ) )
+            this.dropTorch(world, pos);
-		{
-			this.dropTorch( world, pos );
         }
     }
 
-	private void dropTorch( final World w, final BlockPos pos )
+    private void dropTorch(final World w, final BlockPos pos) {
-	{
+        final IBlockState prev = w.getBlockState(pos);
-		final IBlockState prev = w.getBlockState( pos );
+        w.destroyBlock(pos, true);
-		w.destroyBlock( pos, true );
+        w.notifyBlockUpdate(pos, prev, w.getBlockState(pos), 3);
-		w.notifyBlockUpdate( pos, prev, w.getBlockState( pos ), 3 );
     }
 
     @Override
-	public boolean canPlaceBlockAt( final World w, final BlockPos pos )
+    public boolean canPlaceBlockAt(final World w, final BlockPos pos) {
-	{
+        for (final EnumFacing dir : EnumFacing.VALUES) {
-		for( final EnumFacing dir : EnumFacing.VALUES )
+            if (this.canPlaceAt(w, pos, dir)) {
-		{
-			if( this.canPlaceAt( w, pos, dir ) )
-			{
                 return true;
             }
         }
@@ -193,33 +171,28 @@ public class BlockQuartzFixture extends AEBaseBlock implements IOrientableBlock,
     }
 
     @Override
-	public boolean usesMetadata()
+    public boolean usesMetadata() {
-	{
         return true;
     }
 
     @Override
-	public IOrientable getOrientable( final IBlockAccess w, final BlockPos pos )
+    public IOrientable getOrientable(final IBlockAccess w, final BlockPos pos) {
-	{
+        return new MetaRotation(w, pos, FACING);
-		return new MetaRotation( w, pos, FACING );
     }
 
     @Override
-	public boolean isOpaque()
+    public boolean isOpaque() {
-	{
         return false;
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 

src/main/java/appeng/block/misc/BlockQuartzGrowthAccelerator.java

@@ -19,8 +19,13 @@
 package appeng.block.misc;
 
 
-import java.util.Random;
+import appeng.api.util.IOrientableBlock;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.client.render.effects.LightningFX;
+import appeng.core.AEConfig;
+import appeng.core.AppEng;
+import appeng.tile.misc.TileQuartzGrowthAccelerator;
+import appeng.util.Platform;
 import net.minecraft.block.SoundType;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
@@ -34,62 +39,49 @@ import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.IOrientableBlock;
+import java.util.Random;
-import appeng.block.AEBaseTileBlock;
-import appeng.client.render.effects.LightningFX;
-import appeng.core.AEConfig;
-import appeng.core.AppEng;
-import appeng.tile.misc.TileQuartzGrowthAccelerator;
-import appeng.util.Platform;
 
 
-public class BlockQuartzGrowthAccelerator extends AEBaseTileBlock implements IOrientableBlock
+public class BlockQuartzGrowthAccelerator extends AEBaseTileBlock implements IOrientableBlock {
-{
 
-	private static final PropertyBool POWERED = PropertyBool.create( "powered" );
+    private static final PropertyBool POWERED = PropertyBool.create("powered");
 
-	public BlockQuartzGrowthAccelerator()
+    public BlockQuartzGrowthAccelerator() {
-	{
+        super(Material.ROCK);
-		super( Material.ROCK );
+        this.setSoundType(SoundType.METAL);
-		this.setSoundType( SoundType.METAL );
+        this.setDefaultState(this.getDefaultState().withProperty(POWERED, false));
-		this.setDefaultState( this.getDefaultState().withProperty( POWERED, false ) );
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
+        TileQuartzGrowthAccelerator te = this.getTileEntity(world, pos);
-		TileQuartzGrowthAccelerator te = this.getTileEntity( world, pos );
         boolean powered = te != null && te.isPowered();
 
-		return super.getActualState( state, world, pos )
+        return super.getActualState(state, world, pos)
-				.withProperty( POWERED, powered );
+                .withProperty(POWERED, powered);
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{POWERED};
-		return new IProperty[] { POWERED };
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public void randomDisplayTick( final IBlockState state, final World w, final BlockPos pos, final Random r )
+    public void randomDisplayTick(final IBlockState state, final World w, final BlockPos pos, final Random r) {
-	{
+        if (!AEConfig.instance().isEnableEffects()) {
-		if( !AEConfig.instance().isEnableEffects() )
-		{
             return;
         }
 
-		final TileQuartzGrowthAccelerator cga = this.getTileEntity( w, pos );
+        final TileQuartzGrowthAccelerator cga = this.getTileEntity(w, pos);
 
-		if( cga != null && cga.isPowered() && AppEng.proxy.shouldAddParticles( r ) )
+        if (cga != null && cga.isPowered() && AppEng.proxy.shouldAddParticles(r)) {
-		{
             final double d0 = r.nextFloat() - 0.5F;
             final double d1 = r.nextFloat() - 0.5F;
 
             final EnumFacing up = cga.getUp();
             final EnumFacing forward = cga.getForward();
-			final EnumFacing west = Platform.crossProduct( forward, up );
+            final EnumFacing west = Platform.crossProduct(forward, up);
 
             double rx = 0.5 + pos.getX();
             double ry = 0.5 + pos.getY();
@@ -107,36 +99,34 @@ public class BlockQuartzGrowthAccelerator extends AEBaseTileBlock implements IOr
             double dx = 0;
             BlockPos pt = null;
 
-			switch( r.nextInt( 4 ) )
+            switch (r.nextInt(4)) {
-			{
                 case 0:
                     dx = 0.6;
                     dz = d1;
-					pt = new BlockPos( x + west.getFrontOffsetX(), y + west.getFrontOffsetY(), z + west.getFrontOffsetZ() );
+                    pt = new BlockPos(x + west.getFrontOffsetX(), y + west.getFrontOffsetY(), z + west.getFrontOffsetZ());
 
                     break;
                 case 1:
                     dx = d1;
                     dz += 0.6;
-					pt = new BlockPos( x + forward.getFrontOffsetX(), y + forward.getFrontOffsetY(), z + forward.getFrontOffsetZ() );
+                    pt = new BlockPos(x + forward.getFrontOffsetX(), y + forward.getFrontOffsetY(), z + forward.getFrontOffsetZ());
 
                     break;
                 case 2:
                     dx = d1;
                     dz = -0.6;
-					pt = new BlockPos( x - forward.getFrontOffsetX(), y - forward.getFrontOffsetY(), z - forward.getFrontOffsetZ() );
+                    pt = new BlockPos(x - forward.getFrontOffsetX(), y - forward.getFrontOffsetY(), z - forward.getFrontOffsetZ());
 
                     break;
                 case 3:
                     dx = -0.6;
                     dz = d1;
-					pt = new BlockPos( x - west.getFrontOffsetX(), y - west.getFrontOffsetY(), z - west.getFrontOffsetZ() );
+                    pt = new BlockPos(x - west.getFrontOffsetX(), y - west.getFrontOffsetY(), z - west.getFrontOffsetZ());
 
                     break;
             }
 
-			if( !w.getBlockState( pt ).getBlock().isAir( w.getBlockState( pt ), w, pt ) )
+            if (!w.getBlockState(pt).getBlock().isAir(w.getBlockState(pt), w, pt)) {
-			{
                 return;
             }
 
@@ -148,14 +138,13 @@ public class BlockQuartzGrowthAccelerator extends AEBaseTileBlock implements IOr
             ry += dz * forward.getFrontOffsetY();
             rz += dz * forward.getFrontOffsetZ();
 
-			final LightningFX fx = new LightningFX( w, rx, ry, rz, 0.0D, 0.0D, 0.0D );
+            final LightningFX fx = new LightningFX(w, rx, ry, rz, 0.0D, 0.0D, 0.0D);
-			Minecraft.getMinecraft().effectRenderer.addEffect( fx );
+            Minecraft.getMinecraft().effectRenderer.addEffect(fx);
         }
     }
 
     @Override
-	public boolean usesMetadata()
+    public boolean usesMetadata() {
-	{
         return false;
     }
 

src/main/java/appeng/block/misc/BlockSecurityStation.java

@@ -19,8 +19,11 @@
 package appeng.block.misc;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.misc.TileSecurityStation;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.properties.PropertyBool;
@@ -34,68 +37,54 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.misc.TileSecurityStation;
-import appeng.util.Platform;
 
 
-public class BlockSecurityStation extends AEBaseTileBlock
+public class BlockSecurityStation extends AEBaseTileBlock {
-{
 
-	private static final PropertyBool POWERED = PropertyBool.create( "powered" );
+    private static final PropertyBool POWERED = PropertyBool.create("powered");
 
-	public BlockSecurityStation()
+    public BlockSecurityStation() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
 
-		this.setDefaultState( this.getDefaultState().withProperty( POWERED, false ) );
+        this.setDefaultState(this.getDefaultState().withProperty(POWERED, false));
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{POWERED};
-		return new IProperty[] { POWERED };
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         boolean powered = false;
-		TileSecurityStation te = this.getTileEntity( world, pos );
+        TileSecurityStation te = this.getTileEntity(world, pos);
-		if( te != null )
+        if (te != null) {
-		{
             powered = te.isActive();
         }
 
-		return super.getActualState( state, world, pos )
+        return super.getActualState(state, world, pos)
-				.withProperty( POWERED, powered );
+                .withProperty(POWERED, powered);
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileSecurityStation tg = this.getTileEntity( w, pos );
+        final TileSecurityStation tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isClient()) {
-			if( Platform.isClient() )
-			{
                 return true;
             }
 
-			Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_SECURITY );
+            Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_SECURITY);
             return true;
         }
         return false;

src/main/java/appeng/block/misc/BlockSkyCompass.java

@@ -19,9 +19,9 @@
 package appeng.block.misc;
 
 
-import java.util.Collections;
+import appeng.block.AEBaseTileBlock;
-import java.util.List;
+import appeng.helpers.ICustomCollision;
-
+import appeng.tile.misc.TileSkyCompass;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.BlockStateContainer;
@@ -36,72 +36,59 @@ import net.minecraftforge.common.property.ExtendedBlockState;
 import net.minecraftforge.common.property.IUnlistedProperty;
 import net.minecraftforge.common.property.PropertyFloat;
 
-import appeng.block.AEBaseTileBlock;
+import java.util.Collections;
-import appeng.helpers.ICustomCollision;
+import java.util.List;
-import appeng.tile.misc.TileSkyCompass;
 
 
-public class BlockSkyCompass extends AEBaseTileBlock implements ICustomCollision
+public class BlockSkyCompass extends AEBaseTileBlock implements ICustomCollision {
-{
 
     // Rotation is expressed as radians
-	public static final PropertyFloat ROTATION = new PropertyFloat( "rotation" );
+    public static final PropertyFloat ROTATION = new PropertyFloat("rotation");
 
-	public BlockSkyCompass()
+    public BlockSkyCompass() {
-	{
+        super(Material.CIRCUITS);
-		super( Material.CIRCUITS );
+        this.setLightOpacity(0);
-		this.setLightOpacity( 0 );
+        this.setFullSize(false);
-		this.setFullSize( false );
+        this.setOpaque(false);
-		this.setOpaque( false );
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, this.getAEStates(), new IUnlistedProperty[]{FORWARD, UP, ROTATION});
-		return new ExtendedBlockState( this, this.getAEStates(), new IUnlistedProperty[] { FORWARD, UP, ROTATION } );
     }
 
     @Override
-	public boolean isValidOrientation( final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up )
+    public boolean isValidOrientation(final World w, final BlockPos pos, final EnumFacing forward, final EnumFacing up) {
-	{
+        final TileSkyCompass sc = this.getTileEntity(w, pos);
-		final TileSkyCompass sc = this.getTileEntity( w, pos );
+        if (sc != null) {
-		if( sc != null )
-		{
             return false;
         }
-		return this.canPlaceAt( w, pos, forward.getOpposite() );
+        return this.canPlaceAt(w, pos, forward.getOpposite());
     }
 
-	private boolean canPlaceAt( final World w, final BlockPos pos, final EnumFacing dir )
+    private boolean canPlaceAt(final World w, final BlockPos pos, final EnumFacing dir) {
-	{
+        return w.isSideSolid(pos.offset(dir), dir.getOpposite(), false);
-		return w.isSideSolid( pos.offset( dir ), dir.getOpposite(), false );
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final TileSkyCompass sc = this.getTileEntity(world, pos);
-		final TileSkyCompass sc = this.getTileEntity( world, pos );
         final EnumFacing forward = sc.getForward();
-		if( !this.canPlaceAt( world, pos, forward.getOpposite() ) )
+        if (!this.canPlaceAt(world, pos, forward.getOpposite())) {
-		{
+            this.dropTorch(world, pos);
-			this.dropTorch( world, pos );
         }
     }
 
-	private void dropTorch( final World w, final BlockPos pos )
+    private void dropTorch(final World w, final BlockPos pos) {
-	{
+        final IBlockState prev = w.getBlockState(pos);
-		final IBlockState prev = w.getBlockState( pos );
+        w.destroyBlock(pos, true);
-		w.destroyBlock( pos, true );
+        w.notifyBlockUpdate(pos, prev, w.getBlockState(pos), 3);
-		w.notifyBlockUpdate( pos, prev, w.getBlockState( pos ), 3 );
     }
 
     @Override
-	public boolean canPlaceBlockAt( final World w, final BlockPos pos )
+    public boolean canPlaceBlockAt(final World w, final BlockPos pos) {
-	{
+        for (final EnumFacing dir : EnumFacing.VALUES) {
-		for( final EnumFacing dir : EnumFacing.VALUES )
+            if (this.canPlaceAt(w, pos, dir)) {
-		{
-			if( this.canPlaceAt( w, pos, dir ) )
-			{
                 return true;
             }
         }
@@ -109,11 +96,9 @@ public class BlockSkyCompass extends AEBaseTileBlock implements ICustomCollision
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
+        final TileSkyCompass tile = this.getTileEntity(w, pos);
-		final TileSkyCompass tile = this.getTileEntity( w, pos );
+        if (tile != null) {
-		if( tile != null )
-		{
             final EnumFacing forward = tile.getForward();
 
             double minX = 0;
@@ -123,8 +108,7 @@ public class BlockSkyCompass extends AEBaseTileBlock implements ICustomCollision
             double maxY = 1;
             double maxZ = 1;
 
-			switch( forward )
+            switch (forward) {
-			{
                 case DOWN:
                     minZ = minX = 5.0 / 16.0;
                     maxZ = maxX = 11.0 / 16.0;
@@ -165,26 +149,23 @@ public class BlockSkyCompass extends AEBaseTileBlock implements ICustomCollision
                     break;
             }
 
-			return Collections.singletonList( new AxisAlignedBB( minX, minY, minZ, maxX, maxY, maxZ ) );
+            return Collections.singletonList(new AxisAlignedBB(minX, minY, minZ, maxX, maxY, maxZ));
         }
-		return Collections.singletonList( new AxisAlignedBB( 0.0, 0, 0.0, 1.0, 1.0, 1.0 ) );
+        return Collections.singletonList(new AxisAlignedBB(0.0, 0, 0.0, 1.0, 1.0, 1.0));
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
 
     }
 
     @Override
-	public EnumBlockRenderType getRenderType( IBlockState state )
+    public EnumBlockRenderType getRenderType(IBlockState state) {
-	{
         return EnumBlockRenderType.ENTITYBLOCK_ANIMATED;
     }
 
     @Override
-	public boolean isFullBlock( IBlockState state )
+    public boolean isFullBlock(IBlockState state) {
-	{
         return false;
     }
 

src/main/java/appeng/block/misc/BlockTinyTNT.java

@@ -19,11 +19,9 @@
 package appeng.block.misc;
 
 
-import java.util.Collections;
+import appeng.block.AEBaseBlock;
-import java.util.List;
+import appeng.entity.EntityTinyTNTPrimed;
-
+import appeng.helpers.ICustomCollision;
-import javax.annotation.Nullable;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.SoundType;
 import net.minecraft.block.material.Material;
@@ -43,126 +41,105 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.Explosion;
 import net.minecraft.world.World;
 
-import appeng.block.AEBaseBlock;
+import javax.annotation.Nullable;
-import appeng.entity.EntityTinyTNTPrimed;
+import java.util.Collections;
-import appeng.helpers.ICustomCollision;
+import java.util.List;
 
 
-public class BlockTinyTNT extends AEBaseBlock implements ICustomCollision
+public class BlockTinyTNT extends AEBaseBlock implements ICustomCollision {
-{
 
-	public BlockTinyTNT()
+    public BlockTinyTNT() {
-	{
+        super(Material.TNT);
-		super( Material.TNT );
 
-		this.boundingBox = new AxisAlignedBB( 0.25f, 0.0f, 0.25f, 0.75f, 0.5f, 0.75f );
+        this.boundingBox = new AxisAlignedBB(0.25f, 0.0f, 0.25f, 0.75f, 0.5f, 0.75f);
 
-		this.setLightOpacity( 2 );
+        this.setLightOpacity(2);
-		this.setFullSize( false );
+        this.setFullSize(false);
-		this.setOpaque( false );
+        this.setOpaque(false);
 
-		this.setSoundType( SoundType.GROUND );
+        this.setSoundType(SoundType.GROUND);
-		this.setHardness( 0F );
+        this.setHardness(0F);
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (heldItem != null && heldItem.getItem() == Items.FLINT_AND_STEEL) {
-		if( heldItem != null && heldItem.getItem() == Items.FLINT_AND_STEEL )
+            this.startFuse(w, pos, player);
-		{
+            w.setBlockToAir(pos);
-			this.startFuse( w, pos, player );
+            heldItem.damageItem(1, player);
-			w.setBlockToAir( pos );
-			heldItem.damageItem( 1, player );
             return true;
-		}
+        } else {
-		else
+            return super.onActivated(w, pos, player, hand, heldItem, side, hitX, hitY, hitZ);
-		{
-			return super.onActivated( w, pos, player, hand, heldItem, side, hitX, hitY, hitZ );
         }
     }
 
-	public void startFuse( final World w, final BlockPos pos, final EntityLivingBase igniter )
+    public void startFuse(final World w, final BlockPos pos, final EntityLivingBase igniter) {
-	{
+        if (!w.isRemote) {
-		if( !w.isRemote )
+            final EntityTinyTNTPrimed primedTinyTNTEntity = new EntityTinyTNTPrimed(w, pos.getX() + 0.5F, pos.getY() + 0.5F, pos.getZ() + 0.5F, igniter);
-		{
+            w.spawnEntity(primedTinyTNTEntity);
-			final EntityTinyTNTPrimed primedTinyTNTEntity = new EntityTinyTNTPrimed( w, pos.getX() + 0.5F, pos.getY() + 0.5F, pos.getZ() + 0.5F, igniter );
+            w.playSound(null, primedTinyTNTEntity.posX, primedTinyTNTEntity.posY, primedTinyTNTEntity.posZ, SoundEvents.ENTITY_TNT_PRIMED,
-			w.spawnEntity( primedTinyTNTEntity );
+                    SoundCategory.BLOCKS, 1, 1);
-			w.playSound( null, primedTinyTNTEntity.posX, primedTinyTNTEntity.posY, primedTinyTNTEntity.posZ, SoundEvents.ENTITY_TNT_PRIMED,
-					SoundCategory.BLOCKS, 1, 1 );
         }
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        if (world.isBlockIndirectlyGettingPowered(pos) > 0) {
-		if( world.isBlockIndirectlyGettingPowered( pos ) > 0 )
+            this.startFuse(world, pos, null);
-		{
+            world.setBlockToAir(pos);
-			this.startFuse( world, pos, null );
-			world.setBlockToAir( pos );
         }
     }
 
     @Override
-	public void onBlockAdded( final World w, final BlockPos pos, final IBlockState state )
+    public void onBlockAdded(final World w, final BlockPos pos, final IBlockState state) {
-	{
+        super.onBlockAdded(w, pos, state);
-		super.onBlockAdded( w, pos, state );
 
-		if( w.isBlockIndirectlyGettingPowered( pos ) > 0 )
+        if (w.isBlockIndirectlyGettingPowered(pos) > 0) {
-		{
+            this.startFuse(w, pos, null);
-			this.startFuse( w, pos, null );
+            w.setBlockToAir(pos);
-			w.setBlockToAir( pos );
         }
     }
 
     @Override
-	public void onEntityWalk( final World w, final BlockPos pos, final Entity entity )
+    public void onEntityWalk(final World w, final BlockPos pos, final Entity entity) {
-	{
+        if (entity instanceof EntityArrow && !w.isRemote) {
-		if( entity instanceof EntityArrow && !w.isRemote )
-		{
             final EntityArrow entityarrow = (EntityArrow) entity;
 
-			if( entityarrow.isBurning() )
+            if (entityarrow.isBurning()) {
-			{
+                this.startFuse(w, pos, entityarrow.shootingEntity instanceof EntityLivingBase ? (EntityLivingBase) entityarrow.shootingEntity : null);
-				this.startFuse( w, pos, entityarrow.shootingEntity instanceof EntityLivingBase ? (EntityLivingBase) entityarrow.shootingEntity : null );
+                w.setBlockToAir(pos);
-				w.setBlockToAir( pos );
             }
         }
     }
 
     @Override
-	public boolean canDropFromExplosion( final Explosion exp )
+    public boolean canDropFromExplosion(final Explosion exp) {
-	{
         return false;
     }
 
     @Override
-	public void onBlockExploded( final World w, final BlockPos pos, final Explosion exp )
+    public void onBlockExploded(final World w, final BlockPos pos, final Explosion exp) {
-	{
+        super.onBlockExploded(w, pos, exp);
-		super.onBlockExploded( w, pos, exp );
+        if (!w.isRemote) {
-		if( !w.isRemote )
+            final EntityTinyTNTPrimed primedTinyTNTEntity = new EntityTinyTNTPrimed(w, pos.getX() + 0.5F, pos.getY() + 0.5F, pos.getZ() + 0.5F, exp
-		{
+                    .getExplosivePlacedBy());
-			final EntityTinyTNTPrimed primedTinyTNTEntity = new EntityTinyTNTPrimed( w, pos.getX() + 0.5F, pos.getY() + 0.5F, pos.getZ() + 0.5F, exp
+            primedTinyTNTEntity.setFuse(w.rand.nextInt(primedTinyTNTEntity.getFuse() / 4) + primedTinyTNTEntity.getFuse() / 8);
-					.getExplosivePlacedBy() );
+            w.spawnEntity(primedTinyTNTEntity);
-			primedTinyTNTEntity.setFuse( w.rand.nextInt( primedTinyTNTEntity.getFuse() / 4 ) + primedTinyTNTEntity.getFuse() / 8 );
-			w.spawnEntity( primedTinyTNTEntity );
         }
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
+        return Collections.singletonList(new AxisAlignedBB(0.25, 0, 0.25, 0.75, 0.5, 0.75));
-		return Collections.singletonList( new AxisAlignedBB( 0.25, 0, 0.25, 0.75, 0.5, 0.75 ) );
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
+        out.add(new AxisAlignedBB(0.25, 0, 0.25, 0.75, 0.5, 0.75));
-		out.add( new AxisAlignedBB( 0.25, 0, 0.25, 0.75, 0.5, 0.75 ) );
     }
 }

src/main/java/appeng/block/misc/BlockVibrationChamber.java

@@ -19,10 +19,13 @@
 package appeng.block.misc;
 
 
-import java.util.Random;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
-import javax.annotation.Nullable;
+import appeng.core.AEConfig;
-
+import appeng.core.sync.GuiBridge;
+import appeng.tile.AEBaseTile;
+import appeng.tile.misc.TileVibrationChamber;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.properties.PropertyBool;
@@ -36,58 +39,45 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
+import java.util.Random;
-import appeng.core.AEConfig;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.AEBaseTile;
-import appeng.tile.misc.TileVibrationChamber;
-import appeng.util.Platform;
 
 
-public final class BlockVibrationChamber extends AEBaseTileBlock
+public final class BlockVibrationChamber extends AEBaseTileBlock {
-{
 
     // Indicates that the vibration chamber is currently working
-	private static final PropertyBool ACTIVE = PropertyBool.create( "active" );
+    private static final PropertyBool ACTIVE = PropertyBool.create("active");
 
-	public BlockVibrationChamber()
+    public BlockVibrationChamber() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
+        this.setHardness(4.2F);
-		this.setHardness( 4.2F );
+        this.setDefaultState(this.getDefaultState().withProperty(ACTIVE, false));
-		this.setDefaultState( this.getDefaultState().withProperty( ACTIVE, false ) );
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
+        TileVibrationChamber te = this.getTileEntity(world, pos);
-		TileVibrationChamber te = this.getTileEntity( world, pos );
         boolean active = te != null && te.isOn;
 
-		return super.getActualState( state, world, pos )
+        return super.getActualState(state, world, pos)
-				.withProperty( ACTIVE, active );
+                .withProperty(ACTIVE, active);
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{ACTIVE};
-		return new IProperty[] { ACTIVE };
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (player.isSneaking()) {
-		if( player.isSneaking() )
-		{
             return false;
         }
 
-		if( Platform.isServer() )
+        if (Platform.isServer()) {
-		{
+            final TileVibrationChamber tc = this.getTileEntity(w, pos);
-			final TileVibrationChamber tc = this.getTileEntity( w, pos );
+            if (tc != null && !player.isSneaking()) {
-			if( tc != null && !player.isSneaking() )
+                Platform.openGUI(player, tc, AEPartLocation.fromFacing(side), GuiBridge.GUI_VIBRATION_CHAMBER);
-			{
-				Platform.openGUI( player, tc, AEPartLocation.fromFacing( side ), GuiBridge.GUI_VIBRATION_CHAMBER );
                 return true;
             }
         }
@@ -96,19 +86,15 @@ public final class BlockVibrationChamber extends AEBaseTileBlock
     }
 
     @Override
-	public void randomDisplayTick( final IBlockState state, final World w, final BlockPos pos, final Random r )
+    public void randomDisplayTick(final IBlockState state, final World w, final BlockPos pos, final Random r) {
-	{
+        if (!AEConfig.instance().isEnableEffects()) {
-		if( !AEConfig.instance().isEnableEffects() )
-		{
             return;
         }
 
-		final AEBaseTile tile = this.getTileEntity( w, pos );
+        final AEBaseTile tile = this.getTileEntity(w, pos);
-		if( tile instanceof TileVibrationChamber )
+        if (tile instanceof TileVibrationChamber) {
-		{
             final TileVibrationChamber tc = (TileVibrationChamber) tile;
-			if( tc.isOn )
+            if (tc.isOn) {
-			{
                 float f1 = pos.getX() + 0.5F;
                 float f2 = pos.getY() + 0.5F;
                 float f3 = pos.getZ() + 0.5F;
@@ -127,16 +113,16 @@ public final class BlockVibrationChamber extends AEBaseTileBlock
                 final float ox = r.nextFloat();
                 final float oy = r.nextFloat() * 0.2f;
 
-				f1 += up.getFrontOffsetX() * ( -0.3 + oy );
+                f1 += up.getFrontOffsetX() * (-0.3 + oy);
-				f2 += up.getFrontOffsetY() * ( -0.3 + oy );
+                f2 += up.getFrontOffsetY() * (-0.3 + oy);
-				f3 += up.getFrontOffsetZ() * ( -0.3 + oy );
+                f3 += up.getFrontOffsetZ() * (-0.3 + oy);
 
-				f1 += west_x * ( 0.3 * ox - 0.15 );
+                f1 += west_x * (0.3 * ox - 0.15);
-				f2 += west_y * ( 0.3 * ox - 0.15 );
+                f2 += west_y * (0.3 * ox - 0.15);
-				f3 += west_z * ( 0.3 * ox - 0.15 );
+                f3 += west_z * (0.3 * ox - 0.15);
 
-				w.spawnParticle( EnumParticleTypes.SMOKE_NORMAL, f1, f2, f3, 0.0D, 0.0D, 0.0D, new int[0] );
+                w.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, f1, f2, f3, 0.0D, 0.0D, 0.0D);
-				w.spawnParticle( EnumParticleTypes.FLAME, f1, f2, f3, 0.0D, 0.0D, 0.0D, new int[0] );
+                w.spawnParticle(EnumParticleTypes.FLAME, f1, f2, f3, 0.0D, 0.0D, 0.0D);
             }
         }
     }

src/main/java/appeng/block/misc/InscriberRendering.java

@@ -1,24 +1,20 @@
-
 package appeng.block.misc;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.tesr.InscriberTESR;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class InscriberRendering extends BlockRenderingCustomizer
+public class InscriberRendering extends BlockRenderingCustomizer {
-{
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.tesr(new InscriberTESR());
-		rendering.tesr( new InscriberTESR() );
     }
 
 }

src/main/java/appeng/block/misc/SecurityStationRendering.java

@@ -19,25 +19,22 @@
 package appeng.block.misc;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.api.util.AEColor;
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.ColorableTileBlockColor;
 import appeng.client.render.StaticItemColor;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class SecurityStationRendering extends BlockRenderingCustomizer
+public class SecurityStationRendering extends BlockRenderingCustomizer {
-{
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.blockColor(ColorableTileBlockColor.INSTANCE);
-		rendering.blockColor( ColorableTileBlockColor.INSTANCE );
+        itemRendering.color(new StaticItemColor(AEColor.TRANSPARENT));
-		itemRendering.color( new StaticItemColor( AEColor.TRANSPARENT ) );
     }
 }

src/main/java/appeng/block/misc/SkyCompassRendering.java

@@ -19,29 +19,26 @@
 package appeng.block.misc;
 
 
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.model.SkyCompassModel;
 import appeng.client.render.tesr.SkyCompassTESR;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class SkyCompassRendering extends BlockRenderingCustomizer
+public class SkyCompassRendering extends BlockRenderingCustomizer {
-{
 
-	private static final ModelResourceLocation ITEM_MODEL = new ModelResourceLocation( "appliedenergistics2:sky_compass", "normal" );
+    private static final ModelResourceLocation ITEM_MODEL = new ModelResourceLocation("appliedenergistics2:sky_compass", "normal");
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.tesr(new SkyCompassTESR());
-		rendering.tesr( new SkyCompassTESR() );
+        itemRendering.model(ITEM_MODEL);
-		itemRendering.model( ITEM_MODEL );
+        itemRendering.builtInModel("models/block/builtin/sky_compass", new SkyCompassModel());
-		itemRendering.builtInModel( "models/block/builtin/sky_compass", new SkyCompassModel() );
     }
 
 }

src/main/java/appeng/block/networking/BlockCableBus.java

@@ -19,14 +19,32 @@
 package appeng.block.networking;
 
 
-import java.util.EnumSet;
+import appeng.api.parts.IFacadeContainer;
-import java.util.List;
+import appeng.api.parts.IFacadePart;
-import java.util.Random;
+import appeng.api.parts.PartItemStack;
-
+import appeng.api.parts.SelectedPart;
-import javax.annotation.Nullable;
+import appeng.api.util.AEColor;
-
+import appeng.api.util.AEPartLocation;
+import appeng.block.AEBaseTileBlock;
+import appeng.client.UnlistedProperty;
+import appeng.client.render.cablebus.CableBusBakedModel;
+import appeng.client.render.cablebus.CableBusRenderState;
+import appeng.core.Api;
+import appeng.core.AppEng;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketClick;
+import appeng.helpers.AEGlassMaterial;
+import appeng.integration.abstraction.IAEFacade;
+import appeng.parts.ICableBusContainer;
+import appeng.parts.NullCableBusContainer;
+import appeng.tile.AEBaseTile;
+import appeng.tile.networking.CableBusTESR;
+import appeng.tile.networking.TileCableBus;
+import appeng.tile.networking.TileCableBusTESR;
+import appeng.util.Platform;
 import net.minecraft.block.Block;
 import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.state.BlockFaceShape;
 import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
@@ -61,35 +79,15 @@ import net.minecraftforge.fml.common.registry.GameRegistry;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.parts.IFacadeContainer;
+import javax.annotation.Nullable;
-import appeng.api.parts.IFacadePart;
+import java.util.EnumSet;
-import appeng.api.parts.PartItemStack;
+import java.util.List;
-import appeng.api.parts.SelectedPart;
+import java.util.Random;
-import appeng.api.util.AEColor;
-import appeng.api.util.AEPartLocation;
-import appeng.block.AEBaseTileBlock;
-import appeng.client.UnlistedProperty;
-import appeng.client.render.cablebus.CableBusBakedModel;
-import appeng.client.render.cablebus.CableBusRenderState;
-import appeng.core.Api;
-import appeng.core.AppEng;
-import appeng.core.sync.network.NetworkHandler;
-import appeng.core.sync.packets.PacketClick;
-import appeng.helpers.AEGlassMaterial;
-import appeng.integration.abstraction.IAEFacade;
-import appeng.parts.ICableBusContainer;
-import appeng.parts.NullCableBusContainer;
-import appeng.tile.AEBaseTile;
-import appeng.tile.networking.CableBusTESR;
-import appeng.tile.networking.TileCableBus;
-import appeng.tile.networking.TileCableBusTESR;
-import appeng.util.Platform;
 
 
-public class BlockCableBus extends AEBaseTileBlock implements IAEFacade
+public class BlockCableBus extends AEBaseTileBlock implements IAEFacade {
-{
 
-	public static final UnlistedProperty<CableBusRenderState> RENDER_STATE_PROPERTY = new UnlistedProperty<>( "cable_bus_render_state", CableBusRenderState.class );
+    public static final UnlistedProperty<CableBusRenderState> RENDER_STATE_PROPERTY = new UnlistedProperty<>("cable_bus_render_state", CableBusRenderState.class);
 
     private static final ICableBusContainer NULL_CABLE_BUS = new NullCableBusContainer();
 
@@ -97,151 +95,126 @@ public class BlockCableBus extends AEBaseTileBlock implements IAEFacade
 
     private static Class<? extends AEBaseTile> tesrTile;
 
-	public BlockCableBus()
+    public BlockCableBus() {
-	{
+        super(AEGlassMaterial.INSTANCE);
-		super( AEGlassMaterial.INSTANCE );
+        this.setLightOpacity(0);
-		this.setLightOpacity( 0 );
+        this.setFullSize(false);
-		this.setFullSize( false );
+        this.setOpaque(false);
-		this.setOpaque( false );
 
         // this will actually be overwritten later through setupTile and the
         // combined layers
-		this.setTileEntity( TileCableBus.class );
+        this.setTileEntity(TileCableBus.class);
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, new IProperty[0], new IUnlistedProperty[]{RENDER_STATE_PROPERTY});
-		return new ExtendedBlockState( this, new IProperty[0], new IUnlistedProperty[] { RENDER_STATE_PROPERTY } );
     }
 
     @Override
-	public IBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
+        CableBusRenderState renderState = this.cb(world, pos).getRenderState();
-		CableBusRenderState renderState = this.cb( world, pos ).getRenderState();
+        renderState.setWorld(world);
-		renderState.setWorld( world );
+        renderState.setPos(pos);
-		renderState.setPos( pos );
+        return ((IExtendedBlockState) state).withProperty(RENDER_STATE_PROPERTY, renderState);
-		return ( (IExtendedBlockState) state ).withProperty( RENDER_STATE_PROPERTY, renderState );
     }
 
     @Override
-	public void randomDisplayTick( final IBlockState state, final World worldIn, final BlockPos pos, final Random rand )
+    public void randomDisplayTick(final IBlockState state, final World worldIn, final BlockPos pos, final Random rand) {
-	{
+        this.cb(worldIn, pos).randomDisplayTick(worldIn, pos, rand);
-		this.cb( worldIn, pos ).randomDisplayTick( worldIn, pos, rand );
     }
 
     @Override
-	public void onNeighborChange( final IBlockAccess w, final BlockPos pos, final BlockPos neighbor )
+    public void onNeighborChange(final IBlockAccess w, final BlockPos pos, final BlockPos neighbor) {
-	{
+        this.cb(w, pos).onNeighborChanged(w, pos, neighbor);
-		this.cb( w, pos ).onNeighborChanged( w, pos, neighbor );
     }
 
     @Override
-	public Item getItemDropped( final IBlockState state, final Random rand, final int fortune )
+    public Item getItemDropped(final IBlockState state, final Random rand, final int fortune) {
-	{
         return null;
     }
 
     @Override
-	public int getWeakPower( final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side )
+    public int getWeakPower(final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side) {
-	{
+        return this.cb(w, pos).isProvidingWeakPower(side.getOpposite()); // TODO:
-		return this.cb( w, pos ).isProvidingWeakPower( side.getOpposite() ); // TODO:
         // IS
         // OPPOSITE!?
     }
 
     @Override
-	public boolean canProvidePower( final IBlockState state )
+    public boolean canProvidePower(final IBlockState state) {
-	{
         return true;
     }
 
     @Override
-	public void onEntityCollidedWithBlock( final World w, final BlockPos pos, final IBlockState state, final Entity entityIn )
+    public void onEntityCollidedWithBlock(final World w, final BlockPos pos, final IBlockState state, final Entity entityIn) {
-	{
+        this.cb(w, pos).onEntityCollision(entityIn);
-		this.cb( w, pos ).onEntityCollision( entityIn );
     }
 
     @Override
-	public int getStrongPower( final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side )
+    public int getStrongPower(final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side) {
-	{
+        return this.cb(w, pos).isProvidingStrongPower(side.getOpposite()); // TODO:
-		return this.cb( w, pos ).isProvidingStrongPower( side.getOpposite() ); // TODO:
         // IS
         // OPPOSITE!?
     }
 
     @Override
-	public int getLightValue( final IBlockState state, final IBlockAccess world, final BlockPos pos )
+    public int getLightValue(final IBlockState state, final IBlockAccess world, final BlockPos pos) {
-	{
+        if (state.getBlock() != this) {
-		if( state.getBlock() != this )
+            return state.getBlock().getLightValue(state, world, pos);
-		{
-			return state.getBlock().getLightValue( state, world, pos );
         }
-		return this.cb( world, pos ).getLightValue();
+        return this.cb(world, pos).getLightValue();
     }
 
     @Override
-	public boolean isLadder( final IBlockState state, final IBlockAccess world, final BlockPos pos, final EntityLivingBase entity )
+    public boolean isLadder(final IBlockState state, final IBlockAccess world, final BlockPos pos, final EntityLivingBase entity) {
-	{
+        return this.cb(world, pos).isLadder(entity);
-		return this.cb( world, pos ).isLadder( entity );
     }
 
     @Override
-	public boolean isSideSolid( final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side )
+    public boolean isSideSolid(final IBlockState state, final IBlockAccess w, final BlockPos pos, final EnumFacing side) {
-	{
+        return this.cb(w, pos).isSolidOnSide(side);
-		return this.cb( w, pos ).isSolidOnSide( side );
     }
 
     @Override
-	public boolean isReplaceable( final IBlockAccess w, final BlockPos pos )
+    public boolean isReplaceable(final IBlockAccess w, final BlockPos pos) {
-	{
+        return this.cb(w, pos).isEmpty();
-		return this.cb( w, pos ).isEmpty();
     }
 
     @Override
-	public boolean removedByPlayer( final IBlockState state, final World world, final BlockPos pos, final EntityPlayer player, final boolean willHarvest )
+    public boolean removedByPlayer(final IBlockState state, final World world, final BlockPos pos, final EntityPlayer player, final boolean willHarvest) {
-	{
+        if (player.capabilities.isCreativeMode) {
-		if( player.capabilities.isCreativeMode )
+            final AEBaseTile tile = this.getTileEntity(world, pos);
-		{
+            if (tile != null) {
-			final AEBaseTile tile = this.getTileEntity( world, pos );
-			if( tile != null )
-			{
                 tile.disableDrops();
             }
             // maybe ray trace?
         }
-		return super.removedByPlayer( state, world, pos, player, willHarvest );
+        return super.removedByPlayer(state, world, pos, player, willHarvest);
     }
 
     @Override
-	public boolean canConnectRedstone( final IBlockState state, final IBlockAccess w, final BlockPos pos, EnumFacing side )
+    public boolean canConnectRedstone(final IBlockState state, final IBlockAccess w, final BlockPos pos, EnumFacing side) {
-	{
+        if (side == null) {
-		if( side == null )
-		{
             side = EnumFacing.UP;
         }
 
-		return this.cb( w, pos ).canConnectRedstone( EnumSet.of( side ) );
+        return this.cb(w, pos).canConnectRedstone(EnumSet.of(side));
     }
 
     @Override
-	public ItemStack getPickBlock( final IBlockState state, final RayTraceResult target, final World world, final BlockPos pos, final EntityPlayer player )
+    public ItemStack getPickBlock(final IBlockState state, final RayTraceResult target, final World world, final BlockPos pos, final EntityPlayer player) {
-	{
+        final Vec3d v3 = target.hitVec.subtract(pos.getX(), pos.getY(), pos.getZ());
-		final Vec3d v3 = target.hitVec.subtract( pos.getX(), pos.getY(), pos.getZ() );
+        final SelectedPart sp = this.cb(world, pos).selectPart(v3);
-		final SelectedPart sp = this.cb( world, pos ).selectPart( v3 );
 
-		if( sp.part != null )
+        if (sp.part != null) {
-		{
+            return sp.part.getItemStack(PartItemStack.PICK);
-			return sp.part.getItemStack( PartItemStack.PICK );
+        } else if (sp.facade != null) {
-		}
-		else if( sp.facade != null )
-		{
             return sp.facade.getItemStack();
         }
 
@@ -249,25 +222,22 @@ public class BlockCableBus extends AEBaseTileBlock implements IAEFacade
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public boolean addHitEffects( final IBlockState state, final World world, final RayTraceResult target, final ParticleManager effectRenderer )
+    public boolean addHitEffects(final IBlockState state, final World world, final RayTraceResult target, final ParticleManager effectRenderer) {
-	{
 
         // Half the particle rate. Since we're spawning concentrated on a specific spot,
         // our particle effect otherwise looks too strong
-		if( Platform.getRandom().nextBoolean() )
+        if (Platform.getRandom().nextBoolean()) {
-		{
             return true;
         }
 
-		ICableBusContainer cb = this.cb( world, target.getBlockPos() );
+        ICableBusContainer cb = this.cb(world, target.getBlockPos());
 
         // Our built-in model has the actual baked sprites we need
-		IBakedModel model = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState( this.getDefaultState() );
+        IBakedModel model = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState(this.getDefaultState());
 
         // We cannot add the effect if we don't have the model
-		if( !( model instanceof CableBusBakedModel ) )
+        if (!(model instanceof CableBusBakedModel)) {
-		{
             return true;
         }
 
@@ -276,33 +246,30 @@ public class BlockCableBus extends AEBaseTileBlock implements IAEFacade
         CableBusRenderState renderState = cb.getRenderState();
 
         // Spawn a particle for one of the particle textures
-		TextureAtlasSprite texture = Platform.pickRandom( cableBusModel.getParticleTextures( renderState ) );
+        TextureAtlasSprite texture = Platform.pickRandom(cableBusModel.getParticleTextures(renderState));
-		if( texture != null )
+        if (texture != null) {
-		{
             double x = target.hitVec.x;
             double y = target.hitVec.y;
             double z = target.hitVec.z;
 
-			Particle fx = new DestroyFX( world, x, y, z, 0.0D, 0.0D, 0.0D, state ).setBlockPos( target.getBlockPos() ).multipleParticleScaleBy( 0.8F );
+            Particle fx = new DestroyFX(world, x, y, z, 0.0D, 0.0D, 0.0D, state).setBlockPos(target.getBlockPos()).multipleParticleScaleBy(0.8F);
-			fx.setParticleTexture( texture );
+            fx.setParticleTexture(texture);
-			effectRenderer.addEffect( fx );
+            effectRenderer.addEffect(fx);
         }
 
         return true;
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public boolean addDestroyEffects( final World world, final BlockPos pos, final ParticleManager effectRenderer )
+    public boolean addDestroyEffects(final World world, final BlockPos pos, final ParticleManager effectRenderer) {
-	{
+        ICableBusContainer cb = this.cb(world, pos);
-		ICableBusContainer cb = this.cb( world, pos );
 
         // Our built-in model has the actual baked sprites we need
-		IBakedModel model = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState( this.getDefaultState() );
+        IBakedModel model = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState(this.getDefaultState());
 
         // We cannot add the effect if we dont have the model
-		if( !( model instanceof CableBusBakedModel ) )
+        if (!(model instanceof CableBusBakedModel)) {
-		{
             return true;
         }
 
@@ -310,28 +277,24 @@ public class BlockCableBus extends AEBaseTileBlock implements IAEFacade
 
         CableBusRenderState renderState = cb.getRenderState();
 
-		List<TextureAtlasSprite> textures = cableBusModel.getParticleTextures( renderState );
+        List<TextureAtlasSprite> textures = cableBusModel.getParticleTextures(renderState);
 
-		if( !textures.isEmpty() )
+        if (!textures.isEmpty()) {
-		{
             // Shamelessly inspired by ParticleManager.addBlockDestroyEffects
-			for( int j = 0; j < 4; ++j )
+            for (int j = 0; j < 4; ++j) {
-			{
+                for (int k = 0; k < 4; ++k) {
-				for( int k = 0; k < 4; ++k )
+                    for (int l = 0; l < 4; ++l) {
-				{
-					for( int l = 0; l < 4; ++l )
-					{
                         // Randomly select one of the textures if the cable bus has more than just one possibility here
-						final TextureAtlasSprite texture = Platform.pickRandom( textures );
+                        final TextureAtlasSprite texture = Platform.pickRandom(textures);
 
-						final double d0 = pos.getX() + ( j + 0.5D ) / 4.0D;
+                        final double d0 = pos.getX() + (j + 0.5D) / 4.0D;
-						final double d1 = pos.getY() + ( k + 0.5D ) / 4.0D;
+                        final double d1 = pos.getY() + (k + 0.5D) / 4.0D;
-						final double d2 = pos.getZ() + ( l + 0.5D ) / 4.0D;
+                        final double d2 = pos.getZ() + (l + 0.5D) / 4.0D;
-						final ParticleDigging particle = new DestroyFX( world, d0, d1, d2, d0 - pos.getX() - 0.5D, d1 - pos
+                        final ParticleDigging particle = new DestroyFX(world, d0, d1, d2, d0 - pos.getX() - 0.5D, d1 - pos
-								.getY() - 0.5D, d2 - pos.getZ() - 0.5D, this.getDefaultState() ).setBlockPos( pos );
+                                .getY() - 0.5D, d2 - pos.getZ() - 0.5D, this.getDefaultState()).setBlockPos(pos);
 
-						particle.setParticleTexture( texture );
+                        particle.setParticleTexture(texture);
-						effectRenderer.addEffect( particle );
+                        effectRenderer.addEffect(particle);
                     }
                 }
             }
@@ -341,159 +304,153 @@ public class BlockCableBus extends AEBaseTileBlock implements IAEFacade
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        if (Platform.isServer()) {
-		if( Platform.isServer() )
+            this.cb(world, pos).onNeighborChanged(world, pos, fromPos);
-		{
-			this.cb( world, pos ).onNeighborChanged( world, pos, fromPos );
         }
     }
 
-	private ICableBusContainer cb( final IBlockAccess w, final BlockPos pos )
+    private ICableBusContainer cb(final IBlockAccess w, final BlockPos pos) {
-	{
+        final TileEntity te = w.getTileEntity(pos);
-		final TileEntity te = w.getTileEntity( pos );
         ICableBusContainer out = null;
 
-		if( te instanceof TileCableBus )
+        if (te instanceof TileCableBus) {
-		{
+            out = ((TileCableBus) te).getCableBus();
-			out = ( (TileCableBus) te ).getCableBus();
         }
 
         return out == null ? NULL_CABLE_BUS : out;
     }
 
     @Nullable
-	private IFacadeContainer fc( final IBlockAccess w, final BlockPos pos )
+    private IFacadeContainer fc(final IBlockAccess w, final BlockPos pos) {
-	{
+        final TileEntity te = w.getTileEntity(pos);
-		final TileEntity te = w.getTileEntity( pos );
         IFacadeContainer out = null;
 
-		if( te instanceof TileCableBus )
+        if (te instanceof TileCableBus) {
-		{
+            out = ((TileCableBus) te).getCableBus().getFacadeContainer();
-			out = ( (TileCableBus) te ).getCableBus().getFacadeContainer();
         }
 
         return out;
     }
 
     @Override
-	public void onBlockClicked( World worldIn, BlockPos pos, EntityPlayer playerIn )
+    public void onBlockClicked(World worldIn, BlockPos pos, EntityPlayer playerIn) {
-	{
+        if (Platform.isClient()) {
-		if( Platform.isClient() )
-		{
             final RayTraceResult rtr = Minecraft.getMinecraft().objectMouseOver;
-			if( rtr != null && rtr.typeOfHit == Type.BLOCK && pos.equals( rtr.getBlockPos() ) )
+            if (rtr != null && rtr.typeOfHit == Type.BLOCK && pos.equals(rtr.getBlockPos())) {
-			{
+                final Vec3d hitVec = rtr.hitVec.subtract(new Vec3d(pos));
-				final Vec3d hitVec = rtr.hitVec.subtract( new Vec3d( pos ) );
 
-				if( this.cb( worldIn, pos ).clicked( playerIn, EnumHand.MAIN_HAND, hitVec ) )
+                if (this.cb(worldIn, pos).clicked(playerIn, EnumHand.MAIN_HAND, hitVec)) {
-				{
                     NetworkHandler.instance()
                             .sendToServer(
-									new PacketClick( pos, rtr.sideHit, (float) hitVec.x, (float) hitVec.y, (float) hitVec.z, EnumHand.MAIN_HAND, true ) );
+                                    new PacketClick(pos, rtr.sideHit, (float) hitVec.x, (float) hitVec.y, (float) hitVec.z, EnumHand.MAIN_HAND, true));
                 }
             }
         }
     }
 
-	public void onBlockClickPacket( World worldIn, BlockPos pos, EntityPlayer playerIn, EnumHand hand, Vec3d hitVec )
+    public void onBlockClickPacket(World worldIn, BlockPos pos, EntityPlayer playerIn, EnumHand hand, Vec3d hitVec) {
-	{
+        this.cb(worldIn, pos).clicked(playerIn, hand, hitVec);
-		this.cb( worldIn, pos ).clicked( playerIn, hand, hitVec );
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        return this.cb(w, pos).activate(player, hand, new Vec3d(hitX, hitY, hitZ));
-		return this.cb( w, pos ).activate( player, hand, new Vec3d( hitX, hitY, hitZ ) );
     }
 
     @Override
-	public boolean recolorBlock( final World world, final BlockPos pos, final EnumFacing side, final EnumDyeColor color )
+    public boolean recolorBlock(final World world, final BlockPos pos, final EnumFacing side, final EnumDyeColor color) {
-	{
+        return this.recolorBlock(world, pos, side, color, null);
-		return this.recolorBlock( world, pos, side, color, null );
     }
 
-	public boolean recolorBlock( final World world, final BlockPos pos, final EnumFacing side, final EnumDyeColor color, final EntityPlayer who )
+    public boolean recolorBlock(final World world, final BlockPos pos, final EnumFacing side, final EnumDyeColor color, final EntityPlayer who) {
-	{
+        try {
-		try
+            return this.cb(world, pos).recolourBlock(side, AEColor.values()[color.ordinal()], who);
-		{
+        } catch (final Throwable ignored) {
-			return this.cb( world, pos ).recolourBlock( side, AEColor.values()[color.ordinal()], who );
-		}
-		catch( final Throwable ignored )
-		{
         }
         return false;
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void getSubBlocks( final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks )
+    public void getSubBlocks(final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks) {
-	{
         // do nothing
     }
 
-	public void setupTile()
+    public void setupTile() {
-	{
+        noTesrTile = Api.INSTANCE.partHelper().getCombinedInstance(TileCableBus.class);
-		noTesrTile = Api.INSTANCE.partHelper().getCombinedInstance( TileCableBus.class );
+        this.setTileEntity(noTesrTile);
-		this.setTileEntity( noTesrTile );
 
-		GameRegistry.registerTileEntity( noTesrTile, AppEng.MOD_ID.toLowerCase() + ":" + "BlockCableBus" );
+        GameRegistry.registerTileEntity(noTesrTile, AppEng.MOD_ID.toLowerCase() + ":" + "BlockCableBus");
 
-		if( Platform.isClient() )
+        if (Platform.isClient()) {
-		{
             setupTesr();
         }
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	private static void setupTesr()
+    private static void setupTesr() {
-	{
+        tesrTile = Api.INSTANCE.partHelper().getCombinedInstance(TileCableBusTESR.class);
-		tesrTile = Api.INSTANCE.partHelper().getCombinedInstance( TileCableBusTESR.class );
+        GameRegistry.registerTileEntity(tesrTile, AppEng.MOD_ID.toLowerCase() + ":" + "ClientOnly_TESR_CableBus");
-		GameRegistry.registerTileEntity( tesrTile, AppEng.MOD_ID.toLowerCase() + ":" + "ClientOnly_TESR_CableBus" );
+        ClientRegistry.bindTileEntitySpecialRenderer(BlockCableBus.getTesrTile(), new CableBusTESR());
-		ClientRegistry.bindTileEntitySpecialRenderer( BlockCableBus.getTesrTile(), new CableBusTESR() );
     }
 
     @Override
-	public boolean canRenderInLayer( IBlockState state, BlockRenderLayer layer )
+    public boolean canRenderInLayer(IBlockState state, BlockRenderLayer layer) {
-	{
         return true;
     }
 
     @Override
-	public IBlockState getFacadeState( IBlockAccess world, BlockPos pos, EnumFacing side )
+    public IBlockState getFacadeState(IBlockAccess world, BlockPos pos, EnumFacing side) {
-	{
+        if (side != null) {
-		if( side != null )
+            IFacadeContainer container = this.fc(world, pos);
-		{
+            if (container != null) {
-			IFacadeContainer container = this.fc( world, pos );
+                IFacadePart facade = container.getFacade(AEPartLocation.fromFacing(side));
-			if( container != null )
+                if (facade != null) {
-			{
-				IFacadePart facade = container.getFacade( AEPartLocation.fromFacing( side ) );
-				if( facade != null )
-				{
                     return facade.getBlockState();
                 }
             }
         }
-		return world.getBlockState( pos );
+        return world.getBlockState(pos);
     }
 
-	public static Class<? extends AEBaseTile> getNoTesrTile()
+    @Override
-	{
+    public BlockFaceShape getBlockFaceShape(IBlockAccess world, IBlockState state, BlockPos pos, EnumFacing side) {
+        IFacadeContainer container = this.fc(world, pos);
+        if (container != null) {
+            IFacadePart facade = container.getFacade(AEPartLocation.fromFacing(side));
+            if (facade != null) {
+                return BlockFaceShape.SOLID;
+            }
+        }
+        return BlockFaceShape.UNDEFINED;
+    }
+
+    @Override
+    public void onEntityWalk(World world, BlockPos pos, Entity entityIn) {
+        IFacadeContainer container = this.fc(world, pos);
+        if (container != null) {
+            IFacadePart facade = container.getFacade(AEPartLocation.fromFacing(EnumFacing.UP));
+            if (facade != null) {
+                facade.getBlockState().getBlock().onEntityWalk(world, pos, entityIn);
+            }
+        }
+        super.onEntityWalk(world, pos, entityIn);
+    }
+
+    public static Class<? extends AEBaseTile> getNoTesrTile() {
         return noTesrTile;
     }
 
-	public static Class<? extends AEBaseTile> getTesrTile()
+    public static Class<? extends AEBaseTile> getTesrTile() {
-	{
         return tesrTile;
     }
 
     // Helper to get access to the protected constructor
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	private static class DestroyFX extends ParticleDigging
+    private static class DestroyFX extends ParticleDigging {
-	{
+        DestroyFX(World worldIn, double xCoordIn, double yCoordIn, double zCoordIn, double xSpeedIn, double ySpeedIn, double zSpeedIn, IBlockState state) {
-		DestroyFX( World worldIn, double xCoordIn, double yCoordIn, double zCoordIn, double xSpeedIn, double ySpeedIn, double zSpeedIn, IBlockState state )
+            super(worldIn, xCoordIn, yCoordIn, zCoordIn, xSpeedIn, ySpeedIn, zSpeedIn, state);
-		{
-			super( worldIn, xCoordIn, yCoordIn, zCoordIn, xSpeedIn, ySpeedIn, zSpeedIn, state );
         }
     }
 }

src/main/java/appeng/block/networking/BlockController.java

@@ -19,6 +19,8 @@
 package appeng.block.networking;
 
 
+import appeng.block.AEBaseTileBlock;
+import appeng.tile.networking.TileController;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
@@ -31,20 +33,14 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
-import appeng.block.AEBaseTileBlock;
-import appeng.tile.networking.TileController;
 
+public class BlockController extends AEBaseTileBlock {
 
-public class BlockController extends AEBaseTileBlock
+    public enum ControllerBlockState implements IStringSerializable {
-{
-
-	public enum ControllerBlockState implements IStringSerializable
-	{
         offline, online, conflicted;
 
         @Override
-		public String getName()
+        public String getName() {
-		{
             return this.name();
         }
 
@@ -55,41 +51,36 @@ public class BlockController extends AEBaseTileBlock
      * inside_a and inside_b are alternating patterns for a controller that is enclosed by other controllers,
      * and since they are always offline, they do not have the usual sub-states.
      */
-	public enum ControllerRenderType implements IStringSerializable
+    public enum ControllerRenderType implements IStringSerializable {
-	{
         block, column_x, column_y, column_z, inside_a, inside_b;
 
         @Override
-		public String getName()
+        public String getName() {
-		{
             return this.name();
         }
 
     }
 
-	public static final PropertyEnum<ControllerBlockState> CONTROLLER_STATE = PropertyEnum.create( "state", ControllerBlockState.class );
+    public static final PropertyEnum<ControllerBlockState> CONTROLLER_STATE = PropertyEnum.create("state", ControllerBlockState.class);
 
-	public static final PropertyEnum<ControllerRenderType> CONTROLLER_TYPE = PropertyEnum.create( "type", ControllerRenderType.class );
+    public static final PropertyEnum<ControllerRenderType> CONTROLLER_TYPE = PropertyEnum.create("type", ControllerRenderType.class);
 
-	public BlockController()
+    public BlockController() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
+        this.setHardness(6);
-		this.setHardness( 6 );
+        this.setDefaultState(this.getDefaultState()
-		this.setDefaultState( this.getDefaultState()
+                .withProperty(CONTROLLER_STATE, ControllerBlockState.offline)
-				.withProperty( CONTROLLER_STATE, ControllerBlockState.offline )
+                .withProperty(CONTROLLER_TYPE, ControllerRenderType.block));
-				.withProperty( CONTROLLER_TYPE, ControllerRenderType.block ) );
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{CONTROLLER_STATE, CONTROLLER_TYPE};
-		return new IProperty[] { CONTROLLER_STATE, CONTROLLER_TYPE };
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new BlockStateContainer(this, this.getAEStates());
-		return new BlockStateContainer( this, this.getAEStates() );
     }
 
     /**
@@ -98,8 +89,7 @@ public class BlockController extends AEBaseTileBlock
      * get a rudimentary connected texture feel for the controller based on how it is placed.
      */
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
 
         // Only used for columns, really
         ControllerRenderType type = ControllerRenderType.block;
@@ -109,76 +99,60 @@ public class BlockController extends AEBaseTileBlock
         int z = pos.getZ();
 
         // Detect whether controllers are on both sides of the x, y, and z axes
-		final boolean xx = this.getTileEntity( world, x - 1, y, z ) instanceof TileController && this.getTileEntity( world, x + 1, y,
+        final boolean xx = this.getTileEntity(world, x - 1, y, z) instanceof TileController && this.getTileEntity(world, x + 1, y,
-				z ) instanceof TileController;
+                z) instanceof TileController;
-		final boolean yy = this.getTileEntity( world, x, y - 1, z ) instanceof TileController && this.getTileEntity( world, x, y + 1,
+        final boolean yy = this.getTileEntity(world, x, y - 1, z) instanceof TileController && this.getTileEntity(world, x, y + 1,
-				z ) instanceof TileController;
+                z) instanceof TileController;
-		final boolean zz = this.getTileEntity( world, x, y, z - 1 ) instanceof TileController && this.getTileEntity( world, x, y,
+        final boolean zz = this.getTileEntity(world, x, y, z - 1) instanceof TileController && this.getTileEntity(world, x, y,
-				z + 1 ) instanceof TileController;
+                z + 1) instanceof TileController;
 
-		if( xx && !yy && !zz )
+        if (xx && !yy && !zz) {
-		{
             type = ControllerRenderType.column_x;
-		}
+        } else if (!xx && yy && !zz) {
-		else if( !xx && yy && !zz )
-		{
             type = ControllerRenderType.column_y;
-		}
+        } else if (!xx && !yy && zz) {
-		else if( !xx && !yy && zz )
-		{
             type = ControllerRenderType.column_z;
-		}
+        } else if ((xx ? 1 : 0) + (yy ? 1 : 0) + (zz ? 1 : 0) >= 2) {
-		else if( ( xx ? 1 : 0 ) + ( yy ? 1 : 0 ) + ( zz ? 1 : 0 ) >= 2 )
+            final int v = (Math.abs(x) + Math.abs(y) + Math.abs(z)) % 2;
-		{
-			final int v = ( Math.abs( x ) + Math.abs( y ) + Math.abs( z ) ) % 2;
 
             // While i'd like this to be based on the blockstate randomization feature, this generates
             // an alternating pattern based on world position, so this is not 100% doable with blockstates.
-			if( v == 0 )
+            if (v == 0) {
-			{
                 type = ControllerRenderType.inside_a;
-			}
+            } else {
-			else
-			{
                 type = ControllerRenderType.inside_b;
             }
         }
 
-		return state.withProperty( CONTROLLER_TYPE, type );
+        return state.withProperty(CONTROLLER_TYPE, type);
     }
 
     @Override
-	public IBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         return state;
     }
 
     @Override
-	public int getMetaFromState( final IBlockState state )
+    public int getMetaFromState(final IBlockState state) {
-	{
+        return state.getValue(CONTROLLER_STATE).ordinal();
-		return state.getValue( CONTROLLER_STATE ).ordinal();
     }
 
     @Override
-	public IBlockState getStateFromMeta( final int meta )
+    public IBlockState getStateFromMeta(final int meta) {
-	{
         ControllerBlockState state = ControllerBlockState.values()[meta];
-		return this.getDefaultState().withProperty( CONTROLLER_STATE, state );
+        return this.getDefaultState().withProperty(CONTROLLER_STATE, state);
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final TileController tc = this.getTileEntity(world, pos);
-		final TileController tc = this.getTileEntity( world, pos );
+        if (tc != null) {
-		if( tc != null )
+            tc.onNeighborChange(false);
-		{
-			tc.onNeighborChange( false );
         }
     }
 }

src/main/java/appeng/block/networking/BlockCreativeEnergyCell.java

@@ -23,11 +23,9 @@ import appeng.block.AEBaseTileBlock;
 import appeng.helpers.AEGlassMaterial;
 
 
-public class BlockCreativeEnergyCell extends AEBaseTileBlock
+public class BlockCreativeEnergyCell extends AEBaseTileBlock {
-{
 
-	public BlockCreativeEnergyCell()
+    public BlockCreativeEnergyCell() {
-	{
+        super(AEGlassMaterial.INSTANCE);
-		super( AEGlassMaterial.INSTANCE );
     }
 }

src/main/java/appeng/block/networking/BlockDenseEnergyCell.java

@@ -19,17 +19,14 @@
 package appeng.block.networking;
 
 
-public class BlockDenseEnergyCell extends BlockEnergyCell
+public class BlockDenseEnergyCell extends BlockEnergyCell {
-{
 
-	public BlockDenseEnergyCell()
+    public BlockDenseEnergyCell() {
-	{
 
     }
 
     @Override
-	public double getMaxPower()
+    public double getMaxPower() {
-	{
         return 200000.0 * 8.0;
     }
 }

src/main/java/appeng/block/networking/BlockEnergyAcceptor.java

@@ -19,16 +19,13 @@
 package appeng.block.networking;
 
 
+import appeng.block.AEBaseTileBlock;
 import net.minecraft.block.material.Material;
 
-import appeng.block.AEBaseTileBlock;
 
+public class BlockEnergyAcceptor extends AEBaseTileBlock {
 
-public class BlockEnergyAcceptor extends AEBaseTileBlock
+    public BlockEnergyAcceptor() {
-{
+        super(Material.IRON);
-
-	public BlockEnergyAcceptor()
-	{
-		super( Material.IRON );
     }
 }

src/main/java/appeng/block/networking/BlockEnergyCell.java

@@ -19,6 +19,9 @@
 package appeng.block.networking;
 
 
+import appeng.block.AEBaseTileBlock;
+import appeng.helpers.AEGlassMaterial;
+import appeng.util.Platform;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.properties.PropertyInteger;
 import net.minecraft.block.state.IBlockState;
@@ -29,56 +32,45 @@ import net.minecraft.util.NonNullList;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.block.AEBaseTileBlock;
-import appeng.helpers.AEGlassMaterial;
-import appeng.util.Platform;
 
+public class BlockEnergyCell extends AEBaseTileBlock {
 
-public class BlockEnergyCell extends AEBaseTileBlock
+    public static final PropertyInteger ENERGY_STORAGE = PropertyInteger.create("fullness", 0, 7);
-{
-
-	public static final PropertyInteger ENERGY_STORAGE = PropertyInteger.create( "fullness", 0, 7 );
 
     @Override
-	public int getMetaFromState( final IBlockState state )
+    public int getMetaFromState(final IBlockState state) {
-	{
+        return state.getValue(ENERGY_STORAGE);
-		return state.getValue( ENERGY_STORAGE );
     }
 
     @Override
-	public IBlockState getStateFromMeta( final int meta )
+    public IBlockState getStateFromMeta(final int meta) {
-	{
+        return this.getDefaultState().withProperty(ENERGY_STORAGE, Math.min(7, Math.max(0, meta)));
-		return this.getDefaultState().withProperty( ENERGY_STORAGE, Math.min( 7, Math.max( 0, meta ) ) );
     }
 
-	public BlockEnergyCell()
+    public BlockEnergyCell() {
-	{
+        super(AEGlassMaterial.INSTANCE);
-		super( AEGlassMaterial.INSTANCE );
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void getSubBlocks( final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks )
+    public void getSubBlocks(final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks) {
-	{
+        super.getSubBlocks(tabs, itemStacks);
-		super.getSubBlocks( tabs, itemStacks );
 
-		final ItemStack charged = new ItemStack( this, 1 );
+        final ItemStack charged = new ItemStack(this, 1);
-		final NBTTagCompound tag = Platform.openNbtData( charged );
+        final NBTTagCompound tag = Platform.openNbtData(charged);
-		tag.setDouble( "internalCurrentPower", this.getMaxPower() );
+        tag.setDouble("internalCurrentPower", this.getMaxPower());
-		tag.setDouble( "internalMaxPower", this.getMaxPower() );
+        tag.setDouble("internalMaxPower", this.getMaxPower());
 
-		itemStacks.add( charged );
+        itemStacks.add(charged);
     }
 
-	public double getMaxPower()
+    public double getMaxPower() {
-	{
         return 200000.0;
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{ENERGY_STORAGE};
-		return new IProperty[] { ENERGY_STORAGE };
     }
 
 }

src/main/java/appeng/block/networking/BlockEnergyCellRendering.java

@@ -19,32 +19,28 @@
 package appeng.block.networking;
 
 
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.ResourceLocation;
-
 import appeng.api.implementations.items.IAEItemPowerStorage;
 import appeng.block.AEBaseItemBlockChargeable;
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.tile.networking.TileEnergyCell;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
 
 
-public class BlockEnergyCellRendering extends BlockRenderingCustomizer
+public class BlockEnergyCellRendering extends BlockRenderingCustomizer {
-{
 
     private final ResourceLocation baseModel;
 
-	public BlockEnergyCellRendering( ResourceLocation baseModel )
+    public BlockEnergyCellRendering(ResourceLocation baseModel) {
-	{
         this.baseModel = baseModel;
     }
 
     @Override
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        itemRendering.meshDefinition(this::getItemModel);
-		itemRendering.meshDefinition( this::getItemModel );
         // Note: Since we use the block models, we dont need to register custom variants
     }
 
@@ -52,28 +48,25 @@ public class BlockEnergyCellRendering extends BlockRenderingCustomizer
      * Determines which version of the energy cell model should be used depending on the fill factor
      * of the item stack.
      */
-	private ModelResourceLocation getItemModel( ItemStack is )
+    private ModelResourceLocation getItemModel(ItemStack is) {
-	{
+        double fillFactor = getFillFactor(is);
-		double fillFactor = getFillFactor( is );
 
-		int storageLevel = TileEnergyCell.getStorageLevelFromFillFactor( fillFactor );
+        int storageLevel = TileEnergyCell.getStorageLevelFromFillFactor(fillFactor);
-		return new ModelResourceLocation( this.baseModel, "fullness=" + storageLevel );
+        return new ModelResourceLocation(this.baseModel, "fullness=" + storageLevel);
     }
 
     /**
      * Helper method that returns the energy fill factor (between 0 and 1) of a given item stack.
      * Returns 0 if the item stack has no fill factor.
      */
-	private static double getFillFactor( ItemStack is )
+    private static double getFillFactor(ItemStack is) {
-	{
+        if (!(is.getItem() instanceof IAEItemPowerStorage)) {
-		if( !( is.getItem() instanceof IAEItemPowerStorage ) )
-		{
             return 0;
         }
 
         AEBaseItemBlockChargeable itemChargeable = (AEBaseItemBlockChargeable) is.getItem();
-		double curPower = itemChargeable.getAECurrentPower( is );
+        double curPower = itemChargeable.getAECurrentPower(is);
-		double maxPower = itemChargeable.getAEMaxPower( is );
+        double maxPower = itemChargeable.getAEMaxPower(is);
 
         return curPower / maxPower;
     }

src/main/java/appeng/block/networking/BlockWireless.java

@@ -19,9 +19,13 @@
 package appeng.block.networking;
 
 
-import java.util.Collections;
+import appeng.api.util.AEPartLocation;
-import java.util.List;
+import appeng.block.AEBaseTileBlock;
-
+import appeng.core.sync.GuiBridge;
+import appeng.helpers.AEGlassMaterial;
+import appeng.helpers.ICustomCollision;
+import appeng.tile.networking.TileWireless;
+import appeng.util.Platform;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.properties.PropertyEnum;
 import net.minecraft.block.state.IBlockState;
@@ -36,99 +40,78 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import java.util.Collections;
-import appeng.block.AEBaseTileBlock;
+import java.util.List;
-import appeng.core.sync.GuiBridge;
-import appeng.helpers.AEGlassMaterial;
-import appeng.helpers.ICustomCollision;
-import appeng.tile.networking.TileWireless;
-import appeng.util.Platform;
 
 
-public class BlockWireless extends AEBaseTileBlock implements ICustomCollision
+public class BlockWireless extends AEBaseTileBlock implements ICustomCollision {
-{
 
-	enum State implements IStringSerializable
+    enum State implements IStringSerializable {
-	{
         OFF,
         ON,
         HAS_CHANNEL;
 
         @Override
-		public String getName()
+        public String getName() {
-		{
             return this.name().toLowerCase();
         }
     }
 
-	public static final PropertyEnum<State> STATE = PropertyEnum.create( "state", State.class );
+    public static final PropertyEnum<State> STATE = PropertyEnum.create("state", State.class);
 
-	public BlockWireless()
+    public BlockWireless() {
-	{
+        super(AEGlassMaterial.INSTANCE);
-		super( AEGlassMaterial.INSTANCE );
+        this.setLightOpacity(0);
-		this.setLightOpacity( 0 );
+        this.setFullSize(false);
-		this.setFullSize( false );
+        this.setOpaque(false);
-		this.setOpaque( false );
+        this.setDefaultState(this.getDefaultState().withProperty(STATE, State.OFF));
-		this.setDefaultState( this.getDefaultState().withProperty( STATE, State.OFF ) );
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess worldIn, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
-	{
         State teState = State.OFF;
 
-		TileWireless te = this.getTileEntity( worldIn, pos );
+        TileWireless te = this.getTileEntity(worldIn, pos);
-		if( te != null )
+        if (te != null) {
-		{
+            if (te.isActive()) {
-			if( te.isActive() )
-			{
                 teState = State.HAS_CHANNEL;
-			}
+            } else if (te.isPowered()) {
-			else if( te.isPowered() )
-			{
                 teState = State.ON;
             }
         }
 
-		return super.getActualState( state, worldIn, pos )
+        return super.getActualState(state, worldIn, pos)
-				.withProperty( STATE, teState );
+                .withProperty(STATE, teState);
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{STATE};
-		return new IProperty[] { STATE };
     }
 
     @Override
-	public boolean onBlockActivated( final World w, final BlockPos pos, final IBlockState state, final EntityPlayer player, final EnumHand hand, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onBlockActivated(final World w, final BlockPos pos, final IBlockState state, final EntityPlayer player, final EnumHand hand, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        final TileWireless tg = this.getTileEntity(w, pos);
-		final TileWireless tg = this.getTileEntity( w, pos );
 
-		if( tg != null && !player.isSneaking() )
+        if (tg != null && !player.isSneaking()) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(player, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_WIRELESS);
-			{
-				Platform.openGUI( player, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_WIRELESS );
             }
             return true;
         }
 
-		return super.onBlockActivated( w, pos, state, player, hand, side, hitX, hitY, hitZ );
+        return super.onBlockActivated(w, pos, state, player, hand, side, hitX, hitY, hitZ);
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
+        final TileWireless tile = this.getTileEntity(w, pos);
-		final TileWireless tile = this.getTileEntity( w, pos );
+        if (tile != null) {
-		if( tile != null )
-		{
             final EnumFacing forward = tile.getForward();
 
             double minX = 0;
@@ -138,8 +121,7 @@ public class BlockWireless extends AEBaseTileBlock implements ICustomCollision
             double maxY = 1;
             double maxZ = 1;
 
-			switch( forward )
+            switch (forward) {
-			{
                 case DOWN:
                     minZ = minX = 3.0 / 16.0;
                     maxZ = maxX = 13.0 / 16.0;
@@ -180,17 +162,15 @@ public class BlockWireless extends AEBaseTileBlock implements ICustomCollision
                     break;
             }
 
-			return Collections.singletonList( new AxisAlignedBB( minX, minY, minZ, maxX, maxY, maxZ ) );
+            return Collections.singletonList(new AxisAlignedBB(minX, minY, minZ, maxX, maxY, maxZ));
         }
-		return Collections.singletonList( new AxisAlignedBB( 0.0, 0, 0.0, 1.0, 1.0, 1.0 ) );
+        return Collections.singletonList(new AxisAlignedBB(0.0, 0, 0.0, 1.0, 1.0, 1.0));
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
+        final TileWireless tile = this.getTileEntity(w, pos);
-		final TileWireless tile = this.getTileEntity( w, pos );
+        if (tile != null) {
-		if( tile != null )
-		{
             final EnumFacing forward = tile.getForward();
 
             double minX = 0;
@@ -200,8 +180,7 @@ public class BlockWireless extends AEBaseTileBlock implements ICustomCollision
             double maxY = 1;
             double maxZ = 1;
 
-			switch( forward )
+            switch (forward) {
-			{
                 case DOWN:
                     minZ = minX = 3.0 / 16.0;
                     maxZ = maxX = 13.0 / 16.0;
@@ -242,17 +221,14 @@ public class BlockWireless extends AEBaseTileBlock implements ICustomCollision
                     break;
             }
 
-			out.add( new AxisAlignedBB( minX, minY, minZ, maxX, maxY, maxZ ) );
+            out.add(new AxisAlignedBB(minX, minY, minZ, maxX, maxY, maxZ));
-		}
+        } else {
-		else
+            out.add(new AxisAlignedBB(0.0, 0.0, 0.0, 1.0, 1.0, 1.0));
-		{
-			out.add( new AxisAlignedBB( 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ) );
         }
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 

src/main/java/appeng/block/networking/CableBusColor.java

@@ -19,6 +19,8 @@
 package appeng.block.networking;
 
 
+import appeng.api.util.AEColor;
+import appeng.client.render.cablebus.CableBusRenderState;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.renderer.color.IBlockColor;
 import net.minecraft.util.math.BlockPos;
@@ -27,33 +29,26 @@ import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.api.util.AEColor;
-import appeng.client.render.cablebus.CableBusRenderState;
-
 
 /**
  * Exposes the cable bus color as tint indices 0 (dark variant), 1 (medium variant) and 2 (bright variant).
  */
-@SideOnly( Side.CLIENT )
+@SideOnly(Side.CLIENT)
-public class CableBusColor implements IBlockColor
+public class CableBusColor implements IBlockColor {
-{
 
     @Override
-	public int colorMultiplier( IBlockState state, IBlockAccess worldIn, BlockPos pos, int color )
+    public int colorMultiplier(IBlockState state, IBlockAccess worldIn, BlockPos pos, int color) {
-	{
 
         AEColor busColor = AEColor.TRANSPARENT;
 
-		if( state instanceof IExtendedBlockState )
+        if (state instanceof IExtendedBlockState) {
-		{
+            CableBusRenderState renderState = ((IExtendedBlockState) state).getValue(BlockCableBus.RENDER_STATE_PROPERTY);
-			CableBusRenderState renderState = ( (IExtendedBlockState) state ).getValue( BlockCableBus.RENDER_STATE_PROPERTY );
+            if (renderState != null) {
-			if( renderState != null )
-			{
                 busColor = renderState.getCableColor();
             }
         }
 
-		return busColor.getVariantByTintIndex( color );
+        return busColor.getVariantByTintIndex(color);
 
     }
 }

src/main/java/appeng/block/networking/CableBusRendering.java

@@ -19,34 +19,30 @@
 package appeng.block.networking;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.cablebus.CableBusModel;
 import appeng.core.features.registries.PartModels;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
 /**
  * Customizes the rendering behavior for cable busses, which are the biggest multipart of AE2.
  */
-public class CableBusRendering extends BlockRenderingCustomizer
+public class CableBusRendering extends BlockRenderingCustomizer {
-{
     private final PartModels partModels;
 
-	public CableBusRendering( PartModels partModels )
+    public CableBusRendering(PartModels partModels) {
-	{
         this.partModels = partModels;
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.builtInModel("models/block/builtin/cable_bus", new CableBusModel(this.partModels));
-		rendering.builtInModel( "models/block/builtin/cable_bus", new CableBusModel( this.partModels ) );
+        rendering.blockColor(new CableBusColor());
-		rendering.blockColor( new CableBusColor() );
+        rendering.modelCustomizer((loc, model) -> model);
-		rendering.modelCustomizer( ( loc, model ) -> model );
     }
 }

src/main/java/appeng/block/networking/ControllerRendering.java

@@ -24,12 +24,10 @@ import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 
 
-public class ControllerRendering extends BlockRenderingCustomizer
+public class ControllerRendering extends BlockRenderingCustomizer {
-{
     @Override
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
         // Disables the default model rotator
-		rendering.modelCustomizer( ( loc, model ) -> model );
+        rendering.modelCustomizer((loc, model) -> model);
     }
 }

src/main/java/appeng/block/networking/WirelessRendering.java

@@ -1,23 +1,19 @@
-
 package appeng.block.networking;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.api.util.AEColor;
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.StaticBlockColor;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class WirelessRendering extends BlockRenderingCustomizer
+public class WirelessRendering extends BlockRenderingCustomizer {
-{
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.blockColor(new StaticBlockColor(AEColor.TRANSPARENT));
-		rendering.blockColor( new StaticBlockColor( AEColor.TRANSPARENT ) );
     }
 }

src/main/java/appeng/block/paint/BlockPaint.java

@@ -19,10 +19,10 @@
 package appeng.block.paint;
 
 
-import java.util.Collection;
+import appeng.block.AEBaseTileBlock;
-import java.util.Collections;
+import appeng.helpers.Splotch;
-import java.util.Random;
+import appeng.tile.misc.TilePaint;
-
+import appeng.util.Platform;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.MapColor;
 import net.minecraft.block.material.MaterialLiquid;
@@ -44,112 +44,94 @@ import net.minecraftforge.common.property.IUnlistedProperty;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.block.AEBaseTileBlock;
+import java.util.Collection;
-import appeng.helpers.Splotch;
+import java.util.Collections;
-import appeng.tile.misc.TilePaint;
+import java.util.Random;
-import appeng.util.Platform;
 
 
-public class BlockPaint extends AEBaseTileBlock
+public class BlockPaint extends AEBaseTileBlock {
-{
 
     static final PaintSplotchesProperty SPLOTCHES = new PaintSplotchesProperty();
 
-	public BlockPaint()
+    public BlockPaint() {
-	{
+        super(new MaterialLiquid(MapColor.AIR));
-		super( new MaterialLiquid( MapColor.AIR ) );
 
-		this.setLightOpacity( 0 );
+        this.setLightOpacity(0);
-		this.setFullSize( false );
+        this.setFullSize(false);
-		this.setOpaque( false );
+        this.setOpaque(false);
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, new IProperty[0], new IUnlistedProperty[]{SPLOTCHES});
-		return new ExtendedBlockState( this, new IProperty[0], new IUnlistedProperty[] { SPLOTCHES } );
     }
 
     @Override
-	public IBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         IExtendedBlockState extState = (IExtendedBlockState) state;
 
-		TilePaint te = this.getTileEntity( world, pos );
+        TilePaint te = this.getTileEntity(world, pos);
 
         Collection<Splotch> splotches = Collections.emptyList();
-		if( te != null )
+        if (te != null) {
-		{
             splotches = te.getDots();
         }
 
-		return extState.withProperty( SPLOTCHES, new PaintSplotches( splotches ) );
+        return extState.withProperty(SPLOTCHES, new PaintSplotches(splotches));
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void getSubBlocks( final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks )
+    public void getSubBlocks(final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks) {
-	{
         // do nothing
     }
 
     @Override
-	public AxisAlignedBB getCollisionBoundingBox( IBlockState blockState, IBlockAccess worldIn, BlockPos pos )
+    public AxisAlignedBB getCollisionBoundingBox(IBlockState blockState, IBlockAccess worldIn, BlockPos pos) {
-	{
         return null;
     }
 
     @Override
-	public boolean canCollideCheck( final IBlockState state, final boolean hitIfLiquid )
+    public boolean canCollideCheck(final IBlockState state, final boolean hitIfLiquid) {
-	{
         return false;
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final TilePaint tp = this.getTileEntity(world, pos);
-		final TilePaint tp = this.getTileEntity( world, pos );
 
-		if( tp != null )
+        if (tp != null) {
-		{
             tp.neighborChanged();
         }
     }
 
     @Override
-	public Item getItemDropped( final IBlockState state, final Random rand, final int fortune )
+    public Item getItemDropped(final IBlockState state, final Random rand, final int fortune) {
-	{
         return null;
     }
 
     @Override
-	public void dropBlockAsItemWithChance( final World worldIn, final BlockPos pos, final IBlockState state, final float chance, final int fortune )
+    public void dropBlockAsItemWithChance(final World worldIn, final BlockPos pos, final IBlockState state, final float chance, final int fortune) {
-	{
 
     }
 
     @Override
-	public void fillWithRain( final World w, final BlockPos pos )
+    public void fillWithRain(final World w, final BlockPos pos) {
-	{
+        if (Platform.isServer()) {
-		if( Platform.isServer() )
+            w.setBlockToAir(pos);
-		{
-			w.setBlockToAir( pos );
         }
     }
 
     @Override
-	public int getLightValue( final IBlockState state, final IBlockAccess w, final BlockPos pos )
+    public int getLightValue(final IBlockState state, final IBlockAccess w, final BlockPos pos) {
-	{
+        final TilePaint tp = this.getTileEntity(w, pos);
-		final TilePaint tp = this.getTileEntity( w, pos );
 
-		if( tp != null )
+        if (tp != null) {
-		{
             return tp.getLightLevel();
         }
 
@@ -157,14 +139,12 @@ public class BlockPaint extends AEBaseTileBlock
     }
 
     @Override
-	public boolean isAir( final IBlockState state, final IBlockAccess world, final BlockPos pos )
+    public boolean isAir(final IBlockState state, final IBlockAccess world, final BlockPos pos) {
-	{
         return true;
     }
 
     @Override
-	public boolean isReplaceable( final IBlockAccess worldIn, final BlockPos pos )
+    public boolean isReplaceable(final IBlockAccess worldIn, final BlockPos pos) {
-	{
         return true;
     }
 

src/main/java/appeng/block/paint/PaintBakedModel.java

@@ -1,16 +1,10 @@
-
 package appeng.block.paint;
 
 
-import java.util.ArrayList;
+import appeng.client.render.cablebus.CubeBuilder;
-import java.util.Collections;
+import appeng.core.AppEng;
-import java.util.List;
+import appeng.helpers.Splotch;
-import java.util.function.Function;
-
-import javax.annotation.Nullable;
-
 import com.google.common.collect.ImmutableList;
-
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.renderer.block.model.BakedQuad;
 import net.minecraft.client.renderer.block.model.IBakedModel;
@@ -22,9 +16,11 @@ import net.minecraft.util.EnumFacing;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.common.property.IExtendedBlockState;
 
-import appeng.client.render.cablebus.CubeBuilder;
+import javax.annotation.Nullable;
-import appeng.core.AppEng;
+import java.util.ArrayList;
-import appeng.helpers.Splotch;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
 
 
 /**
@@ -32,70 +28,60 @@ import appeng.helpers.Splotch;
  * a
  * matter cannon with paint balls.
  */
-class PaintBakedModel implements IBakedModel
+class PaintBakedModel implements IBakedModel {
-{
 
-	private static final ResourceLocation TEXTURE_PAINT1 = new ResourceLocation( AppEng.MOD_ID, "blocks/paint1" );
+    private static final ResourceLocation TEXTURE_PAINT1 = new ResourceLocation(AppEng.MOD_ID, "blocks/paint1");
-	private static final ResourceLocation TEXTURE_PAINT2 = new ResourceLocation( AppEng.MOD_ID, "blocks/paint2" );
+    private static final ResourceLocation TEXTURE_PAINT2 = new ResourceLocation(AppEng.MOD_ID, "blocks/paint2");
-	private static final ResourceLocation TEXTURE_PAINT3 = new ResourceLocation( AppEng.MOD_ID, "blocks/paint3" );
+    private static final ResourceLocation TEXTURE_PAINT3 = new ResourceLocation(AppEng.MOD_ID, "blocks/paint3");
 
     private final VertexFormat vertexFormat;
 
     private final TextureAtlasSprite[] textures;
 
-	PaintBakedModel( VertexFormat vertexFormat, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+    PaintBakedModel(VertexFormat vertexFormat, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
-	{
         this.vertexFormat = vertexFormat;
-		this.textures = new TextureAtlasSprite[] {
+        this.textures = new TextureAtlasSprite[]{
-				bakedTextureGetter.apply( TEXTURE_PAINT1 ),
+                bakedTextureGetter.apply(TEXTURE_PAINT1),
-				bakedTextureGetter.apply( TEXTURE_PAINT2 ),
+                bakedTextureGetter.apply(TEXTURE_PAINT2),
-				bakedTextureGetter.apply( TEXTURE_PAINT3 )
+                bakedTextureGetter.apply(TEXTURE_PAINT3)
         };
     }
 
     @Override
-	public List<BakedQuad> getQuads( @Nullable IBlockState state, @Nullable EnumFacing side, long rand )
+    public List<BakedQuad> getQuads(@Nullable IBlockState state, @Nullable EnumFacing side, long rand) {
-	{
+        if (side != null) {
-		if( side != null )
-		{
             return Collections.emptyList();
         }
 
-		if( !( state instanceof IExtendedBlockState ) )
+        if (!(state instanceof IExtendedBlockState)) {
-		{
             // This is the inventory model which should usually not be used other than in special cases
-			List<BakedQuad> quads = new ArrayList<>( 1 );
+            List<BakedQuad> quads = new ArrayList<>(1);
-			CubeBuilder builder = new CubeBuilder( this.vertexFormat, quads );
+            CubeBuilder builder = new CubeBuilder(this.vertexFormat, quads);
-			builder.setTexture( this.textures[0] );
+            builder.setTexture(this.textures[0]);
-			builder.addCube( 0, 0, 0, 16, 16, 16 );
+            builder.addCube(0, 0, 0, 16, 16, 16);
             return quads;
         }
 
         IExtendedBlockState extendedBlockState = (IExtendedBlockState) state;
-		PaintSplotches splotchesState = extendedBlockState.getValue( BlockPaint.SPLOTCHES );
+        PaintSplotches splotchesState = extendedBlockState.getValue(BlockPaint.SPLOTCHES);
 
-		if( splotchesState == null )
+        if (splotchesState == null) {
-		{
             return Collections.emptyList();
         }
 
         List<Splotch> splotches = splotchesState.getSplotches();
 
-		CubeBuilder builder = new CubeBuilder( this.vertexFormat );
+        CubeBuilder builder = new CubeBuilder(this.vertexFormat);
 
         float offsetConstant = 0.001f;
-		for( final Splotch s : splotches )
+        for (final Splotch s : splotches) {
-		{
 
-			if( s.isLumen() )
+            if (s.isLumen()) {
-			{
+                builder.setColorRGB(s.getColor().whiteVariant);
-				builder.setColorRGB( s.getColor().whiteVariant );
+                builder.setRenderFullBright(true);
-				builder.setRenderFullBright( true );
+            } else {
-			}
+                builder.setColorRGB(s.getColor().mediumVariant);
-			else
+                builder.setRenderFullBright(false);
-			{
-				builder.setColorRGB( s.getColor().mediumVariant );
-				builder.setRenderFullBright( false );
             }
 
             float offset = offsetConstant;
@@ -106,46 +92,45 @@ class PaintBakedModel implements IBakedModel
             float pos_x = s.x();
             float pos_y = s.y();
 
-			pos_x = Math.max( buffer, Math.min( 1.0f - buffer, pos_x ) );
+            pos_x = Math.max(buffer, Math.min(1.0f - buffer, pos_x));
-			pos_y = Math.max( buffer, Math.min( 1.0f - buffer, pos_y ) );
+            pos_y = Math.max(buffer, Math.min(1.0f - buffer, pos_y));
 
             TextureAtlasSprite ico = this.textures[s.getSeed() % this.textures.length];
-			builder.setTexture( ico );
+            builder.setTexture(ico);
-			builder.setCustomUv( s.getSide().getOpposite(), 0, 0, 16, 16 );
+            builder.setCustomUv(s.getSide().getOpposite(), 0, 0, 16, 16);
 
-			switch( s.getSide() )
+            switch (s.getSide()) {
-			{
                 case UP:
                     offset = 1.0f - offset;
-					builder.addQuad( EnumFacing.DOWN, pos_x - buffer, offset, pos_y - buffer,
+                    builder.addQuad(EnumFacing.DOWN, pos_x - buffer, offset, pos_y - buffer,
-							pos_x + buffer, offset, pos_y + buffer );
+                            pos_x + buffer, offset, pos_y + buffer);
                     break;
 
                 case DOWN:
-					builder.addQuad( EnumFacing.UP, pos_x - buffer, offset, pos_y - buffer,
+                    builder.addQuad(EnumFacing.UP, pos_x - buffer, offset, pos_y - buffer,
-							pos_x + buffer, offset, pos_y + buffer );
+                            pos_x + buffer, offset, pos_y + buffer);
                     break;
 
                 case EAST:
                     offset = 1.0f - offset;
-					builder.addQuad( EnumFacing.WEST, offset, pos_x - buffer, pos_y - buffer,
+                    builder.addQuad(EnumFacing.WEST, offset, pos_x - buffer, pos_y - buffer,
-							offset, pos_x + buffer, pos_y + buffer );
+                            offset, pos_x + buffer, pos_y + buffer);
                     break;
 
                 case WEST:
-					builder.addQuad( EnumFacing.EAST, offset, pos_x - buffer, pos_y - buffer,
+                    builder.addQuad(EnumFacing.EAST, offset, pos_x - buffer, pos_y - buffer,
-							offset, pos_x + buffer, pos_y + buffer );
+                            offset, pos_x + buffer, pos_y + buffer);
                     break;
 
                 case SOUTH:
                     offset = 1.0f - offset;
-					builder.addQuad( EnumFacing.NORTH, pos_x - buffer, pos_y - buffer, offset,
+                    builder.addQuad(EnumFacing.NORTH, pos_x - buffer, pos_y - buffer, offset,
-							pos_x + buffer, pos_y + buffer, offset );
+                            pos_x + buffer, pos_y + buffer, offset);
                     break;
 
                 case NORTH:
-					builder.addQuad( EnumFacing.SOUTH, pos_x - buffer, pos_y - buffer, offset,
+                    builder.addQuad(EnumFacing.SOUTH, pos_x - buffer, pos_y - buffer, offset,
-							pos_x + buffer, pos_y + buffer, offset );
+                            pos_x + buffer, pos_y + buffer, offset);
                     break;
 
                 default:
@@ -156,44 +141,37 @@ class PaintBakedModel implements IBakedModel
     }
 
     @Override
-	public boolean isAmbientOcclusion()
+    public boolean isAmbientOcclusion() {
-	{
         return false;
     }
 
     @Override
-	public boolean isGui3d()
+    public boolean isGui3d() {
-	{
         return true;
     }
 
     @Override
-	public boolean isBuiltInRenderer()
+    public boolean isBuiltInRenderer() {
-	{
         return false;
     }
 
     @Override
-	public TextureAtlasSprite getParticleTexture()
+    public TextureAtlasSprite getParticleTexture() {
-	{
         return this.textures[0];
     }
 
     @Override
-	public ItemCameraTransforms getItemCameraTransforms()
+    public ItemCameraTransforms getItemCameraTransforms() {
-	{
         return ItemCameraTransforms.DEFAULT;
     }
 
     @Override
-	public ItemOverrideList getOverrides()
+    public ItemOverrideList getOverrides() {
-	{
         return ItemOverrideList.NONE;
     }
 
-	static List<ResourceLocation> getRequiredTextures()
+    static List<ResourceLocation> getRequiredTextures() {
-	{
         return ImmutableList.of(
-				TEXTURE_PAINT1, TEXTURE_PAINT2, TEXTURE_PAINT3 );
+                TEXTURE_PAINT1, TEXTURE_PAINT2, TEXTURE_PAINT3);
     }
 }

src/main/java/appeng/block/paint/PaintModel.java

@@ -1,11 +1,6 @@
-
 package appeng.block.paint;
 
 
-import java.util.Collection;
-import java.util.Collections;
-import java.util.function.Function;
-
 import net.minecraft.client.renderer.block.model.IBakedModel;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.client.renderer.vertex.VertexFormat;
@@ -14,31 +9,30 @@ import net.minecraftforge.client.model.IModel;
 import net.minecraftforge.common.model.IModelState;
 import net.minecraftforge.common.model.TRSRTransformation;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.function.Function;
 
-class PaintModel implements IModel
+
-{
+class PaintModel implements IModel {
 
     @Override
-	public Collection<ResourceLocation> getDependencies()
+    public Collection<ResourceLocation> getDependencies() {
-	{
         return Collections.emptyList();
     }
 
     @Override
-	public Collection<ResourceLocation> getTextures()
+    public Collection<ResourceLocation> getTextures() {
-	{
         return PaintBakedModel.getRequiredTextures();
     }
 
     @Override
-	public IBakedModel bake( IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+    public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
-	{
+        return new PaintBakedModel(format, bakedTextureGetter);
-		return new PaintBakedModel( format, bakedTextureGetter );
     }
 
     @Override
-	public IModelState getDefaultState()
+    public IModelState getDefaultState() {
-	{
         return TRSRTransformation.identity();
     }
 

src/main/java/appeng/block/paint/PaintRendering.java

@@ -1,24 +1,20 @@
-
 package appeng.block.paint;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class PaintRendering extends BlockRenderingCustomizer
+public class PaintRendering extends BlockRenderingCustomizer {
-{
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.builtInModel("models/block/paint", new PaintModel());
-		rendering.builtInModel( "models/block/paint", new PaintModel() );
         // Disable auto rotation
-		rendering.modelCustomizer( ( location, model ) -> model );
+        rendering.modelCustomizer((location, model) -> model);
     }
 }

src/main/java/appeng/block/paint/PaintSplotches.java

@@ -1,30 +1,25 @@
-
 package appeng.block.paint;
 
 
-import java.util.Collection;
+import appeng.helpers.Splotch;
-import java.util.List;
-
 import com.google.common.collect.ImmutableList;
 
-import appeng.helpers.Splotch;
+import java.util.Collection;
+import java.util.List;
 
 
 /**
  * Used to transfer the state about paint splotches from the game thread to the render thread.
  */
-class PaintSplotches
+class PaintSplotches {
-{
 
     private final List<Splotch> splotches;
 
-	PaintSplotches( Collection<Splotch> splotches )
+    PaintSplotches(Collection<Splotch> splotches) {
-	{
+        this.splotches = ImmutableList.copyOf(splotches);
-		this.splotches = ImmutableList.copyOf( splotches );
     }
 
-	List<Splotch> getSplotches()
+    List<Splotch> getSplotches() {
-	{
         return this.splotches;
     }
 

src/main/java/appeng/block/paint/PaintSplotchesProperty.java

@@ -1,34 +1,28 @@
-
 package appeng.block.paint;
 
 
 import net.minecraftforge.common.property.IUnlistedProperty;
 
 
-class PaintSplotchesProperty implements IUnlistedProperty<PaintSplotches>
+class PaintSplotchesProperty implements IUnlistedProperty<PaintSplotches> {
-{
 
     @Override
-	public String getName()
+    public String getName() {
-	{
         return "paint_splots";
     }
 
     @Override
-	public boolean isValid( PaintSplotches value )
+    public boolean isValid(PaintSplotches value) {
-	{
         return value != null;
     }
 
     @Override
-	public Class<PaintSplotches> getType()
+    public Class<PaintSplotches> getType() {
-	{
         return PaintSplotches.class;
     }
 
     @Override
-	public String valueToString( PaintSplotches value )
+    public String valueToString(PaintSplotches value) {
-	{
         return null;
     }
 }

src/main/java/appeng/block/qnb/BlockQuantumBase.java

@@ -19,6 +19,9 @@
 package appeng.block.qnb;
 
 
+import appeng.block.AEBaseTileBlock;
+import appeng.helpers.ICustomCollision;
+import appeng.tile.qnb.TileQuantumBridge;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
@@ -34,97 +37,79 @@ import net.minecraftforge.common.property.ExtendedBlockState;
 import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.common.property.IUnlistedProperty;
 
-import appeng.block.AEBaseTileBlock;
-import appeng.helpers.ICustomCollision;
-import appeng.tile.qnb.TileQuantumBridge;
 
+public abstract class BlockQuantumBase extends AEBaseTileBlock implements ICustomCollision {
 
-public abstract class BlockQuantumBase extends AEBaseTileBlock implements ICustomCollision
+    public static final PropertyBool FORMED = PropertyBool.create("formed");
-{
-
-	public static final PropertyBool FORMED = PropertyBool.create( "formed" );
 
     public static final QnbFormedStateProperty FORMED_STATE = new QnbFormedStateProperty();
 
-	public BlockQuantumBase( final Material mat )
+    public BlockQuantumBase(final Material mat) {
-	{
+        super(mat);
-		super( mat );
         final float shave = 2.0f / 16.0f;
-		this.boundingBox = new AxisAlignedBB( shave, shave, shave, 1.0f - shave, 1.0f - shave, 1.0f - shave );
+        this.boundingBox = new AxisAlignedBB(shave, shave, shave, 1.0f - shave, 1.0f - shave, 1.0f - shave);
-		this.setLightOpacity( 0 );
+        this.setLightOpacity(0);
-		this.setFullSize( this.setOpaque( false ) );
+        this.setFullSize(this.setOpaque(false));
-		this.setDefaultState( this.getDefaultState().withProperty( FORMED, false ) );
+        this.setDefaultState(this.getDefaultState().withProperty(FORMED, false));
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{FORMED};
-		return new IProperty[] { FORMED };
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, this.getAEStates(), new IUnlistedProperty[]{FORMED_STATE});
-		return new ExtendedBlockState( this, this.getAEStates(), new IUnlistedProperty[] { FORMED_STATE } );
     }
 
     @Override
-	public IBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         IExtendedBlockState extState = (IExtendedBlockState) state;
 
-		TileQuantumBridge bridge = this.getTileEntity( world, pos );
+        TileQuantumBridge bridge = this.getTileEntity(world, pos);
-		if( bridge != null )
+        if (bridge != null) {
-		{
+            QnbFormedState formedState = new QnbFormedState(bridge.getAdjacentQuantumBridges(), bridge.isCorner(), bridge.isPowered());
-			QnbFormedState formedState = new QnbFormedState( bridge.getAdjacentQuantumBridges(), bridge.isCorner(), bridge.isPowered() );
+            extState = extState.withProperty(FORMED_STATE, formedState);
-			extState = extState.withProperty( FORMED_STATE, formedState );
         }
 
         return extState;
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess worldIn, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
-	{
+        TileQuantumBridge bridge = this.getTileEntity(worldIn, pos);
-		TileQuantumBridge bridge = this.getTileEntity( worldIn, pos );
+        if (bridge != null) {
-		if( bridge != null )
+            state = state.withProperty(FORMED, bridge.isFormed());
-		{
-			state = state.withProperty( FORMED, bridge.isFormed() );
         }
         return state;
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final TileQuantumBridge bridge = this.getTileEntity(world, pos);
-		final TileQuantumBridge bridge = this.getTileEntity( world, pos );
+        if (bridge != null) {
-		if( bridge != null )
-		{
             bridge.neighborUpdate();
         }
     }
 
     @Override
-	public void breakBlock( final World w, final BlockPos pos, final IBlockState state )
+    public void breakBlock(final World w, final BlockPos pos, final IBlockState state) {
-	{
+        final TileQuantumBridge bridge = this.getTileEntity(w, pos);
-		final TileQuantumBridge bridge = this.getTileEntity( w, pos );
+        if (bridge != null) {
-		if( bridge != null )
-		{
             bridge.breakCluster();
         }
 
-		super.breakBlock( w, pos, state );
+        super.breakBlock(w, pos, state);
     }
 
     @Override
-	public boolean isFullCube( IBlockState state )
+    public boolean isFullCube(IBlockState state) {
-	{
         return false;
     }
 }

src/main/java/appeng/block/qnb/BlockQuantumLinkChamber.java

@@ -19,12 +19,13 @@
 package appeng.block.qnb;
 
 
-import java.util.Collections;
+import appeng.api.util.AEPartLocation;
-import java.util.List;
+import appeng.client.EffectType;
-import java.util.Random;
+import appeng.core.AppEng;
-
+import appeng.core.sync.GuiBridge;
-import javax.annotation.Nullable;
+import appeng.helpers.AEGlassMaterial;
-
+import appeng.tile.qnb.TileQuantumBridge;
+import appeng.util.Platform;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
@@ -35,53 +36,40 @@ import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.client.EffectType;
+import java.util.Collections;
-import appeng.core.AppEng;
+import java.util.List;
-import appeng.core.sync.GuiBridge;
+import java.util.Random;
-import appeng.helpers.AEGlassMaterial;
-import appeng.tile.qnb.TileQuantumBridge;
-import appeng.util.Platform;
 
 
-public class BlockQuantumLinkChamber extends BlockQuantumBase
+public class BlockQuantumLinkChamber extends BlockQuantumBase {
-{
 
-	public BlockQuantumLinkChamber()
+    public BlockQuantumLinkChamber() {
-	{
+        super(AEGlassMaterial.INSTANCE);
-		super( AEGlassMaterial.INSTANCE );
     }
 
     @Override
-	public void randomDisplayTick( final IBlockState state, final World w, final BlockPos pos, final Random rand )
+    public void randomDisplayTick(final IBlockState state, final World w, final BlockPos pos, final Random rand) {
-	{
+        final TileQuantumBridge bridge = this.getTileEntity(w, pos);
-		final TileQuantumBridge bridge = this.getTileEntity( w, pos );
+        if (bridge != null) {
-		if( bridge != null )
+            if (bridge.hasQES()) {
-		{
+                if (AppEng.proxy.shouldAddParticles(rand)) {
-			if( bridge.hasQES() )
+                    AppEng.proxy.spawnEffect(EffectType.Energy, w, pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5, null);
-			{
-				if( AppEng.proxy.shouldAddParticles( rand ) )
-				{
-					AppEng.proxy.spawnEffect( EffectType.Energy, w, pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5, null );
                 }
             }
         }
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileQuantumBridge tg = this.getTileEntity( w, pos );
+        final TileQuantumBridge tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_QNB);
-			{
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_QNB );
             }
             return true;
         }
@@ -89,16 +77,14 @@ public class BlockQuantumLinkChamber extends BlockQuantumBase
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
         final double onePixel = 2.0 / 16.0;
-		return Collections.singletonList( new AxisAlignedBB( onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel ) );
+        return Collections.singletonList(new AxisAlignedBB(onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel));
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
         final double onePixel = 2.0 / 16.0;
-		out.add( new AxisAlignedBB( onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel ) );
+        out.add(new AxisAlignedBB(onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel));
     }
 }

src/main/java/appeng/block/qnb/BlockQuantumRing.java

@@ -19,55 +19,44 @@
 package appeng.block.qnb;
 
 
-import java.util.Collections;
+import appeng.tile.qnb.TileQuantumBridge;
-import java.util.List;
-
 import net.minecraft.block.material.Material;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.tile.qnb.TileQuantumBridge;
+import java.util.Collections;
+import java.util.List;
 
 
-public class BlockQuantumRing extends BlockQuantumBase
+public class BlockQuantumRing extends BlockQuantumBase {
-{
 
-	public BlockQuantumRing()
+    public BlockQuantumRing() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
         double onePixel = 2.0 / 16.0;
-		final TileQuantumBridge bridge = this.getTileEntity( w, pos );
+        final TileQuantumBridge bridge = this.getTileEntity(w, pos);
-		if( bridge != null && bridge.isCorner() )
+        if (bridge != null && bridge.isCorner()) {
-		{
             onePixel = 4.0 / 16.0;
-		}
+        } else if (bridge != null && bridge.isFormed()) {
-		else if( bridge != null && bridge.isFormed() )
-		{
             onePixel = 1.0 / 16.0;
         }
-		return Collections.singletonList( new AxisAlignedBB( onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel ) );
+        return Collections.singletonList(new AxisAlignedBB(onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel));
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
         double onePixel = 2.0 / 16.0;
-		final TileQuantumBridge bridge = this.getTileEntity( w, pos );
+        final TileQuantumBridge bridge = this.getTileEntity(w, pos);
-		if( bridge != null && bridge.isCorner() )
+        if (bridge != null && bridge.isCorner()) {
-		{
             onePixel = 4.0 / 16.0;
-		}
+        } else if (bridge != null && bridge.isFormed()) {
-		else if( bridge != null && bridge.isFormed() )
-		{
             onePixel = 1.0 / 16.0;
         }
-		out.add( new AxisAlignedBB( onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel ) );
+        out.add(new AxisAlignedBB(onePixel, onePixel, onePixel, 1.0 - onePixel, 1.0 - onePixel, 1.0 - onePixel));
     }
 }

src/main/java/appeng/block/qnb/QnbFormedBakedModel.java

@@ -1,16 +1,10 @@
-
 package appeng.block.qnb;
 
 
-import java.util.EnumSet;
+import appeng.api.AEApi;
-import java.util.List;
+import appeng.client.render.cablebus.CubeBuilder;
-import java.util.Set;
+import appeng.core.AppEng;
-import java.util.function.Function;
-
-import javax.annotation.Nullable;
-
 import com.google.common.collect.ImmutableList;
-
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.renderer.block.model.BakedQuad;
@@ -23,20 +17,21 @@ import net.minecraft.util.EnumFacing;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.common.property.IExtendedBlockState;
 
-import appeng.api.AEApi;
+import javax.annotation.Nullable;
-import appeng.client.render.cablebus.CubeBuilder;
+import java.util.EnumSet;
-import appeng.core.AppEng;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
 
 
-class QnbFormedBakedModel implements IBakedModel
+class QnbFormedBakedModel implements IBakedModel {
-{
 
-	private static final ResourceLocation TEXTURE_LINK = new ResourceLocation( AppEng.MOD_ID, "blocks/quantum_link" );
+    private static final ResourceLocation TEXTURE_LINK = new ResourceLocation(AppEng.MOD_ID, "blocks/quantum_link");
-	private static final ResourceLocation TEXTURE_RING = new ResourceLocation( AppEng.MOD_ID, "blocks/quantum_ring" );
+    private static final ResourceLocation TEXTURE_RING = new ResourceLocation(AppEng.MOD_ID, "blocks/quantum_ring");
-	private static final ResourceLocation TEXTURE_RING_LIGHT = new ResourceLocation( AppEng.MOD_ID, "blocks/quantum_ring_light" );
+    private static final ResourceLocation TEXTURE_RING_LIGHT = new ResourceLocation(AppEng.MOD_ID, "blocks/quantum_ring_light");
-	private static final ResourceLocation TEXTURE_RING_LIGHT_CORNER = new ResourceLocation( AppEng.MOD_ID, "blocks/quantum_ring_light_corner" );
+    private static final ResourceLocation TEXTURE_RING_LIGHT_CORNER = new ResourceLocation(AppEng.MOD_ID, "blocks/quantum_ring_light_corner");
-	private static final ResourceLocation TEXTURE_CABLE_GLASS = new ResourceLocation( AppEng.MOD_ID, "parts/cable/glass/transparent" );
+    private static final ResourceLocation TEXTURE_CABLE_GLASS = new ResourceLocation(AppEng.MOD_ID, "parts/cable/glass/transparent");
-	private static final ResourceLocation TEXTURE_COVERED_CABLE = new ResourceLocation( AppEng.MOD_ID, "parts/cable/covered/transparent" );
+    private static final ResourceLocation TEXTURE_COVERED_CABLE = new ResourceLocation(AppEng.MOD_ID, "parts/cable/covered/transparent");
 
     private static final float DEFAULT_RENDER_MIN = 2.0f;
     private static final float DEFAULT_RENDER_MAX = 14.0f;
@@ -60,103 +55,89 @@ class QnbFormedBakedModel implements IBakedModel
     private final TextureAtlasSprite lightTexture;
     private final TextureAtlasSprite lightCornerTexture;
 
-	public QnbFormedBakedModel( VertexFormat vertexFormat, IBakedModel baseModel, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+    public QnbFormedBakedModel(VertexFormat vertexFormat, IBakedModel baseModel, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
-	{
         this.vertexFormat = vertexFormat;
         this.baseModel = baseModel;
-		this.linkTexture = bakedTextureGetter.apply( TEXTURE_LINK );
+        this.linkTexture = bakedTextureGetter.apply(TEXTURE_LINK);
-		this.ringTexture = bakedTextureGetter.apply( TEXTURE_RING );
+        this.ringTexture = bakedTextureGetter.apply(TEXTURE_RING);
-		this.glassCableTexture = bakedTextureGetter.apply( TEXTURE_CABLE_GLASS );
+        this.glassCableTexture = bakedTextureGetter.apply(TEXTURE_CABLE_GLASS);
-		this.coveredCableTexture = bakedTextureGetter.apply( TEXTURE_COVERED_CABLE );
+        this.coveredCableTexture = bakedTextureGetter.apply(TEXTURE_COVERED_CABLE);
-		this.lightTexture = bakedTextureGetter.apply( TEXTURE_RING_LIGHT );
+        this.lightTexture = bakedTextureGetter.apply(TEXTURE_RING_LIGHT);
-		this.lightCornerTexture = bakedTextureGetter.apply( TEXTURE_RING_LIGHT_CORNER );
+        this.lightCornerTexture = bakedTextureGetter.apply(TEXTURE_RING_LIGHT_CORNER);
-		this.linkBlock = AEApi.instance().definitions().blocks().quantumLink().maybeBlock().orElse( null );
+        this.linkBlock = AEApi.instance().definitions().blocks().quantumLink().maybeBlock().orElse(null);
     }
 
     @Override
-	public List<BakedQuad> getQuads( @Nullable IBlockState state, @Nullable EnumFacing side, long rand )
+    public List<BakedQuad> getQuads(@Nullable IBlockState state, @Nullable EnumFacing side, long rand) {
-	{
         // Get the correct base model
-		if( !( state instanceof IExtendedBlockState ) )
+        if (!(state instanceof IExtendedBlockState)) {
-		{
+            return this.baseModel.getQuads(state, side, rand);
-			return this.baseModel.getQuads( state, side, rand );
         }
 
         IExtendedBlockState extendedBlockState = (IExtendedBlockState) state;
-		QnbFormedState formedState = extendedBlockState.getValue( BlockQuantumBase.FORMED_STATE );
+        QnbFormedState formedState = extendedBlockState.getValue(BlockQuantumBase.FORMED_STATE);
 
-		return this.getQuads( formedState, state, side, rand );
+        return this.getQuads(formedState, state, side, rand);
     }
 
-	private List<BakedQuad> getQuads( QnbFormedState formedState, IBlockState state, EnumFacing side, long rand )
+    private List<BakedQuad> getQuads(QnbFormedState formedState, IBlockState state, EnumFacing side, long rand) {
-	{
+        CubeBuilder builder = new CubeBuilder(this.vertexFormat);
-		CubeBuilder builder = new CubeBuilder( this.vertexFormat );
 
-		if( state.getBlock() == this.linkBlock )
+        if (state.getBlock() == this.linkBlock) {
-		{
             Set<EnumFacing> sides = formedState.getAdjacentQuantumBridges();
 
-			this.renderCableAt( builder, 0.11f * 16, this.glassCableTexture, 0.141f * 16, sides );
+            this.renderCableAt(builder, 0.11f * 16, this.glassCableTexture, 0.141f * 16, sides);
 
-			this.renderCableAt( builder, 0.188f * 16, this.coveredCableTexture, 0.1875f * 16, sides );
+            this.renderCableAt(builder, 0.188f * 16, this.coveredCableTexture, 0.1875f * 16, sides);
 
-			builder.setTexture( this.linkTexture );
+            builder.setTexture(this.linkTexture);
-			builder.addCube( DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX );
+            builder.addCube(DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX);
-		}
+        } else {
-		else
+            if (formedState.isCorner()) {
-		{
+                this.renderCableAt(builder, 0.188f * 16, this.coveredCableTexture, 0.05f * 16, formedState.getAdjacentQuantumBridges());
-			if( formedState.isCorner() )
-			{
-				this.renderCableAt( builder, 0.188f * 16, this.coveredCableTexture, 0.05f * 16, formedState.getAdjacentQuantumBridges() );
 
-				builder.setTexture( this.ringTexture );
+                builder.setTexture(this.ringTexture);
-				builder.addCube( DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX );
+                builder.addCube(DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX);
 
-				if( formedState.isPowered() )
+                if (formedState.isPowered()) {
-				{
+                    builder.setTexture(this.lightCornerTexture);
-					builder.setTexture( this.lightCornerTexture );
+                    builder.setRenderFullBright(true);
-					builder.setRenderFullBright( true );
+                    for (EnumFacing facing : EnumFacing.values()) {
-					for( EnumFacing facing : EnumFacing.values() )
-					{
                         // Offset the face by a slight amount so that it is drawn over the already drawn ring texture
                         // (avoids z-fighting)
-						float xOffset = Math.abs( facing.getFrontOffsetX() * 0.01f );
+                        float xOffset = Math.abs(facing.getFrontOffsetX() * 0.01f);
-						float yOffset = Math.abs( facing.getFrontOffsetY() * 0.01f );
+                        float yOffset = Math.abs(facing.getFrontOffsetY() * 0.01f);
-						float zOffset = Math.abs( facing.getFrontOffsetZ() * 0.01f );
+                        float zOffset = Math.abs(facing.getFrontOffsetZ() * 0.01f);
 
-						builder.setDrawFaces( EnumSet.of( facing ) );
+                        builder.setDrawFaces(EnumSet.of(facing));
                         builder.addCube(
                                 DEFAULT_RENDER_MIN - xOffset, DEFAULT_RENDER_MIN - yOffset, DEFAULT_RENDER_MIN - zOffset,
-								DEFAULT_RENDER_MAX + xOffset, DEFAULT_RENDER_MAX + yOffset, DEFAULT_RENDER_MAX + zOffset );
+                                DEFAULT_RENDER_MAX + xOffset, DEFAULT_RENDER_MAX + yOffset, DEFAULT_RENDER_MAX + zOffset);
                     }
                 }
-			}
+            } else {
-			else
+                builder.setTexture(this.ringTexture);
-			{
-				builder.setTexture( this.ringTexture );
 
-				builder.addCube( 0, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, 16, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX );
+                builder.addCube(0, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, 16, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX);
 
-				builder.addCube( DEFAULT_RENDER_MIN, 0, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MAX, 16, DEFAULT_RENDER_MAX );
+                builder.addCube(DEFAULT_RENDER_MIN, 0, DEFAULT_RENDER_MIN, DEFAULT_RENDER_MAX, 16, DEFAULT_RENDER_MAX);
 
-				builder.addCube( DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, 0, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX, 16 );
+                builder.addCube(DEFAULT_RENDER_MIN, DEFAULT_RENDER_MIN, 0, DEFAULT_RENDER_MAX, DEFAULT_RENDER_MAX, 16);
 
-				if( formedState.isPowered() )
+                if (formedState.isPowered()) {
-				{
+                    builder.setTexture(this.lightTexture);
-					builder.setTexture( this.lightTexture );
+                    builder.setRenderFullBright(true);
-					builder.setRenderFullBright( true );
+                    for (EnumFacing facing : EnumFacing.values()) {
-					for( EnumFacing facing : EnumFacing.values() )
-					{
                         // Offset the face by a slight amount so that it is drawn over the already drawn ring texture
                         // (avoids z-fighting)
-						float xOffset = Math.abs( facing.getFrontOffsetX() * 0.01f );
+                        float xOffset = Math.abs(facing.getFrontOffsetX() * 0.01f);
-						float yOffset = Math.abs( facing.getFrontOffsetY() * 0.01f );
+                        float yOffset = Math.abs(facing.getFrontOffsetY() * 0.01f);
-						float zOffset = Math.abs( facing.getFrontOffsetZ() * 0.01f );
+                        float zOffset = Math.abs(facing.getFrontOffsetZ() * 0.01f);
 
-						builder.setDrawFaces( EnumSet.of( facing ) );
+                        builder.setDrawFaces(EnumSet.of(facing));
                         builder.addCube(
                                 -xOffset, -yOffset, -zOffset,
-								16 + xOffset, 16 + yOffset, 16 + zOffset );
+                                16 + xOffset, 16 + yOffset, 16 + zOffset);
                     }
                 }
             }
@@ -165,80 +146,66 @@ class QnbFormedBakedModel implements IBakedModel
         return builder.getOutput();
     }
 
-	private void renderCableAt( CubeBuilder builder, float thickness, TextureAtlasSprite texture, float pull, Set<EnumFacing> connections )
+    private void renderCableAt(CubeBuilder builder, float thickness, TextureAtlasSprite texture, float pull, Set<EnumFacing> connections) {
-	{
+        builder.setTexture(texture);
-		builder.setTexture( texture );
 
-		if( connections.contains( EnumFacing.WEST ) )
+        if (connections.contains(EnumFacing.WEST)) {
-		{
+            builder.addCube(0, 8 - thickness, 8 - thickness, 8 - thickness - pull, 8 + thickness, 8 + thickness);
-			builder.addCube( 0, 8 - thickness, 8 - thickness, 8 - thickness - pull, 8 + thickness, 8 + thickness );
         }
 
-		if( connections.contains( EnumFacing.EAST ) )
+        if (connections.contains(EnumFacing.EAST)) {
-		{
+            builder.addCube(8 + thickness + pull, 8 - thickness, 8 - thickness, 16, 8 + thickness, 8 + thickness);
-			builder.addCube( 8 + thickness + pull, 8 - thickness, 8 - thickness, 16, 8 + thickness, 8 + thickness );
         }
 
-		if( connections.contains( EnumFacing.NORTH ) )
+        if (connections.contains(EnumFacing.NORTH)) {
-		{
+            builder.addCube(8 - thickness, 8 - thickness, 0, 8 + thickness, 8 + thickness, 8 - thickness - pull);
-			builder.addCube( 8 - thickness, 8 - thickness, 0, 8 + thickness, 8 + thickness, 8 - thickness - pull );
         }
 
-		if( connections.contains( EnumFacing.SOUTH ) )
+        if (connections.contains(EnumFacing.SOUTH)) {
-		{
+            builder.addCube(8 - thickness, 8 - thickness, 8 + thickness + pull, 8 + thickness, 8 + thickness, 16);
-			builder.addCube( 8 - thickness, 8 - thickness, 8 + thickness + pull, 8 + thickness, 8 + thickness, 16 );
         }
 
-		if( connections.contains( EnumFacing.DOWN ) )
+        if (connections.contains(EnumFacing.DOWN)) {
-		{
+            builder.addCube(8 - thickness, 0, 8 - thickness, 8 + thickness, 8 - thickness - pull, 8 + thickness);
-			builder.addCube( 8 - thickness, 0, 8 - thickness, 8 + thickness, 8 - thickness - pull, 8 + thickness );
         }
 
-		if( connections.contains( EnumFacing.UP ) )
+        if (connections.contains(EnumFacing.UP)) {
-		{
+            builder.addCube(8 - thickness, 8 + thickness + pull, 8 - thickness, 8 + thickness, 16, 8 + thickness);
-			builder.addCube( 8 - thickness, 8 + thickness + pull, 8 - thickness, 8 + thickness, 16, 8 + thickness );
         }
     }
 
     @Override
-	public boolean isAmbientOcclusion()
+    public boolean isAmbientOcclusion() {
-	{
         return this.baseModel.isAmbientOcclusion();
     }
 
     @Override
-	public boolean isGui3d()
+    public boolean isGui3d() {
-	{
         return true;
     }
 
     @Override
-	public boolean isBuiltInRenderer()
+    public boolean isBuiltInRenderer() {
-	{
         return false;
     }
 
     @Override
-	public TextureAtlasSprite getParticleTexture()
+    public TextureAtlasSprite getParticleTexture() {
-	{
         return this.baseModel.getParticleTexture();
     }
 
     @Override
-	public ItemCameraTransforms getItemCameraTransforms()
+    public ItemCameraTransforms getItemCameraTransforms() {
-	{
         return this.baseModel.getItemCameraTransforms();
     }
 
     @Override
-	public ItemOverrideList getOverrides()
+    public ItemOverrideList getOverrides() {
-	{
         return this.baseModel.getOverrides();
     }
 
-	public static List<ResourceLocation> getRequiredTextures()
+    public static List<ResourceLocation> getRequiredTextures() {
-	{
         return ImmutableList.of(
-				TEXTURE_LINK, TEXTURE_RING, TEXTURE_CABLE_GLASS, TEXTURE_COVERED_CABLE, TEXTURE_RING_LIGHT, TEXTURE_RING_LIGHT_CORNER );
+                TEXTURE_LINK, TEXTURE_RING, TEXTURE_CABLE_GLASS, TEXTURE_COVERED_CABLE, TEXTURE_RING_LIGHT, TEXTURE_RING_LIGHT_CORNER);
     }
 }

src/main/java/appeng/block/qnb/QnbFormedModel.java

@@ -1,12 +1,8 @@
-
 package appeng.block.qnb;
 
 
-import java.util.Collection;
+import appeng.core.AppEng;
-import java.util.function.Function;
-
 import com.google.common.collect.ImmutableList;
-
 import net.minecraft.client.renderer.block.model.IBakedModel;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.client.renderer.vertex.VertexFormat;
@@ -16,49 +12,41 @@ import net.minecraftforge.client.model.ModelLoaderRegistry;
 import net.minecraftforge.common.model.IModelState;
 import net.minecraftforge.common.model.TRSRTransformation;
 
-import appeng.core.AppEng;
+import java.util.Collection;
+import java.util.function.Function;
 
 
-public class QnbFormedModel implements IModel
+public class QnbFormedModel implements IModel {
-{
 
-	private static final ResourceLocation MODEL_RING = new ResourceLocation( AppEng.MOD_ID, "block/qnb/ring" );
+    private static final ResourceLocation MODEL_RING = new ResourceLocation(AppEng.MOD_ID, "block/qnb/ring");
 
     @Override
-	public Collection<ResourceLocation> getDependencies()
+    public Collection<ResourceLocation> getDependencies() {
-	{
+        return ImmutableList.of(MODEL_RING);
-		return ImmutableList.of( MODEL_RING );
     }
 
     @Override
-	public Collection<ResourceLocation> getTextures()
+    public Collection<ResourceLocation> getTextures() {
-	{
         return QnbFormedBakedModel.getRequiredTextures();
     }
 
     @Override
-	public IBakedModel bake( IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+    public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
-	{
+        IBakedModel ringModel = this.getBaseModel(MODEL_RING, state, format, bakedTextureGetter);
-		IBakedModel ringModel = this.getBaseModel( MODEL_RING, state, format, bakedTextureGetter );
+        return new QnbFormedBakedModel(format, ringModel, bakedTextureGetter);
-		return new QnbFormedBakedModel( format, ringModel, bakedTextureGetter );
     }
 
     @Override
-	public IModelState getDefaultState()
+    public IModelState getDefaultState() {
-	{
         return TRSRTransformation.identity();
     }
 
-	private IBakedModel getBaseModel( ResourceLocation model, IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter )
+    private IBakedModel getBaseModel(ResourceLocation model, IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
-	{
         // Load the base model
-		try
+        try {
-		{
+            return ModelLoaderRegistry.getModel(model).bake(state, format, bakedTextureGetter);
-			return ModelLoaderRegistry.getModel( model ).bake( state, format, bakedTextureGetter );
+        } catch (Exception e) {
-		}
+            throw new RuntimeException(e);
-		catch( Exception e )
-		{
-			throw new RuntimeException( e );
         }
     }
 }

src/main/java/appeng/block/qnb/QnbFormedState.java

@@ -1,14 +1,12 @@
-
 package appeng.block.qnb;
 
 
-import java.util.Set;
-
 import net.minecraft.util.EnumFacing;
 
+import java.util.Set;
 
-public class QnbFormedState
+
-{
+public class QnbFormedState {
 
     private final Set<EnumFacing> adjacentQuantumBridges;
 
@@ -16,25 +14,21 @@ public class QnbFormedState
 
     private final boolean powered;
 
-	public QnbFormedState( Set<EnumFacing> adjacentQuantumBridges, boolean corner, boolean powered )
+    public QnbFormedState(Set<EnumFacing> adjacentQuantumBridges, boolean corner, boolean powered) {
-	{
         this.adjacentQuantumBridges = adjacentQuantumBridges;
         this.corner = corner;
         this.powered = powered;
     }
 
-	public Set<EnumFacing> getAdjacentQuantumBridges()
+    public Set<EnumFacing> getAdjacentQuantumBridges() {
-	{
         return this.adjacentQuantumBridges;
     }
 
-	public boolean isCorner()
+    public boolean isCorner() {
-	{
         return this.corner;
     }
 
-	public boolean isPowered()
+    public boolean isPowered() {
-	{
         return this.powered;
     }
 

src/main/java/appeng/block/qnb/QnbFormedStateProperty.java

@@ -1,34 +1,28 @@
-
 package appeng.block.qnb;
 
 
 import net.minecraftforge.common.property.IUnlistedProperty;
 
 
-public class QnbFormedStateProperty implements IUnlistedProperty<QnbFormedState>
+public class QnbFormedStateProperty implements IUnlistedProperty<QnbFormedState> {
-{
 
     @Override
-	public String getName()
+    public String getName() {
-	{
         return "qnb_formed";
     }
 
     @Override
-	public boolean isValid( QnbFormedState value )
+    public boolean isValid(QnbFormedState value) {
-	{
         return value != null;
     }
 
     @Override
-	public Class<QnbFormedState> getType()
+    public Class<QnbFormedState> getType() {
-	{
         return QnbFormedState.class;
     }
 
     @Override
-	public String valueToString( QnbFormedState value )
+    public String valueToString(QnbFormedState value) {
-	{
         return null;
     }
 }

src/main/java/appeng/block/qnb/QuantumBridgeRendering.java

@@ -1,24 +1,20 @@
-
 package appeng.block.qnb;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class QuantumBridgeRendering extends BlockRenderingCustomizer
+public class QuantumBridgeRendering extends BlockRenderingCustomizer {
-{
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.builtInModel("models/block/qnb/qnb_formed", new QnbFormedModel());
-		rendering.builtInModel( "models/block/qnb/qnb_formed", new QnbFormedModel() );
         // Disable auto rotation
-		rendering.modelCustomizer( ( location, model ) -> model );
+        rendering.modelCustomizer((location, model) -> model);
     }
 }

src/main/java/appeng/block/spatial/BlockMatrixFrame.java

@@ -19,9 +19,8 @@
 package appeng.block.spatial;
 
 
-import java.util.Arrays;
+import appeng.block.AEBaseBlock;
-import java.util.List;
+import appeng.helpers.ICustomCollision;
-
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.creativetab.CreativeTabs;
@@ -36,57 +35,49 @@ import net.minecraft.world.World;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 
-import appeng.block.AEBaseBlock;
+import java.util.Arrays;
-import appeng.helpers.ICustomCollision;
+import java.util.List;
 
 
-public class BlockMatrixFrame extends AEBaseBlock implements ICustomCollision
+public class BlockMatrixFrame extends AEBaseBlock implements ICustomCollision {
-{
 
-	public BlockMatrixFrame()
+    public BlockMatrixFrame() {
-	{
+        super(Material.ANVIL);
-		super( Material.ANVIL );
+        this.setResistance(6000000.0F);
-		this.setResistance( 6000000.0F );
         this.setBlockUnbreakable();
-		this.setLightOpacity( 0 );
+        this.setLightOpacity(0);
-		this.setOpaque( false );
+        this.setOpaque(false);
     }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void getSubBlocks( final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks )
+    public void getSubBlocks(final CreativeTabs tabs, final NonNullList<ItemStack> itemStacks) {
-	{
         // do nothing
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
+        return Arrays.asList(new AxisAlignedBB[]{});// AxisAlignedBB.getBoundingBox( 0.25, 0, 0.25, 0.75, 0.5, 0.75 )
-		return Arrays.asList( new AxisAlignedBB[] {} );// AxisAlignedBB.getBoundingBox( 0.25, 0, 0.25, 0.75, 0.5, 0.75 )
         // } );
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
+        out.add(new AxisAlignedBB(0.0, 0.0, 0.0, 1.0, 1.0, 1.0));
-		out.add( new AxisAlignedBB( 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ) );
     }
 
     @Override
-	public boolean canPlaceBlockAt( final World worldIn, final BlockPos pos )
+    public boolean canPlaceBlockAt(final World worldIn, final BlockPos pos) {
-	{
         return false;
     }
 
     @Override
-	public void onBlockExploded( final World world, final BlockPos pos, final Explosion explosion )
+    public void onBlockExploded(final World world, final BlockPos pos, final Explosion explosion) {
-	{
         // Don't explode.
     }
 
     @Override
-	public boolean canEntityDestroy( final IBlockState state, final IBlockAccess world, final BlockPos pos, final Entity entity )
+    public boolean canEntityDestroy(final IBlockState state, final IBlockAccess world, final BlockPos pos, final Entity entity) {
-	{
         return false;
     }
 }

src/main/java/appeng/block/spatial/BlockSpatialIOPort.java

@@ -19,8 +19,11 @@
 package appeng.block.spatial;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.spatial.TileSpatialIOPort;
+import appeng.util.Platform;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
@@ -31,45 +34,33 @@ import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.spatial.TileSpatialIOPort;
-import appeng.util.Platform;
 
 
-public class BlockSpatialIOPort extends AEBaseTileBlock
+public class BlockSpatialIOPort extends AEBaseTileBlock {
-{
 
-	public BlockSpatialIOPort()
+    public BlockSpatialIOPort() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final TileSpatialIOPort te = this.getTileEntity(world, pos);
-		final TileSpatialIOPort te = this.getTileEntity( world, pos );
+        if (te != null) {
-		if( te != null )
-		{
             te.updateRedstoneState();
         }
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileSpatialIOPort tg = this.getTileEntity( w, pos );
+        final TileSpatialIOPort tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_SPATIAL_IO_PORT);
-			{
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_SPATIAL_IO_PORT );
             }
             return true;
         }

src/main/java/appeng/block/spatial/BlockSpatialPylon.java

@@ -19,6 +19,10 @@
 package appeng.block.spatial;
 
 
+import appeng.block.AEBaseTileBlock;
+import appeng.client.render.spatial.SpatialPylonStateProperty;
+import appeng.helpers.AEGlassMaterial;
+import appeng.tile.spatial.TileSpatialPylon;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
@@ -30,63 +34,48 @@ import net.minecraftforge.common.property.ExtendedBlockState;
 import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.common.property.IUnlistedProperty;
 
-import appeng.block.AEBaseTileBlock;
-import appeng.client.render.spatial.SpatialPylonStateProperty;
-import appeng.helpers.AEGlassMaterial;
-import appeng.tile.spatial.TileSpatialPylon;
 
-
+public class BlockSpatialPylon extends AEBaseTileBlock {
-public class BlockSpatialPylon extends AEBaseTileBlock
-{
 
     public static final SpatialPylonStateProperty STATE = new SpatialPylonStateProperty();
 
-	public BlockSpatialPylon()
+    public BlockSpatialPylon() {
-	{
+        super(AEGlassMaterial.INSTANCE);
-		super( AEGlassMaterial.INSTANCE );
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, this.getAEStates(), new IUnlistedProperty[]{STATE});
-		return new ExtendedBlockState( this, this.getAEStates(), new IUnlistedProperty[] { STATE } );
     }
 
     @Override
-	public IBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
         IExtendedBlockState extState = (IExtendedBlockState) state;
 
-		return extState.withProperty( STATE, this.getDisplayState( world, pos ) );
+        return extState.withProperty(STATE, this.getDisplayState(world, pos));
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final TileSpatialPylon tsp = this.getTileEntity(world, pos);
-		final TileSpatialPylon tsp = this.getTileEntity( world, pos );
+        if (tsp != null) {
-		if( tsp != null )
-		{
             tsp.neighborChanged();
         }
     }
 
     @Override
-	public int getLightValue( final IBlockState state, final IBlockAccess w, final BlockPos pos )
+    public int getLightValue(final IBlockState state, final IBlockAccess w, final BlockPos pos) {
-	{
+        final TileSpatialPylon tsp = this.getTileEntity(w, pos);
-		final TileSpatialPylon tsp = this.getTileEntity( w, pos );
+        if (tsp != null) {
-		if( tsp != null )
-		{
             return tsp.getLightValue();
         }
-		return super.getLightValue( state, w, pos );
+        return super.getLightValue(state, w, pos);
     }
 
-	private int getDisplayState( IBlockAccess world, BlockPos pos )
+    private int getDisplayState(IBlockAccess world, BlockPos pos) {
-	{
+        TileSpatialPylon te = this.getTileEntity(world, pos);
-		TileSpatialPylon te = this.getTileEntity( world, pos );
 
-		if( te == null )
+        if (te == null) {
-		{
             return 0;
         }
 
@@ -94,8 +83,7 @@ public class BlockSpatialPylon extends AEBaseTileBlock
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 

src/main/java/appeng/block/storage/BlockChest.java

@@ -19,8 +19,12 @@
 package appeng.block.storage;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.localization.PlayerMessages;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.storage.TileChest;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.properties.PropertyEnum;
@@ -34,81 +38,61 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.localization.PlayerMessages;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.storage.TileChest;
-import appeng.util.Platform;
 
 
-public class BlockChest extends AEBaseTileBlock
+public class BlockChest extends AEBaseTileBlock {
-{
 
-	private final static PropertyEnum<DriveSlotState> SLOT_STATE = PropertyEnum.create( "slot_state", DriveSlotState.class );
+    private final static PropertyEnum<DriveSlotState> SLOT_STATE = PropertyEnum.create("slot_state", DriveSlotState.class);
 
-	public BlockChest()
+    public BlockChest() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
+        this.setDefaultState(this.getDefaultState().withProperty(SLOT_STATE, DriveSlotState.EMPTY));
-		this.setDefaultState( this.getDefaultState().withProperty( SLOT_STATE, DriveSlotState.EMPTY ) );
     }
 
     @Override
-	protected IProperty[] getAEStates()
+    protected IProperty[] getAEStates() {
-	{
+        return new IProperty[]{SLOT_STATE};
-		return new IProperty[] { SLOT_STATE };
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	public IBlockState getActualState( IBlockState state, IBlockAccess worldIn, BlockPos pos )
+    public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
-	{
         DriveSlotState slotState = DriveSlotState.EMPTY;
 
-		TileChest te = this.getTileEntity( worldIn, pos );
+        TileChest te = this.getTileEntity(worldIn, pos);
 
-		if( te != null )
+        if (te != null) {
-		{
+            if (te.getCellCount() >= 1) {
-			if( te.getCellCount() >= 1 )
+                slotState = DriveSlotState.fromCellStatus(te.getCellStatus(0));
-			{
-				slotState = DriveSlotState.fromCellStatus( te.getCellStatus( 0 ) );
             }
             // Power-state has to be checked separately
-			if( !te.isPowered() && slotState != DriveSlotState.EMPTY )
+            if (!te.isPowered() && slotState != DriveSlotState.EMPTY) {
-			{
                 slotState = DriveSlotState.OFFLINE;
             }
         }
 
-		return super.getActualState( state, worldIn, pos )
+        return super.getActualState(state, worldIn, pos)
-				.withProperty( SLOT_STATE, slotState );
+                .withProperty(SLOT_STATE, slotState);
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        final TileChest tg = this.getTileEntity(w, pos);
-		final TileChest tg = this.getTileEntity( w, pos );
+        if (tg != null && !p.isSneaking()) {
-		if( tg != null && !p.isSneaking() )
+            if (Platform.isClient()) {
-		{
-			if( Platform.isClient() )
-			{
                 return true;
             }
 
-			if( side != tg.getUp() )
+            if (side != tg.getUp()) {
-			{
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_CHEST);
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_CHEST );
+            } else {
-			}
+                if (!tg.openGui(p)) {
-			else
+                    p.sendMessage(PlayerMessages.ChestCannotReadStorageCell.get());
-			{
-				if( !tg.openGui( p ) )
-				{
-					p.sendMessage( PlayerMessages.ChestCannotReadStorageCell.get() );
                 }
             }
 

src/main/java/appeng/block/storage/BlockDrive.java

@@ -19,8 +19,12 @@
 package appeng.block.storage;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.client.UnlistedProperty;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.storage.TileDrive;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
@@ -36,62 +40,48 @@ import net.minecraftforge.common.property.ExtendedBlockState;
 import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.common.property.IUnlistedProperty;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.client.UnlistedProperty;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.storage.TileDrive;
-import appeng.util.Platform;
 
 
-public class BlockDrive extends AEBaseTileBlock
+public class BlockDrive extends AEBaseTileBlock {
-{
 
-	public static final UnlistedProperty<DriveSlotsState> SLOTS_STATE = new UnlistedProperty<>( "drive_slots_state", DriveSlotsState.class );
+    public static final UnlistedProperty<DriveSlotsState> SLOTS_STATE = new UnlistedProperty<>("drive_slots_state", DriveSlotsState.class);
 
-	public BlockDrive()
+    public BlockDrive() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
     }
 
     @Override
-	public BlockRenderLayer getBlockLayer()
+    public BlockRenderLayer getBlockLayer() {
-	{
         return BlockRenderLayer.CUTOUT;
     }
 
     @Override
-	protected BlockStateContainer createBlockState()
+    protected BlockStateContainer createBlockState() {
-	{
+        return new ExtendedBlockState(this, this.getAEStates(), new IUnlistedProperty[]{
-		return new ExtendedBlockState( this, this.getAEStates(), new IUnlistedProperty[] {
                 SLOTS_STATE,
                 FORWARD,
                 UP
-		} );
+        });
     }
 
     @Override
-	public IBlockState getExtendedState( IBlockState state, IBlockAccess world, BlockPos pos )
+    public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) {
-	{
+        TileDrive te = this.getTileEntity(world, pos);
-		TileDrive te = this.getTileEntity( world, pos );
+        IExtendedBlockState extState = (IExtendedBlockState) super.getExtendedState(state, world, pos);
-		IExtendedBlockState extState = (IExtendedBlockState) super.getExtendedState( state, world, pos );
+        return extState.withProperty(SLOTS_STATE, te == null ? DriveSlotsState.createEmpty(10) : DriveSlotsState.fromChestOrDrive(te));
-		return extState.withProperty( SLOTS_STATE, te == null ? DriveSlotsState.createEmpty( 10 ) : DriveSlotsState.fromChestOrDrive( te ) );
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileDrive tg = this.getTileEntity( w, pos );
+        final TileDrive tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_DRIVE);
-			{
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_DRIVE );
             }
             return true;
         }

src/main/java/appeng/block/storage/BlockIOPort.java

@@ -19,8 +19,11 @@
 package appeng.block.storage;
 
 
-import javax.annotation.Nullable;
+import appeng.api.util.AEPartLocation;
-
+import appeng.block.AEBaseTileBlock;
+import appeng.core.sync.GuiBridge;
+import appeng.tile.storage.TileIOPort;
+import appeng.util.Platform;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
@@ -31,45 +34,33 @@ import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
-import appeng.core.sync.GuiBridge;
-import appeng.tile.storage.TileIOPort;
-import appeng.util.Platform;
 
 
-public class BlockIOPort extends AEBaseTileBlock
+public class BlockIOPort extends AEBaseTileBlock {
-{
 
-	public BlockIOPort()
+    public BlockIOPort() {
-	{
+        super(Material.IRON);
-		super( Material.IRON );
     }
 
     @Override
-	public void neighborChanged( IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos )
+    public void neighborChanged(IBlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos) {
-	{
+        final TileIOPort te = this.getTileEntity(world, pos);
-		final TileIOPort te = this.getTileEntity( world, pos );
+        if (te != null) {
-		if( te != null )
-		{
             te.updateRedstoneState();
         }
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer p, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (p.isSneaking()) {
-		if( p.isSneaking() )
-		{
             return false;
         }
 
-		final TileIOPort tg = this.getTileEntity( w, pos );
+        final TileIOPort tg = this.getTileEntity(w, pos);
-		if( tg != null )
+        if (tg != null) {
-		{
+            if (Platform.isServer()) {
-			if( Platform.isServer() )
+                Platform.openGUI(p, tg, AEPartLocation.fromFacing(side), GuiBridge.GUI_IOPORT);
-			{
-				Platform.openGUI( p, tg, AEPartLocation.fromFacing( side ), GuiBridge.GUI_IOPORT );
             }
             return true;
         }

src/main/java/appeng/block/storage/BlockSkyChest.java

@@ -19,11 +19,12 @@
 package appeng.block.storage;
 
 
-import java.util.Collections;
+import appeng.api.util.AEPartLocation;
-import java.util.List;
+import appeng.block.AEBaseTileBlock;
-
+import appeng.core.sync.GuiBridge;
-import javax.annotation.Nullable;
+import appeng.helpers.ICustomCollision;
-
+import appeng.tile.storage.TileSkyChest;
+import appeng.util.Platform;
 import net.minecraft.block.material.Material;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
@@ -36,78 +37,65 @@ import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-import appeng.api.util.AEPartLocation;
+import javax.annotation.Nullable;
-import appeng.block.AEBaseTileBlock;
+import java.util.Collections;
-import appeng.core.sync.GuiBridge;
+import java.util.List;
-import appeng.helpers.ICustomCollision;
-import appeng.tile.storage.TileSkyChest;
-import appeng.util.Platform;
 
 
-public class BlockSkyChest extends AEBaseTileBlock implements ICustomCollision
+public class BlockSkyChest extends AEBaseTileBlock implements ICustomCollision {
-{
 
     private static final double AABB_OFFSET_BOTTOM = 0.00;
     private static final double AABB_OFFSET_SIDES = 0.06;
     private static final double AABB_OFFSET_TOP = 0.125;
 
-	public enum SkyChestType
+    public enum SkyChestType {
-	{
         STONE, BLOCK
-	};
+    }
 
     public final SkyChestType type;
 
-	public BlockSkyChest( final SkyChestType type )
+    public BlockSkyChest(final SkyChestType type) {
-	{
+        super(Material.ROCK);
-		super( Material.ROCK );
+        this.setOpaque(this.setFullSize(false));
-		this.setOpaque( this.setFullSize( false ) );
         this.lightOpacity = 0;
-		this.setHardness( 50 );
+        this.setHardness(50);
         this.blockResistance = 150.0f;
         this.type = type;
     }
 
     @Override
-	public EnumBlockRenderType getRenderType( IBlockState state )
+    public EnumBlockRenderType getRenderType(IBlockState state) {
-	{
         return EnumBlockRenderType.ENTITYBLOCK_ANIMATED;
     }
 
     @Override
-	public boolean onActivated( final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ )
+    public boolean onActivated(final World w, final BlockPos pos, final EntityPlayer player, final EnumHand hand, final @Nullable ItemStack heldItem, final EnumFacing side, final float hitX, final float hitY, final float hitZ) {
-	{
+        if (Platform.isServer()) {
-		if( Platform.isServer() )
+            Platform.openGUI(player, this.getTileEntity(w, pos), AEPartLocation.fromFacing(side), GuiBridge.GUI_SKYCHEST);
-		{
-			Platform.openGUI( player, this.getTileEntity( w, pos ), AEPartLocation.fromFacing( side ), GuiBridge.GUI_SKYCHEST );
         }
 
         return true;
     }
 
     @Override
-	public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool( final World w, final BlockPos pos, final Entity thePlayer, final boolean b )
+    public Iterable<AxisAlignedBB> getSelectedBoundingBoxesFromPool(final World w, final BlockPos pos, final Entity thePlayer, final boolean b) {
-	{
+        final AxisAlignedBB aabb = this.computeAABB(w, pos);
-		final AxisAlignedBB aabb = this.computeAABB( w, pos );
 
-		return Collections.singletonList( aabb );
+        return Collections.singletonList(aabb);
     }
 
     @Override
-	public void addCollidingBlockToList( final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e )
+    public void addCollidingBlockToList(final World w, final BlockPos pos, final AxisAlignedBB bb, final List<AxisAlignedBB> out, final Entity e) {
-	{
+        final AxisAlignedBB aabb = this.computeAABB(w, pos);
-		final AxisAlignedBB aabb = this.computeAABB( w, pos );
 
-		out.add( aabb );
+        out.add(aabb);
     }
 
-	private AxisAlignedBB computeAABB( final World w, final BlockPos pos )
+    private AxisAlignedBB computeAABB(final World w, final BlockPos pos) {
-	{
+        final TileSkyChest sk = this.getTileEntity(w, pos);
-		final TileSkyChest sk = this.getTileEntity( w, pos );
         EnumFacing o = EnumFacing.UP;
 
-		if( sk != null )
+        if (sk != null) {
-		{
             o = sk.getUp();
         }
 
@@ -116,14 +104,14 @@ public class BlockSkyChest extends AEBaseTileBlock implements ICustomCollision
         final double offsetZ = o.getFrontOffsetZ() == 0 ? AABB_OFFSET_SIDES : 0.0;
 
         // for x/z top and bottom is swapped
-		final double minX = Math.max( 0.0, offsetX + ( o.getFrontOffsetX() < 0 ? AABB_OFFSET_BOTTOM : ( o.getFrontOffsetX() * AABB_OFFSET_TOP ) ) );
+        final double minX = Math.max(0.0, offsetX + (o.getFrontOffsetX() < 0 ? AABB_OFFSET_BOTTOM : (o.getFrontOffsetX() * AABB_OFFSET_TOP)));
-		final double minY = Math.max( 0.0, offsetY + ( o.getFrontOffsetY() < 0 ? AABB_OFFSET_TOP : ( o.getFrontOffsetY() * AABB_OFFSET_BOTTOM ) ) );
+        final double minY = Math.max(0.0, offsetY + (o.getFrontOffsetY() < 0 ? AABB_OFFSET_TOP : (o.getFrontOffsetY() * AABB_OFFSET_BOTTOM)));
-		final double minZ = Math.max( 0.0, offsetZ + ( o.getFrontOffsetZ() < 0 ? AABB_OFFSET_BOTTOM : ( o.getFrontOffsetZ() * AABB_OFFSET_TOP ) ) );
+        final double minZ = Math.max(0.0, offsetZ + (o.getFrontOffsetZ() < 0 ? AABB_OFFSET_BOTTOM : (o.getFrontOffsetZ() * AABB_OFFSET_TOP)));
 
-		final double maxX = Math.min( 1.0, 1.0 - offsetX - ( o.getFrontOffsetX() < 0 ? AABB_OFFSET_TOP : ( o.getFrontOffsetX() * AABB_OFFSET_BOTTOM ) ) );
+        final double maxX = Math.min(1.0, 1.0 - offsetX - (o.getFrontOffsetX() < 0 ? AABB_OFFSET_TOP : (o.getFrontOffsetX() * AABB_OFFSET_BOTTOM)));
-		final double maxY = Math.min( 1.0, 1.0 - offsetY - ( o.getFrontOffsetY() < 0 ? AABB_OFFSET_BOTTOM : ( o.getFrontOffsetY() * AABB_OFFSET_TOP ) ) );
+        final double maxY = Math.min(1.0, 1.0 - offsetY - (o.getFrontOffsetY() < 0 ? AABB_OFFSET_BOTTOM : (o.getFrontOffsetY() * AABB_OFFSET_TOP)));
-		final double maxZ = Math.min( 1.0, 1.0 - offsetZ - ( o.getFrontOffsetZ() < 0 ? AABB_OFFSET_TOP : ( o.getFrontOffsetZ() * AABB_OFFSET_BOTTOM ) ) );
+        final double maxZ = Math.min(1.0, 1.0 - offsetZ - (o.getFrontOffsetZ() < 0 ? AABB_OFFSET_TOP : (o.getFrontOffsetZ() * AABB_OFFSET_BOTTOM)));
 
-		return new AxisAlignedBB( minX, minY, minZ, maxX, maxY, maxZ );
+        return new AxisAlignedBB(minX, minY, minZ, maxX, maxY, maxZ);
     }
 }

src/main/java/appeng/block/storage/ChestRendering.java

@@ -19,27 +19,24 @@
 package appeng.block.storage;
 
 
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.api.util.AEColor;
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.ColorableTileBlockColor;
 import appeng.client.render.StaticItemColor;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class ChestRendering extends BlockRenderingCustomizer
+public class ChestRendering extends BlockRenderingCustomizer {
-{
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
         // I checked, the ME chest doesn't keep its color in item form
-		itemRendering.color( new StaticItemColor( AEColor.TRANSPARENT ) );
+        itemRendering.color(new StaticItemColor(AEColor.TRANSPARENT));
-		rendering.blockColor( new ColorableTileBlockColor() );
+        rendering.blockColor(new ColorableTileBlockColor());
     }
 
 }

src/main/java/appeng/block/storage/DriveRendering.java

@@ -25,11 +25,9 @@ import appeng.bootstrap.IItemRendering;
 import appeng.client.render.model.DriveModel;
 
 
-public class DriveRendering extends BlockRenderingCustomizer
+public class DriveRendering extends BlockRenderingCustomizer {
-{
     @Override
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.builtInModel("models/block/builtin/drive", new DriveModel());
-		rendering.builtInModel( "models/block/builtin/drive", new DriveModel() );
     }
 }

src/main/java/appeng/block/storage/DriveSlotState.java

@@ -25,41 +25,36 @@ import net.minecraft.util.IStringSerializable;
 /**
  * Describes the different states a single slot of a BlockDrive can be in in terms of rendering.
  */
-public enum DriveSlotState implements IStringSerializable
+public enum DriveSlotState implements IStringSerializable {
-{
 
     // No cell in slot
-	EMPTY( "empty" ),
+    EMPTY("empty"),
 
     // Cell in slot, but unpowered
-	OFFLINE( "offline" ),
+    OFFLINE("offline"),
 
     // Online and free space
-	ONLINE( "online" ),
+    ONLINE("online"),
 
     // Types full, space left
-	TYPES_FULL( "types_full" ),
+    TYPES_FULL("types_full"),
 
     // Completely full
-	FULL( "full" );
+    FULL("full");
 
     private final String name;
 
-	DriveSlotState( String name )
+    DriveSlotState(String name) {
-	{
         this.name = name;
     }
 
     @Override
-	public String getName()
+    public String getName() {
-	{
         return this.name;
     }
 
-	public static DriveSlotState fromCellStatus( int cellStatus )
+    public static DriveSlotState fromCellStatus(int cellStatus) {
-	{
+        switch (cellStatus) {
-		switch( cellStatus )
-		{
             default:
             case 0:
                 return DriveSlotState.EMPTY;

src/main/java/appeng/block/storage/DriveSlotsState.java

@@ -25,64 +25,49 @@ import appeng.api.implementations.tiles.IChestOrDrive;
 /**
  * Contains the full information about what the state of the slots in a BlockDrive is.
  */
-public class DriveSlotsState
+public class DriveSlotsState {
-{
 
     private final DriveSlotState[] slots;
 
-	private DriveSlotsState( DriveSlotState[] slots )
+    private DriveSlotsState(DriveSlotState[] slots) {
-	{
         this.slots = slots;
     }
 
-	public DriveSlotState getState( int index )
+    public DriveSlotState getState(int index) {
-	{
+        if (index >= this.slots.length) {
-		if( index >= this.slots.length )
-		{
             return DriveSlotState.EMPTY;
         }
         return this.slots[index];
     }
 
-	public int getSlotCount()
+    public int getSlotCount() {
-	{
         return this.slots.length;
     }
 
     /**
      * Retrieve an array that describes the state of each slot in this drive or chest.
      */
-	public static DriveSlotsState fromChestOrDrive( IChestOrDrive chestOrDrive )
+    public static DriveSlotsState fromChestOrDrive(IChestOrDrive chestOrDrive) {
-	{
         DriveSlotState[] slots = new DriveSlotState[chestOrDrive.getCellCount()];
-		for( int i = 0; i < chestOrDrive.getCellCount(); i++ )
+        for (int i = 0; i < chestOrDrive.getCellCount(); i++) {
-		{
+            if (!chestOrDrive.isPowered()) {
-			if( !chestOrDrive.isPowered() )
+                if (chestOrDrive.getCellStatus(i) != 0) {
-			{
-				if( chestOrDrive.getCellStatus( i ) != 0 )
-				{
                     slots[i] = DriveSlotState.OFFLINE;
-				}
+                } else {
-				else
-				{
                     slots[i] = DriveSlotState.EMPTY;
                 }
-			}
+            } else {
-			else
+                slots[i] = DriveSlotState.fromCellStatus(chestOrDrive.getCellStatus(i));
-			{
-				slots[i] = DriveSlotState.fromCellStatus( chestOrDrive.getCellStatus( i ) );
             }
         }
-		return new DriveSlotsState( slots );
+        return new DriveSlotsState(slots);
     }
 
-	public static DriveSlotsState createEmpty( int slotCount )
+    public static DriveSlotsState createEmpty(int slotCount) {
-	{
         DriveSlotState[] slots = new DriveSlotState[slotCount];
-		for( int i = 0; i < slotCount; i++ )
+        for (int i = 0; i < slotCount; i++) {
-		{
             slots[i] = DriveSlotState.EMPTY;
         }
-		return new DriveSlotsState( slots );
+        return new DriveSlotsState(slots);
     }
 }

src/main/java/appeng/block/storage/SkyChestRenderingCustomizer.java

@@ -19,43 +19,37 @@
 package appeng.block.storage;
 
 
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.bootstrap.BlockRenderingCustomizer;
 import appeng.bootstrap.IBlockRendering;
 import appeng.bootstrap.IItemRendering;
 import appeng.client.render.tesr.SkyChestTESR;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 
-public class SkyChestRenderingCustomizer extends BlockRenderingCustomizer
+public class SkyChestRenderingCustomizer extends BlockRenderingCustomizer {
-{
 
     private final BlockSkyChest.SkyChestType type;
 
-	public SkyChestRenderingCustomizer( BlockSkyChest.SkyChestType type )
+    public SkyChestRenderingCustomizer(BlockSkyChest.SkyChestType type) {
-	{
         this.type = type;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+    public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-	{
+        rendering.tesr(new SkyChestTESR());
-		rendering.tesr( new SkyChestTESR() );
 
         // Register a custom non-tesr item model
         String modelName = this.getModelFromType();
-		ModelResourceLocation model = new ModelResourceLocation( "appliedenergistics2:" + modelName, "inventory" );
+        ModelResourceLocation model = new ModelResourceLocation("appliedenergistics2:" + modelName, "inventory");
-		itemRendering.model( model ).variants( model );
+        itemRendering.model(model).variants(model);
     }
 
-	private String getModelFromType()
+    private String getModelFromType() {
-	{
         final String modelName;
-		switch( this.type )
+        switch (this.type) {
-		{
             default:
             case STONE:
                 modelName = "sky_stone_chest";

src/main/java/appeng/bootstrap/BlockDefinitionBuilder.java

@@ -19,25 +19,6 @@
 package appeng.bootstrap;
 
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.creativetab.CreativeTabs;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemBlock;
-import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.api.definitions.IBlockDefinition;
 import appeng.block.AEBaseBlock;
 import appeng.block.AEBaseItemBlock;
@@ -49,17 +30,29 @@ import appeng.bootstrap.definitions.TileEntityDefinition;
 import appeng.core.AEConfig;
 import appeng.core.AppEng;
 import appeng.core.CreativeTab;
-import appeng.core.features.AEFeature;
+import appeng.core.features.*;
-import appeng.core.features.ActivityState;
-import appeng.core.features.BlockDefinition;
-import appeng.core.features.BlockStackSrc;
-import appeng.core.features.TileDefinition;
 import appeng.tile.AEBaseTile;
 import appeng.util.Platform;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 
-class BlockDefinitionBuilder implements IBlockBuilder
+class BlockDefinitionBuilder implements IBlockBuilder {
-{
 
     private final FeatureFactory factory;
 
@@ -69,9 +62,9 @@ class BlockDefinitionBuilder implements IBlockBuilder
 
     private final List<BiFunction<Block, Item, IBootstrapComponent>> bootstrapComponents = new ArrayList<>();
 
-	private final EnumSet<AEFeature> features = EnumSet.noneOf( AEFeature.class );
+    private final EnumSet<AEFeature> features = EnumSet.noneOf(AEFeature.class);
 
-	private CreativeTabs creativeTab = CreativeTab.instance;
+    private final CreativeTabs creativeTab = CreativeTab.instance;
 
     private TileEntityDefinition tileEntityDefinition;
 
@@ -79,203 +72,167 @@ class BlockDefinitionBuilder implements IBlockBuilder
 
     private Function<Block, ItemBlock> itemFactory;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private BlockRendering blockRendering;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private ItemRendering itemRendering;
 
-	BlockDefinitionBuilder( FeatureFactory factory, String id, Supplier<? extends Block> blockSupplier )
+    BlockDefinitionBuilder(FeatureFactory factory, String id, Supplier<? extends Block> blockSupplier) {
-	{
         this.factory = factory;
         this.registryName = id;
         this.blockSupplier = blockSupplier;
 
-		if( Platform.isClient() )
+        if (Platform.isClient()) {
-		{
             this.blockRendering = new BlockRendering();
             this.itemRendering = new ItemRendering();
         }
     }
 
     @Override
-	public BlockDefinitionBuilder bootstrap( BiFunction<Block, Item, IBootstrapComponent> callback )
+    public BlockDefinitionBuilder bootstrap(BiFunction<Block, Item, IBootstrapComponent> callback) {
-	{
+        this.bootstrapComponents.add(callback);
-		this.bootstrapComponents.add( callback );
         return this;
     }
 
     @Override
-	public IBlockBuilder features( AEFeature... features )
+    public IBlockBuilder features(AEFeature... features) {
-	{
         this.features.clear();
-		this.addFeatures( features );
+        this.addFeatures(features);
         return this;
     }
 
     @Override
-	public IBlockBuilder addFeatures( AEFeature... features )
+    public IBlockBuilder addFeatures(AEFeature... features) {
-	{
+        Collections.addAll(this.features, features);
-		Collections.addAll( this.features, features );
         return this;
     }
 
     @Override
-	public BlockDefinitionBuilder rendering( BlockRenderingCustomizer callback )
+    public BlockDefinitionBuilder rendering(BlockRenderingCustomizer callback) {
-	{
+        if (Platform.isClient()) {
-		if( Platform.isClient() )
+            this.customizeForClient(callback);
-		{
-			this.customizeForClient( callback );
         }
 
         return this;
     }
 
     @Override
-	public IBlockBuilder tileEntity( TileEntityDefinition tileEntityDefinition )
+    public IBlockBuilder tileEntity(TileEntityDefinition tileEntityDefinition) {
-	{
         this.tileEntityDefinition = tileEntityDefinition;
         return this;
     }
 
     @Override
-	public IBlockBuilder useCustomItemModel()
+    public IBlockBuilder useCustomItemModel() {
-	{
+        this.rendering(new BlockRenderingCustomizer() {
-		this.rendering( new BlockRenderingCustomizer()
-		{
             @Override
-			@SideOnly( Side.CLIENT )
+            @SideOnly(Side.CLIENT)
-			public void customize( IBlockRendering rendering, IItemRendering itemRendering )
+            public void customize(IBlockRendering rendering, IItemRendering itemRendering) {
-			{
+                ModelResourceLocation model = new ModelResourceLocation(new ResourceLocation(AppEng.MOD_ID, BlockDefinitionBuilder.this.registryName), "inventory");
-				ModelResourceLocation model = new ModelResourceLocation( new ResourceLocation( AppEng.MOD_ID, BlockDefinitionBuilder.this.registryName ), "inventory" );
+                itemRendering.model(model).variants(model);
-				itemRendering.model( model ).variants( model );
             }
-		} );
+        });
 
         return this;
     }
 
     @Override
-	public IBlockBuilder item( Function<Block, ItemBlock> factory )
+    public IBlockBuilder item(Function<Block, ItemBlock> factory) {
-	{
         this.itemFactory = factory;
         return this;
     }
 
     @Override
-	public IBlockBuilder disableItem()
+    public IBlockBuilder disableItem() {
-	{
         this.disableItem = true;
         return this;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	private void customizeForClient( BlockRenderingCustomizer callback )
+    private void customizeForClient(BlockRenderingCustomizer callback) {
-	{
+        callback.customize(this.blockRendering, this.itemRendering);
-		callback.customize( this.blockRendering, this.itemRendering );
     }
 
-	@SuppressWarnings( "unchecked" )
+    @SuppressWarnings("unchecked")
     @Override
-	public <T extends IBlockDefinition> T build()
+    public <T extends IBlockDefinition> T build() {
-	{
+        if (!AEConfig.instance().areFeaturesEnabled(this.features)) {
-		if( !AEConfig.instance().areFeaturesEnabled( this.features ) )
+            return (T) new TileDefinition(this.registryName, null, null);
-		{
-			return (T) new TileDefinition( this.registryName, null, null );
         }
 
         // Create block and matching item, and set factory name of both
         Block block = this.blockSupplier.get();
-		block.setRegistryName( AppEng.MOD_ID, this.registryName );
+        block.setRegistryName(AppEng.MOD_ID, this.registryName);
-		block.setUnlocalizedName( "appliedenergistics2." + this.registryName );
+        block.setUnlocalizedName("appliedenergistics2." + this.registryName);
 
-		ItemBlock item = this.constructItemFromBlock( block );
+        ItemBlock item = this.constructItemFromBlock(block);
-		if( item != null )
+        if (item != null) {
-		{
+            item.setRegistryName(AppEng.MOD_ID, this.registryName);
-			item.setRegistryName( AppEng.MOD_ID, this.registryName );
         }
 
         // Register the item and block with the game
-		this.factory.addBootstrapComponent( (IBlockRegistrationComponent) ( side, registry ) -> registry.register( block ) );
+        this.factory.addBootstrapComponent((IBlockRegistrationComponent) (side, registry) -> registry.register(block));
-		if( item != null )
+        if (item != null) {
-		{
+            this.factory.addBootstrapComponent((IItemRegistrationComponent) (side, registry) -> registry.register(item));
-			this.factory.addBootstrapComponent( (IItemRegistrationComponent) ( side, registry ) -> registry.register( item ) );
         }
 
-		block.setCreativeTab( this.creativeTab );
+        block.setCreativeTab(this.creativeTab);
 
         // Register all extra handlers
-		this.bootstrapComponents.forEach( component -> this.factory.addBootstrapComponent( component.apply( block, item ) ) );
+        this.bootstrapComponents.forEach(component -> this.factory.addBootstrapComponent(component.apply(block, item)));
 
-		if( this.tileEntityDefinition != null && block instanceof AEBaseTileBlock )
+        if (this.tileEntityDefinition != null && block instanceof AEBaseTileBlock) {
-		{
+            ((AEBaseTileBlock) block).setTileEntity(this.tileEntityDefinition.getTileEntityClass());
-			( (AEBaseTileBlock) block ).setTileEntity( this.tileEntityDefinition.getTileEntityClass() );
+            if (this.tileEntityDefinition.getName() == null) {
-			if( this.tileEntityDefinition.getName() == null )
+                this.tileEntityDefinition.setName(this.registryName);
-			{
-				this.tileEntityDefinition.setName( this.registryName );
             }
 
         }
 
-		if( Platform.isClient() )
+        if (Platform.isClient()) {
-		{
+            if (block instanceof AEBaseTileBlock) {
-			if( block instanceof AEBaseTileBlock )
-			{
                 AEBaseTileBlock tileBlock = (AEBaseTileBlock) block;
-				this.blockRendering.apply( this.factory, block, tileBlock.getTileEntityClass() );
+                this.blockRendering.apply(this.factory, block, tileBlock.getTileEntityClass());
-			}
+            } else {
-			else
+                this.blockRendering.apply(this.factory, block, null);
-			{
-				this.blockRendering.apply( this.factory, block, null );
             }
 
-			if( item != null )
+            if (item != null) {
-			{
+                this.itemRendering.apply(this.factory, item);
-				this.itemRendering.apply( this.factory, item );
             }
         }
 
-		if( block instanceof AEBaseTileBlock )
+        if (block instanceof AEBaseTileBlock) {
-		{
+            this.factory.addBootstrapComponent((IPreInitComponent) side ->
-			this.factory.addBootstrapComponent( (IPreInitComponent) side ->
             {
                 AEBaseTile.registerTileItem(
-						this.tileEntityDefinition == null ? ( (AEBaseTileBlock) block ).getTileEntityClass() : this.tileEntityDefinition.getTileEntityClass(),
+                        this.tileEntityDefinition == null ? ((AEBaseTileBlock) block).getTileEntityClass() : this.tileEntityDefinition.getTileEntityClass(),
-						new BlockStackSrc( block, 0, ActivityState.Enabled ) );
+                        new BlockStackSrc(block, 0, ActivityState.Enabled));
-			} );
+            });
 
-			if( this.tileEntityDefinition != null )
+            if (this.tileEntityDefinition != null) {
-			{
+                this.factory.tileEntityComponent.addTileEntity(this.tileEntityDefinition);
-				this.factory.tileEntityComponent.addTileEntity( this.tileEntityDefinition );
             }
 
-			return (T) new TileDefinition( this.registryName, (AEBaseTileBlock) block, item );
+            return (T) new TileDefinition(this.registryName, (AEBaseTileBlock) block, item);
-		}
+        } else {
-		else
+            return (T) new BlockDefinition(this.registryName, block, item);
-		{
-			return (T) new BlockDefinition( this.registryName, block, item );
         }
     }
 
     @Nullable
-	private ItemBlock constructItemFromBlock( Block block )
+    private ItemBlock constructItemFromBlock(Block block) {
-	{
+        if (this.disableItem) {
-		if( this.disableItem )
-		{
             return null;
         }
 
-		if( this.itemFactory != null )
+        if (this.itemFactory != null) {
-		{
+            return this.itemFactory.apply(block);
-			return this.itemFactory.apply( block );
+        } else if (block instanceof AEBaseBlock) {
-		}
+            return new AEBaseItemBlock(block);
-		else if( block instanceof AEBaseBlock )
+        } else {
-		{
+            return new ItemBlock(block);
-			return new AEBaseItemBlock( block );
-		}
-		else
-		{
-			return new ItemBlock( block );
         }
     }
 }

src/main/java/appeng/bootstrap/BlockRendering.java

@@ -19,117 +19,132 @@
 package appeng.bootstrap;
 
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.BiFunction;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.renderer.block.model.IBakedModel;
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.client.renderer.block.statemap.IStateMapper;
-import net.minecraft.client.renderer.color.IBlockColor;
-import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
-import net.minecraftforge.client.model.IModel;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.block.AEBaseTileBlock;
 import appeng.bootstrap.components.BlockColorComponent;
 import appeng.bootstrap.components.StateMapperComponent;
 import appeng.bootstrap.components.TesrComponent;
 import appeng.client.render.model.AutoRotatingModel;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.block.model.IBakedModel;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.client.renderer.block.statemap.IStateMapper;
+import net.minecraft.client.renderer.color.IBlockColor;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.client.resources.IReloadableResourceManager;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.client.resources.IResourceManagerReloadListener;
+import net.minecraftforge.client.model.IModel;
+import net.minecraftforge.client.resource.IResourceType;
+import net.minecraftforge.client.resource.ISelectiveResourceReloadListener;
+import net.minecraftforge.client.resource.VanillaResourceType;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
 
 
-class BlockRendering implements IBlockRendering
+class BlockRendering implements IBlockRendering, ISelectiveResourceReloadListener {
-{
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private BiFunction<ModelResourceLocation, IBakedModel, IBakedModel> modelCustomizer;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private IBlockColor blockColor;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private TileEntitySpecialRenderer<?> tesr;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private IStateMapper stateMapper;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	private Map<String, IModel> builtInModels = new HashMap<>();
+    private final Map<String, IModel> builtInModels = new HashMap<>();
+
+    @SideOnly(Side.CLIENT)
+    private final List<IResourceManagerReloadListener> reloads = new ArrayList<>();
+
+    BlockRendering() {
+        ((IReloadableResourceManager) Minecraft.getMinecraft().getResourceManager()).registerReloadListener(this);
+    }
 
     @Override
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public IBlockRendering modelCustomizer( BiFunction<ModelResourceLocation, IBakedModel, IBakedModel> customizer )
+    public IBlockRendering modelCustomizer(BiFunction<ModelResourceLocation, IBakedModel, IBakedModel> customizer) {
-	{
         this.modelCustomizer = customizer;
         return this;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public IBlockRendering blockColor( IBlockColor blockColor )
+    public IBlockRendering blockColor(IBlockColor blockColor) {
-	{
         this.blockColor = blockColor;
         return this;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public IBlockRendering tesr( TileEntitySpecialRenderer<?> tesr )
+    public IBlockRendering tesr(TileEntitySpecialRenderer<?> tesr) {
-	{
         this.tesr = tesr;
         return this;
     }
 
     @Override
-	public IBlockRendering builtInModel( String name, IModel model )
+    public IBlockRendering builtInModel(String name, IModel model) {
-	{
+        this.builtInModels.put(name, model);
-		this.builtInModels.put( name, model );
         return this;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     @Override
-	public IBlockRendering stateMapper( IStateMapper mapper )
+    public IBlockRendering stateMapper(IStateMapper mapper) {
-	{
         this.stateMapper = mapper;
         return this;
     }
 
-	void apply( FeatureFactory factory, Block block, Class<?> tileEntityClass )
+    void apply(FeatureFactory factory, Block block, Class<?> tileEntityClass) {
-	{
+        if (this.tesr != null) {
-		if( this.tesr != null )
+            if (tileEntityClass == null) {
-		{
+                throw new IllegalStateException("Tried to register a TESR for " + block + " even though no tile entity has been specified.");
-			if( tileEntityClass == null )
-			{
-				throw new IllegalStateException( "Tried to register a TESR for " + block + " even though no tile entity has been specified." );
             }
-			factory.addBootstrapComponent( new TesrComponent( tileEntityClass, this.tesr ) );
+            factory.addBootstrapComponent(new TesrComponent(tileEntityClass, this.tesr));
         }
 
-		if( this.modelCustomizer != null )
+        if (this.modelCustomizer != null) {
-		{
+            factory.addModelOverride(block.getRegistryName().getResourcePath(), this.modelCustomizer);
-			factory.addModelOverride( block.getRegistryName().getResourcePath(), this.modelCustomizer );
+        } else if (block instanceof AEBaseTileBlock) {
-		}
-		else if( block instanceof AEBaseTileBlock )
-		{
             // This is a default rotating model if the base-block uses an AE tile entity which exposes UP/FRONT as
             // extended props
-			factory.addModelOverride( block.getRegistryName().getResourcePath(), ( l, m ) -> new AutoRotatingModel( m ) );
+            factory.addModelOverride(block.getRegistryName().getResourcePath(), (l, m) -> {
+                AutoRotatingModel model = new AutoRotatingModel(m);
+                BlockRendering.this.reloads.add(model);
+                return model;
+            });
         }
 
         // TODO : 1.12
-		this.builtInModels.forEach( factory::addBuiltInModel );
+        this.builtInModels.forEach(factory::addBuiltInModel);
 
-		if( this.blockColor != null )
+        if (this.blockColor != null) {
-		{
+            factory.addBootstrapComponent(new BlockColorComponent(block, this.blockColor));
-			factory.addBootstrapComponent( new BlockColorComponent( block, this.blockColor ) );
         }
 
-		if( this.stateMapper != null )
+        if (this.stateMapper != null) {
-		{
+            factory.addBootstrapComponent(new StateMapperComponent(block, this.stateMapper));
-			factory.addBootstrapComponent( new StateMapperComponent( block, this.stateMapper ) );
         }
     }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void onResourceManagerReload(IResourceManager resourceManager, Predicate<IResourceType> resourcePredicate) {
+        if (resourcePredicate.test(VanillaResourceType.MODELS)) {
+            this.reloads.forEach(listener -> listener.onResourceManagerReload(resourceManager));
+        }
+    }
+
 }

src/main/java/appeng/bootstrap/BlockRenderingCustomizer.java

@@ -28,10 +28,9 @@ import net.minecraftforge.fml.relauncher.SideOnly;
  * used
  * due to them not being able to be annotated with @SideOnly(CLIENT).
  */
-public abstract class BlockRenderingCustomizer
+public abstract class BlockRenderingCustomizer {
-{
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public abstract void customize( IBlockRendering rendering, IItemRendering itemRendering );
+    public abstract void customize(IBlockRendering rendering, IItemRendering itemRendering);
 
 }

src/main/java/appeng/bootstrap/FeatureFactory.java

@@ -19,24 +19,6 @@
 package appeng.bootstrap;
 
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.function.BiFunction;
-import java.util.function.Supplier;
-
-import net.minecraft.block.Block;
-import net.minecraft.client.renderer.block.model.IBakedModel;
-import net.minecraft.client.renderer.block.model.ModelResourceLocation;
-import net.minecraft.item.Item;
-import net.minecraftforge.client.model.IModel;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-
 import appeng.api.definitions.IItemDefinition;
 import appeng.api.util.AEColor;
 import appeng.api.util.AEColoredItemDefinition;
@@ -48,111 +30,107 @@ import appeng.core.features.ActivityState;
 import appeng.core.features.ColoredItemDefinition;
 import appeng.core.features.ItemStackSrc;
 import appeng.util.Platform;
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.block.model.IBakedModel;
+import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.item.Item;
+import net.minecraftforge.client.model.IModel;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Supplier;
 
 
-public class FeatureFactory
+public class FeatureFactory {
-{
 
     private final AEFeature[] defaultFeatures;
 
     private final Map<Class<? extends IBootstrapComponent>, List<IBootstrapComponent>> bootstrapComponents;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private ModelOverrideComponent modelOverrideComponent;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private BuiltInModelComponent builtInModelComponent;
 
     public final TileEntityComponent tileEntityComponent;
 
-	public FeatureFactory()
+    public FeatureFactory() {
-	{
+        this.defaultFeatures = new AEFeature[]{AEFeature.CORE};
-		this.defaultFeatures = new AEFeature[] { AEFeature.CORE };
         this.bootstrapComponents = new HashMap<>();
 
         this.tileEntityComponent = new TileEntityComponent();
-		this.addBootstrapComponent( this.tileEntityComponent );
+        this.addBootstrapComponent(this.tileEntityComponent);
 
-		if( Platform.isClient() )
+        if (Platform.isClient()) {
-		{
             this.modelOverrideComponent = new ModelOverrideComponent();
-			this.addBootstrapComponent( this.modelOverrideComponent );
+            this.addBootstrapComponent(this.modelOverrideComponent);
 
             this.builtInModelComponent = new BuiltInModelComponent();
-			this.addBootstrapComponent( this.builtInModelComponent );
+            this.addBootstrapComponent(this.builtInModelComponent);
         }
     }
 
-	private FeatureFactory( FeatureFactory parent, AEFeature... defaultFeatures )
+    private FeatureFactory(FeatureFactory parent, AEFeature... defaultFeatures) {
-	{
         this.defaultFeatures = defaultFeatures.clone();
         this.bootstrapComponents = parent.bootstrapComponents;
         this.tileEntityComponent = parent.tileEntityComponent;
-		if( Platform.isClient() )
+        if (Platform.isClient()) {
-		{
             this.modelOverrideComponent = parent.modelOverrideComponent;
             this.builtInModelComponent = parent.builtInModelComponent;
         }
     }
 
-	public IBlockBuilder block( String id, Supplier<Block> block )
+    public IBlockBuilder block(String id, Supplier<Block> block) {
-	{
+        return new BlockDefinitionBuilder(this, id, block).features(this.defaultFeatures);
-		return new BlockDefinitionBuilder( this, id, block ).features( this.defaultFeatures );
     }
 
-	public IItemBuilder item( String id, Supplier<Item> item )
+    public IItemBuilder item(String id, Supplier<Item> item) {
-	{
+        return new ItemDefinitionBuilder(this, id, item).features(this.defaultFeatures);
-		return new ItemDefinitionBuilder( this, id, item ).features( this.defaultFeatures );
     }
 
-	public AEColoredItemDefinition colored( IItemDefinition target, int offset )
+    public AEColoredItemDefinition colored(IItemDefinition target, int offset) {
-	{
         ColoredItemDefinition definition = new ColoredItemDefinition();
 
-		target.maybeItem().ifPresent( targetItem ->
+        target.maybeItem().ifPresent(targetItem ->
         {
-			for( final AEColor color : AEColor.VALID_COLORS )
+            for (final AEColor color : AEColor.VALID_COLORS) {
-			{
+                final ActivityState state = ActivityState.from(target.isEnabled());
-				final ActivityState state = ActivityState.from( target.isEnabled() );
 
-				definition.add( color, new ItemStackSrc( targetItem, offset + color.ordinal(), state ) );
+                definition.add(color, new ItemStackSrc(targetItem, offset + color.ordinal(), state));
             }
-		} );
+        });
 
         return definition;
     }
 
-	public FeatureFactory features( AEFeature... features )
+    public FeatureFactory features(AEFeature... features) {
-	{
+        return new FeatureFactory(this, features);
-		return new FeatureFactory( this, features );
     }
 
-	public void addBootstrapComponent( IBootstrapComponent component )
+    public void addBootstrapComponent(IBootstrapComponent component) {
-	{
+        Arrays.stream(component.getClass().getInterfaces())
-		Arrays.stream( component.getClass().getInterfaces() )
+                .filter(i -> IBootstrapComponent.class.isAssignableFrom(i))
-				.filter( i -> IBootstrapComponent.class.isAssignableFrom( i ) )
+                .forEach(i -> this.addBootstrapComponent((Class<? extends IBootstrapComponent>) i, component));
-				.forEach( i -> this.addBootstrapComponent( (Class<? extends IBootstrapComponent>) i, component ) );
     }
 
-	private <T extends IBootstrapComponent> void addBootstrapComponent( Class<? extends IBootstrapComponent> eventType, T component )
+    private <T extends IBootstrapComponent> void addBootstrapComponent(Class<? extends IBootstrapComponent> eventType, T component) {
-	{
+        this.bootstrapComponents.computeIfAbsent(eventType, c -> new ArrayList<IBootstrapComponent>()).add(component);
-		this.bootstrapComponents.computeIfAbsent( eventType, c -> new ArrayList<IBootstrapComponent>() ).add( component );
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	void addBuiltInModel( String path, IModel model )
+    void addBuiltInModel(String path, IModel model) {
-	{
+        this.builtInModelComponent.addModel(path, model);
-		this.builtInModelComponent.addModel( path, model );
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	void addModelOverride( String resourcePath, BiFunction<ModelResourceLocation, IBakedModel, IBakedModel> customizer )
+    void addModelOverride(String resourcePath, BiFunction<ModelResourceLocation, IBakedModel, IBakedModel> customizer) {
-	{
+        this.modelOverrideComponent.addOverride(resourcePath, customizer);
-		this.modelOverrideComponent.addOverride( resourcePath, customizer );
     }
 
-	public <T extends IBootstrapComponent> Iterator<T> getBootstrapComponents( Class<T> eventType )
+    public <T extends IBootstrapComponent> Iterator<T> getBootstrapComponents(Class<T> eventType) {
-	{
+        return (Iterator<T>) this.bootstrapComponents.getOrDefault(eventType, Collections.emptyList()).iterator();
-		return (Iterator<T>) this.bootstrapComponents.getOrDefault( eventType, Collections.emptyList() ).iterator();
     }
 }