Merge branch 'main' of https://gitea.codersquack.nl/NeoFlock/NeoComputers

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

@@ -3,25 +3,19 @@ package org.neoflock.neocomputers
 import dev.architectury.event.events.client.ClientLifecycleEvent
 import dev.architectury.event.events.common.PlayerEvent
 import dev.architectury.event.events.common.TickEvent
-import dev.architectury.impl.NetworkAggregator
 import dev.architectury.networking.NetworkManager
 import net.minecraft.resources.ResourceLocation
 import org.neoflock.neocomputers.block.Blocks
 import org.neoflock.neocomputers.entity.BlockEntities
-import org.neoflock.neocomputers.gui.buffer.BufferRenderer
 import org.neoflock.neocomputers.gui.menu.Menus
-import org.neoflock.neocomputers.gui.screen.ScreenScreen
-import dev.architectury.registry.menu.MenuRegistry
 import dev.architectury.utils.Env
 import dev.architectury.utils.EnvExecutor
 import net.minecraft.client.Minecraft
-import net.minecraft.client.player.LocalPlayer
-import net.minecraft.network.protocol.common.custom.CustomPacketPayload
 import net.minecraft.server.level.ServerPlayer
-import org.neoflock.neocomputers.block.NodeBlock
 import org.neoflock.neocomputers.block.NodeBlockEntity
 import org.neoflock.neocomputers.block.NodeSynchronizer
 import org.neoflock.neocomputers.gui.render.ScreenRenderer
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
 import org.neoflock.neocomputers.item.Items
 import org.neoflock.neocomputers.item.Tabs
 import org.neoflock.neocomputers.network.Networking
@@ -46,6 +40,7 @@ object NeoComputers {
         BlockEntities.registerPowerBlocks()
         Menus.MENUS.register()
         Tabs.TABS.register()
+        ComponentRoles.mapDefaultTextures()
         // i dont know why architectury wants two lambdas but whatever
         EnvExecutor.runInEnv(Env.CLIENT) {{
             ClientLifecycleEvent.CLIENT_SETUP.register {
@@ -101,7 +96,6 @@ object NeoComputers {
 
         }}
 
-
         LOGGER.info("Registered!")
         //LOGGER.info("Started mod in %s loader".formatted(NeoComputersInit.PLATFORM.getModloader()))
         //LOGGER.info("Kotlin: %s".formatted(NeoComputers.hello()))

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/menu/CaseMenu.kt

@@ -1,5 +1,6 @@
 package org.neoflock.neocomputers.gui.menu;
 
+import net.minecraft.world.Container
 import net.minecraft.world.SimpleContainer
 import net.minecraft.world.entity.player.Inventory
 import org.neoflock.neocomputers.gui.menu.Menus;
@@ -8,18 +9,32 @@ import net.minecraft.world.inventory.AbstractContainerMenu
 import net.minecraft.world.inventory.MenuType
 import net.minecraft.world.item.ItemStack
 import org.neoflock.neocomputers.NeoComputers
+import org.neoflock.neocomputers.gui.widget.ComponentRoles
+import org.neoflock.neocomputers.gui.widget.ComponentSlot
+import org.neoflock.neocomputers.gui.widget.ComponentSlotRequirement
 import org.neoflock.neocomputers.gui.widget.DynamicSlot
 import org.neoflock.neocomputers.utils.GenericContainerMenu
 
 class CaseMenu : GenericContainerMenu {
+    constructor(i: Int, inv: Inventory) : this(i, inv, SimpleContainer(7))
 
-    constructor(i: Int, inv: Inventory) : super(Menus.CASE_MENU.get(), i, SimpleContainer(10)) {
+    open val eepromRequirement = ComponentSlotRequirement(1, ComponentRoles.FIRMWARE)
+    open val slotRequirements = listOf(
+        listOf(ComponentSlotRequirement(1, ComponentRoles.CARD), ComponentSlotRequirement(1, ComponentRoles.CARD)),
+        listOf(ComponentSlotRequirement(1, ComponentRoles.COMPUTE), ComponentSlotRequirement(1, ComponentRoles.MEMORY), ComponentSlotRequirement(1, ComponentRoles.MEMORY)),
+        listOf(ComponentSlotRequirement(1, ComponentRoles.STORAGE)),
+    )
+
+    constructor(i: Int, inv: Inventory, container: Container) : super(Menus.CASE_MENU.get(), i, container) {
         this.addInventorySlots(inv, 8, 84)
 
-        for (col in 0..2) {
+        this.addSlot(ComponentSlot(this.container!!, 0, 20, 34, eepromRequirement))
-            for (row in 0..2) {
+
-                var i = col*3+row
+        var i = 1
-                this.addSlot(DynamicSlot(this.container!!, i, 98+(col*22), 18*(row+1)-2))
+        for ((col, slotCol) in slotRequirements.withIndex()) {
+            for ((row, slotReq) in slotCol.withIndex()) {
+                this.addSlot(ComponentSlot(this.container!!, i, 98+(col*22), 18*(row+1)-2, slotReq))
+                i++
             }
         }
         // for (int col=1; col<4; col++) {
@@ -31,7 +46,4 @@ class CaseMenu : GenericContainerMenu {
         //     }
         // }
     }
-
-    override fun stillValid(player: Player) = true // TODO: implement this properly
-    override fun quickMoveStack(player: Player, i: Int): ItemStack = ItemStack.EMPTY // there's no container here anyways
 }

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

@@ -18,6 +18,8 @@ import org.neoflock.neocomputers.utils.GenericContainerScreen
 
 class CaseScreen : GenericContainerScreen<CaseMenu> {
     private val PCB: ResourceLocation = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/computer.png")
+
+    override fun shouldCenterTitle(): Boolean = false
     
     constructor(abstractContainerMenu: CaseMenu, inventory: Inventory, component: Component) : super(abstractContainerMenu, inventory, component)
     override fun renderBg(guiGraphics: GuiGraphics, f: Float, i: Int, j: Int) {

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

@@ -0,0 +1,133 @@
+package org.neoflock.neocomputers.gui.widget
+
+import com.mojang.blaze3d.systems.RenderSystem
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.renderer.GameRenderer
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.Container
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.level.ItemLike
+import org.neoflock.neocomputers.NeoComputers
+import org.neoflock.neocomputers.item.ComponentItem
+
+// Sort of a mis-nomer, does not need to be associated with components specifically
+
+object ComponentRoles {
+    // For card slots
+    val CARD = "card"
+    // For memory slots
+    val MEMORY = "memory"
+    // For storage slots, aside from EEPROMs and floppys
+    val STORAGE = "storage"
+    // For floppy drive slots
+    val FLOPPY = "floppy"
+    // For EEPROM slots
+    val FIRMWARE = "firmware"
+    // For CPU slot
+    val COMPUTE = "compute"
+    // For component bus
+    val BUS = "bus"
+    val TOOL = "tool"
+    val UPGRADE = "upgrade"
+    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")
+
+    val textureMap = mutableMapOf<String, ResourceLocation>()
+
+    fun mapTexture(role: String, texture: ResourceLocation) {
+        textureMap[role] = texture
+    }
+
+    fun getTextureFor(role: String) = textureMap[role] ?: MISSING_ROLE_TEXTURE
+
+    fun mapDefaultTextures() {
+        val core = mapOf(
+            CARD to "card",
+            BUS to "component_bus",
+            CONTAINER to "container",
+            COMPUTE to "cpu",
+            FIRMWARE to "eeprom",
+            FLOPPY to "floppy",
+            STORAGE to "hdd",
+            MEMORY to "memory",
+            TABLET to "tablet",
+            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"))
+        }
+    }
+}
+
+data class ComponentSlotRequirement(val tier: Int, val role: String) {
+    fun allowsItemStack(itemStack: ItemStack): Boolean {
+        val item = itemStack.item
+        if(item !is ComponentItem) return false
+        if(tier > 0 && item.getComponentTier(itemStack) > tier) return false
+        return item.getComponentRoles(itemStack).contains(role)
+    }
+}
+
+// Tier 0 allows ALL tiers, making it completely untiered.
+// Role determines what the role is.
+class ComponentSlot(container: Container, slot: Int, x: Int, y: Int, val requirement: ComponentSlotRequirement): DynamicSlot(container, slot, x, y) {
+    override fun draw(graphics: GuiGraphics, relX: Int, relY: Int, mouseX: Int, mouseY: Int) {
+        super.draw(graphics, relX, relY, mouseX, mouseY)
+        if(!hasItem()) {
+            RenderSystem.enableBlend()
+            RenderSystem.setShaderTexture(0, ComponentRoles.getTextureFor(requirement.role))
+            RenderSystem.setShader { GameRenderer.getPositionTexShader() }
+            drawQuad(relX + x - 1, relY + y - 1, 18, 18, 0F, 0F, 15F, 15F)
+            if (requirement.tier > 0) {
+                RenderSystem.setShaderTexture(
+                    0,
+                    ResourceLocation.fromNamespaceAndPath(
+                        NeoComputers.MODID,
+                        "textures/gui/slots/tier${requirement.tier - 1}.png"
+                    )
+                )
+                RenderSystem.setShader { GameRenderer.getPositionTexShader() }
+                drawQuad(relX + x - 1, relY + y - 1, 18, 18, 0F, 0F, 15F, 15F)
+            }
+            RenderSystem.disableBlend()
+        }
+    }
+
+    override fun mayPlace(itemStack: ItemStack): Boolean {
+        if(!requirement.allowsItemStack(itemStack)) return false
+        return super.mayPlace(itemStack)
+    }
+
+    override fun set(itemStack: ItemStack) {
+        super.set(itemStack)
+        val item = itemStack.item
+        if(item is ComponentItem) {
+            item.whenComponentPlaced(itemStack, requirement.role)
+        }
+    }
+
+    override fun onTake(player: Player, itemStack: ItemStack) {
+        val item = itemStack.item
+        if(item is ComponentItem) {
+            item.whenComponentTaken(itemStack, requirement.role)
+        }
+        super.onTake(player, itemStack)
+    }
+
+    override fun getMaxStackSize(): Int = 1
+    override fun getMaxStackSize(itemStack: ItemStack): Int = 1
+}

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

@@ -18,7 +18,7 @@ open class DynamicSlot(container: Container, slot: Int, x: Int, y: Int) : Slot(c
 
     val BACKGROUND: ResourceLocation = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "textures/gui/slots/slot.png")
 
-    fun draw(graphics: GuiGraphics, relX: Int, relY: Int, mouseX: Int, mouseY: Int) {
+    open fun draw(graphics: GuiGraphics, relX: Int, relY: Int, mouseX: Int, mouseY: Int) {
         RenderSystem.enableBlend() // background
         RenderSystem.setShaderTexture(0, BACKGROUND)
         RenderSystem.setShader { GameRenderer.getPositionTexShader() }
@@ -26,7 +26,7 @@ open class DynamicSlot(container: Container, slot: Int, x: Int, y: Int) : Slot(c
         RenderSystem.disableBlend()
     }
 
-    private fun drawQuad(x: Int, y: Int, width: Int, height: Int, u1: Float, v1: Float, u2: Float, v2: Float) {
+    fun drawQuad(x: Int, y: Int, width: Int, height: Int, u1: Float, v1: Float, u2: Float, v2: Float) {
         var t: Tesselator = Tesselator.getInstance()
         var builder: BufferBuilder = t.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX)
 

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

@@ -0,0 +1,37 @@
+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 {
+    fun getComponentRoles(itemStack: ItemStack): Set<String>
+    fun getComponentTier(itemStack: ItemStack): Int
+
+    // Get machine properties they can influence
+    fun getMemoryCapacity(itemStack: ItemStack): Int = 0
+    fun getComponentCapacity(itemStack: ItemStack): Int = 0
+
+    // 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

@@ -0,0 +1,21 @@
+package org.neoflock.neocomputers.item
+
+import com.mojang.serialization.Codec
+import net.minecraft.core.Registry
+import net.minecraft.core.component.DataComponentType
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.resources.ResourceLocation
+import org.neoflock.neocomputers.NeoComputers
+
+object DataComponents {
+    val ADDRESS = Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "address"),
+        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"),
+        DataComponentType.builder<String>().persistent(Codec.STRING).build())
+}

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

@@ -0,0 +1,67 @@
+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 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)
+
+    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 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)
+            list.addLast(addrComp)
+            list.addLast(Component.translatable("neocomputers.eeprom.codeused", Formatting.formatMemory(codeSize.toLong()),
+                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)
+    }
+
+    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 EEPROM0: EEPROMItem(1, 4096, 256)

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,4 +1,4 @@
-package org.neoflock.neocomputers.item;
+package org.neoflock.neocomputers.item
 
 import dev.architectury.registry.registries.DeferredRegister
 import net.minecraft.core.registries.Registries
@@ -7,4 +7,43 @@ import org.neoflock.neocomputers.NeoComputers
 
 object Items {
     val ITEMS: DeferredRegister<Item> = DeferredRegister.create(NeoComputers.MODID, Registries.ITEM)
+
+    val MEM0 = ITEMS.register("memory0") { MemoryTier1() }
+    val MEM1 = ITEMS.register("memory1") { MemoryTier1_5() }
+    val MEM2 = ITEMS.register("memory2") { MemoryTier2() }
+    val MEM3 = ITEMS.register("memory3") { MemoryTier2_5() }
+    val MEM4 = ITEMS.register("memory4") { MemoryTier3() }
+    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() }
+
+    val REDIO0 = ITEMS.register("redio0") { RedstoneCard0() }
+    val REDIO1 = ITEMS.register("redio1") { RedstoneCard1() }
 }

src/main/kotlin/org/neoflock/neocomputers/item/MemoryItem.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
+
+open class MemoryItem(val tier: Int, val capacity: Int): Item(Item.Properties().`arch$tab`(Tabs.TAB)), ComponentItem {
+    override fun getComponentRoles(itemStack: ItemStack) = setOf(ComponentRoles.MEMORY)
+
+    override fun getComponentTier(itemStack: ItemStack): Int = tier
+
+    override fun getMemoryCapacity(itemStack: ItemStack): Int = capacity
+
+    override fun getComponentCapacity(itemStack: ItemStack): Int = 0
+
+    override fun whenComponentPlaced(itemStack: ItemStack, newRole: String) {}
+
+    override fun whenComponentTaken(itemStack: ItemStack, previousRole: String) {}
+
+    // no node for memory
+    override fun toComponentNode(itemStack: ItemStack): Networking.Node? = null
+
+    override fun appendHoverText(
+        itemStack: ItemStack,
+        tooltipContext: TooltipContext,
+        list: MutableList<Component?>,
+        tooltipFlag: TooltipFlag
+    ) {
+        if(tooltipFlag.isAdvanced) {
+            list.addLast(Component.translatable("neocomputers.memory.capacity", Formatting.formatMemory(capacity.toLong())))
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+}
+
+class MemoryTier1(): MemoryItem(1, 192 shl 10)
+class MemoryTier1_5(): MemoryItem(1, 256 shl 10)
+class MemoryTier2(): MemoryItem(2, 384 shl 10)
+class MemoryTier2_5(): MemoryItem(2, 512 shl 10)
+class MemoryTier3(): MemoryItem(3, 768 shl 10)
+class MemoryTier3_5(): MemoryItem(3, 1 shl 20)

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/RedstoneCard.kt

@@ -0,0 +1,41 @@
+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 RedstoneCard(val tier: Int): 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: Redstone 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)
+            // TODO: show redstone and whatnot
+        }
+        super.appendHoverText(itemStack, tooltipContext, list, tooltipFlag)
+    }
+}
+
+class RedstoneCard0: RedstoneCard(1)
+class RedstoneCard1: RedstoneCard(2)

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

@@ -1,22 +1,64 @@
-package org.neoflock.neocomputers.item;
+package org.neoflock.neocomputers.item
 
 import dev.architectury.registry.CreativeTabRegistry
 import dev.architectury.registry.registries.DeferredRegister
-import dev.architectury.registry.registries.RegistrySupplier
 import net.minecraft.core.registries.Registries
 import net.minecraft.network.chat.Component
 import net.minecraft.world.item.CreativeModeTab
 import net.minecraft.world.item.ItemStack
-import net.minecraft.world.item.Items
 import org.neoflock.neocomputers.NeoComputers
-import java.util.function.Supplier
-
 
 object Tabs {
-    val TABS: DeferredRegister<CreativeModeTab> = DeferredRegister.create(NeoComputers.MODID, Registries.CREATIVE_MODE_TAB)
+    val TABS: DeferredRegister<CreativeModeTab> =
+        DeferredRegister.create(NeoComputers.MODID, Registries.CREATIVE_MODE_TAB)
 
-    val TAB: RegistrySupplier<CreativeModeTab> = TABS.register("neocomputers_tab", Supplier {CreativeTabRegistry.create( 
+    val TAB = TABS.register("neocomputers_tab") {
-        Component.literal("NeoComputers"),
+        // its only experimental once they change it
-        Supplier { ItemStack(Items.ACACIA_BOAT) }
+        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.REDIO0.get()))
+                output.accept(ItemStack(Items.REDIO1.get()))
+
+                output.accept(ItemStack(Items.EE0.get()))
+
+                val luaBios = ItemStack(Items.EE0.get())
+                luaBios.set(DataComponents.LABEL, "Lua BIOS")
+                luaBios.set(DataComponents.EEPROM_CODE, "error('hi')")
+                luaBios.set(DataComponents.EEPROM_DATA, "random garbage")
+                output.accept(luaBios)
+            }
+        }
+    }
 }

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;
+        if(node !in allNodes) return
-        allNodes.remove(node);
+        allNodes.forEach { it.onNodeRemoved(node) }
-        if(node is WirelessEndpoint) {
-            wirelessNodes.remove(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/kotlin/org/neoflock/neocomputers/utils/Formatting.kt

@@ -0,0 +1,15 @@
+package org.neoflock.neocomputers.utils
+
+object Formatting {
+    fun formatMemory(size: Long, spacing: String = " "): String {
+        var unit = 0
+        val units = listOf("B", "KiB", "MiB", "GiB", "TiB", "PiB")
+        var num = size.toDouble()
+        while(unit < units.lastIndex && num >= 1024) {
+            num /= 1024
+            unit++
+        }
+        num = (num * 100).toInt().toDouble() / 100
+        return "$num$spacing${units[unit]}"
+    }
+}

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

@@ -2,5 +2,49 @@
   "neocomputers.confirm": "Confirm",
   "neocomputers.cancel": "Cancel",
   "block.neocomputers.combustgen": "Combustion Generator",
-  "block.neocomputers.redio": "Redstone I/O"
+  "block.neocomputers.redio": "Redstone I/O",
+  "item.neocomputers.redio0": "Redstone Card (Tier 1)",
+  "item.neocomputers.redio1": "Redstone Card (Tier 2)",
+  "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",
+  "neocomputers.eeprom.dataused": "Data 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/eeprom0.json

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

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/memory0.json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 }
+    ]
+  }
+}