Blanket reformat

plugin/rei/src/main/kotlin/net/shadowfacts/phycon/plugin/rei/PhyConPluginClient.kt

@@ -39,7 +39,8 @@ object PhyConPluginClient: ClientModInitializer, REIClientPlugin, AbstractTermin
         AbstractTerminalScreen.searchQueryListener = this
         try {
             val clazz = Class.forName("me.shedaniel.rei.impl.client.gui.widget.search.OverlaySearchField")
-			isHighlightingHandle = MethodHandles.publicLookup().findStaticGetter(clazz, "isHighlighting", Boolean::class.java)
+            isHighlightingHandle =
+                MethodHandles.publicLookup().findStaticGetter(clazz, "isHighlighting", Boolean::class.java)
         } catch (e: ReflectiveOperationException) {
             logger.warn("Unable to find OverlaySearchField.isHighlighting, highlight sync will be disabled", e)
         }

plugin/rei/src/main/kotlin/net/shadowfacts/phycon/plugin/rei/PhyConPluginCommon.kt

@@ -25,7 +25,11 @@ object PhyConPluginCommon: REIServerPlugin, PhyConPlugin {
         private set
 
     override fun registerMenuInfo(registry: MenuInfoRegistry) {
-		registry.register(CategoryIdentifier.of("minecraft", "plugins/crafting"), CraftingTerminalScreenHandler::class.java, SimpleMenuInfoProvider.of(::TerminalInfo))
+        registry.register(
+            CategoryIdentifier.of("minecraft", "plugins/crafting"),
+            CraftingTerminalScreenHandler::class.java,
+            SimpleMenuInfoProvider.of(::TerminalInfo)
+        )
     }
 
     override fun initializePhyCon(api: PhyConAPI) {

plugin/techreborn/src/main/kotlin/net/shadowfacts/phycon/plugin/techreborn/PhyConTR.kt

@@ -18,11 +18,20 @@ object PhyConTR: ModInitializer {
 
     override fun onInitialize() {
         TRContent.StorageUnit.values().forEach {
-			ItemAttributes.GROUPED_INV.setBlockAdder(AttributeSourceType.COMPAT_WRAPPER, it.block, ::addStorageUnitGroupedInv)
+            ItemAttributes.GROUPED_INV.setBlockAdder(
+                AttributeSourceType.COMPAT_WRAPPER,
+                it.block,
+                ::addStorageUnitGroupedInv
+            )
         }
     }
 
-	private fun addStorageUnitGroupedInv(world: World, pos: BlockPos, state: BlockState, to: AttributeList<GroupedItemInv>) {
+    private fun addStorageUnitGroupedInv(
+        world: World,
+        pos: BlockPos,
+        state: BlockState,
+        to: AttributeList<GroupedItemInv>
+    ) {
         (world.getBlockEntity(pos) as? StorageUnitBaseBlockEntity)?.also { su ->
             to.offer(StorageUnitWrapper(su))
         }

src/main/java/net/shadowfacts/phycon/api/Interface.java

@@ -16,6 +16,7 @@ public interface Interface {
 
 	void send(@NotNull EthernetFrame frame);
 
-	default void cableDisconnected() {}
+	default void cableDisconnected() {
+	}
 
 }

src/main/java/net/shadowfacts/phycon/api/NetworkDevice.java

@@ -10,9 +10,9 @@ public interface NetworkDevice {
 
 	/**
 	 * The IP address of this device.
-	 *
+	 * <p>
 	 * If a device has not been assigned an address by a DHCP server, it may self-assign a randomly generated one.
-	 *
+	 * <p>
 	 * The address of a network device should never be the broadcast address.
 	 *
 	 * @return The IP address of this device.

src/main/java/net/shadowfacts/phycon/api/TerminalSetting.java

@@ -13,6 +13,7 @@ public interface TerminalSetting {
 
 	int[] getUV();
 
-	@Nullable Text getTooltip();
+	@Nullable
+	Text getTooltip();
 
 }

src/main/java/net/shadowfacts/phycon/api/util/IPAddress.java

@@ -23,12 +23,14 @@ public final class IPAddress {
 	}
 
 	private static final Random ipAddressRandom = new Random();
+
 	@NotNull
 	public static IPAddress random() {
 		return random(ipAddressRandom);
 	}
 
 	private static final Pattern IP_PATTERN = Pattern.compile("^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$");
+
 	@Nullable
 	public static IPAddress parse(String s) {
 		Matcher matcher = IP_PATTERN.matcher(s);

src/main/java/net/shadowfacts/phycon/api/util/MACAddress.java

@@ -22,6 +22,7 @@ public final class MACAddress {
 	}
 
 	private static final Random macAddressRandom = new Random();
+
 	@NotNull
 	public static MACAddress random() {
 		return random(macAddressRandom);

src/main/kotlin/net/shadowfacts/cacao/CacaoScreen.kt

@@ -24,6 +24,7 @@ open class CacaoScreen(title: Text = LiteralText("CacaoScreen")): Screen(title),
 
     // _windows is the internal, mutable object, since we only want it to by mutated by the add/removeWindow methods.
     private val _windows = LinkedList<Window>()
+
     /**
      * The list of windows that belong to this screen.
      *

src/main/kotlin/net/shadowfacts/cacao/README.md

@@ -1,9 +1,12 @@
 # Cacao
+
 Cacao is a UI framework for Fabric/Minecraft mods based on Apple's [Cocoa](https://en.wikipedia.org/wiki/Cocoa_(API)
 UI toolkit.
 
 ## Architecture
+
 ### Screen
+
 A [CacaoScreen][] is the object that acts as the interface between Minecraft GUI code and the Cacao framework.
 
 The CacaoScreen draws Cacao views on screen and passes Minecraft input events to the appropriate Views. The CacaoScreen
@@ -12,6 +15,7 @@ owns a group of [Window](#window) objects which are displayed on screen, one on
 [CacaoScreen]: https://git.shadowfacts.net/minecraft/ASMR/src/branch/master/src/main/kotlin/net/shadowfacts/cacao/CacaoScreen.kt
 
 ### Window
+
 A [Window][] object has a root [View Controller](#view-controller) that it displays on screen.
 
 The Window occupies the entire screen space and translates events from the screen to the root View Controller's View.
@@ -21,6 +25,7 @@ view hierarchy.
 [Window]: https://git.shadowfacts.net/minecraft/ASMR/src/branch/master/src/main/kotlin/net/shadowfacts/cacao/Window.kt
 
 ### View Controller
+
 A [ViewController][] object owns a view, receives lifecycle events for it, and is generally used to control the view.
 
 Each View Controller has a single root [View](#view) which in turn may have subviews.
@@ -28,6 +33,7 @@ Each View Controller has a single root [View](#view) which in turn may have subv
 [ViewController]: https://git.shadowfacts.net/minecraft/ASMR/src/branch/master/src/main/kotlin/net/shadowfacts/cacao/viewcontroller/ViewController.kt
 
 ### View
+
 A [View][] object represents a single view on screen. It handles drawing, positioning, and directly handles input.
 
 [View]: https://git.shadowfacts.net/minecraft/ASMR/src/branch/master/src/main/kotlin/net/shadowfacts/cacao/view/View.kt

src/main/kotlin/net/shadowfacts/cacao/geometry/AxisPosition.kt

@@ -10,10 +10,12 @@ enum class AxisPosition {
      * Top for vertical, left for horizontal.
      */
     LEADING,
+
     /**
      * Center X/Y.
      */
     CENTER,
+
     /**
      * Bottom for vertical, right for horizontal.
      */

src/main/kotlin/net/shadowfacts/cacao/util/LayoutGuide.kt

@@ -28,6 +28,11 @@ class LayoutGuide(
     val centerYAnchor: LayoutVariable = LayoutVariable(this, "centerY")
 
     val frame: Rect
-		get() = Rect(leftAnchor.value - owningView.leftAnchor.value, topAnchor.value - owningView.topAnchor.value, widthAnchor.value, heightAnchor.value)
+        get() = Rect(
+            leftAnchor.value - owningView.leftAnchor.value,
+            topAnchor.value - owningView.topAnchor.value,
+            widthAnchor.value,
+            heightAnchor.value
+        )
 
 }

src/main/kotlin/net/shadowfacts/cacao/util/RenderHelper.kt

@@ -48,7 +48,17 @@ object RenderHelper: DrawableHelper() {
         if (disabled) return
         RenderSystem.setShader(GameRenderer::getPositionTexShader)
         RenderSystem.setShaderTexture(0, texture.location)
-		draw(matrixStack, rect.left, rect.top, texture.u, texture.v, rect.width, rect.height, texture.width, texture.height)
+        draw(
+            matrixStack,
+            rect.left,
+            rect.top,
+            texture.u,
+            texture.v,
+            rect.width,
+            rect.height,
+            texture.width,
+            texture.height
+        )
     }
 
     fun drawLine(start: Point, end: Point, z: Double, width: Float, color: Color) {
@@ -70,18 +80,50 @@ object RenderHelper: DrawableHelper() {
     /**
      * Draws the bound texture with the given screen and texture position and size.
      */
-	fun draw(matrixStack: MatrixStack, x: Double, y: Double, u: Int, v: Int, width: Double, height: Double, textureWidth: Int, textureHeight: Int) {
+    fun draw(
+        matrixStack: MatrixStack,
+        x: Double,
+        y: Double,
+        u: Int,
+        v: Int,
+        width: Double,
+        height: Double,
+        textureWidth: Int,
+        textureHeight: Int
+    ) {
         if (disabled) return
         val uStart = u.toFloat() / textureWidth
         val uEnd = (u + width).toFloat() / textureWidth
         val vStart = v.toFloat() / textureHeight
         val vEnd = (v + height).toFloat() / textureHeight
-		drawTexturedQuad(matrixStack.peek().positionMatrix, x, x + width, y, y + height, 0.0, uStart, uEnd, vStart, vEnd)
+        drawTexturedQuad(
+            matrixStack.peek().positionMatrix,
+            x,
+            x + width,
+            y,
+            y + height,
+            0.0,
+            uStart,
+            uEnd,
+            vStart,
+            vEnd
+        )
     }
 
     // Copied from net.minecraft.client.gui.DrawableHelper
     // TODO: use an access transformer to just call minecraft's impl
-	private fun drawTexturedQuad(matrix: Matrix4f, x0: Double, x1: Double, y0: Double, y1: Double, z: Double, u0: Float, u1: Float, v0: Float, v1: Float) {
+    private fun drawTexturedQuad(
+        matrix: Matrix4f,
+        x0: Double,
+        x1: Double,
+        y0: Double,
+        y1: Double,
+        z: Double,
+        u0: Float,
+        u1: Float,
+        v0: Float,
+        v1: Float
+    ) {
         val bufferBuilder = Tessellator.getInstance().buffer
         bufferBuilder.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE)
         bufferBuilder.vertex(matrix, x0.toFloat(), y1.toFloat(), z.toFloat()).texture(u0, v1).next()

src/main/kotlin/net/shadowfacts/cacao/util/texture/NinePatchTexture.kt

@@ -15,7 +15,13 @@ import net.minecraft.util.Identifier
  * @param centerWidth The width of the center patch.
  * @param centerHeight The height of the center patch.
  */
-data class NinePatchTexture(val texture: Texture, val cornerWidth: Int, val cornerHeight: Int, val centerWidth: Int, val centerHeight: Int) {
+data class NinePatchTexture(
+    val texture: Texture,
+    val cornerWidth: Int,
+    val cornerHeight: Int,
+    val centerWidth: Int,
+    val centerHeight: Int
+) {
 
     companion object {
         val PANEL_BG = NinePatchTexture(Texture(Identifier("textures/gui/demo_background.png"), 0, 0), 5, 5, 238, 156)

src/main/kotlin/net/shadowfacts/cacao/view/NinePatchView.kt

@@ -26,24 +26,44 @@ open class NinePatchView(val ninePatch: NinePatchTexture): View() {
     protected open val topLeft by topLeftDelegate
 
     private val topRightDelegate = ResettableLazyProperty {
-		Rect(bounds.width - ninePatch.cornerWidth, 0.0, ninePatch.cornerWidth.toDouble(), ninePatch.cornerHeight.toDouble())
+        Rect(
+            bounds.width - ninePatch.cornerWidth,
+            0.0,
+            ninePatch.cornerWidth.toDouble(),
+            ninePatch.cornerHeight.toDouble()
+        )
     }
     protected open val topRight by topRightDelegate
 
     private val bottomLeftDelegate = ResettableLazyProperty {
-		Rect(0.0, bounds.height - ninePatch.cornerHeight, ninePatch.cornerWidth.toDouble(), ninePatch.cornerHeight.toDouble())
+        Rect(
+            0.0,
+            bounds.height - ninePatch.cornerHeight,
+            ninePatch.cornerWidth.toDouble(),
+            ninePatch.cornerHeight.toDouble()
+        )
     }
     protected open val bottomLeft by bottomLeftDelegate
 
     private val bottomRightDelegate = ResettableLazyProperty {
-		Rect(bounds.width - ninePatch.cornerWidth, bounds.height - ninePatch.cornerHeight, ninePatch.cornerWidth.toDouble(), ninePatch.cornerHeight.toDouble())
+        Rect(
+            bounds.width - ninePatch.cornerWidth,
+            bounds.height - ninePatch.cornerHeight,
+            ninePatch.cornerWidth.toDouble(),
+            ninePatch.cornerHeight.toDouble()
+        )
     }
     protected open val bottomRight by bottomRightDelegate
 
 
     // Edges
     private val topMiddleDelegate = ResettableLazyProperty {
-		Rect(ninePatch.cornerWidth.toDouble(), topLeft.top, bounds.width - 2 * ninePatch.cornerWidth, ninePatch.cornerHeight.toDouble())
+        Rect(
+            ninePatch.cornerWidth.toDouble(),
+            topLeft.top,
+            bounds.width - 2 * ninePatch.cornerWidth,
+            ninePatch.cornerHeight.toDouble()
+        )
     }
     protected open val topMiddle by topMiddleDelegate
 
@@ -53,7 +73,12 @@ open class NinePatchView(val ninePatch: NinePatchTexture): View() {
     protected open val bottomMiddle by bottomMiddleDelegate
 
     private val leftMiddleDelegate = ResettableLazyProperty {
-		Rect(topLeft.left, ninePatch.cornerHeight.toDouble(), ninePatch.cornerWidth.toDouble(), bounds.height - 2 * ninePatch.cornerHeight)
+        Rect(
+            topLeft.left,
+            ninePatch.cornerHeight.toDouble(),
+            ninePatch.cornerWidth.toDouble(),
+            bounds.height - 2 * ninePatch.cornerHeight
+        )
     }
     protected open val leftMiddle by leftMiddleDelegate
 
@@ -69,7 +94,17 @@ open class NinePatchView(val ninePatch: NinePatchTexture): View() {
     }
     protected open val center by centerDelegate
 
-	private val delegates = listOf(topLeftDelegate, topRightDelegate, bottomLeftDelegate, bottomRightDelegate, topMiddleDelegate, bottomMiddleDelegate, leftMiddleDelegate, rightMiddleDelegate, centerDelegate)
+    private val delegates = listOf(
+        topLeftDelegate,
+        topRightDelegate,
+        bottomLeftDelegate,
+        bottomRightDelegate,
+        topMiddleDelegate,
+        bottomMiddleDelegate,
+        leftMiddleDelegate,
+        rightMiddleDelegate,
+        centerDelegate
+    )
 
     override fun didLayout() {
         super.didLayout()
@@ -93,30 +128,114 @@ open class NinePatchView(val ninePatch: NinePatchTexture): View() {
     private fun drawEdges(matrixStack: MatrixStack) {
         // Horizontal
         for (i in 0 until (topMiddle.width.roundToInt() / ninePatch.centerWidth)) {
-			RenderHelper.draw(matrixStack, topMiddle.left + i * ninePatch.centerWidth, topMiddle.top, ninePatch.topMiddle.u, ninePatch.topMiddle.v, ninePatch.centerWidth.toDouble(), topMiddle.height, ninePatch.texture.width, ninePatch.texture.height)
+            RenderHelper.draw(
-			RenderHelper.draw(matrixStack, bottomMiddle.left + i * ninePatch.centerWidth, bottomMiddle.top, ninePatch.bottomMiddle.u, ninePatch.bottomMiddle.v, ninePatch.centerWidth.toDouble(), bottomMiddle.height, ninePatch.texture.width, ninePatch.texture.height)
+                matrixStack,
+                topMiddle.left + i * ninePatch.centerWidth,
+                topMiddle.top,
+                ninePatch.topMiddle.u,
+                ninePatch.topMiddle.v,
+                ninePatch.centerWidth.toDouble(),
+                topMiddle.height,
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
+            RenderHelper.draw(
+                matrixStack,
+                bottomMiddle.left + i * ninePatch.centerWidth,
+                bottomMiddle.top,
+                ninePatch.bottomMiddle.u,
+                ninePatch.bottomMiddle.v,
+                ninePatch.centerWidth.toDouble(),
+                bottomMiddle.height,
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
         }
         val remWidth = topMiddle.width.roundToInt() % ninePatch.centerWidth
         if (remWidth > 0) {
-			RenderHelper.draw(matrixStack, topMiddle.right - remWidth, topMiddle.top, ninePatch.topMiddle.u, ninePatch.topMiddle.v, remWidth.toDouble(), ninePatch.cornerHeight.toDouble(), ninePatch.texture.width, ninePatch.texture.height)
+            RenderHelper.draw(
-			RenderHelper.draw(matrixStack, bottomMiddle.right - remWidth, bottomMiddle.top, ninePatch.bottomMiddle.u, ninePatch.bottomMiddle.v, remWidth.toDouble(), ninePatch.cornerHeight.toDouble(), ninePatch.texture.width, ninePatch.texture.height)
+                matrixStack,
+                topMiddle.right - remWidth,
+                topMiddle.top,
+                ninePatch.topMiddle.u,
+                ninePatch.topMiddle.v,
+                remWidth.toDouble(),
+                ninePatch.cornerHeight.toDouble(),
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
+            RenderHelper.draw(
+                matrixStack,
+                bottomMiddle.right - remWidth,
+                bottomMiddle.top,
+                ninePatch.bottomMiddle.u,
+                ninePatch.bottomMiddle.v,
+                remWidth.toDouble(),
+                ninePatch.cornerHeight.toDouble(),
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
         }
 
         // Vertical
         for (i in 0 until (leftMiddle.height.roundToInt() / ninePatch.centerHeight)) {
-			RenderHelper.draw(matrixStack, leftMiddle.left, leftMiddle.top + i * ninePatch.centerHeight, ninePatch.leftMiddle.u, ninePatch.leftMiddle.v, ninePatch.cornerWidth.toDouble(), ninePatch.centerHeight.toDouble(), ninePatch.texture.width, ninePatch.texture.height)
+            RenderHelper.draw(
-			RenderHelper.draw(matrixStack, rightMiddle.left, rightMiddle.top + i * ninePatch.centerHeight, ninePatch.rightMiddle.u, ninePatch.rightMiddle.v, ninePatch.cornerWidth.toDouble(), ninePatch.centerHeight.toDouble(), ninePatch.texture.width, ninePatch.texture.height)
+                matrixStack,
+                leftMiddle.left,
+                leftMiddle.top + i * ninePatch.centerHeight,
+                ninePatch.leftMiddle.u,
+                ninePatch.leftMiddle.v,
+                ninePatch.cornerWidth.toDouble(),
+                ninePatch.centerHeight.toDouble(),
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
+            RenderHelper.draw(
+                matrixStack,
+                rightMiddle.left,
+                rightMiddle.top + i * ninePatch.centerHeight,
+                ninePatch.rightMiddle.u,
+                ninePatch.rightMiddle.v,
+                ninePatch.cornerWidth.toDouble(),
+                ninePatch.centerHeight.toDouble(),
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
         }
         val remHeight = leftMiddle.height.roundToInt() % ninePatch.centerHeight
         if (remHeight > 0) {
-			RenderHelper.draw(matrixStack, leftMiddle.left, leftMiddle.bottom - remHeight, ninePatch.leftMiddle.u, ninePatch.leftMiddle.v, ninePatch.cornerWidth.toDouble(), remHeight.toDouble(), ninePatch.texture.width, ninePatch.texture.height)
+            RenderHelper.draw(
-			RenderHelper.draw(matrixStack, rightMiddle.left, rightMiddle.bottom - remHeight, ninePatch.rightMiddle.u, ninePatch.rightMiddle.v, ninePatch.cornerWidth.toDouble(), remHeight.toDouble(), ninePatch.texture.width, ninePatch.texture.height)
+                matrixStack,
+                leftMiddle.left,
+                leftMiddle.bottom - remHeight,
+                ninePatch.leftMiddle.u,
+                ninePatch.leftMiddle.v,
+                ninePatch.cornerWidth.toDouble(),
+                remHeight.toDouble(),
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
+            RenderHelper.draw(
+                matrixStack,
+                rightMiddle.left,
+                rightMiddle.bottom - remHeight,
+                ninePatch.rightMiddle.u,
+                ninePatch.rightMiddle.v,
+                ninePatch.cornerWidth.toDouble(),
+                remHeight.toDouble(),
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
         }
     }
 
     private fun drawCenter(matrixStack: MatrixStack) {
         for (i in 0 until (center.height.roundToInt() / ninePatch.centerHeight)) {
-			drawCenterRow(matrixStack, center.top + i * ninePatch.centerHeight.toDouble(), ninePatch.centerHeight.toDouble())
+            drawCenterRow(
+                matrixStack,
+                center.top + i * ninePatch.centerHeight.toDouble(),
+                ninePatch.centerHeight.toDouble()
+            )
         }
         val remHeight = center.height.roundToInt() % ninePatch.centerHeight
         if (remHeight > 0) {
@@ -126,11 +245,31 @@ open class NinePatchView(val ninePatch: NinePatchTexture): View() {
 
     private fun drawCenterRow(matrixStack: MatrixStack, y: Double, height: Double) {
         for (i in 0 until (center.width.roundToInt() / ninePatch.centerWidth)) {
-			RenderHelper.draw(matrixStack, center.left + i * ninePatch.centerWidth, y, ninePatch.center.u, ninePatch.center.v, ninePatch.centerWidth.toDouble(), height, ninePatch.texture.width, ninePatch.texture.height)
+            RenderHelper.draw(
+                matrixStack,
+                center.left + i * ninePatch.centerWidth,
+                y,
+                ninePatch.center.u,
+                ninePatch.center.v,
+                ninePatch.centerWidth.toDouble(),
+                height,
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
         }
         val remWidth = center.width.roundToInt() % ninePatch.centerWidth
         if (remWidth > 0) {
-			RenderHelper.draw(matrixStack, center.right - remWidth, y, ninePatch.center.u, ninePatch.center.v, remWidth.toDouble(), height, ninePatch.texture.width, ninePatch.texture.height)
+            RenderHelper.draw(
+                matrixStack,
+                center.right - remWidth,
+                y,
+                ninePatch.center.u,
+                ninePatch.center.v,
+                remWidth.toDouble(),
+                height,
+                ninePatch.texture.width,
+                ninePatch.texture.height
+            )
         }
     }
 

src/main/kotlin/net/shadowfacts/cacao/view/StackView.kt

@@ -29,6 +29,7 @@ open class StackView(
 
     // the internal, mutable list of arranged subviews
     private val _arrangedSubviews = LinkedList<View>()
+
     /**
      * The list of arranged subviews belonging to this stack view.
      * This list should never be mutated directly, only be calling the [addArrangedSubview]/[removeArrangedSubview]
@@ -139,10 +140,16 @@ open class StackView(
                 val previous = arrangedSubviews.getOrNull(index - 1)
                 val next = arrangedSubviews.getOrNull(index + 1)
                 if (next != null) {
-					arrangedSubviewConnections.add(index, anchor(TRAILING, view) equalTo (anchor(LEADING, next) + spacing))
+                    arrangedSubviewConnections.add(
+                        index,
+                        anchor(TRAILING, view) equalTo (anchor(LEADING, next) + spacing)
+                    )
                 }
                 if (previous != null) {
-					arrangedSubviewConnections.add(index - 1, anchor(TRAILING, previous) equalTo (anchor(LEADING, view) - spacing))
+                    arrangedSubviewConnections.add(
+                        index - 1,
+                        anchor(TRAILING, previous) equalTo (anchor(LEADING, view) - spacing)
+                    )
                 }
             }
         }
@@ -150,12 +157,15 @@ open class StackView(
             when (distribution) {
                 Distribution.LEADING ->
                     perpAnchor(LEADING) equalTo perpAnchor(LEADING, view)
+
                 Distribution.TRAILING ->
                     perpAnchor(TRAILING) equalTo perpAnchor(TRAILING, view)
+
                 Distribution.FILL -> {
                     perpAnchor(LEADING) equalTo perpAnchor(LEADING, view)
                     perpAnchor(TRAILING) equalTo perpAnchor(TRAILING, view)
                 }
+
                 Distribution.CENTER ->
                     perpAnchor(CENTER) equalTo perpAnchor(CENTER, view)
             }
@@ -165,6 +175,7 @@ open class StackView(
     private fun anchor(position: AxisPosition, view: View = this): LayoutVariable {
         return view.getAnchor(axis, position)
     }
+
     private fun perpAnchor(position: AxisPosition, view: View = this): LayoutVariable {
         return view.getAnchor(axis.perpendicular, position)
     }
@@ -199,6 +210,7 @@ open class StackView(
          * ```
          */
         LEADING,
+
         /**
          * The centers of the arranged subviews are pinned to the center of the stack view.
          * ```
@@ -222,6 +234,7 @@ open class StackView(
          * ```
          */
         CENTER,
+
         /**
          * The trailing edges of arranged subviews are pinned to the leading edge of the stack view.
          * ```
@@ -245,6 +258,7 @@ open class StackView(
          * ```
          */
         TRAILING,
+
         /**
          * The arranged subviews fill the perpendicular axis of the stack view.
          * ```

src/main/kotlin/net/shadowfacts/cacao/view/View.kt

@@ -42,6 +42,7 @@ open class View(): Responder {
             v.solver = it
         }
     }
+
     /**
      * The constraint solver used by the [Window] this view belongs to.
      * Not initialized until [wasAdded] called, using it before that will throw a runtime exception.
@@ -55,30 +56,37 @@ open class View(): Responder {
      * Layout anchor for the left edge of this view in the window's coordinate system.
      */
     val leftAnchor = LayoutVariable(this, "left")
+
     /**
      * Layout anchor for the right edge of this view in the window's coordinate system.
      */
     val rightAnchor = LayoutVariable(this, "right")
+
     /**
      * Layout anchor for the top edge of this view in the window's coordinate system.
      */
     val topAnchor = LayoutVariable(this, "top")
+
     /**
      * Layout anchor for the bottom edge of this view in the window's coordinate system.
      */
     val bottomAnchor = LayoutVariable(this, "bottom")
+
     /**
      * Layout anchor for the width of this view in the window's coordinate system.
      */
     val widthAnchor = LayoutVariable(this, "width")
+
     /**
      * Layout anchor for the height of this view in the window's coordinate system.
      */
     val heightAnchor = LayoutVariable(this, "height")
+
     /**
      * Layout anchor for the center X position of this view in the window's coordinate system.
      */
     val centerXAnchor = LayoutVariable(this, "centerX")
+
     /**
      * Layout anchor for the center Y position of this view in the window's coordinate system.
      */
@@ -155,6 +163,7 @@ open class View(): Responder {
      * This view's parent view. If `null`, this view is a top-level view in the [Window].
      */
     var superview: View? = null
+
     // _subviews is the internal, mutable object since we only want it to be mutated by the add/removeSubview methods
     private val _subviews = LinkedList<View>()
     private var subviewsSortedByZIndex: List<View> = listOf()
@@ -181,6 +190,7 @@ open class View(): Responder {
                     AxisPosition.CENTER -> centerXAnchor
                     AxisPosition.TRAILING -> rightAnchor
                 }
+
             Axis.VERTICAL ->
                 when (position) {
                     AxisPosition.LEADING -> topAnchor
@@ -240,7 +250,11 @@ open class View(): Responder {
                 for (b in a + 1 until variables.size) {
                     // if the variable views have no common ancestor after the removed view's superview is unset,
                     // the constraint crossed the this<->view boundary and should be removed
-					val ancestor = LowestCommonAncestor.find(variables[a].viewOrLayoutGuideView, variables[b].viewOrLayoutGuideView, View::superview)
+                    val ancestor = LowestCommonAncestor.find(
+                        variables[a].viewOrLayoutGuideView,
+                        variables[b].viewOrLayoutGuideView,
+                        View::superview
+                    )
                     if (ancestor == null) {
                         return@filter true
                     }
@@ -350,7 +364,12 @@ open class View(): Responder {
         if (usesConstraintBasedLayout) {
             val superviewLeft = superview?.leftAnchor?.value ?: 0.0
             val superviewTop = superview?.topAnchor?.value ?: 0.0
-			frame = Rect(leftAnchor.value - superviewLeft, topAnchor.value - superviewTop, widthAnchor.value, heightAnchor.value)
+            frame = Rect(
+                leftAnchor.value - superviewLeft,
+                topAnchor.value - superviewTop,
+                widthAnchor.value,
+                heightAnchor.value
+            )
             bounds = Rect(0.0, 0.0, widthAnchor.value, heightAnchor.value)
         }
 

src/main/kotlin/net/shadowfacts/cacao/view/button/AbstractButton.kt

@@ -51,6 +51,7 @@ abstract class AbstractButton<Impl: AbstractButton<Impl>>(val content: View, val
             field = value
             value?.also(::addBackground)
         }
+
     /**
      * The background to draw when the button is hovered over by the mouse.
      * If `null`, the normal [background] will be used.
@@ -62,6 +63,7 @@ abstract class AbstractButton<Impl: AbstractButton<Impl>>(val content: View, val
             field = value
             value?.also(::addBackground)
         }
+
     /**
      * The background to draw when the button is [disabled].
      * If `null`, the normal [background] will be used.

src/main/kotlin/net/shadowfacts/cacao/view/button/DropdownButton.kt

@@ -159,7 +159,12 @@ private class DropdownItemBackgroundView(
     override val topRight by topRightDelegate
 
     private val bottomLeftDelegate = ResettableLazyProperty {
-		Rect(topLeft.left, bounds.height - ninePatch.cornerHeight, topLeft.width, if (last) ninePatch.cornerHeight.toDouble() else 0.0)
+        Rect(
+            topLeft.left,
+            bounds.height - ninePatch.cornerHeight,
+            topLeft.width,
+            if (last) ninePatch.cornerHeight.toDouble() else 0.0
+        )
     }
     override val bottomLeft by bottomLeftDelegate
 
@@ -180,7 +185,12 @@ private class DropdownItemBackgroundView(
     override val bottomMiddle by bottomMiddleDelegate
 
     private val leftMiddleDelegate = ResettableLazyProperty {
-		Rect(topLeft.left, topLeft.bottom, topLeft.width, bounds.height - (if (first && last) 2 else if (first || last) 1 else 0) * ninePatch.cornerHeight)
+        Rect(
+            topLeft.left,
+            topLeft.bottom,
+            topLeft.width,
+            bounds.height - (if (first && last) 2 else if (first || last) 1 else 0) * ninePatch.cornerHeight
+        )
     }
     override val leftMiddle by leftMiddleDelegate
 
@@ -195,7 +205,17 @@ private class DropdownItemBackgroundView(
     }
     override val center by centerDelegate
 
-	private val delegates = listOf(topLeftDelegate, topRightDelegate, bottomLeftDelegate, bottomRightDelegate, topMiddleDelegate, bottomMiddleDelegate, leftMiddleDelegate, rightMiddleDelegate, centerDelegate)
+    private val delegates = listOf(
+        topLeftDelegate,
+        topRightDelegate,
+        bottomLeftDelegate,
+        bottomRightDelegate,
+        topMiddleDelegate,
+        bottomMiddleDelegate,
+        leftMiddleDelegate,
+        rightMiddleDelegate,
+        centerDelegate
+    )
 
     override fun didLayout() {
         super.didLayout()

src/main/kotlin/net/shadowfacts/cacao/view/textfield/AbstractTextField.kt

@@ -166,7 +166,8 @@ abstract class AbstractTextField<Impl: AbstractTextField<Impl>>(
     }
 
     // todo: label for the TextFieldWidget?
-	private class ProxyWidget: TextFieldWidget(MinecraftClient.getInstance().textRenderer, 0, 0, 0, 0, LiteralText("")) {
+    private class ProxyWidget :
+        TextFieldWidget(MinecraftClient.getInstance().textRenderer, 0, 0, 0, 0, LiteralText("")) {
         // AbstractButtonWidget.height is protected
         fun setHeight(height: Int) {
             this.height = height

src/main/kotlin/net/shadowfacts/cacao/viewcontroller/TabViewController.kt

@@ -99,6 +99,7 @@ class TabViewController<T: TabViewController.Tab>(
     private lateinit var outerStack: StackView
     private lateinit var tabStack: StackView
     private lateinit var currentTabController: ViewController
+
     // todo: this shouldn't be public, use layout guides
     lateinit var tabVCContainer: View
         private set

src/main/kotlin/net/shadowfacts/cacao/viewcontroller/ViewController.kt

@@ -58,6 +58,7 @@ abstract class ViewController {
 
     // _children is the internal, mutable object since we only want it to be mutated by the embed/removeChild methods
     private var _children = LinkedList<ViewController>()
+
     /**
      * The list of all the child VCs of this view controller.
      * This list should never be mutated directly, only by the [embedChild]/[removeChild] methods.

src/main/kotlin/net/shadowfacts/cacao/window/Window.kt

@@ -48,30 +48,37 @@ open class Window(
      * Layout anchor for the left edge of this view in the window's coordinate system.
      */
     val leftAnchor = Variable("left")
+
     /**
      * Layout anchor for the right edge of this view in the window's coordinate system.
      */
     val rightAnchor = Variable("right")
+
     /**
      * Layout anchor for the top edge of this view in the window's coordinate system.
      */
     val topAnchor = Variable("top")
+
     /**
      * Layout anchor for the bottom edge of this view in the window's coordinate system.
      */
     val bottomAnchor = Variable("bottom")
+
     /**
      * Layout anchor for the width of this view in the window's coordinate system.
      */
     val widthAnchor = Variable("width")
+
     /**
      * Layout anchor for the height of this view in the window's coordinate system.
      */
     val heightAnchor = Variable("height")
+
     /**
      * Layout anchor for the center X position of this view in the window's coordinate system.
      */
     val centerXAnchor = Variable("centerX")
+
     /**
      * Layout anchor for the center Y position of this view in the window's coordinate system.
      */

src/main/kotlin/net/shadowfacts/kiwidsl/KiwiDSL.kt

@@ -17,7 +17,8 @@ class KiwiContext(val solver: Solver) {
     }
 
     fun ExpressionConvertible.equalTo(other: ExpressionConvertible, strength: Double): Constraint {
-		return Symbolics.equals(this.toExpression(), other.toExpression()).setStrength(strength).apply(solver::addConstraint)
+        return Symbolics.equals(this.toExpression(), other.toExpression()).setStrength(strength)
+            .apply(solver::addConstraint)
     }
 
     infix fun ExpressionConvertible.equalTo(constant: Number): Constraint {
@@ -25,7 +26,8 @@ class KiwiContext(val solver: Solver) {
     }
 
     fun ExpressionConvertible.equalTo(constant: Number, strength: Double): Constraint {
-		return Symbolics.equals(this.toExpression(), constant.toDouble()).setStrength(strength).apply(solver::addConstraint)
+        return Symbolics.equals(this.toExpression(), constant.toDouble()).setStrength(strength)
+            .apply(solver::addConstraint)
     }
 
     infix fun ExpressionConvertible.lessThanOrEqualTo(other: ExpressionConvertible): Constraint {
@@ -33,7 +35,8 @@ class KiwiContext(val solver: Solver) {
     }
 
     fun ExpressionConvertible.lessThanOrEqualTo(other: ExpressionConvertible, strength: Double): Constraint {
-		return Symbolics.lessThanOrEqualTo(this.toExpression(), other.toExpression()).setStrength(strength).apply(solver::addConstraint)
+        return Symbolics.lessThanOrEqualTo(this.toExpression(), other.toExpression()).setStrength(strength)
+            .apply(solver::addConstraint)
     }
 
     infix fun ExpressionConvertible.lessThanOrEqualTo(constant: Number): Constraint {
@@ -41,7 +44,8 @@ class KiwiContext(val solver: Solver) {
     }
 
     fun ExpressionConvertible.lessThanOrEqualTo(constant: Number, strength: Double): Constraint {
-		return Symbolics.lessThanOrEqualTo(this.toExpression(), constant.toDouble()).setStrength(strength).apply(solver::addConstraint)
+        return Symbolics.lessThanOrEqualTo(this.toExpression(), constant.toDouble()).setStrength(strength)
+            .apply(solver::addConstraint)
     }
 
     infix fun ExpressionConvertible.greaterThanOrEqualTo(other: ExpressionConvertible): Constraint {
@@ -49,7 +53,8 @@ class KiwiContext(val solver: Solver) {
     }
 
     fun ExpressionConvertible.greaterThanOrEqualTo(other: ExpressionConvertible, strength: Double): Constraint {
-		return Symbolics.greaterThanOrEqualTo(this.toExpression(), other.toExpression()).setStrength(strength).apply(solver::addConstraint)
+        return Symbolics.greaterThanOrEqualTo(this.toExpression(), other.toExpression()).setStrength(strength)
+            .apply(solver::addConstraint)
     }
 
     infix fun ExpressionConvertible.greaterThanOrEqualTo(constant: Number): Constraint {
@@ -57,7 +62,8 @@ class KiwiContext(val solver: Solver) {
     }
 
     fun ExpressionConvertible.greaterThanOrEqualTo(constant: Number, strength: Double): Constraint {
-		return Symbolics.greaterThanOrEqualTo(this.toExpression(), constant.toDouble()).setStrength(strength).apply(solver::addConstraint)
+        return Symbolics.greaterThanOrEqualTo(this.toExpression(), constant.toDouble()).setStrength(strength)
+            .apply(solver::addConstraint)
     }
 
     // Addition

src/main/kotlin/net/shadowfacts/phycon/DefaultPlugin.kt

@@ -15,7 +15,8 @@ object DefaultPlugin: PhyConPlugin {
         private set
 
     override fun initializePhyCon(api: PhyConAPI) {
-		SORT_MODE = api.registerTerminalSetting(Identifier(PhysicalConnectivity.MODID, "sort"), SortMode.COUNT_HIGH_FIRST)
+        SORT_MODE =
+            api.registerTerminalSetting(Identifier(PhysicalConnectivity.MODID, "sort"), SortMode.COUNT_HIGH_FIRST)
         SORT_MODE.setPriority(Int.MAX_VALUE)
     }
 

src/main/kotlin/net/shadowfacts/phycon/PhyConAPIImpl.kt

@@ -11,7 +11,10 @@ import net.shadowfacts.phycon.util.TerminalSettings
  */
 object PhyConAPIImpl : PhyConAPI {
 
-	override fun <E> registerTerminalSetting(id: Identifier, defaultValue: E): TerminalSettingKey<E> where E: Enum<E>, E: TerminalSetting? {
+    override fun <E> registerTerminalSetting(
+        id: Identifier,
+        defaultValue: E
+    ): TerminalSettingKey<E> where E : Enum<E>, E : TerminalSetting? {
         return TerminalSettings.register(id, defaultValue)
     }
 

src/main/kotlin/net/shadowfacts/phycon/PhysicalConnectivity.kt

@@ -33,7 +33,10 @@ object PhysicalConnectivity: ModInitializer {
         registerGlobalReceiver(C2STerminalRequestItem)
         registerGlobalReceiver(C2STerminalUpdateDisplayedItems)
 
-		ItemStorage.SIDED.registerForBlockEntity(P2PReceiverBlockEntity::provideItemStorage, PhyBlockEntities.P2P_RECEIVER)
+        ItemStorage.SIDED.registerForBlockEntity(
+            P2PReceiverBlockEntity::provideItemStorage,
+            PhyBlockEntities.P2P_RECEIVER
+        )
 
         for (it in FabricLoader.getInstance().getEntrypoints("phycon", PhyConPlugin::class.java)) {
             it.initializePhyCon(PhyConAPIImpl)

src/main/kotlin/net/shadowfacts/phycon/block/DeviceBlock.kt

@@ -15,11 +15,21 @@ import net.shadowfacts.phycon.api.NetworkComponentBlock
 /**
  * @author shadowfacts
  */
-abstract class DeviceBlock<T: DeviceBlockEntity>(settings: Settings): BlockWithEntity<T>(settings), NetworkComponentBlock {
+abstract class DeviceBlock<T : DeviceBlockEntity>(settings: Settings) : BlockWithEntity<T>(settings),
+    NetworkComponentBlock {
 
-	abstract override fun getNetworkConnectedSides(state: BlockState, world: WorldAccess, pos: BlockPos): Collection<Direction>
+    abstract override fun getNetworkConnectedSides(
+        state: BlockState,
+        world: WorldAccess,
+        pos: BlockPos
+    ): Collection<Direction>
 
-	override fun getNetworkInterfaceForSide(side: Direction, state: BlockState, world: WorldAccess, pos: BlockPos): Interface? {
+    override fun getNetworkInterfaceForSide(
+        side: Direction,
+        state: BlockState,
+        world: WorldAccess,
+        pos: BlockPos
+    ): Interface? {
         return getBlockEntity(world, pos)!!
     }
 
@@ -28,7 +38,11 @@ abstract class DeviceBlock<T: DeviceBlockEntity>(settings: Settings): BlockWithE
         getBlockEntity(world, pos)!!.onBreak()
     }
 
-	override fun <T: BlockEntity> getTicker(world: World, state: BlockState, type: BlockEntityType<T>): BlockEntityTicker<T>? {
+    override fun <T : BlockEntity> getTicker(
+        world: World,
+        state: BlockState,
+        type: BlockEntityType<T>
+    ): BlockEntityTicker<T>? {
         return if (world.isClient) {
             null
         } else {

src/main/kotlin/net/shadowfacts/phycon/block/DeviceBlockEntity.kt

@@ -28,7 +28,8 @@ import java.util.*
 /**
  * @author shadowfacts
  */
-abstract class DeviceBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state: BlockState): BlockEntity(type, pos, state),
+abstract class DeviceBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state: BlockState) :
+    BlockEntity(type, pos, state),
     PacketSink,
     PacketSource,
     Interface {
@@ -60,6 +61,7 @@ abstract class DeviceBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state:
             is DeviceRemovedPacket -> {
                 arpTable.remove(packet.source)
             }
+
             is PingPacket -> {
                 sendPacket(PongPacket(ipAddress, packet.source))
             }
@@ -72,7 +74,14 @@ abstract class DeviceBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state:
     }
 
     override fun receive(frame: EthernetFrame) {
-		PhysicalConnectivity.NETWORK_LOGGER.debug("{} ({}, {}) received frame from {}: {}", this, ipAddress, macAddress, frame.source, frame)
+        PhysicalConnectivity.NETWORK_LOGGER.debug(
+            "{} ({}, {}) received frame from {}: {}",
+            this,
+            ipAddress,
+            macAddress,
+            frame.source,
+            frame
+        )
         when (frame) {
             is ARPQueryFrame -> handleARPQuery(frame)
             is ARPResponseFrame -> handleARPResponse(frame)
@@ -89,14 +98,26 @@ abstract class DeviceBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state:
         PhysicalConnectivity.NETWORK_LOGGER.debug("{}, ({}), received ARP query for {}", this, ipAddress, frame.queryIP)
         arpTable[frame.sourceIP] = frame.source
         if (frame.queryIP == ipAddress) {
-			PhysicalConnectivity.NETWORK_LOGGER.debug("{} ({}) sending ARP response to {} with {}", this, ipAddress, frame.sourceIP, macAddress)
+            PhysicalConnectivity.NETWORK_LOGGER.debug(
+                "{} ({}) sending ARP response to {} with {}",
+                this,
+                ipAddress,
+                frame.sourceIP,
+                macAddress
+            )
             send(ARPResponseFrame(ipAddress, macAddress, frame.source))
         }
     }
 
     private fun handleARPResponse(frame: ARPResponseFrame) {
         arpTable[frame.query] = frame.source
-		PhysicalConnectivity.NETWORK_LOGGER.debug("{}, ({}) received ARP response for {} with {}", this, ipAddress, frame.query, frame.source)
+        PhysicalConnectivity.NETWORK_LOGGER.debug(
+            "{}, ({}) received ARP response for {} with {}",
+            this,
+            ipAddress,
+            frame.query,
+            frame.source
+        )
 
         val toRemove = packetQueue.filter { (packet, _) ->
             if (packet.destination == frame.query) {
@@ -122,7 +143,12 @@ abstract class DeviceBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state:
         } else {
             packetQueue.add(PendingPacket(packet, counter))
 
-			PhysicalConnectivity.NETWORK_LOGGER.debug("{} ({}) sending ARP query for {}", this, ipAddress, packet.destination)
+            PhysicalConnectivity.NETWORK_LOGGER.debug(
+                "{} ({}) sending ARP query for {}",
+                this,
+                ipAddress,
+                packet.destination
+            )
             send(ARPQueryFrame(packet.destination, ipAddress, macAddress))
         }
     }
@@ -141,6 +167,7 @@ abstract class DeviceBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state:
                     this.cachedDestination = WeakReference(it)
                 }
             }
+
             else -> throw RuntimeException("DeviceBlockEntity.findDestination must be overridden by devices which have more than 1 network connected side")
         }
     }

src/main/kotlin/net/shadowfacts/phycon/block/FaceDeviceBlock.kt

@@ -82,7 +82,11 @@ abstract class FaceDeviceBlock<T: DeviceBlockEntity>(settings: Settings): Device
             if (cableConnection == FaceCableConnection.NONE) {
                 VoxelShapes.union(faceShapes[facing], centerShapes[facing])
             } else {
-				VoxelShapes.union(faceShapes[facing], centerShapes[facing], CableBlock.SIDE_SHAPES[cableConnection.direction])
+                VoxelShapes.union(
+                    faceShapes[facing],
+                    centerShapes[facing],
+                    CableBlock.SIDE_SHAPES[cableConnection.direction]
+                )
             }
         }
     }
@@ -92,7 +96,12 @@ abstract class FaceDeviceBlock<T: DeviceBlockEntity>(settings: Settings): Device
         return if (direction != null) EnumSet.of(direction) else setOf()
     }
 
-	override fun getNetworkInterfaceForSide(side: Direction, state: BlockState, world: WorldAccess, pos: BlockPos): Interface? {
+    override fun getNetworkInterfaceForSide(
+        side: Direction,
+        state: BlockState,
+        world: WorldAccess,
+        pos: BlockPos
+    ): Interface? {
         return if (side == state[FACING]) {
             null
         } else {
@@ -108,15 +117,22 @@ abstract class FaceDeviceBlock<T: DeviceBlockEntity>(settings: Settings): Device
     }
 
     override fun getPlacementState(context: ItemPlacementContext): BlockState {
-		val facing = if (context.player?.isSneaking == true) context.side.opposite else context.playerLookDirection.opposite
+        val facing =
+            if (context.player?.isSneaking == true) context.side.opposite else context.playerLookDirection.opposite
         // todo: this should never be called
-		val cableConnection = FaceCableConnection.from(getCableConnectedSide(context.world, context.blockPos, facing, DyeColor.BLUE))
+        val cableConnection =
+            FaceCableConnection.from(getCableConnectedSide(context.world, context.blockPos, facing, DyeColor.BLUE))
         return defaultState
             .with(FACING, facing)
             .with(CABLE_CONNECTION, cableConnection)
     }
 
-	private fun getCableConnectedSide(world: WorldAccess, pos: BlockPos, facing: Direction, color: DyeColor): Direction? {
+    private fun getCableConnectedSide(
+        world: WorldAccess,
+        pos: BlockPos,
+        facing: Direction,
+        color: DyeColor
+    ): Direction? {
         for (side in Direction.values()) {
             if (side == facing) {
                 continue
@@ -130,18 +146,32 @@ abstract class FaceDeviceBlock<T: DeviceBlockEntity>(settings: Settings): Device
         return null
     }
 
-	private fun canConnectTo(world: WorldAccess, side: Direction, candidateState: BlockState, candidatePos: BlockPos, myColor: DyeColor): Boolean {
+    private fun canConnectTo(
+        world: WorldAccess,
+        side: Direction,
+        candidateState: BlockState,
+        candidatePos: BlockPos,
+        myColor: DyeColor
+    ): Boolean {
         val block = candidateState.block
         return if (block is FaceDeviceBlock<*> && candidateState[COLOR] == myColor) {
             true
         } else if (block is CableBlock && block.color == myColor) {
             true
         } else {
-			block is NetworkComponentBlock && block.getNetworkConnectedSides(candidateState, world, candidatePos).contains(side.opposite)
+            block is NetworkComponentBlock && block.getNetworkConnectedSides(candidateState, world, candidatePos)
+                .contains(side.opposite)
         }
     }
 
-	override fun getStateForNeighborUpdate(state: BlockState, side: Direction, neighborState: BlockState, world: WorldAccess, pos: BlockPos, neighborPos: BlockPos): BlockState {
+    override fun getStateForNeighborUpdate(
+        state: BlockState,
+        side: Direction,
+        neighborState: BlockState,
+        world: WorldAccess,
+        pos: BlockPos,
+        neighborPos: BlockPos
+    ): BlockState {
         val current = state[CABLE_CONNECTION]
         var newConnection = current
 
@@ -159,7 +189,12 @@ abstract class FaceDeviceBlock<T: DeviceBlockEntity>(settings: Settings): Device
         return state.with(CABLE_CONNECTION, newConnection)
     }
 
-	override fun getOutlineShape(state: BlockState, world: BlockView, pos: BlockPos, context: ShapeContext): VoxelShape {
+    override fun getOutlineShape(
+        state: BlockState,
+        world: BlockView,
+        pos: BlockPos,
+        context: ShapeContext
+    ): VoxelShape {
         return getShape(state[FACING], state[CABLE_CONNECTION])
     }
 

src/main/kotlin/net/shadowfacts/phycon/block/cable/CableBlock.kt

@@ -63,7 +63,8 @@ class CableBlock(
                 VoxelShapes.union(acc, SIDE_SHAPES[side])
             }
         }
-		val CONNECTIONS: Map<Direction, EnumProperty<CableConnection>> = Direction.values().associate { it to EnumProperty.of(it.name.toLowerCase(), CableConnection::class.java) }
+        val CONNECTIONS: Map<Direction, EnumProperty<CableConnection>> =
+            Direction.values().associate { it to EnumProperty.of(it.name.toLowerCase(), CableConnection::class.java) }
 
         fun getShape(state: BlockState): VoxelShape {
             val key = Direction.values().foldIndexed(0) { i, acc, dir ->
@@ -110,7 +111,14 @@ class CableBlock(
         return getInitialState(context.world, context.blockPos)
     }
 
-	override fun getStateForNeighborUpdate(state: BlockState, side: Direction, neighborState: BlockState, world: WorldAccess, blockPos_1: BlockPos, blockPos_2: BlockPos): BlockState {
+    override fun getStateForNeighborUpdate(
+        state: BlockState,
+        side: Direction,
+        neighborState: BlockState,
+        world: WorldAccess,
+        blockPos_1: BlockPos,
+        blockPos_2: BlockPos
+    ): BlockState {
         val prop = CONNECTIONS[side]
         val current = state[prop]
         return when (current) {
@@ -119,7 +127,11 @@ class CableBlock(
         }
     }
 
-	private fun getConnectionStateInDirection(world: WorldAccess, pos: BlockPos, direction: Direction): CableConnection {
+    private fun getConnectionStateInDirection(
+        world: WorldAccess,
+        pos: BlockPos,
+        direction: Direction
+    ): CableConnection {
         val offsetPos = pos.offset(direction)
         val state = world.getBlockState(offsetPos)
         val block = state.block
@@ -140,7 +152,12 @@ class CableBlock(
         }
     }
 
-	override fun getNetworkInterfaceForSide(side: Direction, state: BlockState, world: WorldAccess, pos: BlockPos): Interface? {
+    override fun getNetworkInterfaceForSide(
+        side: Direction,
+        state: BlockState,
+        world: WorldAccess,
+        pos: BlockPos
+    ): Interface? {
         // cables don't have network interfaces
         return null
     }
@@ -169,11 +186,18 @@ class CableBlock(
                         val connectedToPos = pos.offset(side)
                         val connectedTo = world.getBlockState(connectedToPos)
                         if (connectedTo.block == this && connectedTo[CONNECTIONS[side.opposite]] == CableConnection.DISABLED) {
-							world.setBlockState(connectedToPos, connectedTo.with(CONNECTIONS[side.opposite], CableConnection.ON))
+                            world.setBlockState(
+                                connectedToPos,
+                                connectedTo.with(CONNECTIONS[side.opposite], CableConnection.ON)
+                            )
                         }
 
-						state.with(prop, if (connectedTo.block is NetworkComponentBlock) CableConnection.ON else CableConnection.OFF)
+                        state.with(
+                            prop,
+                            if (connectedTo.block is NetworkComponentBlock) CableConnection.ON else CableConnection.OFF
+                        )
                     }
+
                     else -> state.with(prop, CableConnection.DISABLED)
                 }
                 world.setBlockState(pos, newState)
@@ -195,7 +219,12 @@ class CableBlock(
 //		return false
 //	}
 
-	override fun getOutlineShape(state: BlockState, world: BlockView, pos: BlockPos, context: ShapeContext): VoxelShape {
+    override fun getOutlineShape(
+        state: BlockState,
+        world: BlockView,
+        pos: BlockPos,
+        context: ShapeContext
+    ): VoxelShape {
         return getShape(state)
     }
 

src/main/kotlin/net/shadowfacts/phycon/block/extractor/ExtractorBlock.kt

@@ -59,7 +59,14 @@ class ExtractorBlock: FaceDeviceBlock<ExtractorBlockEntity>(
                             arr[i] = 16.0 - arr[i]
                         }
                     }
-					createCuboidShape(min(arr[0], arr[3]), min(arr[1], arr[4]), min(arr[2], arr[5]), max(arr[0], arr[3]), max(arr[1], arr[4]), max(arr[2], arr[5]))
+                    createCuboidShape(
+                        min(arr[0], arr[3]),
+                        min(arr[1], arr[4]),
+                        min(arr[2], arr[5]),
+                        max(arr[0], arr[3]),
+                        max(arr[1], arr[4]),
+                        max(arr[2], arr[5])
+                    )
                 }
                 EXTRACTOR_SHAPES[dir] = shapes.reduce { a, b -> VoxelShapes.union(a, b) }
             }
@@ -77,7 +84,14 @@ class ExtractorBlock: FaceDeviceBlock<ExtractorBlockEntity>(
         }
     }
 
-	override fun neighborUpdate(state: BlockState, world: World, pos: BlockPos, neighbor: Block, neighborPos: BlockPos, bl: Boolean) {
+    override fun neighborUpdate(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        neighbor: Block,
+        neighborPos: BlockPos,
+        bl: Boolean
+    ) {
         if (!world.isClient) {
             getBlockEntity(world, pos)!!.updateInventory()
         }

src/main/kotlin/net/shadowfacts/phycon/block/extractor/ExtractorBlockEntity.kt

@@ -28,7 +28,8 @@ import kotlin.properties.Delegates
 /**
  * @author shadowfacts
  */
-class ExtractorBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyBlockEntities.EXTRACTOR, pos, state),
+class ExtractorBlockEntity(pos: BlockPos, state: BlockState) :
+    DeviceBlockEntity(PhyBlockEntities.EXTRACTOR, pos, state),
     NetworkStackDispatcher<ExtractorBlockEntity.PendingInsertion>,
     ActivationController.ActivatableDevice,
     ClientConfigurableDevice {
@@ -75,7 +76,13 @@ class ExtractorBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(
         val inventory = getInventory() ?: return insertion.stack
         // if the inventory has changed, the old slot index is meaningless
         if (inventory !== insertion.inventory) return insertion.stack
-		val extracted = inventory.extractStack(insertion.inventorySlot, ExactItemStackFilter(insertion.stack), ItemStack.EMPTY, insertion.totalCapacity, Simulation.ACTION)
+        val extracted = inventory.extractStack(
+            insertion.inventorySlot,
+            ExactItemStackFilter(insertion.stack),
+            ItemStack.EMPTY,
+            insertion.totalCapacity,
+            Simulation.ACTION
+        )
         if (extracted.isEmpty) return insertion.stack
         // if we extracted less than expected, make sure super.finishInsertion doesn't send more than we actually have
         insertion.stack = extracted
@@ -97,7 +104,13 @@ class ExtractorBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(
         for (slot in 0 until inventory.slotCount) {
             val slotStack = inventory.getInvStack(slot)
             if (slotStack.isEmpty) continue
-			val extractable = inventory.extractStack(slot, ExactItemStackFilter(slotStack), ItemStack.EMPTY, slotStack.count, Simulation.SIMULATE)
+            val extractable = inventory.extractStack(
+                slot,
+                ExactItemStackFilter(slotStack),
+                ItemStack.EMPTY,
+                slotStack.count,
+                Simulation.SIMULATE
+            )
             if (extractable.isEmpty) continue
             dispatchItemStack(extractable) { insertion ->
                 insertion.inventory = inventory
@@ -126,7 +139,8 @@ class ExtractorBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(
         controller.activationMode = ActivationMode.valueOf(tag.getString("ActivationMode"))
     }
 
-	class PendingInsertion(stack: ItemStack, timestamp: Long): NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
+    class PendingInsertion(stack: ItemStack, timestamp: Long) :
+        NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
         lateinit var inventory: FixedItemInv
         var inventorySlot by Delegates.notNull<Int>()
     }

src/main/kotlin/net/shadowfacts/phycon/block/inserter/InserterBlock.kt

@@ -68,7 +68,14 @@ class InserterBlock: FaceDeviceBlock<InserterBlockEntity>(
                             arr[i] = 16.0 - arr[i]
                         }
                     }
-					createCuboidShape(min(arr[0], arr[3]), min(arr[1], arr[4]), min(arr[2], arr[5]), max(arr[0], arr[3]), max(arr[1], arr[4]), max(arr[2], arr[5]))
+                    createCuboidShape(
+                        min(arr[0], arr[3]),
+                        min(arr[1], arr[4]),
+                        min(arr[2], arr[5]),
+                        max(arr[0], arr[3]),
+                        max(arr[1], arr[4]),
+                        max(arr[2], arr[5])
+                    )
                 }
                 INSERTER_SHAPES[dir] = shapes.reduce { a, b -> VoxelShapes.union(a, b) }
             }
@@ -86,13 +93,27 @@ class InserterBlock: FaceDeviceBlock<InserterBlockEntity>(
         }
     }
 
-	override fun neighborUpdate(state: BlockState, world: World, pos: BlockPos, neighborBlock: Block, neighborPos: BlockPos, bl: Boolean) {
+    override fun neighborUpdate(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        neighborBlock: Block,
+        neighborPos: BlockPos,
+        bl: Boolean
+    ) {
         if (!world.isClient) {
             getBlockEntity(world, pos)!!.updateInventory()
         }
     }
 
-	override fun onUse(state: BlockState, world: World, pos: BlockPos, player: PlayerEntity, hand: Hand, hitResult: BlockHitResult): ActionResult {
+    override fun onUse(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        player: PlayerEntity,
+        hand: Hand,
+        hitResult: BlockHitResult
+    ): ActionResult {
         if (!world.isClient) {
             val be = getBlockEntity(world, pos)!!
 

src/main/kotlin/net/shadowfacts/phycon/block/inserter/InserterBlockEntity.kt

@@ -46,7 +46,9 @@ class InserterBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(P
     var stackToExtract: ItemStack = ItemStack.EMPTY
     override var ghostSlotStack: ItemStack
         get() = stackToExtract
-		set(value) { stackToExtract = value }
+        set(value) {
+            stackToExtract = value
+        }
     var amountToExtract = 1
     override val controller = ActivationController(SLEEP_TIME, this)
 

src/main/kotlin/net/shadowfacts/phycon/block/miner/MinerBlock.kt

@@ -38,7 +38,12 @@ class MinerBlock: DeviceBlock<MinerBlockEntity>(
         return EnumSet.of(state[FACING].opposite)
     }
 
-	override fun getNetworkInterfaceForSide(side: Direction, state: BlockState, world: WorldAccess, pos: BlockPos): Interface? {
+    override fun getNetworkInterfaceForSide(
+        side: Direction,
+        state: BlockState,
+        world: WorldAccess,
+        pos: BlockPos
+    ): Interface? {
         return if (side == state[FACING]) {
             null
         } else {
@@ -64,7 +69,14 @@ class MinerBlock: DeviceBlock<MinerBlockEntity>(
         }
     }
 
-	override fun neighborUpdate(state: BlockState, world: World, pos: BlockPos, neighbor: Block, neighborPos: BlockPos, bl: Boolean) {
+    override fun neighborUpdate(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        neighbor: Block,
+        neighborPos: BlockPos,
+        bl: Boolean
+    ) {
         if (!world.isClient) {
 //			getBlockEntity(world, pos)!!.updateBlockToMine()
         }

src/main/kotlin/net/shadowfacts/phycon/block/miner/MinerBlockEntity.kt

@@ -234,7 +234,8 @@ class MinerBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyB
         }
     }
 
-	class PendingInsertion(stack: ItemStack, timestamp: Long): NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
+    class PendingInsertion(stack: ItemStack, timestamp: Long) :
+        NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
     }
 
 }

src/main/kotlin/net/shadowfacts/phycon/block/netinterface/InterfaceBlock.kt

@@ -48,7 +48,14 @@ class InterfaceBlock: FaceDeviceBlock<InterfaceBlockEntity>(
         }
     }
 
-	override fun neighborUpdate(state: BlockState, world: World, pos: BlockPos, neighborBlock: Block, neighborPos: BlockPos, boolean_1: Boolean) {
+    override fun neighborUpdate(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        neighborBlock: Block,
+        neighborPos: BlockPos,
+        boolean_1: Boolean
+    ) {
         if (!world.isClient) {
             getBlockEntity(world, pos)!!.updateInventory()
         }

src/main/kotlin/net/shadowfacts/phycon/block/netinterface/InterfaceBlockEntity.kt

@@ -25,7 +25,8 @@ import kotlin.math.min
 /**
  * @author shadowfacts
  */
-class InterfaceBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyBlockEntities.INTERFACE, pos, state),
+class InterfaceBlockEntity(pos: BlockPos, state: BlockState) :
+    DeviceBlockEntity(PhyBlockEntities.INTERFACE, pos, state),
     ItemStackPacketHandler,
     NetworkStackProvider,
     NetworkStackReceiver,

src/main/kotlin/net/shadowfacts/phycon/block/netswitch/SwitchBlock.kt

@@ -39,13 +39,22 @@ class SwitchBlock: BlockWithEntity<SwitchBlockEntity>(
         return EnumSet.allOf(Direction::class.java)
     }
 
-	override fun getNetworkInterfaceForSide(side: Direction, state: BlockState, world: WorldAccess, pos: BlockPos): Interface? {
+    override fun getNetworkInterfaceForSide(
+        side: Direction,
+        state: BlockState,
+        world: WorldAccess,
+        pos: BlockPos
+    ): Interface? {
         return getBlockEntity(world, pos)?.interfaces?.find { it.side == side }
     }
 
     override fun createBlockEntity(pos: BlockPos, state: BlockState) = SwitchBlockEntity(pos, state)
 
-	override fun <T: BlockEntity> getTicker(world: World, state: BlockState, type: BlockEntityType<T>): BlockEntityTicker<T>? {
+    override fun <T : BlockEntity> getTicker(
+        world: World,
+        state: BlockState,
+        type: BlockEntityType<T>
+    ): BlockEntityTicker<T>? {
         return if (world.isClient) {
             null
         } else {

src/main/kotlin/net/shadowfacts/phycon/block/netswitch/SwitchBlockEntity.kt

@@ -69,7 +69,14 @@ class SwitchBlockEntity(pos: BlockPos, state: BlockState): BlockEntity(PhyBlockE
     private fun resend(frame: EthernetFrame, fromItf: SwitchInterface) {
         if (frame.destination.type != MACAddress.Type.BROADCAST && macTable.containsKey(frame.destination)) {
             val dir = macTable[frame.destination]!!
-			PhysicalConnectivity.NETWORK_LOGGER.debug("{} ({}, {}) forwarding {} to side {}", this, fromItf.side, fromItf.macAddress, frame, dir)
+            PhysicalConnectivity.NETWORK_LOGGER.debug(
+                "{} ({}, {}) forwarding {} to side {}",
+                this,
+                fromItf.side,
+                fromItf.macAddress,
+                frame,
+                dir
+            )
             interfaceForSide(dir).send(frame)
         } else {
             flood(frame, fromItf)
@@ -77,7 +84,13 @@ class SwitchBlockEntity(pos: BlockPos, state: BlockState): BlockEntity(PhyBlockE
     }
 
     private fun flood(frame: EthernetFrame, source: SwitchInterface) {
-		PhysicalConnectivity.NETWORK_LOGGER.debug("{} ({}, {}) flooding {}", this, source.side, source.macAddress, frame)
+        PhysicalConnectivity.NETWORK_LOGGER.debug(
+            "{} ({}, {}) flooding {}",
+            this,
+            source.side,
+            source.macAddress,
+            frame
+        )
         for (itf in interfaces) {
             if (source == itf) continue
             itf.send(frame)

src/main/kotlin/net/shadowfacts/phycon/block/netswitch/SwitchConsoleScreen.kt

@@ -73,7 +73,13 @@ class SwitchPacketStatisticsView(val switch: SwitchBlockEntity): View() {
             return
         }
         // TODO: drawLine isn't working for some reason
-        RenderHelper.drawLine(Point(bounds.left, bounds.top), Point(bounds.right, bounds.bottom), 1.0, 2f, Color.MAGENTA)
+        RenderHelper.drawLine(
+            Point(bounds.left, bounds.top),
+            Point(bounds.right, bounds.bottom),
+            1.0,
+            2f,
+            Color.MAGENTA
+        )
         return
         val maxPackets = switch.packetStatistics.maxOf { it }
         val maxDataPointsCount = 60

src/main/kotlin/net/shadowfacts/phycon/block/p2p/P2PInterfaceBlockEntity.kt

@@ -15,7 +15,8 @@ import net.shadowfacts.phycon.packet.RequestInventoryPacket
 /**
  * @author shadowfacts
  */
-class P2PInterfaceBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyBlockEntities.P2P_INTERFACE, pos, state) {
+class P2PInterfaceBlockEntity(pos: BlockPos, state: BlockState) :
+    DeviceBlockEntity(PhyBlockEntities.P2P_INTERFACE, pos, state) {
 
     private var inventory: Storage<ItemVariant>? = null
 

src/main/kotlin/net/shadowfacts/phycon/block/p2p/P2PReceiverBlockEntity.kt

@@ -21,7 +21,8 @@ import java.lang.ref.WeakReference
 /**
  * @author shadowfacts
  */
-class P2PReceiverBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyBlockEntities.P2P_RECEIVER, pos, state),
+class P2PReceiverBlockEntity(pos: BlockPos, state: BlockState) :
+    DeviceBlockEntity(PhyBlockEntities.P2P_RECEIVER, pos, state),
     ClientConfigurableDevice {
 
     enum class Status {

src/main/kotlin/net/shadowfacts/phycon/block/redstone_controller/RedstoneControllerBlock.kt

@@ -51,7 +51,14 @@ class RedstoneControllerBlock: FaceDeviceBlock<RedstoneControllerBlockEntity>(
         return state.with(POWERED, isPowered(context.world, context.blockPos, state[FACING]))
     }
 
-	override fun neighborUpdate(state: BlockState, world: World, pos: BlockPos, neighborBlock: Block, neighborPos: BlockPos, bl: Boolean) {
+    override fun neighborUpdate(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        neighborBlock: Block,
+        neighborPos: BlockPos,
+        bl: Boolean
+    ) {
         // this can't be done in getStateForNeighborUpdate because getEmittedRedstonePower is defined in World not WorldAccess
         if (!world.isClient) {
             val wasLit = state[POWERED]

src/main/kotlin/net/shadowfacts/phycon/block/redstone_controller/RedstoneControllerBlockEntity.kt

@@ -14,7 +14,8 @@ import net.shadowfacts.phycon.util.RedstoneMode
 /**
  * @author shadowfacts
  */
-class RedstoneControllerBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyBlockEntities.REDSTONE_CONTROLLER, pos, state),
+class RedstoneControllerBlockEntity(pos: BlockPos, state: BlockState) :
+    DeviceBlockEntity(PhyBlockEntities.REDSTONE_CONTROLLER, pos, state),
     ClientConfigurableDevice {
 
     var managedDevices = Array<IPAddress?>(5) { null }

src/main/kotlin/net/shadowfacts/phycon/block/redstone_emitter/RedstoneEmitterBlock.kt

@@ -51,7 +51,12 @@ class RedstoneEmitterBlock: FaceDeviceBlock<RedstoneEmitterBlockEntity>(
         return true
     }
 
-	override fun getStrongRedstonePower(state: BlockState, world: BlockView, pos: BlockPos, receivingSide: Direction): Int {
+    override fun getStrongRedstonePower(
+        state: BlockState,
+        world: BlockView,
+        pos: BlockPos,
+        receivingSide: Direction
+    ): Int {
         return if (receivingSide.opposite == state[FACING]) {
             getBlockEntity(world, pos)!!.cachedEmittedPower
         } else {
@@ -59,11 +64,23 @@ class RedstoneEmitterBlock: FaceDeviceBlock<RedstoneEmitterBlockEntity>(
         }
     }
 
-	override fun getWeakRedstonePower(state: BlockState, world: BlockView, pos: BlockPos, receivingSide: Direction): Int {
+    override fun getWeakRedstonePower(
+        state: BlockState,
+        world: BlockView,
+        pos: BlockPos,
+        receivingSide: Direction
+    ): Int {
         return getStrongRedstonePower(state, world, pos, receivingSide)
     }
 
-	override fun onUse(state: BlockState, world: World, pos: BlockPos, player: PlayerEntity, hand: Hand, result: BlockHitResult): ActionResult {
+    override fun onUse(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        player: PlayerEntity,
+        hand: Hand,
+        result: BlockHitResult
+    ): ActionResult {
         if (!world.isClient) {
             val be = getBlockEntity(world, pos)!!
 

src/main/kotlin/net/shadowfacts/phycon/block/redstone_emitter/RedstoneEmitterBlockEntity.kt

@@ -21,7 +21,8 @@ import kotlin.math.round
 /**
  * @author shadowfacts
  */
-class RedstoneEmitterBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockEntity(PhyBlockEntities.REDSTONE_EMITTER, pos, state),
+class RedstoneEmitterBlockEntity(pos: BlockPos, state: BlockState) :
+    DeviceBlockEntity(PhyBlockEntities.REDSTONE_EMITTER, pos, state),
     ClientConfigurableDevice,
     GhostInv {
 
@@ -32,7 +33,9 @@ class RedstoneEmitterBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockE
     var stackToMonitor: ItemStack = ItemStack.EMPTY
     override var ghostSlotStack: ItemStack
         get() = stackToMonitor
-		set(value) { stackToMonitor = value }
+        set(value) {
+            stackToMonitor = value
+        }
     var maxAmount = 64
     var mode = Mode.ANALOG
         set(value) {
@@ -91,6 +94,7 @@ class RedstoneEmitterBlockEntity(pos: BlockPos, state: BlockState): DeviceBlockE
                 } else {
                     1 + round(networkAmount / maxAmount.toDouble() * 14).toInt()
                 }
+
                 Mode.DIGITAL -> if (networkAmount >= maxAmount) 15 else 0
             }
 

src/main/kotlin/net/shadowfacts/phycon/block/redstone_emitter/RedstoneEmitterScreen.kt

@@ -90,7 +90,12 @@ class RedstoneEmitterScreen(
             view.addSubview(hStack)
 
             val zeroStack = hStack.addArrangedSubview(StackView(Axis.VERTICAL))
-			zeroStack.addArrangedSubview(Label(TranslatableText("gui.phycon.emitter.count", 0), textAlignment = Label.TextAlignment.CENTER)).apply {
+            zeroStack.addArrangedSubview(
+                Label(
+                    TranslatableText("gui.phycon.emitter.count", 0),
+                    textAlignment = Label.TextAlignment.CENTER
+                )
+            ).apply {
                 textColor = Color.TEXT
             }
             zeroStack.addArrangedSubview(View())

src/main/kotlin/net/shadowfacts/phycon/block/terminal/AbstractTerminalBlock.kt

@@ -55,7 +55,14 @@ abstract class AbstractTerminalBlock<T: AbstractTerminalBlockEntity>: DeviceBloc
         return defaultState.with(FACING, context.playerLookDirection.opposite)
     }
 
-	override fun onUse(state: BlockState, world: World, pos: BlockPos, player: PlayerEntity, hand: Hand, hitResult: BlockHitResult): ActionResult {
+    override fun onUse(
+        state: BlockState,
+        world: World,
+        pos: BlockPos,
+        player: PlayerEntity,
+        hand: Hand,
+        hitResult: BlockHitResult
+    ): ActionResult {
         getBlockEntity(world, pos)!!.onActivate(player)
         return ActionResult.SUCCESS
     }

src/main/kotlin/net/shadowfacts/phycon/block/terminal/AbstractTerminalBlockEntity.kt

@@ -30,7 +30,8 @@ import kotlin.properties.Delegates
 /**
  * @author shadowfacts
  */
-abstract class AbstractTerminalBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state: BlockState): DeviceBlockEntity(type, pos, state),
+abstract class AbstractTerminalBlockEntity(type: BlockEntityType<*>, pos: BlockPos, state: BlockState) :
+    DeviceBlockEntity(type, pos, state),
     InventoryChangedListener,
     ItemStackPacketHandler,
     NetworkStackDispatcher<AbstractTerminalBlockEntity.PendingInsertion> {
@@ -259,7 +260,8 @@ abstract class AbstractTerminalBlockEntity(type: BlockEntityType<*>, pos: BlockP
         fun netItemsChanged()
     }
 
-	class PendingInsertion(stack: ItemStack, timestamp: Long): NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
+    class PendingInsertion(stack: ItemStack, timestamp: Long) :
+        NetworkStackDispatcher.PendingInsertion<PendingInsertion>(stack, timestamp) {
         var bufferSlot by Delegates.notNull<Int>()
     }
 

src/main/kotlin/net/shadowfacts/phycon/block/terminal/AbstractTerminalScreen.kt

@@ -80,7 +80,13 @@ abstract class AbstractTerminalScreen<BE: AbstractTerminalBlockEntity, T: Abstra
 
     fun requestUpdatedItems() {
         val player = MinecraftClient.getInstance().player!!
-		player.networkHandler.sendPacket(C2STerminalUpdateDisplayedItems(handler.terminal, searchQuery, scrollPosition.toFloat()))
+        player.networkHandler.sendPacket(
+            C2STerminalUpdateDisplayedItems(
+                handler.terminal,
+                searchQuery,
+                scrollPosition.toFloat()
+            )
+        )
     }
 
     private fun showRequestAmountDialog(stack: ItemStack) {
@@ -115,10 +121,12 @@ abstract class AbstractTerminalScreen<BE: AbstractTerminalBlockEntity, T: Abstra
                 val format = if (amount < 10_000) DECIMAL_FORMAT else FORMAT
                 format.format(amount / 1_000.0) + "K"
             }
+
             amount < 1_000_000_000 -> {
                 val format = if (amount < 10_000_000) DECIMAL_FORMAT else FORMAT
                 format.format(amount / 1_000_000.0) + "M"
             }
+
             else -> {
                 DECIMAL_FORMAT.format(amount / 1000000000.0).toString() + "B"
             }
@@ -136,7 +144,18 @@ abstract class AbstractTerminalScreen<BE: AbstractTerminalBlockEntity, T: Abstra
         val immediate = VertexConsumerProvider.immediate(Tessellator.getInstance().buffer)
         val textX = (1 / scale * 18) - textRenderer.getWidth(s).toFloat() - 3
         val textY = (1 / scale * 18) - 11
-		textRenderer.draw(s, textX, textY, 0xffffff, true, matrixStack.peek().positionMatrix, immediate, false, 0, 0xF000F0)
+        textRenderer.draw(
+            s,
+            textX,
+            textY,
+            0xffffff,
+            true,
+            matrixStack.peek().positionMatrix,
+            immediate,
+            false,
+            0,
+            0xF000F0
+        )
         RenderSystem.enableDepthTest()
         immediate.draw()
     }

src/main/kotlin/net/shadowfacts/phycon/block/terminal/AbstractTerminalScreenHandler.kt

@@ -125,7 +125,16 @@ abstract class AbstractTerminalScreenHandler<T: AbstractTerminalBlockEntity>(
 
 //		itemEntries = sorted.map { Entry(it.key, it.intValue) }
 
-		(player as ServerPlayerEntity).networkHandler.sendPacket(S2CTerminalUpdateDisplayedItems(terminal, itemEntries, searchQuery, settings, scrollPosition, totalEntries))
+        (player as ServerPlayerEntity).networkHandler.sendPacket(
+            S2CTerminalUpdateDisplayedItems(
+                terminal,
+                itemEntries,
+                searchQuery,
+                settings,
+                scrollPosition,
+                totalEntries
+            )
+        )
     }
 
     fun totalRows(): Int {
@@ -144,7 +153,12 @@ abstract class AbstractTerminalScreenHandler<T: AbstractTerminalBlockEntity>(
         return currentScrollOffsetInRows() * 9
     }
 
-	fun sendUpdatedItemsToClient(player: ServerPlayerEntity, query: String, settings: TerminalSettings, scrollPosition: Float) {
+    fun sendUpdatedItemsToClient(
+        player: ServerPlayerEntity,
+        query: String,
+        settings: TerminalSettings,
+        scrollPosition: Float
+    ) {
         this.searchQuery = query
         this.settings = settings
         this.scrollPosition = scrollPosition
@@ -175,7 +189,8 @@ abstract class AbstractTerminalScreenHandler<T: AbstractTerminalBlockEntity>(
             // todo: why does this think it's quick_craft sometimes?
             if ((actionType == SlotActionType.PICKUP || actionType == SlotActionType.QUICK_CRAFT) && !cursorStack.isEmpty) {
                 // placing cursor stack into buffer
-				val bufferSlot = slotId - bufferSlotsStart // subtract 54 to convert the handler slot ID to a valid buffer index
+                val bufferSlot =
+                    slotId - bufferSlotsStart // subtract 54 to convert the handler slot ID to a valid buffer index
                 terminal.internalBuffer.markSlot(bufferSlot, TerminalBufferInventory.Mode.TO_NETWORK)
             }
         }
@@ -203,8 +218,16 @@ abstract class AbstractTerminalScreenHandler<T: AbstractTerminalBlockEntity>(
                 terminal.internalBuffer.markSlot(slotId - bufferSlotsStart, TerminalBufferInventory.Mode.UNASSIGNED)
             }
         } else if (isPlayerSlot(slotId)) {
-			val slotsInsertedInto = tryInsertItem(slot.stack, bufferSlotsStart until playerSlotsStart) { terminal.internalBuffer.getMode(it - bufferSlotsStart) != TerminalBufferInventory.Mode.FROM_NETWORK }
+            val slotsInsertedInto = tryInsertItem(
-			slotsInsertedInto.forEach { terminal.internalBuffer.markSlot(it - bufferSlotsStart, TerminalBufferInventory.Mode.TO_NETWORK) }
+                slot.stack,
+                bufferSlotsStart until playerSlotsStart
+            ) { terminal.internalBuffer.getMode(it - bufferSlotsStart) != TerminalBufferInventory.Mode.FROM_NETWORK }
+            slotsInsertedInto.forEach {
+                terminal.internalBuffer.markSlot(
+                    it - bufferSlotsStart,
+                    TerminalBufferInventory.Mode.TO_NETWORK
+                )
+            }
             if (slotsInsertedInto.isEmpty()) {
                 return ItemStack.EMPTY
             }

src/main/kotlin/net/shadowfacts/phycon/block/terminal/CraftingTerminalBlockEntity.kt

@@ -26,7 +26,8 @@ import kotlin.math.min
 /**
  * @author shadowfacts
  */
-class CraftingTerminalBlockEntity(pos: BlockPos, state: BlockState): AbstractTerminalBlockEntity(PhyBlockEntities.CRAFTING_TERMINAL, pos, state) {
+class CraftingTerminalBlockEntity(pos: BlockPos, state: BlockState) :
+    AbstractTerminalBlockEntity(PhyBlockEntities.CRAFTING_TERMINAL, pos, state) {
 
     val craftingInv = SimpleInventory(9)
 
@@ -80,7 +81,8 @@ class CraftingTerminalBlockEntity(pos: BlockPos, state: BlockState): AbstractTer
     }
 
     override fun doHandleItemStack(packet: ItemStackPacket): ItemStack {
-		val craftingReq = completedCraftingStackRequests.find { ItemStackUtil.areEqualIgnoreAmounts(it.stack, packet.stack) }
+        val craftingReq =
+            completedCraftingStackRequests.find { ItemStackUtil.areEqualIgnoreAmounts(it.stack, packet.stack) }
         if (craftingReq != null) {
             var remaining = packet.stack.copy()
 
@@ -89,7 +91,8 @@ class CraftingTerminalBlockEntity(pos: BlockPos, state: BlockState): AbstractTer
                 if (currentStack.count >= currentStack.maxCount) continue
                 if (!ItemStackUtil.areEqualIgnoreAmounts(currentStack, remaining)) continue
 
-				val toInsert = minOf(remaining.count, currentStack.maxCount - currentStack.count, craftingReq.amountPerSlot[i])
+                val toInsert =
+                    minOf(remaining.count, currentStack.maxCount - currentStack.count, craftingReq.amountPerSlot[i])
                 currentStack.count += toInsert
                 remaining.count -= toInsert
                 craftingReq.amountPerSlot[i] -= toInsert

src/main/kotlin/net/shadowfacts/phycon/block/terminal/CraftingTerminalScreenHandler.kt

@@ -23,7 +23,12 @@ class CraftingTerminalScreenHandler(
     syncId: Int,
     playerInv: PlayerInventory,
     terminal: CraftingTerminalBlockEntity,
-): AbstractTerminalScreenHandler<CraftingTerminalBlockEntity>(PhyScreens.CRAFTING_TERMINAL, syncId, playerInv, terminal) {
+) : AbstractTerminalScreenHandler<CraftingTerminalBlockEntity>(
+    PhyScreens.CRAFTING_TERMINAL,
+    syncId,
+    playerInv,
+    terminal
+) {
 
     val craftingInv = CraftingInv(this)
     val result = CraftingResultInventory()
@@ -73,7 +78,14 @@ class CraftingTerminalScreenHandler(
                     ItemStack.EMPTY
                 }
             result.setStack(0, resultStack)
-			player.networkHandler.sendPacket(ScreenHandlerSlotUpdateS2CPacket(syncId, nextRevision(), resultSlot.id, resultStack))
+            player.networkHandler.sendPacket(
+                ScreenHandlerSlotUpdateS2CPacket(
+                    syncId,
+                    nextRevision(),
+                    resultSlot.id,
+                    resultStack
+                )
+            )
         }
     }
 

src/main/kotlin/net/shadowfacts/phycon/block/terminal/CraftingTerminalViewController.kt

@@ -84,7 +84,12 @@ class CraftingTerminalViewController(
     }
 
     private fun clearPressed(button: Button) {
-		MinecraftClient.getInstance().player!!.networkHandler.sendPacket(C2STerminalCraftingButton(terminal, C2STerminalCraftingButton.Action.CLEAR_GRID))
+        MinecraftClient.getInstance().player!!.networkHandler.sendPacket(
+            C2STerminalCraftingButton(
+                terminal,
+                C2STerminalCraftingButton.Action.CLEAR_GRID
+            )
+        )
     }
 
     private fun plusPressed(button: Button) {

src/main/kotlin/net/shadowfacts/phycon/block/terminal/TerminalBlockEntity.kt

@@ -15,7 +15,8 @@ import net.shadowfacts.phycon.packet.RequestInventoryPacket
 /**
  * @author shadowfacts
  */
-class TerminalBlockEntity(pos: BlockPos, state: BlockState): AbstractTerminalBlockEntity(PhyBlockEntities.TERMINAL, pos, state) {
+class TerminalBlockEntity(pos: BlockPos, state: BlockState) :
+    AbstractTerminalBlockEntity(PhyBlockEntities.TERMINAL, pos, state) {
 
     override fun onActivate(player: PlayerEntity) {
         super.onActivate(player)

src/main/kotlin/net/shadowfacts/phycon/block/terminal/TerminalRequestAmountViewController.kt

@@ -24,7 +24,8 @@ class TerminalRequestAmountViewController(
 ) : ViewController() {
 
     companion object {
-		private val BACKGROUND = Texture(Identifier(PhysicalConnectivity.MODID, "textures/gui/terminal_amount.png"), 0, 0)
+        private val BACKGROUND =
+            Texture(Identifier(PhysicalConnectivity.MODID, "textures/gui/terminal_amount.png"), 0, 0)
     }
 
     lateinit var field: NumberField

src/main/kotlin/net/shadowfacts/phycon/client/model/ColoredCableModel.kt

@@ -86,7 +86,12 @@ class ColoredCableModel(
         rotationContainer: ModelBakeSettings,
         modelId: Identifier
     ): BakedModel {
-		centerSprite = textureGetter.apply(SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, Identifier(PhysicalConnectivity.MODID, "block/cable/${color.getName()}/straight")))
+        centerSprite = textureGetter.apply(
+            SpriteIdentifier(
+                PlayerScreenHandler.BLOCK_ATLAS_TEXTURE,
+                Identifier(PhysicalConnectivity.MODID, "block/cable/${color.getName()}/straight")
+            )
+        )
 
         sideRotations.forEach { (side, rot) ->
             this.side[side.ordinal] = loader.bakeRecoloredCable(SIDE, rot, textureGetter, color)

src/main/kotlin/net/shadowfacts/phycon/client/model/FaceDeviceModel.kt

@@ -23,6 +23,7 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
     private val interfaceCableCornerID = Identifier(PhysicalConnectivity.MODID, "block/interface_cable_corner")
     private val interfaceCableCorner2ID = Identifier(PhysicalConnectivity.MODID, "block/interface_cable_corner_2")
     private val interfaceCableCapID = Identifier(PhysicalConnectivity.MODID, "block/interface_cable_cap")
+
     //	private var interfaceCableStraight = Array<BakedModel?>(6) { null }
 //	private var interfaceCableCap = Array<BakedModel?>(6) { null }
 //	private var interfaceCableCorner = mutableMapOf<ModelRotation, BakedModel>()
@@ -65,7 +66,8 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
             for (tex in depTextures) {
                 if (tex.textureId.namespace == PhysicalConnectivity.MODID && tex.textureId.path.startsWith("block/cable/color/")) {
                     for (color in DyeColor.values()) {
-						val newPath = tex.textureId.path.replace("block/cable/color/", "block/cable/${color.getName()}/")
+                        val newPath =
+                            tex.textureId.path.replace("block/cable/color/", "block/cable/${color.getName()}/")
                         val substituted = SpriteIdentifier(tex.atlasId, Identifier(PhysicalConnectivity.MODID, newPath))
                         textures.add(substituted)
                     }
@@ -77,7 +79,12 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
         return textures
     }
 
-	override fun bake(loader: ModelLoader, textureGetter: Function<SpriteIdentifier, Sprite>, rotationContainer: ModelBakeSettings, modelId: Identifier): BakedModel {
+    override fun bake(
+        loader: ModelLoader,
+        textureGetter: Function<SpriteIdentifier, Sprite>,
+        rotationContainer: ModelBakeSettings,
+        modelId: Identifier
+    ): BakedModel {
         bakeSideModels(loader, textureGetter)
 
         DyeColor.values().forEach { color ->
@@ -132,6 +139,7 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
                     FaceCableConnection.WEST -> interfaceCableCorner[color]!![ModelRotation.X0_Y270]
                     else -> null
                 }
+
                 Direction.UP -> when (connection) {
                     FaceCableConnection.NORTH -> interfaceCableCorner[color]!![ModelRotation.X180_Y180]
                     FaceCableConnection.EAST -> interfaceCableCorner[color]!![ModelRotation.X180_Y270]
@@ -139,6 +147,7 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
                     FaceCableConnection.WEST -> interfaceCableCorner[color]!![ModelRotation.X180_Y90]
                     else -> null
                 }
+
                 Direction.NORTH -> when (connection) {
                     FaceCableConnection.UP -> interfaceCableCorner[color]!![ModelRotation.X270_Y0]
                     FaceCableConnection.EAST -> interfaceCableCorner2[color]!![ModelRotation.X180_Y180]
@@ -146,6 +155,7 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
                     FaceCableConnection.WEST -> interfaceCableCorner2[color]!![ModelRotation.X0_Y0]
                     else -> null
                 }
+
                 Direction.SOUTH -> when (connection) {
                     FaceCableConnection.UP -> interfaceCableCorner[color]!![ModelRotation.X270_Y180]
                     FaceCableConnection.WEST -> interfaceCableCorner2[color]!![ModelRotation.X180_Y0]
@@ -153,6 +163,7 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
                     FaceCableConnection.EAST -> interfaceCableCorner2[color]!![ModelRotation.X0_Y180]
                     else -> null
                 }
+
                 Direction.WEST -> when (connection) {
                     FaceCableConnection.UP -> interfaceCableCorner[color]!![ModelRotation.X270_Y270]
                     FaceCableConnection.NORTH -> interfaceCableCorner2[color]!![ModelRotation.X180_Y90]
@@ -160,6 +171,7 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
                     FaceCableConnection.SOUTH -> interfaceCableCorner2[color]!![ModelRotation.X0_Y270]
                     else -> null
                 }
+
                 Direction.EAST -> when (connection) {
                     FaceCableConnection.UP -> interfaceCableCorner[color]!![ModelRotation.X270_Y90]
                     FaceCableConnection.SOUTH -> interfaceCableCorner2[color]!![ModelRotation.X180_Y270]
@@ -167,6 +179,7 @@ abstract class FaceDeviceModel: UnbakedModel, BakedModel {
                     FaceCableConnection.NORTH -> interfaceCableCorner2[color]!![ModelRotation.X0_Y90]
                     else -> null
                 }
+
                 else -> null
             }
             model?.getQuads(state, face, random) ?: listOf()

src/main/kotlin/net/shadowfacts/phycon/client/model/ScreenDeviceModel.kt

@@ -33,7 +33,10 @@ class ScreenDeviceModel(
 ) : UnbakedModel, BakedModel, FabricBakedModel {
 
     companion object {
-		private val CASING = SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, Identifier(PhysicalConnectivity.MODID, "block/casing"))
+        private val CASING = SpriteIdentifier(
+            PlayerScreenHandler.BLOCK_ATLAS_TEXTURE,
+            Identifier(PhysicalConnectivity.MODID, "block/casing")
+        )
     }
 
     private val screenTexture = SpriteIdentifier(PlayerScreenHandler.BLOCK_ATLAS_TEXTURE, screenTexture)

src/main/kotlin/net/shadowfacts/phycon/client/screen/console/DeviceConsoleScreen.kt

@@ -40,65 +40,79 @@ class DeviceConsoleScreen(
             )
         )
         if (device is ActivationController.ActivatableDevice) {
-			tabs.add(TabViewController.SimpleTab(
+            tabs.add(
+                TabViewController.SimpleTab(
                     TextureView(Texture(Identifier("textures/item/ender_pearl.png"), 0, 0, 16, 16)).apply {
                         intrinsicContentSize = Size(16.0, 16.0)
                     },
                     TranslatableText("gui.phycon.console.remote"),
                     ActivatableDeviceViewController(device),
                     device::canConfigureActivationController
-			))
+                )
+            )
         }
         if (device is RedstoneControllerBlockEntity) {
-			tabs.add(TabViewController.SimpleTab(
+            tabs.add(
+                TabViewController.SimpleTab(
                     TextureView(Texture(Identifier("textures/block/redstone_torch.png"), 0, 0, 16, 16)).apply {
                         intrinsicContentSize = Size(16.0, 16.0)
                     },
                     TranslatableText("block.phycon.redstone_controller"),
                     RedstoneControllerViewController(device)
-			))
+                )
+            )
         }
         if (device is MinerBlockEntity) {
-			tabs.add(TabViewController.SimpleTab(
+            tabs.add(
+                TabViewController.SimpleTab(
                     TextureView(Texture(Identifier("textures/item/diamond_pickaxe.png"), 0, 0, 16, 16)).apply {
                         intrinsicContentSize = Size(16.0, 16.0)
                     },
                     TranslatableText("block.phycon.miner"),
                     MinerViewController(device)
-			))
+                )
+            )
         }
         if (device is NetworkStackProvider) {
-			tabs.add(TabViewController.SimpleTab(
+            tabs.add(
+                TabViewController.SimpleTab(
                     Label("P").apply { textColor = Color.TEXT },
                     TranslatableText("gui.phycon.console.provider"),
                     ProviderViewController(device),
                     device::canConfigureProviderPriority
-			))
+                )
+            )
         }
         if (device is NetworkStackReceiver) {
-			tabs.add(TabViewController.SimpleTab(
+            tabs.add(
+                TabViewController.SimpleTab(
                     Label("R").apply { textColor = Color.TEXT },
                     TranslatableText("gui.phycon.console.receiver"),
                     ReceiverViewController(device),
-			))
+                )
+            )
         }
         if (device is RedstoneEmitterBlockEntity) {
-			tabs.add(TabViewController.SimpleTab(
+            tabs.add(
+                TabViewController.SimpleTab(
                     TextureView(Texture(Identifier("textures/item/redstone.png"), 0, 0, 16, 16)).apply {
                         intrinsicContentSize = Size(16.0, 16.0)
                     },
                     TranslatableText("block.phycon.redstone_emitter"),
                     RedstoneEmitterViewController(device)
-			))
+                )
+            )
         }
         if (device is P2PReceiverBlockEntity) {
-			tabs.add(TabViewController.SimpleTab(
+            tabs.add(
+                TabViewController.SimpleTab(
                     TextureView(Texture(Identifier("textures/item/ender_pearl.png"), 0, 0, 16, 16)).apply {
                         intrinsicContentSize = Size(16.0, 16.0)
                     },
                     TranslatableText("block.phycon.p2p_receiver"),
                     P2PReceiverViewController(device)
-			))
+                )
+            )
         }
 
         tabController = TabViewController(tabs)

src/main/kotlin/net/shadowfacts/phycon/component/NetworkStackDispatcher.kt

@@ -13,7 +13,8 @@ import kotlin.math.min
 /**
  * @author shadowfacts
  */
-interface NetworkStackDispatcher<Insertion: NetworkStackDispatcher.PendingInsertion<Insertion>>: ItemStackPacketHandler {
+interface NetworkStackDispatcher<Insertion : NetworkStackDispatcher.PendingInsertion<Insertion>> :
+    ItemStackPacketHandler {
 
     val counter: Long
     val dispatchStackTimeout: Long

src/main/kotlin/net/shadowfacts/phycon/item/FaceDeviceBlockItem.kt

@@ -14,14 +14,18 @@ import kotlin.math.roundToInt
 /**
  * @author shadowfacts
  */
-class FaceDeviceBlockItem(block: FaceDeviceBlock<*>, settings: Settings = Settings()): DeviceBlockItem(block, settings) {
+class FaceDeviceBlockItem(block: FaceDeviceBlock<*>, settings: Settings = Settings()) :
+    DeviceBlockItem(block, settings) {
 
     override fun getPlacementState(context: ItemPlacementContext): BlockState? {
         val hitState = context.world.getBlockState(context.blockPos)
         val hitBlock = hitState.block
         if (hitBlock is CableBlock) {
             val hitBlockEdge = context.hitPos.getComponentAlongAxis(context.side.axis) % 1 == 0.0
-			val hitBlockBeingPlacedIn = floor(context.hitPos.getComponentAlongAxis(context.side.axis)).toInt() == context.blockPos.getComponentAlongAxis(context.side.axis)
+            val hitBlockBeingPlacedIn =
+                floor(context.hitPos.getComponentAlongAxis(context.side.axis)).toInt() == context.blockPos.getComponentAlongAxis(
+                    context.side.axis
+                )
 
             val placementSide: Direction =
                 if (hitBlockEdge xor hitBlockBeingPlacedIn) {

src/main/kotlin/net/shadowfacts/phycon/item/ScrewdriverItem.kt

@@ -42,14 +42,25 @@ class ScrewdriverItem: Item(Settings().maxCount(1)) {
 
         if (newState != null) {
             context.world.setBlockState(context.blockPos, newState)
-			context.world.playSound(context.player, context.blockPos, SoundEvents.BLOCK_METAL_PLACE, SoundCategory.BLOCKS, 0.8f, 0.65f)
+            context.world.playSound(
+                context.player,
+                context.blockPos,
+                SoundEvents.BLOCK_METAL_PLACE,
+                SoundCategory.BLOCKS,
+                0.8f,
+                0.65f
+            )
             return ActionResult.SUCCESS
         } else {
             return ActionResult.PASS
         }
     }
 
-	private fun screwdriverDeviceBlock(context: ItemUsageContext, state: BlockState, block: DeviceBlock<*>): BlockState? {
+    private fun screwdriverDeviceBlock(
+        context: ItemUsageContext,
+        state: BlockState,
+        block: DeviceBlock<*>
+    ): BlockState? {
         if (!context.world.isClient) {
             val be = block.getBlockEntity(context.world, context.blockPos)!!
 
@@ -66,7 +77,13 @@ class ScrewdriverItem: Item(Settings().maxCount(1)) {
                 beTag.remove("InternalBuffer")
             }
 
-			val entity = ItemEntity(context.world, context.blockPos.x.toDouble(), context.blockPos.y.toDouble(), context.blockPos.z.toDouble(), stack)
+            val entity = ItemEntity(
+                context.world,
+                context.blockPos.x.toDouble(),
+                context.blockPos.y.toDouble(),
+                context.blockPos.z.toDouble(),
+                stack
+            )
             context.world.spawnEntity(entity)
         }
 
@@ -77,8 +94,16 @@ class ScrewdriverItem: Item(Settings().maxCount(1)) {
         }
     }
 
-	private fun screwdriverFaceDeviceBlock(context: ItemUsageContext, state: BlockState, block: FaceDeviceBlock<*>): BlockState? {
+    private fun screwdriverFaceDeviceBlock(
-		val hitInsideBlock = Vec3d(context.hitPos.x - context.blockPos.x, context.hitPos.y - context.blockPos.y, context.hitPos.z - context.blockPos.z)
+        context: ItemUsageContext,
+        state: BlockState,
+        block: FaceDeviceBlock<*>
+    ): BlockState? {
+        val hitInsideBlock = Vec3d(
+            context.hitPos.x - context.blockPos.x,
+            context.hitPos.y - context.blockPos.y,
+            context.hitPos.z - context.blockPos.z
+        )
         val faceShape = block.faceShapes[state[FaceDeviceBlock.FACING]]!!
         // if we hit the face part of block, leave the cable behind
         if (faceShape.boundingBox.containsInclusive(hitInsideBlock)) {
@@ -86,7 +111,13 @@ class ScrewdriverItem: Item(Settings().maxCount(1)) {
             return cableBlock.getInitialState(context.world, context.blockPos)
         } else {
             if (!context.world.isClient) {
-				val cable = ItemEntity(context.world, context.blockPos.x.toDouble(), context.blockPos.y.toDouble(), context.blockPos.z.toDouble(), ItemStack(state.block))
+                val cable = ItemEntity(
+                    context.world,
+                    context.blockPos.x.toDouble(),
+                    context.blockPos.y.toDouble(),
+                    context.blockPos.z.toDouble(),
+                    ItemStack(state.block)
+                )
                 context.world.spawnEntity(cable)
             }
             return Blocks.AIR.defaultState
@@ -95,7 +126,13 @@ class ScrewdriverItem: Item(Settings().maxCount(1)) {
 
     private fun screwdriverCableBlock(context: ItemUsageContext, state: BlockState): BlockState? {
         if (!context.world.isClient) {
-			val entity = ItemEntity(context.world, context.blockPos.x.toDouble(), context.blockPos.y.toDouble(), context.blockPos.z.toDouble(), ItemStack(state.block))
+            val entity = ItemEntity(
+                context.world,
+                context.blockPos.x.toDouble(),
+                context.blockPos.y.toDouble(),
+                context.blockPos.z.toDouble(),
+                ItemStack(state.block)
+            )
             context.world.spawnEntity(entity)
         }
         return Blocks.AIR.defaultState
@@ -103,7 +140,13 @@ class ScrewdriverItem: Item(Settings().maxCount(1)) {
 
     private fun screwdriverSwitchBlock(context: ItemUsageContext): BlockState? {
         if (!context.world.isClient) {
-			val entity = ItemEntity(context.world, context.blockPos.x.toDouble(), context.blockPos.y.toDouble(), context.blockPos.z.toDouble(), ItemStack(PhyBlocks.SWITCH))
+            val entity = ItemEntity(
+                context.world,
+                context.blockPos.x.toDouble(),
+                context.blockPos.y.toDouble(),
+                context.blockPos.z.toDouble(),
+                ItemStack(PhyBlocks.SWITCH)
+            )
             context.world.spawnEntity(entity)
         }
         return Blocks.AIR.defaultState

src/main/kotlin/net/shadowfacts/phycon/networking/C2SConfigureDevice.kt

@@ -31,7 +31,13 @@ object C2SConfigureDevice: ServerReceiver {
         return createPacket(buf)
     }
 
-	override fun receive(server: MinecraftServer, player: ServerPlayerEntity, handler: ServerPlayNetworkHandler, buf: PacketByteBuf, responseSender: PacketSender) {
+    override fun receive(
+        server: MinecraftServer,
+        player: ServerPlayerEntity,
+        handler: ServerPlayNetworkHandler,
+        buf: PacketByteBuf,
+        responseSender: PacketSender
+    ) {
         val dimID = buf.readIdentifier()
         val pos = buf.readBlockPos()
         val tag = buf.readNbt() ?: return

src/main/kotlin/net/shadowfacts/phycon/networking/C2STerminalCraftingButton.kt

@@ -36,7 +36,13 @@ object C2STerminalCraftingButton: ServerReceiver {
         return createPacket(buf)
     }
 
-	override fun receive(server: MinecraftServer, player: ServerPlayerEntity, handler: ServerPlayNetworkHandler, buf: PacketByteBuf, responseSender: PacketSender) {
+    override fun receive(
+        server: MinecraftServer,
+        player: ServerPlayerEntity,
+        handler: ServerPlayNetworkHandler,
+        buf: PacketByteBuf,
+        responseSender: PacketSender
+    ) {
         val dimID = buf.readIdentifier()
         val pos = buf.readBlockPos()
         val action = Action.values()[buf.readByte().toInt()]

src/main/kotlin/net/shadowfacts/phycon/networking/C2STerminalRequestItem.kt

@@ -38,7 +38,13 @@ object C2STerminalRequestItem: ServerReceiver {
         return ClientPlayNetworking.createC2SPacket(CHANNEL, buf)
     }
 
-	override fun receive(server: MinecraftServer, player: ServerPlayerEntity, handler: ServerPlayNetworkHandler, buf: PacketByteBuf, responseSender: PacketSender) {
+    override fun receive(
+        server: MinecraftServer,
+        player: ServerPlayerEntity,
+        handler: ServerPlayNetworkHandler,
+        buf: PacketByteBuf,
+        responseSender: PacketSender
+    ) {
         val dimID = buf.readIdentifier()
         val pos = buf.readBlockPos()
         val stack = buf.readItemStackWithoutCount()

src/main/kotlin/net/shadowfacts/phycon/networking/C2STerminalUpdateDisplayedItems.kt

@@ -35,7 +35,13 @@ object C2STerminalUpdateDisplayedItems: ServerReceiver {
         return ClientPlayNetworking.createC2SPacket(CHANNEL, buf)
     }
 
-	override fun receive(server: MinecraftServer, player: ServerPlayerEntity, handler: ServerPlayNetworkHandler, buf: PacketByteBuf, responseSender: PacketSender) {
+    override fun receive(
+        server: MinecraftServer,
+        player: ServerPlayerEntity,
+        handler: ServerPlayNetworkHandler,
+        buf: PacketByteBuf,
+        responseSender: PacketSender
+    ) {
         val dimID = buf.readIdentifier()
         val pos = buf.readBlockPos()
         val query = buf.readString()

src/main/kotlin/net/shadowfacts/phycon/networking/S2CTerminalUpdateDisplayedItems.kt

@@ -20,7 +20,14 @@ import net.shadowfacts.phycon.util.writeItemStackWithoutCount
 object S2CTerminalUpdateDisplayedItems : ClientReceiver {
     override val CHANNEL = C2STerminalUpdateDisplayedItems.CHANNEL
 
-	operator fun invoke(terminal: AbstractTerminalBlockEntity, entries: List<AbstractTerminalScreenHandler.Entry>, query: String, settings: TerminalSettings, scrollPosition: Float, totalEntries: Int): Packet<*> {
+    operator fun invoke(
+        terminal: AbstractTerminalBlockEntity,
+        entries: List<AbstractTerminalScreenHandler.Entry>,
+        query: String,
+        settings: TerminalSettings,
+        scrollPosition: Float,
+        totalEntries: Int
+    ): Packet<*> {
         val buf = PacketByteBufs.create()
 
         buf.writeIdentifier(terminal.world!!.registryKey.value)
@@ -40,7 +47,12 @@ object S2CTerminalUpdateDisplayedItems: ClientReceiver {
         return ServerPlayNetworking.createS2CPacket(CHANNEL, buf)
     }
 
-	override fun receive(client: MinecraftClient, handler: ClientPlayNetworkHandler, buf: PacketByteBuf, responseSender: PacketSender) {
+    override fun receive(
+        client: MinecraftClient,
+        handler: ClientPlayNetworkHandler,
+        buf: PacketByteBuf,
+        responseSender: PacketSender
+    ) {
         val dimID = buf.readIdentifier()
         val pos = buf.readBlockPos()
         val entryCount = buf.readVarInt()

src/main/kotlin/net/shadowfacts/phycon/packet/CheckCapacityPacket.kt

@@ -6,5 +6,6 @@ import net.shadowfacts.phycon.api.util.IPAddress
 /**
  * @author shadowfacts
  */
-class CheckCapacityPacket(val stack: ItemStack, source: IPAddress, destination: IPAddress): BasePacket(source, destination) {
+class CheckCapacityPacket(val stack: ItemStack, source: IPAddress, destination: IPAddress) :
+    BasePacket(source, destination) {
 }

src/main/kotlin/net/shadowfacts/phycon/packet/DeviceRemovedPacket.kt

@@ -6,6 +6,7 @@ import net.shadowfacts.phycon.block.DeviceBlockEntity
 /**
  * @author shadowfacts
  */
-class DeviceRemovedPacket(source: IPAddress, destination: IPAddress = IPAddress.BROADCAST): BasePacket(source, destination) {
+class DeviceRemovedPacket(source: IPAddress, destination: IPAddress = IPAddress.BROADCAST) :
+    BasePacket(source, destination) {
     constructor(device: DeviceBlockEntity) : this(device.ipAddress)
 }

src/main/kotlin/net/shadowfacts/phycon/packet/ExtractStackPacket.kt

@@ -6,5 +6,6 @@ import net.shadowfacts.phycon.api.util.IPAddress
 /**
  * @author shadowfacts
  */
-class ExtractStackPacket(val stack: ItemStack, val amount: Int, source: IPAddress, destination: IPAddress): BasePacket(source, destination) {
+class ExtractStackPacket(val stack: ItemStack, val amount: Int, source: IPAddress, destination: IPAddress) :
+    BasePacket(source, destination) {
 }

src/main/kotlin/net/shadowfacts/phycon/packet/ItemStackPacket.kt

@@ -6,6 +6,7 @@ import net.shadowfacts.phycon.api.util.IPAddress
 /**
  * @author shadowfacts
  */
-class ItemStackPacket(val stack: ItemStack, val bounceCount: Int, source: IPAddress, destination: IPAddress): BasePacket(source, destination) {
+class ItemStackPacket(val stack: ItemStack, val bounceCount: Int, source: IPAddress, destination: IPAddress) :
+    BasePacket(source, destination) {
     constructor(stack: ItemStack, source: IPAddress, destination: IPAddress) : this(stack, 0, source, destination)
 }

src/main/kotlin/net/shadowfacts/phycon/packet/LocateStackPacket.kt

@@ -6,5 +6,6 @@ import net.shadowfacts.phycon.api.util.IPAddress
 /**
  * @author shadowfacts
  */
-class LocateStackPacket(val stack: ItemStack, source: IPAddress, destination: IPAddress = IPAddress.BROADCAST): BasePacket(source, destination) {
+class LocateStackPacket(val stack: ItemStack, source: IPAddress, destination: IPAddress = IPAddress.BROADCAST) :
+    BasePacket(source, destination) {
 }

src/main/kotlin/net/shadowfacts/phycon/packet/RemoteActivationPacket.kt

@@ -5,7 +5,8 @@ import net.shadowfacts.phycon.api.util.IPAddress
 /**
  * @author shadowfacts
  */
-class RemoteActivationPacket(val mode: Mode, source: IPAddress, destination: IPAddress): BasePacket(source, destination) {
+class RemoteActivationPacket(val mode: Mode, source: IPAddress, destination: IPAddress) :
+    BasePacket(source, destination) {
     enum class Mode {
         SINGLE,
         ENABLE,

src/main/kotlin/net/shadowfacts/phycon/util/NetworkUtil.kt

@@ -63,7 +63,13 @@ object NetworkUtil {
         return results
     }
 
-	private fun findEdges(queue: MutableList<BlockPos>, visited: Set<BlockPos>, world: World, pos: BlockPos, includeNonCables: Boolean = false) {
+    private fun findEdges(
+        queue: MutableList<BlockPos>,
+        visited: Set<BlockPos>,
+        world: World,
+        pos: BlockPos,
+        includeNonCables: Boolean = false
+    ) {
         val state = world.getBlockState(pos)
         val block = state.block
         if (block is NetworkComponentBlock && (includeNonCables || block is NetworkCableBlock)) {