EEPROMs

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

@@ -3,22 +3,15 @@ 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
@@ -103,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/item/DataComponents.kt

@@ -0,0 +1,19 @@
+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 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,65 @@
+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, "")
+
+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) {
+        if(!itemStack.has(DataComponents.ADDRESS)) {
+            itemStack.set(DataComponents.ADDRESS, UUID.randomUUID().toString())
+        }
+    }
+
+    override fun whenComponentTaken(itemStack: ItemStack, previousRole: String) {}
+
+    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 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())))
+        }
+        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/Items.kt

@@ -1,17 +1,31 @@
-package org.neoflock.neocomputers.item;
+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)
 
-    val MEM0 = ITEMS.register("memory0") { MemoryTier1() }
+    val MEM0 = register("memory0") { MemoryTier1() }
-    val MEM1 = ITEMS.register("memory1") { MemoryTier1_5() }
+    val MEM1 = register("memory1") { MemoryTier1_5() }
-    val MEM2 = ITEMS.register("memory2") { MemoryTier2() }
+    val MEM2 = register("memory2") { MemoryTier2() }
-    val MEM3 = ITEMS.register("memory3") { MemoryTier2_5() }
+    val MEM3 = register("memory3") { MemoryTier2_5() }
-    val MEM4 = ITEMS.register("memory4") { MemoryTier3() }
+    val MEM4 = register("memory4") { MemoryTier3() }
-    val MEM5 = ITEMS.register("memory5") { MemoryTier3_5() }
+    val MEM5 = register("memory5") { MemoryTier3_5() }
+
+    val EE0 = register("eeprom0") { EEPROM0() }
+
+    fun<T: Item> register(name: String, itemFac: Supplier<T>): T {
+        val key = ResourceKey.create(Registries.ITEM, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, name))
+        val item = itemFac.get()
+        Registry.register(BuiltInRegistries.ITEM, key, item)
+        return item
+    }
 }

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

@@ -1,22 +1,35 @@
-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.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 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 TAB: RegistrySupplier<CreativeModeTab> = TABS.register("neocomputers_tab", Supplier {CreativeTabRegistry.create( 
+    val TAB: CreativeModeTab = Registry.register(BuiltInRegistries.CREATIVE_MODE_TAB,
-        Component.literal("NeoComputers"),
+        ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "neocomputers_tab"), CreativeTabRegistry.create {
-        Supplier { ItemStack(Items.ACACIA_BOAT) }
+        builder ->
-     )})
+        builder.title(Component.literal("NeoComputers"))
+        builder.icon {
+            ItemStack(Items.MEM0)
+        }
+        builder.displayItems {
+            parameters, output ->
+            output.accept(ItemStack(Items.EE0))
+
+            val luaBios = ItemStack(Items.EE0)
+            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/resources/assets/neocomputers/lang/en_us.json

@@ -3,5 +3,9 @@
   "neocomputers.cancel": "Cancel",
   "block.neocomputers.combustgen": "Combustion Generator",
   "block.neocomputers.redio": "Redstone I/O",
-  "neocomputers.memory.capacity": "Capacity: %1$s"
+  "item.neocomputers.eeprom0": "EEPROM (Tier 1)",
+  "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"
 }