bunch of cards

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

@@ -3,6 +3,8 @@ package org.neoflock.neocomputers.block
 import dev.architectury.networking.NetworkManager
 import io.netty.buffer.Unpooled
 import net.minecraft.core.BlockPos
+import net.minecraft.core.HolderLookup
+import net.minecraft.nbt.CompoundTag
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.network.codec.StreamCodec
@@ -92,6 +94,7 @@ abstract class NodeBlockEntity(blockEntityType: BlockEntityType<*>, blockPos: Bl
 
     fun initNetworking(): NodeBlockEntity {
         Networking.addNode(node)
+        invalidateNodeState()
         return this
     }
 
@@ -174,6 +177,17 @@ abstract class NodeBlockEntity(blockEntityType: BlockEntityType<*>, blockPos: Bl
         super.setRemoved()
         Networking.removeNode(node)
     }
+
+    override fun clearRemoved() {
+        super.clearRemoved()
+        initNetworking()
+    }
+
+    override fun loadAdditional(compoundTag: CompoundTag, provider: HolderLookup.Provider) {
+        super.loadAdditional(compoundTag, provider)
+        invalidateNodeState()
+        computeEdges().forEach { it.invalidateNodeState() }
+    }
 }
 
 abstract class NodeBlock(properties: Properties = Properties.of()): BaseBlock(properties), EntityBlock {

src/main/kotlin/org/neoflock/neocomputers/gui/widget/ComponentSlot.kt

@@ -34,6 +34,10 @@ object ComponentRoles {
     val CONTAINER = "container"
     val TABLET = "tablet"
     val RACK_MOUNTABLE = "rack"
+    // Conventional network cards, like LAN, WLAN0, WLAN1, etc.
+    val NETWORK = "network"
+    // Internet cards
+    val INET = "internet"
 
     val MISSING_ROLE_TEXTURE = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/slots/na.png")
 
@@ -59,6 +63,9 @@ object ComponentRoles {
             TOOL to "tool",
             UPGRADE to "upgrade",
             RACK_MOUNTABLE to "rack_mountable",
+            // TODO: give them proper textures
+            NETWORK to "card",
+            INET to "card",
         )
         for((role, tex) in core) {
             mapTexture(role, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/slots/$tex.png"))

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

@@ -0,0 +1,20 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+
+open class CBUSItem(val tier: Int, val maxComponents: Int): Item(Item.Properties()), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.BUS)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = tier
+
+    override fun getComponentCapacity(itemStack: ItemStack): Int = maxComponents
+
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+}
+class CBUS0: CBUSItem(1, 8)
+class CBUS1: CBUSItem(2, 12)
+class CBUS2: CBUSItem(3, 16)
+class CBUSCreative: CBUSItem(1, 1024)

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

@@ -0,0 +1,20 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+
+open class CPUItem(val tier: Int, val maxComponents: Int): Item(Item.Properties()), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.COMPUTE)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = tier
+
+    override fun getComponentCapacity(itemStack: ItemStack): Int = maxComponents
+
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+}
+
+class CPU0: CPUItem(1, 8)
+class CPU1: CPUItem(2, 12)
+class CPU2: CPUItem(3, 16)

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

@@ -2,6 +2,7 @@ package org.neoflock.neocomputers.item
 
 import net.minecraft.world.item.ItemStack
 import org.neoflock.neocomputers.network.Networking
+import java.util.UUID
 
 // need not necessarily be just a component, can be upgrades as well
 interface ComponentItem {
@@ -9,12 +10,28 @@ interface ComponentItem {
     fun getComponentTier(itemStack: ItemStack): Int
 
     // Get machine properties they can influence
-    fun getMemoryCapacity(itemStack: ItemStack): Int
-    fun getComponentCapacity(itemStack: ItemStack): Int
+    fun getMemoryCapacity(itemStack: ItemStack): Int = 0
+    fun getComponentCapacity(itemStack: ItemStack): Int = 0
 
-    fun whenComponentPlaced(itemStack: ItemStack, newRole: String)
-    fun whenComponentTaken(itemStack: ItemStack, previousRole: String)
+    // Component placed, node must now exist
+    fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
+        val node = toComponentNode(itemStack) ?: return
+        Networking.addNode(node)
+    }
+
+    // Component taken, and thus removed
+    fun whenComponentTaken(itemStack: ItemStack, previousRole: String) {
+        val node = toComponentNode(itemStack) ?: return
+        Networking.removeNode(node)
+    }
 
     // To node, if applicable
     fun toComponentNode(itemStack: ItemStack): Networking.Node?
+
+    fun ensureHasAddress(itemStack: ItemStack): UUID {
+        if(!itemStack.has(DataComponents.ADDRESS)) {
+            itemStack.set(DataComponents.ADDRESS, UUID.randomUUID().toString())
+        }
+        return UUID.fromString(itemStack.get(DataComponents.ADDRESS))
+    }
 }

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

@@ -0,0 +1,45 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.TooltipFlag
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+import org.neoflock.neocomputers.utils.Formatting
+
+// Note: We'll prob want to replace them with NN component configs later on
+
+open class DataCard(val tier: Int, val limit: Long): Item(Properties()), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.CARD)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = tier
+
+    override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
+        ensureHasAddress(itemStack)
+        super.whenComponentPlaced(itemStack, newRole)
+    }
+
+    // TODO: Modem Component
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+
+    override fun appendHoverText(
+        itemStack: ItemStack,
+        tooltipContext: TooltipContext,
+        list: MutableList<Component?>,
+        tooltipFlag: TooltipFlag
+    ) {
+        if(tooltipFlag.isAdvanced) {
+            val addr = itemStack.get(DataComponents.ADDRESS)
+            val addrComp = if(addr == null) Component.translatable("neocomputers.noaddr") else Component.literal(addr)
+            list.addLast(addrComp)
+            list.addLast(Component.translatable("neocomputers.data.limit", Formatting.formatMemory(limit)))
+            // TODO: show HTTP/TCP/TLS support
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+}
+
+class DataCard0: DataCard(1, 1 shl 20)
+class DataCard1: DataCard(2, 1 shl 20)
+class DataCard2: DataCard(3, 1 shl 20)

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

@@ -12,6 +12,8 @@ object DataComponents {
         DataComponentType.builder<String>().persistent(Codec.STRING).build())
     val LABEL = Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "label"),
         DataComponentType.builder<String>().persistent(Codec.STRING).build())
+    val READONLY = Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "readonly"),
+        DataComponentType.builder<Boolean>().persistent(Codec.BOOL).build())
     val EEPROM_CODE = Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "eeprom_code"),
         DataComponentType.builder<String>().persistent(Codec.STRING).build())
     val EEPROM_DATA = Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "eeprom_data"),

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

@@ -9,8 +9,11 @@ import org.neoflock.neocomputers.network.Networking
 import org.neoflock.neocomputers.utils.Formatting
 import java.util.UUID
 
-fun getEEPROMProperties(): Item.Properties = Item.Properties().component(
-    DataComponents.EEPROM_CODE, "").component(DataComponents.EEPROM_DATA, "").component(DataComponents.LABEL, "")
+fun getEEPROMProperties(): Item.Properties = Item.Properties()
+    .component(DataComponents.EEPROM_CODE, "")
+    .component(DataComponents.EEPROM_DATA, "")
+    .component(DataComponents.LABEL, "")
+    .component(DataComponents.READONLY, false)
 
 open class EEPROMItem(val tier: Int, val codeCapacity: Int, val dataCapacity: Int): Item(getEEPROMProperties()), ComponentItem {
     override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.FIRMWARE)
@@ -22,12 +25,9 @@ open class EEPROMItem(val tier: Int, val codeCapacity: Int, val dataCapacity: In
     override fun getComponentCapacity(itemStack: ItemStack): Int = 0
 
     override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
-        if(!itemStack.has(DataComponents.ADDRESS)) {
-            itemStack.set(DataComponents.ADDRESS, UUID.randomUUID().toString())
+        ensureHasAddress(itemStack)
+        super.whenComponentPlaced(itemStack, newRole)
     }
-    }
-
-    override fun whenComponentTaken(itemStack: ItemStack, previousRole: String) {}
 
     override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
 
@@ -41,6 +41,7 @@ open class EEPROMItem(val tier: Int, val codeCapacity: Int, val dataCapacity: In
             val code = itemStack.get(DataComponents.EEPROM_CODE) ?: ""
             val data = itemStack.get(DataComponents.EEPROM_DATA) ?: ""
             val addr = itemStack.get(DataComponents.ADDRESS)
+            val readonly = itemStack.get(DataComponents.READONLY) ?: false
             val codeSize = code.encodeToByteArray().size
             val dataSize = data.encodeToByteArray().size
             val addrComp = if(addr == null) Component.translatable("neocomputers.noaddr") else Component.literal(addr)
@@ -49,6 +50,7 @@ open class EEPROMItem(val tier: Int, val codeCapacity: Int, val dataCapacity: In
                 Formatting.formatMemory(codeCapacity.toLong())))
             list.addLast(Component.translatable("neocomputers.eeprom.dataused", Formatting.formatMemory(dataSize.toLong()),
                 Formatting.formatMemory(dataCapacity.toLong())))
+            list.addLast(Component.translatable(if(readonly) "neocomputers.readonly" else "neocomputers.readwrite"))
         }
         super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
     }

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

@@ -0,0 +1,44 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.TooltipFlag
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+
+// Note: We'll prob want to replace them with NN component configs later on
+
+open class GPUCard(val tier: Int, val vram: Long): Item(Properties()), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.CARD)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = tier
+
+    override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
+        ensureHasAddress(itemStack)
+        super.whenComponentPlaced(itemStack, newRole)
+    }
+
+    // TODO: Modem Component
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+
+    override fun appendHoverText(
+        itemStack: ItemStack,
+        tooltipContext: TooltipContext,
+        list: MutableList<Component?>,
+        tooltipFlag: TooltipFlag
+    ) {
+        if(tooltipFlag.isAdvanced) {
+            val addr = itemStack.get(DataComponents.ADDRESS)
+            val addrComp = if(addr == null) Component.translatable("neocomputers.noaddr") else Component.literal(addr)
+            list.addLast(addrComp)
+            list.addLast(Component.translatable("neocomputers.gpu.vram", vram))
+            // TODO: show VRAM usage and whatnot
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+}
+
+class GPUCard0: GPUCard(1, 5000)
+class GPUCard1: GPUCard(2, 10000)
+class GPUCard2: GPUCard(3, 20000)

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

@@ -0,0 +1,62 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.TooltipFlag
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+import org.neoflock.neocomputers.utils.Formatting
+import java.util.UUID
+
+fun getDiskProperties(): Item.Properties = Item.Properties()
+    .component(DataComponents.LABEL, "")
+    .component(DataComponents.READONLY, false)
+
+open class HardDiskItem(val tier: Int, val capacity: Long): Item(getDiskProperties()), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.STORAGE)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = tier
+
+    override fun getMemoryCapacity(itemStack: ItemStack): Int = 0
+
+    override fun getComponentCapacity(itemStack: ItemStack): Int = 0
+
+    override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
+        ensureHasAddress(itemStack)
+        super.whenComponentPlaced(itemStack, newRole)
+    }
+
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+
+    override fun appendHoverText(
+        itemStack: ItemStack,
+        tooltipContext: TooltipContext,
+        list: MutableList<Component?>,
+        tooltipFlag: TooltipFlag
+    ) {
+        if(tooltipFlag.isAdvanced) {
+            val addr = itemStack.get(DataComponents.ADDRESS)
+            val readonly = itemStack.get(DataComponents.READONLY) ?: false
+            val spaceUsed: Long = 0
+            val addrComp = if(addr == null) Component.translatable("neocomputers.noaddr") else Component.literal(addr)
+            list.addLast(addrComp)
+            list.addLast(Component.translatable("neocomputers.disk.spaceused", Formatting.formatMemory(spaceUsed),
+                Formatting.formatMemory(capacity)))
+            list.addLast(Component.translatable(if(readonly) "neocomputers.readonly" else "neocomputers.readwrite"))
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+
+    override fun getName(itemStack: ItemStack): Component? {
+        if(itemStack.has(DataComponents.LABEL)) {
+            val label = itemStack.get(DataComponents.LABEL) ?: ""
+            if(label.isNotEmpty()) return Component.literal(label)
+        }
+        return super.getName(itemStack)
+    }
+}
+
+class HardDisk0: HardDiskItem(1, 1 shl 20)
+class HardDisk1: HardDiskItem(2, 2 shl 20)
+class HardDisk2: HardDiskItem(3, 4 shl 20)

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

@@ -0,0 +1,38 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.TooltipFlag
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+import org.neoflock.neocomputers.utils.Formatting
+
+class InternetCard: Item(Item.Properties()), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.CARD, ComponentRoles.INET)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = 1
+
+    override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
+        ensureHasAddress(itemStack)
+        super.whenComponentPlaced(itemStack, newRole)
+    }
+
+    // TODO: Internet Component
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+
+    override fun appendHoverText(
+        itemStack: ItemStack,
+        tooltipContext: TooltipContext,
+        list: MutableList<Component?>,
+        tooltipFlag: TooltipFlag
+    ) {
+        if(tooltipFlag.isAdvanced) {
+            val addr = itemStack.get(DataComponents.ADDRESS)
+            val addrComp = if(addr == null) Component.translatable("neocomputers.noaddr") else Component.literal(addr)
+            list.addLast(addrComp)
+            // TODO: show HTTP/TCP/TLS support
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+}

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

@@ -1,14 +1,9 @@
 package org.neoflock.neocomputers.item
 
 import dev.architectury.registry.registries.DeferredRegister
-import net.minecraft.core.Registry
-import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
-import net.minecraft.resources.ResourceKey
-import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.item.Item
 import org.neoflock.neocomputers.NeoComputers
-import java.util.function.Supplier
 
 object Items {
     val ITEMS: DeferredRegister<Item> = DeferredRegister.create(NeoComputers.MODID, Registries.ITEM)
@@ -21,4 +16,31 @@ object Items {
     val MEM5 = ITEMS.register("memory5") { MemoryTier3_5() }
 
     val EE0 = ITEMS.register("eeprom0") { EEPROM0() }
+
+    val CPU0 = ITEMS.register("cpu0") { CPU0() }
+    val CPU1 = ITEMS.register("cpu1") { CPU1() }
+    val CPU2 = ITEMS.register("cpu2") { CPU2() }
+
+    val CBUS0 = ITEMS.register("cbus0") { CBUS0() }
+    val CBUS1 = ITEMS.register("cbus1") { CBUS1() }
+    val CBUS2 = ITEMS.register("cbus2") { CBUS2() }
+    val CBUS_CREATIVE = ITEMS.register("cbus_creative") { CBUSCreative() }
+
+    val INET = ITEMS.register("inet") { InternetCard() }
+    val TUNNEL = ITEMS.register("tunnel") { TunnelCard() }
+    val LAN = ITEMS.register("lan") { LANCard() }
+    val WLAN0 = ITEMS.register("wlan0") { WLANCard0() }
+    val WLAN1 = ITEMS.register("wlan1") { WLANCard1() }
+
+    val DATA0 = ITEMS.register("data0") { DataCard0() }
+    val DATA1 = ITEMS.register("data1") { DataCard1() }
+    val DATA2 = ITEMS.register("data2") { DataCard2() }
+
+    val GPU0 = ITEMS.register("gpu0") { GPUCard0() }
+    val GPU1 = ITEMS.register("gpu1") { GPUCard1() }
+    val GPU2 = ITEMS.register("gpu2") { GPUCard2() }
+
+    val HDD0 = ITEMS.register("hdd0") { HardDisk0() }
+    val HDD1 = ITEMS.register("hdd1") { HardDisk1() }
+    val HDD2 = ITEMS.register("hdd2") { HardDisk2() }
 }

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

@@ -0,0 +1,43 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.TooltipFlag
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+
+open class NetworkCard(val tier: Int, val maxRange: Int, val isWired: Boolean): Item(Properties()), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.CARD, ComponentRoles.NETWORK)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = tier
+
+    override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
+        ensureHasAddress(itemStack)
+    }
+
+    // TODO: Modem Component
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+
+    override fun appendHoverText(
+        itemStack: ItemStack,
+        tooltipContext: TooltipContext,
+        list: MutableList<Component?>,
+        tooltipFlag: TooltipFlag
+    ) {
+        if(tooltipFlag.isAdvanced) {
+            val addr = itemStack.get(DataComponents.ADDRESS)
+            val addrComp = if(addr == null) Component.translatable("neocomputers.noaddr") else Component.literal(addr)
+            list.addLast(addrComp)
+            if(maxRange > 0) {
+                list.addLast(Component.translatable("neocomputers.wlan.range", maxRange))
+            }
+            // TODO: show max packet size and whatnot
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+}
+
+class LANCard: NetworkCard(1, 0, true)
+class WLANCard0: NetworkCard(1, 16, true)
+class WLANCard1: NetworkCard(1, 400, true)

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

@@ -2,11 +2,8 @@ package org.neoflock.neocomputers.item
 
 import dev.architectury.registry.CreativeTabRegistry
 import dev.architectury.registry.registries.DeferredRegister
-import net.minecraft.core.Registry
-import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
 import net.minecraft.network.chat.Component
-import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.item.CreativeModeTab
 import net.minecraft.world.item.ItemStack
 import org.neoflock.neocomputers.NeoComputers
@@ -16,12 +13,41 @@ object Tabs {
         DeferredRegister.create(NeoComputers.MODID, Registries.CREATIVE_MODE_TAB)
 
     val TAB = TABS.register("neocomputers_tab") {
+        // its only experimental once they change it
         CreativeTabRegistry.create { builder ->
             builder.title(Component.literal("NeoComputers"))
             builder.icon {
                 ItemStack(Items.MEM0.get())
             }
             builder.displayItems { parameters, output ->
+                // TODO: get rid of arch$tab and this shi and replace with loop over items registry
+                output.accept(ItemStack(Items.CPU0.get()))
+                output.accept(ItemStack(Items.CPU1.get()))
+                output.accept(ItemStack(Items.CPU2.get()))
+
+                output.accept(ItemStack(Items.CBUS0.get()))
+                output.accept(ItemStack(Items.CBUS1.get()))
+                output.accept(ItemStack(Items.CBUS2.get()))
+                output.accept(ItemStack(Items.CBUS_CREATIVE.get()))
+
+                output.accept(ItemStack(Items.DATA0.get()))
+                output.accept(ItemStack(Items.DATA1.get()))
+                output.accept(ItemStack(Items.DATA2.get()))
+
+                output.accept(ItemStack(Items.GPU0.get()))
+                output.accept(ItemStack(Items.GPU1.get()))
+                output.accept(ItemStack(Items.GPU2.get()))
+
+                output.accept(ItemStack(Items.HDD0.get()))
+                output.accept(ItemStack(Items.HDD1.get()))
+                output.accept(ItemStack(Items.HDD2.get()))
+
+                output.accept(ItemStack(Items.INET.get()))
+                output.accept(ItemStack(Items.TUNNEL.get()))
+                output.accept(ItemStack(Items.LAN.get()))
+                output.accept(ItemStack(Items.WLAN0.get()))
+                output.accept(ItemStack(Items.WLAN1.get()))
+
                 output.accept(ItemStack(Items.EE0.get()))
 
                 val luaBios = ItemStack(Items.EE0.get())

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

@@ -0,0 +1,39 @@
+package org.neoflock.neocomputers.item
+
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.TooltipFlag
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.network.Networking
+import org.neoflock.neocomputers.utils.Formatting
+
+class TunnelCard: Item(Properties()), ComponentItem {
+    // yes, we're counting TUNNEL as a conventional networking card
+    override fun getComponentRoles(itemStack: ItemStack): Set<String> = setOf(ComponentRoles.CARD, ComponentRoles.NETWORK)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = 3
+
+    override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {
+        ensureHasAddress(itemStack)
+        super.whenComponentPlaced(itemStack, newRole)
+    }
+
+    // TODO: Tunnel Component
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+
+    override fun appendHoverText(
+        itemStack: ItemStack,
+        tooltipContext: TooltipContext,
+        list: MutableList<Component?>,
+        tooltipFlag: TooltipFlag
+    ) {
+        if(tooltipFlag.isAdvanced) {
+            val addr = itemStack.get(DataComponents.ADDRESS)
+            val addrComp = if(addr == null) Component.translatable("neocomputers.noaddr") else Component.literal(addr)
+            list.addLast(addrComp)
+            // TODO: show max packet size and whatnot
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+}

src/main/kotlin/org/neoflock/neocomputers/network/Networking.kt

@@ -287,11 +287,12 @@ object Networking {
 
     fun addNode(node: Node) {
         if(node in allNodes) return;
-        allNodes.forEach { it.onNodeAdded(node) }
-        allNodes.add(node);
+        allNodes.add(node)
         if(node is WirelessEndpoint) {
             wirelessNodes.add(node);
         }
+        // notify at the end so it is notified of its own creation
+        allNodes.forEach { it.onNodeAdded(node) }
     }
 
     fun addNodes(vararg nodes: Node) {
@@ -299,16 +300,17 @@ object Networking {
     }
 
     fun removeNode(node: Node) {
-        if(node !in allNodes) return;
-        allNodes.remove(node);
-        if(node is WirelessEndpoint) {
-            wirelessNodes.remove(node);
-        }
+        if(node !in allNodes) return
+        allNodes.forEach { it.onNodeRemoved(node) }
         // toList() in order to copy it
         node.connections.toList().forEach {
             node.disconnectFrom(it)
         }
-        allNodes.forEach { it.onNodeRemoved(node) }
+        // actually remove at the end so it can listen to its own removal
+        allNodes.remove(node)
+        if(node is WirelessEndpoint) {
+            wirelessNodes.remove(node);
+        }
     }
 
     fun removeNodes(vararg nodes: Node) {

src/main/resources/assets/neocomputers/lang/en_us.json

@@ -3,7 +3,44 @@
   "neocomputers.cancel": "Cancel",
   "block.neocomputers.combustgen": "Combustion Generator",
   "block.neocomputers.redio": "Redstone I/O",
+  "block.neocomputers.solargen": "Solar Generator",
+  "block.neocomputers.screen": "Screen (Untiered)",
+  "block.neocomputers.capacitor": "Small Capacitor",
+  "block.neocomputers.capacitor2": "Medium Capacitor",
+  "block.neocomputers.capacitor3": "Large Capacitor",
   "item.neocomputers.eeprom0": "EEPROM (Tier 1)",
+  "item.neocomputers.cpu0": "CPU (Tier 1)",
+  "item.neocomputers.cpu1": "CPU (Tier 2)",
+  "item.neocomputers.cpu2": "CPU (Tier 3)",
+  "item.neocomputers.cbus0": "Component Bus (Tier 1)",
+  "item.neocomputers.cbus1": "Component Bus (Tier 2)",
+  "item.neocomputers.cbus2": "Component Bus (Tier 3)",
+  "item.neocomputers.cbus_creative": "Component Bus (Creative)",
+  "item.neocomputers.memory0": "Memory (Tier 1)",
+  "item.neocomputers.memory1": "Memory (Tier 1.5)",
+  "item.neocomputers.memory2": "Memory (Tier 2)",
+  "item.neocomputers.memory3": "Memory (Tier 2.5)",
+  "item.neocomputers.memory4": "Memory (Tier 3)",
+  "item.neocomputers.memory5": "Memory (Tier 3.5)",
+  "item.neocomputers.inet": "Internet Card",
+  "item.neocomputers.lan": "Wired Network Card",
+  "item.neocomputers.wlan0": "Wireless Network Card (Tier 1)",
+  "item.neocomputers.wlan1": "Wireless Network Card (Tier 2)",
+  "item.neocomputers.data0": "Data Card (Tier 1)",
+  "item.neocomputers.data1": "Data Card (Tier 2)",
+  "item.neocomputers.data2": "Data Card (Tier 3)",
+  "item.neocomputers.gpu0": "Graphics Card (Tier 1)",
+  "item.neocomputers.gpu1": "Graphics Card (Tier 2)",
+  "item.neocomputers.gpu2": "Graphics Card (Tier 3)",
+  "item.neocomputers.hdd0": "Hard Disk Drive (Tier 1)",
+  "item.neocomputers.hdd1": "Hard Disk Drive (Tier 2)",
+  "item.neocomputers.hdd2": "Hard Disk Drive (Tier 3)",
+  "neocomputers.wlan.range": "Range: %1$s blocks",
+  "neocomputers.data.limit": "Memory: %1$s",
+  "neocomputers.gpu.vram": "Video Memory: %1$spx",
+  "neocomputers.disk.spaceused": "Space Used: %1$s / %2$s",
+  "neocomputers.readonly": "Read-Only",
+  "neocomputers.readwrite": "Read-Write",
   "neocomputers.noaddr": "No address assigned",
   "neocomputers.memory.capacity": "Capacity: %1$s",
   "neocomputers.eeprom.codeused": "Code Storage: %1$s / %2$s",

src/main/resources/assets/neocomputers/models/item/cbus0.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/cbus0"
+  }
+}

src/main/resources/assets/neocomputers/models/item/cbus1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/cbus1"
+  }
+}

src/main/resources/assets/neocomputers/models/item/cbus2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/cbus2"
+  }
+}

src/main/resources/assets/neocomputers/models/item/cbus_creative.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/cbus_creative"
+  }
+}

src/main/resources/assets/neocomputers/models/item/cpu0.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/cpu0"
+  }
+}

src/main/resources/assets/neocomputers/models/item/cpu1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/cpu1"
+  }
+}

src/main/resources/assets/neocomputers/models/item/cpu2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/cpu2"
+  }
+}

src/main/resources/assets/neocomputers/models/item/data0.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/data0"
+  }
+}

src/main/resources/assets/neocomputers/models/item/data1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/data1"
+  }
+}

src/main/resources/assets/neocomputers/models/item/data2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/data2"
+  }
+}

src/main/resources/assets/neocomputers/models/item/gpu0.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/gpu0"
+  }
+}

src/main/resources/assets/neocomputers/models/item/gpu1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/gpu1"
+  }
+}

src/main/resources/assets/neocomputers/models/item/gpu2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/gpu2"
+  }
+}

src/main/resources/assets/neocomputers/models/item/hdd0.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/hdd0"
+  }
+}

src/main/resources/assets/neocomputers/models/item/hdd1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/hdd1"
+  }
+}

src/main/resources/assets/neocomputers/models/item/hdd2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/hdd2"
+  }
+}

src/main/resources/assets/neocomputers/models/item/inet.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/inet"
+  }
+}

src/main/resources/assets/neocomputers/models/item/lan.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/lan"
+  }
+}

src/main/resources/assets/neocomputers/models/item/tunnel.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/tunnel"
+  }
+}

src/main/resources/assets/neocomputers/models/item/wlan0.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/wlan0"
+  }
+}

src/main/resources/assets/neocomputers/models/item/wlan1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "neocomputers:item/wlan1"
+  }
+}

src/main/resources/assets/neocomputers/textures/item/data0.png.mcmeta

@@ -0,0 +1,15 @@
+{
+  "animation": {
+    "frametime": 1,
+    "frames": [
+      { "index": 0, "time": 4 },
+      { "index": 1, "time": 4 },
+      { "index": 2, "time": 4 },
+      { "index": 3, "time": 4 },
+      { "index": 4, "time": 4 },
+      { "index": 5, "time": 4 },
+      { "index": 6, "time": 4 },
+      { "index": 7, "time": 4 }
+    ]
+  }
+}

src/main/resources/assets/neocomputers/textures/item/data1.png.mcmeta

@@ -0,0 +1,15 @@
+{
+  "animation": {
+    "frametime": 1,
+    "frames": [
+      { "index": 0, "time": 4 },
+      { "index": 1, "time": 4 },
+      { "index": 2, "time": 4 },
+      { "index": 3, "time": 4 },
+      { "index": 4, "time": 4 },
+      { "index": 5, "time": 4 },
+      { "index": 6, "time": 4 },
+      { "index": 7, "time": 4 }
+    ]
+  }
+}

src/main/resources/assets/neocomputers/textures/item/data2.png.mcmeta

@@ -0,0 +1,15 @@
+{
+  "animation": {
+    "frametime": 1,
+    "frames": [
+      { "index": 0, "time": 4 },
+      { "index": 1, "time": 4 },
+      { "index": 2, "time": 4 },
+      { "index": 3, "time": 4 },
+      { "index": 4, "time": 4 },
+      { "index": 5, "time": 4 },
+      { "index": 6, "time": 4 },
+      { "index": 7, "time": 4 }
+    ]
+  }
+}

src/main/resources/assets/neocomputers/textures/item/inet.png.mcmeta

@@ -0,0 +1,17 @@
+{
+  "animation": {
+    "frametime": 1,
+    "frames": [
+      { "index": 0, "time": 2 },
+      { "index": 1, "time": 7 },
+      { "index": 0, "time": 5 },
+      { "index": 1, "time": 4 },
+      { "index": 0, "time": 7 },
+      { "index": 1, "time": 2 },
+      { "index": 0, "time": 8 },
+      { "index": 1, "time": 9 },
+      { "index": 0, "time": 6 },
+      { "index": 1, "time": 4 }
+    ]
+  }
+}

src/main/resources/assets/neocomputers/textures/item/tunnel.png.mcmeta

@@ -0,0 +1,13 @@
+{
+  "animation": {
+    "frametime": 1,
+    "frames": [
+      { "index": 0, "time": 3 },
+      { "index": 1, "time": 3 },
+      { "index": 2, "time": 3 },
+      { "index": 3, "time": 3 },
+      { "index": 4, "time": 3 },
+      { "index": 5, "time": 3 }
+    ]
+  }
+}