refactor: Add Extendable Multiblock API & Port PCB Factory to new API

src/main/kotlin/gregtechlite/gtlitecore/api/capability/logic/ExtendableMultiblockRecipeLogic.kt

@@ -0,0 +1,25 @@
+package gregtechlite.gtlitecore.api.capability.logic
+
+import gregtech.api.capability.impl.MultiblockRecipeLogic
+import gregtech.api.recipes.Recipe
+import gregtechlite.gtlitecore.api.metatileentity.multiblock.extendable.AdditionalStructureManager
+import gregtechlite.gtlitecore.api.metatileentity.multiblock.extendable.RecipeMapExtendableMultiblock
+import gregtechlite.gtlitecore.api.recipe.property.RequestAdditionalProperty
+
+open class ExtendableMultiblockRecipeLogic<T: RecipeMapExtendableMultiblock<T>>(controller: RecipeMapExtendableMultiblock<T>,
+                                                                                protected val manager: AdditionalStructureManager<T>)
+    : MultiblockRecipeLogic(controller)
+{
+    override fun checkRecipe(recipe: Recipe): Boolean
+        = super.checkRecipe(recipe) && checkAdditionalRequirement(recipe)
+
+    override fun canProgressRecipe(): Boolean
+        = super.canProgressRecipe() && (previousRecipe?.let { checkAdditionalRequirement(it) } ?: true)
+
+    private fun checkAdditionalRequirement(recipe: Recipe): Boolean
+    {
+        if (!recipe.hasProperty(RequestAdditionalProperty)) return true
+        val requirement = recipe.getProperty(RequestAdditionalProperty, null) ?: return false
+        return requirement.additionalStructures.all { manager.get(it).isNotEmpty() }
+    }
+}

src/main/kotlin/gregtechlite/gtlitecore/api/metatileentity/multiblock/extendable/AdditionalMultiblockBase.kt

@@ -0,0 +1,161 @@
+@file:Suppress("UNCHECKED_CAST")
+package gregtechlite.gtlitecore.api.metatileentity.multiblock.extendable
+
+import codechicken.lib.render.CCRenderState
+import codechicken.lib.render.pipeline.IVertexOperation
+import codechicken.lib.vec.Matrix4
+import gregtech.api.capability.GregtechDataCodes.WORKING_ENABLED
+import gregtech.api.capability.IControllable
+import gregtech.api.capability.IDataStickIntractable
+import gregtech.api.metatileentity.multiblock.MultiblockWithDisplayBase
+import gregtech.api.metatileentity.multiblock.ui.MultiblockUIBuilder
+import gregtech.api.util.GTUtility
+import net.minecraft.entity.player.EntityPlayer
+import net.minecraft.item.ItemStack
+import net.minecraft.nbt.NBTTagCompound
+import net.minecraft.network.PacketBuffer
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+import net.minecraft.util.text.TextComponentTranslation
+
+abstract class AdditionalMultiblockBase<T : ExtendableMultiblock<T>>(metaTileEntityId: ResourceLocation)
+    : MultiblockWithDisplayBase(metaTileEntityId), IControllable, IDataStickIntractable
+{
+    @JvmField
+    protected var mainController: ExtendableMultiblock<T>? = null
+
+    @JvmField
+    protected var isWorkingEnabled: Boolean = false
+
+    private var snapshotControllerPos: BlockPos? = null
+
+    override fun hasMaintenanceMechanics() = false
+
+    override fun isWorkingEnabled() = isStructureFormed && isConnected()
+
+    override fun setWorkingEnabled(workingStatus: Boolean)
+    {
+        isWorkingEnabled = workingStatus
+        markDirty()
+        if (world != null && !world.isRemote)
+        {
+            writeCustomData(WORKING_ENABLED) { it.writeBoolean(isWorkingEnabled) }
+        }
+    }
+
+    protected fun isConnected(): Boolean
+    {
+        if (mainController != null) return mainController!!.isWorkingEnabled()
+        val pendingPos = snapshotControllerPos ?: return false
+        val mte = GTUtility.getMetaTileEntity(world, pendingPos)
+        if (mte is ExtendableMultiblock<*>)
+        {
+            connect(mte as ExtendableMultiblock<T>)
+            return mainController?.isWorkingEnabled() ?: false
+        }
+        return false
+    }
+
+    fun connect(controller: ExtendableMultiblock<T>?)
+    {
+        mainController?.removeAdditional(pos)
+        mainController = controller
+        mainController?.addAdditional(this)
+        snapshotControllerPos = null
+    }
+
+    override fun writeToNBT(data: NBTTagCompound): NBTTagCompound
+    {
+        super.writeToNBT(data)
+        data.setBoolean("isWorkingEnabled", isWorkingEnabled)
+        mainController?.let { controller ->
+            val mainPos = NBTTagCompound()
+            mainPos.setInteger("X", controller.controllerPos.x)
+            mainPos.setInteger("Y", controller.controllerPos.y)
+            mainPos.setInteger("Z", controller.controllerPos.z)
+            data.setTag("MainControllerPos", mainPos)
+        }
+        return data
+    }
+
+    override fun readFromNBT(data: NBTTagCompound)
+    {
+        super.readFromNBT(data)
+        setWorkingEnabled(data.getBoolean("isWorkingEnabled"))
+        if (data.hasKey("MainControllerPos"))
+        {
+            val mainPos = data.getCompoundTag("MainControllerPos")
+            val pos = BlockPos(mainPos.getInteger("X"), mainPos.getInteger("Y"), mainPos.getInteger("Z"))
+            val mte = GTUtility.getMetaTileEntity(world, pos)
+            if (mte is ExtendableMultiblock<*>)
+            {
+                connect(mte as ExtendableMultiblock<T>)
+            }
+            else
+            {
+                snapshotControllerPos = pos
+            }
+        }
+    }
+
+    override fun writeInitialSyncData(buf: PacketBuffer)
+    {
+        super.writeInitialSyncData(buf)
+        buf.writeBoolean(isWorkingEnabled)
+    }
+
+    override fun receiveInitialSyncData(buf: PacketBuffer)
+    {
+        super.receiveInitialSyncData(buf)
+        setWorkingEnabled(buf.readBoolean())
+    }
+
+    override fun receiveCustomData(dataId: Int, buf: PacketBuffer)
+    {
+        super.receiveCustomData(dataId, buf)
+        if (dataId == WORKING_ENABLED)
+        {
+            isWorkingEnabled = buf.readBoolean()
+            scheduleRenderUpdate()
+        }
+    }
+
+    override fun configureDisplayText(builder: MultiblockUIBuilder)
+    {
+        builder.setWorkingStatus(isWorkingEnabled, isConnected())
+            .addWorkingStatusLine()
+    }
+
+    override fun configureWarningText(builder: MultiblockUIBuilder)
+    {
+        val controller = mainController ?: return
+        if (controller.isStructureFormed)
+        {
+            controller.maintenanceProblem.let { builder.addMaintenanceProblemLines(it, true) }
+        }
+    }
+
+    override fun onDataStickLeftClick(player: EntityPlayer, stack: ItemStack)
+    {
+        val tag = stack.tagCompound ?: NBTTagCompound()
+        tag.setTag("AdditionalPos", NBTTagCompound().apply {
+            setInteger("X", pos.x)
+            setInteger("Y", pos.y)
+            setInteger("Z", pos.z)
+        })
+        stack.tagCompound = tag
+        stack.setTranslatableName("gtlitecore.machine.additional_structure.data_stick.name")
+        player.sendStatusMessage(TextComponentTranslation("gtlitecore.machine.additional_structure.pos_saved",
+                                                          pos.x, pos.y, pos.z), true)
+    }
+
+    override fun onDataStickRightClick(player: EntityPlayer, stack: ItemStack): Boolean = false
+
+    override fun renderMetaTileEntity(renderState: CCRenderState,
+                                      translation: Matrix4,
+                                      pipeline: Array<out IVertexOperation>)
+    {
+        super.renderMetaTileEntity(renderState, translation, pipeline)
+        frontOverlay.renderOrientedState(renderState, translation, pipeline, frontFacing, isActive, isWorkingEnabled)
+    }
+}

src/main/kotlin/gregtechlite/gtlitecore/api/metatileentity/multiblock/extendable/AdditionalStructureManager.kt

@@ -0,0 +1,94 @@
+package gregtechlite.gtlitecore.api.metatileentity.multiblock.extendable
+
+import gregtech.api.metatileentity.MetaTileEntity
+import gregtech.api.metatileentity.multiblock.MultiblockAbility
+import gregtech.api.util.GTUtility
+import gregtechlite.gtlitecore.api.collection.openArrayListOf
+import gregtechlite.gtlitecore.api.collection.openHashMapOf
+import net.minecraft.nbt.NBTTagCompound
+import net.minecraft.nbt.NBTTagList
+import net.minecraft.util.ResourceLocation
+import net.minecraft.util.math.BlockPos
+
+open class AdditionalStructureManager<T: ExtendableMultiblock<T>>(protected val base: ExtendableMultiblock<T>)
+{
+    protected val structures = openHashMapOf<BlockPos, AdditionalMultiblockBase<T>>()
+    private val snapshotConnections = openArrayListOf<BlockPos>()
+
+    fun add(additionalMultiblockBase: AdditionalMultiblockBase<T>)
+    {
+        structures[additionalMultiblockBase.pos] = additionalMultiblockBase
+        snapshotConnections.remove(additionalMultiblockBase.pos)
+    }
+
+    fun addSnapshotConnection(pos: BlockPos)
+    {
+        if (pos !in structures.keys && pos !in snapshotConnections)
+            snapshotConnections.add(pos)
+    }
+
+    operator fun get(metaTileEntityId: ResourceLocation): MutableList<AdditionalMultiblockBase<T>>
+    {
+        tryInsertSnapshotConnections()
+        return structures.values.filter { it.metaTileEntityId.equals(metaTileEntityId) }.toMutableList()
+    }
+
+    operator fun get(pos: BlockPos): AdditionalMultiblockBase<T>?
+    {
+        tryInsertSnapshotConnections()
+        return structures[pos]
+    }
+
+    fun remove(pos: BlockPos)
+    {
+        structures.remove(pos)
+        snapshotConnections.remove(pos)
+    }
+
+    fun <A> getAbilities(ability: MultiblockAbility<A>): MutableList<A>
+    {
+        tryInsertSnapshotConnections()
+        val abilities = arrayListOf<A>()
+        structures.values.forEach { it.getAbilities<A>(ability).also { ability -> abilities.addAll(ability) } }
+        return abilities
+    }
+
+    private fun tryInsertSnapshotConnections()
+    {
+        if (snapshotConnections.isEmpty()) return
+        val world = (base as? MetaTileEntity)?.world ?: return
+        val snapshot = snapshotConnections.toList()
+        for (pos in snapshot)
+        {
+            val mte = GTUtility.getMetaTileEntity(world, pos)
+            if (mte is AdditionalMultiblockBase<*>)
+            {
+                @Suppress("UNCHECKED_CAST")
+                (mte as AdditionalMultiblockBase<T>).connect(base)
+            }
+        }
+    }
+
+    fun serialize(): NBTTagCompound
+    {
+        val nbt = NBTTagCompound()
+        val list = NBTTagList()
+        val allPoses = linkedSetOf<BlockPos>()
+        allPoses.addAll(structures.keys)
+        allPoses.addAll(snapshotConnections)
+        allPoses.forEach {
+            val pos = NBTTagCompound().apply {
+                setInteger("X", it.x)
+                setInteger("Y", it.y)
+                setInteger("Z", it.z)
+            }
+            list.appendTag(pos)
+        }
+        nbt.setTag("BlockPoses", list)
+        return nbt
+    }
+
+    fun deserialize(nbt: NBTTagCompound): List<BlockPos>
+        = nbt.getTagList("BlockPoses", 10).filterIsInstance<NBTTagCompound>()
+            .map { BlockPos(it.getInteger("X"), it.getInteger("Y"), it.getInteger("Z")) }
+}

src/main/kotlin/gregtechlite/gtlitecore/api/metatileentity/multiblock/extendable/ExtendableMultiblock.kt

@@ -0,0 +1,25 @@
+package gregtechlite.gtlitecore.api.metatileentity.multiblock.extendable
+
+import gregtech.api.capability.IMultiblockController
+import net.minecraft.util.math.BlockPos
+
+interface ExtendableMultiblock<T: ExtendableMultiblock<T>>: IMultiblockController
+{
+    var additionalStructureManager: AdditionalStructureManager<T>
+
+    val maintenanceProblem: Byte
+
+    val controllerPos: BlockPos
+
+    fun isWorkingEnabled(): Boolean
+
+    fun addAdditional(additionalMultiblockBase: AdditionalMultiblockBase<T>)
+    {
+        additionalStructureManager.add(additionalMultiblockBase)
+    }
+
+    fun removeAdditional(pos: BlockPos)
+    {
+        additionalStructureManager.remove(pos)
+    }
+}