draft: Add Extendable Multiblock 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,176 @@
+package gregtechlite.gtlitecore.api.metatileentity.multiblock.extendable
+
+import codechicken.lib.render.CCRenderState
+import codechicken.lib.render.pipeline.IVertexOperation
+import codechicken.lib.vec.Matrix4
+import com.cleanroommc.modularui.api.widget.IWidget
+import com.cleanroommc.modularui.drawable.ItemDrawable
+import com.cleanroommc.modularui.value.sync.PanelSyncManager
+import com.cleanroommc.modularui.widgets.ButtonWidget
+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.metatileentity.multiblock.ui.MultiblockUIFactory
+import gregtech.api.util.KeyUtil
+import gregtechlite.gtlitecore.api.gui.GTLiteMuiTextures
+import net.minecraft.client.resources.I18n
+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.text.TextComponentTranslation
+import java.awt.event.MouseEvent
+
+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
+
+    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() = mainController != null && mainController!!.isWorkingEnabled()
+
+    fun connect(controller: ExtendableMultiblock<T>?)
+    {
+        mainController?.removeAdditional(pos)
+        mainController = controller
+        mainController?.addAdditional(this)
+    }
+
+    override fun writeToNBT(data: NBTTagCompound): NBTTagCompound
+    {
+        super.writeToNBT(data)
+        data.setBoolean("isWorkingEnabled", isWorkingEnabled)
+        return data
+    }
+
+    override fun readFromNBT(data: NBTTagCompound)
+    {
+        super.readFromNBT(data)
+        setWorkingEnabled(data.getBoolean("isWorkingEnabled"))
+    }
+
+    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 configureWarningText(builder: MultiblockUIBuilder?)
+    {
+        if (mainController?.isStructureFormed!!)
+        {
+            builder?.addMaintenanceProblemLines(mainController?.maintenanceProblem!!, true)
+        }
+    }
+
+    override fun createUIFactory(): MultiblockUIFactory?
+    {
+        return super.createUIFactory()
+            .createFlexButton { _, guiSyncManager ->
+                guiSyncManager.registerSyncedAction("highlight_main_controller") { mainController?.highlightController() }
+                return@createFlexButton ButtonWidget()
+                    .background(GTLiteMuiTextures.BUTTON_ENABLE_MODULE)
+                    .disableHoverBackground()
+                    .onMousePressed {
+                        guiSyncManager.callSyncedAction("highlight_main_controller")
+                        true
+                    }
+                    .tooltip { tooltip ->
+                        tooltip.addLine(KeyUtil.lang("gtlitecore.machine.extendable.highlight_main_controller"))
+                    }
+            }
+    }
+
+    fun highlightController() {
+        TODO()
+    }
+
+    fun getButton(panelSyncManager: PanelSyncManager): IWidget
+    {
+        panelSyncManager.registerSyncedAction("highlight_controller") { highlightController() }
+        return ButtonWidget()
+            .size(18, 18)
+            .overlay(ItemDrawable(stackForm))
+            .addTooltipStringLines(listOf(
+                I18n.format(this.metaFullName),
+                I18n.format("gtlitecore.machine.extendable.additional_button_action") // TODO
+            ))
+            .onMousePressed {
+                if (it == 1)
+                {
+                    // Highlight
+                    panelSyncManager.callSyncedAction("highlight_controller")
+                    return@onMousePressed true
+                }
+                else if (it == 2)
+                {
+                    // Other action... TODO
+                    return@onMousePressed true
+                }
+                else
+                {
+                    return@onMousePressed false
+                }
+            }
+    }
+
+    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,57 @@
+package gregtechlite.gtlitecore.api.metatileentity.multiblock.extendable
+
+import com.cleanroommc.modularui.api.widget.IWidget
+import com.cleanroommc.modularui.value.sync.PanelSyncManager
+import gregtech.api.metatileentity.multiblock.MultiblockAbility
+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>>()
+
+    fun add(additionalMultiblockBase: AdditionalMultiblockBase<T>)
+    {
+        structures[additionalMultiblockBase.pos] = additionalMultiblockBase
+    }
+
+    fun get(metaTileEntityId: ResourceLocation): MutableList<AdditionalMultiblockBase<T>>
+        = structures.values.filter { it.metaTileEntityId.equals(metaTileEntityId) }.toMutableList()
+
+    fun get(pos: BlockPos): AdditionalMultiblockBase<T>? = structures[pos]
+
+    fun remove(pos: BlockPos) = structures.remove(pos)
+
+    fun getWidgets(panelSyncManager: PanelSyncManager): List<IWidget> {
+        return structures.values.map { it.getButton(panelSyncManager) }.toList()
+    }
+
+    fun <A> getAbilities(ability: MultiblockAbility<A>): MutableList<A> {
+        val abilities = ArrayList<A>()
+        structures.values.forEach { it.getAbilities<A>(ability).also { ab -> abilities.addAll(ab) } }
+        return abilities
+    }
+
+    fun serialize(): NBTTagCompound
+    {
+        val nbt = NBTTagCompound()
+        val list = NBTTagList()
+        structures.keys.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,26 @@
+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
+
+    fun getPos(): BlockPos
+
+    fun highlightController()
+
+    fun isWorkingEnabled(): Boolean
+
+    fun addAdditional(additionalMultiblockBase: AdditionalMultiblockBase<T>)
+    {
+        additionalStructureManager.add(additionalMultiblockBase)
+    }
+
+    fun removeAdditional(pos: BlockPos)
+    {
+        additionalStructureManager.remove(pos)
+    }
+}