rack stateslop

src/main/kotlin/org/neoflock/neocomputers/NeoComputers.kt

@@ -56,6 +56,9 @@ object NeoComputers {
         EnvExecutor.runInEnv(Env.CLIENT) {{
             ClientLifecycleEvent.CLIENT_SETUP.register {
                 Menus.registerScreens()
+                Networking.allNodes.remove()
+                Networking.wirelessNodes.remove()
+                Networking.channels.remove()
             }
             ClientLifecycleEvent.CLIENT_STARTED.register {
                 FontProvider.load(ResourceLocation.fromNamespaceAndPath(MODID, "font/unscii.hex"))
@@ -81,12 +84,6 @@ object NeoComputers {
             Networking.channels.remove()
         }
 
-        ClientLifecycleEvent.CLIENT_SETUP.register {
-            Networking.allNodes.remove()
-            Networking.wirelessNodes.remove()
-            Networking.channels.remove()
-        }
-
         PlayerEvent.CLOSE_MENU.register {
             player, menu ->
             if(player is ServerPlayer) NodeSynchronizer.playerScreenClosed(player)

src/main/kotlin/org/neoflock/neocomputers/block/CaseBlock.kt

@@ -34,7 +34,7 @@ import org.neoflock.neocomputers.entity.MachineEntity
 import org.neoflock.neocomputers.network.NodeSynchronizer
 import org.neoflock.neocomputers.sounds.Sounds
 
-class CaseBlock() : DeviceBlock(Properties.of().sound(SoundType.METAL).lightLevel(CaseBlock::getLuminance)) { // placeholder stuff
+class CaseBlock() : DeviceBlock(Properties.of().sound(SoundType.METAL).lightLevel(CaseBlock::getLuminance).noOcclusion()) { // placeholder stuff
     companion object {
         val FACING: EnumProperty<Direction> = EnumProperty.create<Direction>("facing", Direction::class.java)
         val COMPUTER_RUNNING = BooleanProperty.create("running")!!

src/main/kotlin/org/neoflock/neocomputers/block/RackBlock.kt

@@ -22,7 +22,7 @@ import org.neoflock.neocomputers.entity.BlockEntities
 import org.neoflock.neocomputers.entity.RackEntity
 import org.neoflock.neocomputers.network.NodeSynchronizer
 
-class RackBlock : BaseBlock(Properties.of().noOcclusion()), EntityBlock {
+class RackBlock : DeviceBlock(Properties.of().noOcclusion()), EntityBlock {
     override fun newBlockEntity(
         pos: BlockPos,
         state: BlockState
@@ -61,7 +61,7 @@ class RackBlock : BaseBlock(Properties.of().noOcclusion()), EntityBlock {
         }
 
         if (!level.isClientSide) {
-            MenuRegistry.openMenu(player as ServerPlayer, ent)
+            MenuRegistry.openExtendedMenu(player as ServerPlayer, ent)
             NodeSynchronizer.registerPlayerScreen(player as ServerPlayer, ent.node)
         }
         return InteractionResult.SUCCESS

src/main/kotlin/org/neoflock/neocomputers/datagen/ModelGenerator.kt

@@ -4,15 +4,19 @@ import net.fabricmc.fabric.api.datagen.v1.FabricDataOutput
 import net.fabricmc.fabric.api.datagen.v1.provider.FabricModelProvider
 import net.minecraft.data.models.BlockModelGenerators
 import net.minecraft.data.models.ItemModelGenerators
+import net.minecraft.data.models.model.ModelTemplate
+import net.minecraft.data.models.model.ModelTemplates
 import org.neoflock.neocomputers.block.Blocks
+import org.neoflock.neocomputers.item.Items
 
 class ModelGenerator(output: FabricDataOutput) : FabricModelProvider(output) {
     override fun generateBlockStateModels(blockStateModelGenerator: BlockModelGenerators) {
-        blockStateModelGenerator.createGenericCube(Blocks.CASE_BLOCK.get())
+//        blockStateModelGenerator.createGenericCube(Blocks.CASE_BLOCK.get())
 
     }
 
     override fun generateItemModels(itemModelGenerator: ItemModelGenerators) {
+        itemModelGenerator.generateFlatItem(Items.SERVER0.get(), ModelTemplates.FLAT_ITEM)
     }
 
 }

src/main/kotlin/org/neoflock/neocomputers/entity/RackEntity.kt

@@ -1,5 +1,6 @@
 package org.neoflock.neocomputers.entity
 
+import dev.architectury.registry.menu.ExtendedMenuProvider
 import net.minecraft.core.BlockPos
 import net.minecraft.core.Direction
 import net.minecraft.core.HolderLookup
@@ -7,6 +8,8 @@ import net.minecraft.core.NonNullList
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.chat.Component
+import net.minecraft.network.protocol.Packet
+import net.minecraft.network.protocol.game.ClientGamePacketListener
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.ContainerHelper
 import net.minecraft.world.MenuProvider
@@ -14,16 +17,20 @@ import net.minecraft.world.entity.player.Inventory
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.inventory.AbstractContainerMenu
 import net.minecraft.world.item.ItemStack
+import net.minecraft.world.level.block.entity.AbstractFurnaceBlockEntity
 import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.entity.ChestBlockEntity
+import net.minecraft.world.level.block.entity.FurnaceBlockEntity
 import net.minecraft.world.level.block.state.BlockState
 import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.block.DeviceBlockEntity
 import org.neoflock.neocomputers.gui.menu.RackMenu
 import org.neoflock.neocomputers.network.DeviceNode
 import org.neoflock.neocomputers.network.Networking
+import org.neoflock.neocomputers.utils.ContainerUtils
 import org.neoflock.neocomputers.utils.GenericContainer
 
-class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEntities.RACK_ENTITY.get(), pos, state), MenuProvider, GenericContainer {
+class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEntities.RACK_ENTITY.get(), pos, state), ExtendedMenuProvider, GenericContainer {
     val stacks: NonNullList<ItemStack> = NonNullList<ItemStack>.withSize(4, ItemStack.EMPTY)
 
     var conns = mutableListOf(
@@ -42,6 +49,10 @@ class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEnti
             super.writeFullStateCommit(buf)
             buf.writeBoolean(relayMode)
 
+            val tag = CompoundTag() // better way to do this, a better way i do not care to find atm
+            ContainerHelper.saveAllItems(tag, stacks, level!!.registryAccess())
+            buf.writeNbt(tag)
+
 
             for (conn in conns) {
                 buf.writeInt(conn)
@@ -51,10 +62,14 @@ class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEnti
         override fun processCommit(buf: FriendlyByteBuf) {
             super.processCommit(buf)
             relayMode = buf.readBoolean()
+            val tag = buf.readNbt()
+            ContainerHelper.loadAllItems(tag!!, stacks, level!!.registryAccess())
 
             for (i in 0..15) {
                 conns[i] = buf.readInt()
             }
+            markChanged()
+            setChanged()
         }
 
         override fun processScreenInteraction(player: ServerPlayer, buf: FriendlyByteBuf) {
@@ -62,22 +77,22 @@ class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEnti
             relayMode = buf.readBoolean()
 
             val slot = buf.readInt()
-            NeoComputers.LOGGER.info(slot.toString())
+            conns[slot*4+0] = buf.readInt()
-            for (i in 0..3) {
+            conns[slot*4+1] = buf.readInt()
-                conns[slot*4+i] = buf.readInt()
+            conns[slot*4+2] = buf.readInt()
-                NeoComputers.LOGGER.info("{} {}", slot*4+i, conns[slot*4+i])
+            conns[slot*4+3] = buf.readInt()
-            }
+
+            markChanged()
             setChanged()
         }
-
+        override fun encodeScreenData(player: ServerPlayer, buf: FriendlyByteBuf) { // TODO: set this up so other players can mess with racks
-        override fun encodeScreenData(player: ServerPlayer, buf: FriendlyByteBuf) {
             super.encodeScreenData(player, buf)
-            buf.writeBoolean(relayMode)
+        }
+    }
 
-            for (conn in conns) {
+    override fun setChanged() {
-                buf.writeInt(conn)
+        super.setChanged()
-            }
+        node.markChanged()
-        }
     }
 
     override fun getDisplayName(): Component? = Component.literal("Rack")
@@ -90,6 +105,7 @@ class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEnti
 
     override fun getNodeFromSide(directionToRequester: Direction): DeviceNode? = node
 
+
     override fun loadAdditional(tag: CompoundTag, registries: HolderLookup.Provider) {
         super.loadAdditional(tag, registries)
         ContainerHelper.loadAllItems(tag, getItems(), registries)
@@ -97,6 +113,7 @@ class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEnti
 
         val connarray = tag.getIntArray("conns")
         if (connarray.size == 16) conns = connarray.toMutableList()
+        setChanged()
     }
 
     override fun saveAdditional(tag: CompoundTag, registries: HolderLookup.Provider) {
@@ -110,4 +127,7 @@ class RackEntity(pos: BlockPos, state: BlockState) : DeviceBlockEntity(BlockEnti
     override fun getItems(): NonNullList<ItemStack> = stacks
 
     override fun stillValid(player: Player): Boolean = true
+    override fun saveExtraData(buf: FriendlyByteBuf?) {
+        buf!!.writeBlockPos(blockPos)
+    }
 }

src/main/kotlin/org/neoflock/neocomputers/entity/render/CaseEntityRenderer.kt

@@ -5,12 +5,14 @@ import com.mojang.blaze3d.vertex.PoseStack
 import com.mojang.blaze3d.vertex.VertexConsumer
 import com.mojang.blaze3d.vertex.VertexFormat
 import com.mojang.math.Axis
+import net.minecraft.client.renderer.LightTexture
 import net.minecraft.client.renderer.MultiBufferSource
 import net.minecraft.client.renderer.RenderStateShard
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderer
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider
 import net.minecraft.core.Direction
+import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.block.CaseBlock
 import org.neoflock.neocomputers.entity.CaseBlockEntity
 
@@ -23,9 +25,10 @@ class CaseEntityRenderer(private val context: BlockEntityRendererProvider.Contex
 
     val BLINKTIME: Long = 10 // in ticks
 
-    val RENDER_TYPE = RenderType.create("nc_case", DefaultVertexFormat.POSITION_COLOR, VertexFormat.Mode.QUADS,
+    val RENDER_TYPE = RenderType.create("nc_case", DefaultVertexFormat.POSITION_COLOR_LIGHTMAP, VertexFormat.Mode.QUADS,
         RenderType.TRANSIENT_BUFFER_SIZE, RenderType.CompositeState.builder()
-            .setShaderState(RenderStateShard.POSITION_COLOR_SHADER)
+            .setShaderState(RenderStateShard.POSITION_COLOR_LIGHTMAP_SHADER)
+            .setLightmapState(RenderStateShard.LightmapStateShard.LIGHTMAP)
             .createCompositeState(false))
 
     override fun render(ent: CaseBlockEntity, partialTick: Float, mat: PoseStack, bufferSource: MultiBufferSource, packedLight: Int, packedOverlay: Int) {
@@ -38,20 +41,20 @@ class CaseEntityRenderer(private val context: BlockEntityRendererProvider.Contex
         if (ent.isOn) drawLED(buffer, mat.last(), 3F)
         else if (ent.getLastError() != null) { // if else hell
             if ((ent.level!!.dayTime/BLINKTIME) % 2 == 1.toLong()) drawLED(buffer, mat.last(), 3F, RED)
-            else drawLED(buffer, mat.last(), 3F, OFF)
+            else drawLED(buffer, mat.last(), 3F, OFF, packedLight)
-        } else drawLED(buffer, mat.last(), 3F, OFF)
+        } else drawLED(buffer, mat.last(), 3F, OFF, packedLight)
 
         mat.translate(6/16F, 0F, 0F)
-        drawLED(buffer, mat.last(), 2F, if (ent.diskActivityTime > 0) GREEN else OFF)
+        drawLED(buffer, mat.last(), 2F, if (ent.diskActivityTime > 0) GREEN else OFF, if (ent.diskActivityTime > 0) LightTexture.FULL_BRIGHT else packedLight)
 
         mat.popPose()
 
     }
-    private fun drawLED(buffer: VertexConsumer, mat: PoseStack.Pose, width: Float, color: Int = GREEN) {
+    private fun drawLED(buffer: VertexConsumer, mat: PoseStack.Pose, width: Float, color: Int = GREEN, light: Int = LightTexture.FULL_BRIGHT) {
-        buffer.addVertex(mat, width/16F, 0F, 0F).setColor(color)
+        buffer.addVertex(mat, width/16F, 0F, 0F).setColor(color).setLight(light)
-        buffer.addVertex(mat, width/16F, 1/16F, 0F).setColor(color)
+        buffer.addVertex(mat, width/16F, 1/16F, 0F).setColor(color).setLight(light)
-        buffer.addVertex(mat, 0F, 1/16F, 0F).setColor(color)
+        buffer.addVertex(mat, 0F, 1/16F, 0F).setColor(color).setLight(light)
-        buffer.addVertex(mat, 0F, 0F, 0F).setColor(color)
+        buffer.addVertex(mat, 0F, 0F, 0F).setColor(color).setLight(light)
     }
 
     private fun handleDirection(facing: Direction, mat: PoseStack) {

src/main/kotlin/org/neoflock/neocomputers/entity/render/RackEntityRenderer.kt

@@ -22,10 +22,18 @@ class RackEntityRenderer(val context: BlockEntityRendererProvider.Context) : Blo
         poseStack.pushPose()
         poseStack.translate(1/16f, 11/16f, 1/16f)
 
-        val render_slot = (ent.level!!.dayTime/40)%4 // this is purely temporary type shit like true alpha shit, anyway it go to 0-3, change and test it if you want
+        val items = ent.stacks
-        poseStack.translate(0f, (render_slot)*-3/16f, 0f)
+        for (i in 0..3) {
-        val server = object : RackItem { override fun render_lights(source: MultiBufferSource, stack: PoseStack, light: Int) { } }
+            if (items[i].item is RackItem) {
-        server.render(source, poseStack, packedLight, 2f+(3*render_slot)) // who knows atp
+                val item = items[i].item as RackItem
+                item.render(source, poseStack, packedLight, 2f+(3*i))
+            }
+            poseStack.translate(0f, -3/16f, 0f)
+        }
+//        val render_slot = (ent.level!!.dayTime/40)%4 // this is purely temporary type shit like true alpha shit, anyway it go to 0-3, change and test it if you want
+//        poseStack.translate(0f, (render_slot)*-3/16f, 0f)
+//        val server = object : RackItem { override fun render_lights(source: MultiBufferSource, stack: PoseStack, light: Int) { } }
+//        server.render(source, poseStack, packedLight, 2f+(3*render_slot)) // who knows atp
         poseStack.popPose()
     }
 }

src/main/kotlin/org/neoflock/neocomputers/gui/menu/Menus.kt

@@ -23,7 +23,8 @@ object Menus {
     val COMBUSTGEN_MENU: RegistrySupplier<MenuType<CombustionGeneratorMenu>> = MENUS.register("combustgen_menu") { MenuType(::CombustionGeneratorMenu, FeatureFlagSet.of() ) }
     val CASE_MENU: RegistrySupplier<MenuType<CaseMenu>> = MENUS.register("case_menu") { MenuType(::CaseMenu, FeatureFlagSet.of() )}
     val RELAY_MENU: RegistrySupplier<MenuType<RelayMenu>> = MENUS.register("relay_menu") { MenuType(::RelayMenu, FeatureFlagSet.of() )}
-    val RACK_MENU: RegistrySupplier<MenuType<RackMenu>> = MENUS.register("rack_menu") { MenuType(::RackMenu, FeatureFlagSet.of() )}
+    val RACK_MENU: RegistrySupplier<MenuType<RackMenu>> = MENUS.register("rack_menu") { MenuRegistry.ofExtended(::RackMenu) }
+//    val RACK_MENU: RegistrySupplier<MenuType<RackMenu>> = MENUS.register("rack_menu") { MenuType(::RackMenu, FeatureFlagSet.of() )}
 
     fun registerScreens() {
         MenuScreens.register(Menus.COMBUSTGEN_MENU.get()) { m: CombustionGeneratorMenu, u, comp ->CombustionGeneratorScreen(m,u,comp)}

src/main/kotlin/org/neoflock/neocomputers/gui/menu/RackMenu.kt

@@ -20,9 +20,13 @@ import net.minecraft.sounds.SoundEvents
 import net.minecraft.world.Container
 import net.minecraft.world.SimpleContainer
 import net.minecraft.world.entity.player.Inventory
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.ItemStack
 import org.neoflock.neocomputers.NeoComputers
+import org.neoflock.neocomputers.entity.RackEntity
 import org.neoflock.neocomputers.gui.widget.ComponentRoles
 import org.neoflock.neocomputers.gui.widget.DynamicSlot
+import org.neoflock.neocomputers.item.ComponentItem
 import org.neoflock.neocomputers.utils.GenericContainerMenu
 
 class RackSlot(container: Container, slot: Int, x: Int, y: Int) : DynamicSlot(container, slot, x, y), GuiEventListener {
@@ -31,20 +35,37 @@ class RackSlot(container: Container, slot: Int, x: Int, y: Int) : DynamicSlot(co
     val DARK_COLOURS = listOf(0xff6a6ab0.toInt(), 0xff60999d.toInt(), 0xffa2a44e.toInt(), 0xffb36660.toInt(), 0xff67a34e.toInt())
     val LIGHT_COLOURS = listOf(0xffdcdcf0.toInt(), 0xffdcdcf0.toInt(), 0xffececd4.toInt(), 0xfff0dbd9.toInt(), 0xffdbecd4.toInt())
 
-    val secondaries = 3
+    val secondaries = 2 // TODO: make this actually change depending on how many network cards
-    val selected = mutableListOf(-1, -1, -1, -1)
+
+    // todo: kotlin getters and setters
+    fun getSelected(i: Int): Int = (container as RackEntity).conns[containerSlot*4+i]
+    fun setSelected(i: Int, v: Int) { (container as RackEntity).conns[containerSlot*4+i] = v }
 
     override fun draw(graphics: GuiGraphics, mouseX: Int, mouseY: Int) {
         super.draw(graphics, mouseX, mouseY)
         if (!hasItem()) { drawQuad(graphics, ComponentRoles.getTextureFor("rack"), x, y, 16, 16, 0f, 0f, 15f, 15f); return; }
-            // TODO: make this do stuff based on the item inputted
+        for (i in 0..secondaries) {
-        for (i in 0..<selected.size) {
+            if (getSelected(i) > -1) drawConnection(graphics, getSelected(i), i-1)
-            if (selected[i] > -1) drawConnection(graphics, selected[i], i-1)
         }
 
         drawEndpoints(graphics, mouseX, mouseY,  secondaries)
     }
 
+    override fun mayPlace(stack: ItemStack): Boolean {
+        if (stack.item !is ComponentItem) return false
+        return (stack.item as ComponentItem).getComponentRoles(stack).contains(ComponentRoles.RACK_MOUNTABLE)
+    }
+
+    override fun onTake(player: Player, stack: ItemStack) {
+        super.onTake(player, stack)
+        setSelected(0, -1)
+        setSelected(1, -1)
+        setSelected(2, -1)
+        setSelected(3, -1)
+        (container as RackEntity).setChanged()
+
+    }
+
     fun drawConnection(guiGraphics: GuiGraphics, side: Int, sec: Int = -1) {
         val bufferSource = guiGraphics.bufferSource()
         val buffer = bufferSource.getBuffer(RenderType.gui())
@@ -99,20 +120,13 @@ class RackSlot(container: Container, slot: Int, x: Int, y: Int) : DynamicSlot(co
             }
         }
     }
-    fun processStateScreenPacket(buf: FriendlyByteBuf) {
-        selected[0] = buf.readInt()
-        selected[1] = buf.readInt()
-        selected[2] = buf.readInt()
-        selected[3] = buf.readInt()
-    }
 
-    fun encode(buf: FriendlyByteBuf) {
+    fun encode(buf: FriendlyByteBuf) { // client -> server
-//        val buf = FriendlyByteBuf(Unpooled.buffer())
         buf.writeInt(containerSlot)
-        buf.writeInt(selected[0])
+        buf.writeInt(getSelected(0))
-        buf.writeInt(selected[1])
+        buf.writeInt(getSelected(1))
-        buf.writeInt(selected[2])
+        buf.writeInt(getSelected(2))
-        buf.writeInt(selected[3])
+        buf.writeInt(getSelected(3))
 
     }
 
@@ -135,7 +149,8 @@ class RackSlot(container: Container, slot: Int, x: Int, y: Int) : DynamicSlot(co
     override fun mouseClicked(mouseX: Double, mouseY: Double, button: Int): Boolean {
         for (i in 0..4) { // main line
             if (mouseX >= x+25+(11*i) && mouseX <= x+28+(11*i) && mouseY >= y+1 && mouseY <= y+4 && button == 0) {
-                selected[0] = if (selected[0] != i) i else -1
+                setSelected(0, if (getSelected(0) != i) i else -1)
+                (container as RackEntity).setChanged()
                 clickynoise()
                 return true
             }
@@ -144,7 +159,8 @@ class RackSlot(container: Container, slot: Int, x: Int, y: Int) : DynamicSlot(co
         for (i in 0..<secondaries) { // secondary lines
             for (j in 0..4) {
                 if (mouseX >= x+25+(11*j) && mouseX <= x+28+(11*j) && mouseY >= y+6+(4*i) && mouseY <= y+8+(4*i) && button == 0) {
-                    selected[i+1] = if (selected[i+1] != j) j else -1
+                    setSelected(i+1, if (getSelected(i+1) != j) j else -1)
+                    (container as RackEntity).setChanged()
                     clickynoise()
                     return true
                 }
@@ -163,11 +179,12 @@ class RackSlot(container: Container, slot: Int, x: Int, y: Int) : DynamicSlot(co
 
 class RackMenu : GenericContainerMenu {
 
-    constructor(i: Int, inv: Inventory) : this(i, inv, SimpleContainer(4))
+    constructor(i: Int, inv: Inventory, buf: FriendlyByteBuf) : this(i, inv, (inv.player.level().getBlockEntity(buf.readBlockPos()) as RackEntity))
 
     constructor(i: Int, inv: Inventory, container: Container) : super(Menus.RACK_MENU.get(), i, container) {
         for(i in 0..3) {
-            this.addSlot(RackSlot(container,  i, 20, 23+i*20))
+            val slot = RackSlot(container,  i, 20, 23+i*20)
+            this.addSlot(slot)
         }
         this.addInventorySlots(inv, 8, 128)
     }

src/main/kotlin/org/neoflock/neocomputers/gui/screen/RackScreen.kt

@@ -12,6 +12,7 @@ import net.minecraft.network.chat.MutableComponent
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.player.Inventory
 import org.neoflock.neocomputers.NeoComputers
+import org.neoflock.neocomputers.entity.RackEntity
 import org.neoflock.neocomputers.gui.menu.RackMenu
 import org.neoflock.neocomputers.gui.menu.RackSlot
 import org.neoflock.neocomputers.gui.widget.IconTextButton
@@ -23,9 +24,9 @@ class RackScreen(menu: RackMenu, inventory: Inventory, component: Component) : G
     override fun findMenuTexture(): ResourceLocation = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/rack.png")
     val RELAY = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/relay.png")
 
-    var relay_mode = false // TODO: tie this to the menu or entity or whatever
+    var relay_mode = if (menu.container is RackEntity) (menu.container as RackEntity).relayMode else false
 
-    val relaybtn = IconTextButton(100, 96, "Disabled", RELAY, width = 64) {
+    val relaybtn = IconTextButton(100, 96, if(relay_mode) "Enabled" else "Disabled", RELAY, width = 64) {
         if (relay_mode){
             it.message = Component.literal("Disabled")
             relay_mode = false
@@ -38,7 +39,6 @@ class RackScreen(menu: RackMenu, inventory: Inventory, component: Component) : G
         buffer.writeBoolean(relay_mode)
         (menu.slots[0] as RackSlot).encode(buffer)
         NodeSynchronizer.sendScreenInteraction(buffer)
-        NeoComputers.LOGGER.info("sent")
     }
     init {
         this.imageWidth = 175
@@ -71,20 +71,20 @@ class RackScreen(menu: RackMenu, inventory: Inventory, component: Component) : G
         graphics.drawString(font, "Left", x, y+44, 0x404040, false)
     }
 
-    override fun processScreenStatePacket(buf: FriendlyByteBuf) {
+//    override fun processScreenStatePacket(buf: FriendlyByteBuf) {
-        super.processScreenStatePacket(buf)
+//        super.processScreenStatePacket(buf)
-//        NeoComputers.LOGGER.info("porcessing screen state packet...")
+////        NeoComputers.LOGGER.info("porcessing screen state packet...")
-        relay_mode = buf.readBoolean()
+////        relay_mode = buf.readBoolean()
-        if (relay_mode) relaybtn.message = Component.literal("Enabled")
+////        if (relay_mode) relaybtn.message = Component.literal("Enabled")
-        else relaybtn.message = Component.literal("Disabled")
+////        else relaybtn.message = Component.literal("Disabled")
-
+////
-        for (slot in menu.slots) {
+////        for (slot in menu.slots) {
-            if (slot is RackSlot) {
+////            if (slot is RackSlot) {
-                slot.processStateScreenPacket(buf)
+////                slot.processStateScreenPacket(buf)
-            }
+////            }
-        }
+////        }
-
+//
-    }
+//    }
 
     override fun mouseClicked(mouseX: Double, mouseY: Double, button: Int): Boolean {
         if (super.mouseClicked(mouseX, mouseY, button)) return true

src/main/kotlin/org/neoflock/neocomputers/item/Items.kt

@@ -46,4 +46,6 @@ object Items {
 
     val REDIO0 = ITEMS.register("redio0") { RedstoneCard0() }
     val REDIO1 = ITEMS.register("redio1") { RedstoneCard1() }
+
+    val SERVER0 = ITEMS.register("server0") { ServerItem() }
 }

src/main/kotlin/org/neoflock/neocomputers/item/ServerItem.kt

@@ -0,0 +1,26 @@
+package org.neoflock.neocomputers.item
+
+import com.mojang.blaze3d.vertex.PoseStack
+import net.minecraft.client.renderer.MultiBufferSource
+import net.minecraft.client.renderer.item.ItemProperties
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import org.neoflock.neocomputers.entity.ComponentUser
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.DeviceNode
+
+class ServerItem() : Item(Properties()), ComponentItem, RackItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.RACK_MOUNTABLE)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = 0
+
+    override fun toComponentNode(
+        itemStack: ItemStack,
+        machine: ComponentUser?
+    ): DeviceNode? {
+        return null // TODO: atom machine item plz
+    }
+
+    override fun render_lights(source: MultiBufferSource, stack: PoseStack, light: Int) {
+    }
+}

src/main/kotlin/org/neoflock/neocomputers/item/Tabs.kt

@@ -55,6 +55,7 @@ object Tabs {
                 output.accept(ItemStack(Items.REDIO1.get()))
 
                 output.accept(ItemStack(Items.EE0.get()))
+                output.accept(ItemStack(Items.SERVER0.get()))
 
                 // Criminal black magic to put LuaBIOS EEPROM in the tabs
                 do {