Smithing templates + Table and Armour Trims

server/internal/nbtconv/read.go

@@ -148,6 +148,7 @@ func MapItem(x map[string]any, k string) item.Stack {
 		}
 
 		s := readItemStack(m, tag)
+		readArmourTrim(tag, &s)
 		readDamage(tag, &s, true)
 		readEnchantments(tag, &s)
 		readDisplay(tag, &s)
@@ -171,6 +172,7 @@ func Item(data map[string]any, s *item.Stack) item.Stack {
 		s = &a
 	}
 
+	readArmourTrim(tag, s)
 	readAnvilCost(tag, s)
 	readDamage(tag, s, disk)
 	readDisplay(tag, s)
@@ -222,6 +224,20 @@ func readAnvilCost(m map[string]any, s *item.Stack) {
 	*s = s.WithAnvilCost(int(Int32(m, "RepairCost")))
 }
 
+// readArmourTrim reads the armour trim stored in the NBT and saves it to the item.Stack passed.
+func readArmourTrim(m map[string]any, s *item.Stack) {
+	if trim, ok := m["Trim"].(map[string]any); ok {
+		material, ok := trim["Material"].(string)
+		pattern, ok2 := trim["Pattern"].(string)
+		if ok && ok2 {
+			*s = s.WithArmourTrim(item.ArmourTrim{
+				Template: item.TemplateFromString(pattern),
+				Material: item.MaterialFromString(material),
+			})
+		}
+	}
+}
+
 // readEnchantments reads the enchantments stored in the ench tag of the NBT passed and stores it into an item.Stack.
 func readEnchantments(m map[string]any, s *item.Stack) {
 	enchantments, ok := m["ench"].([]map[string]any)

server/internal/nbtconv/write.go

@@ -17,6 +17,7 @@ func WriteItem(s item.Stack, disk bool) map[string]any {
 			tag[k] = v
 		}
 	}
+	writeArmourTrim(tag, s)
 	writeAnvilCost(tag, s)
 	writeDamage(tag, s, disk)
 	writeDisplay(tag, s)
@@ -111,6 +112,16 @@ func writeEnchantments(m map[string]any, s item.Stack) {
 	}
 }
 
+// writeArmourTrim writes the
+func writeArmourTrim(m map[string]any, s item.Stack) {
+	if t := s.ArmourTrim(); t != nil {
+		m["Trim"] = map[string]any{
+			"Material": t.Material.TrimMaterial(),
+			"Pattern":  t.Template.Name,
+		}
+	}
+}
+
 // writeDisplay writes the display name and lore of an item to a map for NBT encoding.
 func writeDisplay(m map[string]any, s item.Stack) {
 	name, lore := s.CustomName(), s.Lore()

server/item/amethyst_shard.go

@@ -7,3 +7,13 @@ type AmethystShard struct{}
 func (AmethystShard) EncodeItem() (name string, meta int16) {
 	return "minecraft:amethyst_shard", 0
 }
+
+// TrimMaterial ...
+func (AmethystShard) TrimMaterial() string {
+	return "amethyst"
+}
+
+// MaterialColor ...
+func (AmethystShard) MaterialColor() string {
+	return "u"
+}

server/item/armour_trim.go

@@ -0,0 +1,48 @@
+package item
+
+import "github.com/df-mc/dragonfly/server/world"
+
+type ArmourTrim struct {
+	Template ArmourTrimTemplate
+	Material TrimMaterial
+}
+
+type TrimMaterial interface {
+	// TrimMaterial returns the material name used for reading and writing trim data.
+	TrimMaterial() string
+	// MaterialColor returns the color code used for internal text formatting. Use text.Colourf for proper formatting.
+	MaterialColor() string
+}
+
+// MaterialFromString returns a TrimMaterial from a string.
+func MaterialFromString(name string) TrimMaterial {
+	switch name {
+	case "amethyst":
+		return AmethystShard{}
+	case "copper":
+		return CopperIngot{}
+	case "diamond":
+		return Diamond{}
+	case "emerald":
+		return Emerald{}
+	case "gold":
+		return GoldIngot{}
+	case "iron":
+		return IronIngot{}
+	case "lapis":
+		return LapisLazuli{}
+	case "netherite":
+		return NetheriteIngot{}
+	case "quartz":
+		return NetherQuartz{}
+	}
+
+	//TODO: add redstone material once pr is merged
+
+	panic("should not happen")
+}
+
+// TrimMaterials returns all the items that can be trim materials.
+func TrimMaterials() []world.Item {
+	return []world.Item{AmethystShard{}, CopperIngot{}, Diamond{}, Emerald{}, GoldIngot{}, IronIngot{}, LapisLazuli{}, NetheriteIngot{}, NetherQuartz{}}
+}

server/item/copper_ingot.go

@@ -7,3 +7,13 @@ type CopperIngot struct{}
 func (c CopperIngot) EncodeItem() (name string, meta int16) {
 	return "minecraft:copper_ingot", 0
 }
+
+// TrimMaterial ...
+func (CopperIngot) TrimMaterial() string {
+	return "copper"
+}
+
+// MaterialColor ...
+func (CopperIngot) MaterialColor() string {
+	return "n"
+}

server/item/diamond.go

@@ -8,6 +8,16 @@ func (Diamond) EncodeItem() (name string, meta int16) {
 	return "minecraft:diamond", 0
 }
 
+// TrimMaterial ...
+func (Diamond) TrimMaterial() string {
+	return "diamond"
+}
+
+// MaterialColor ...
+func (Diamond) MaterialColor() string {
+	return "s"
+}
+
 // PayableForBeacon ...
 func (Diamond) PayableForBeacon() bool {
 	return true

server/item/emerald.go

@@ -8,6 +8,16 @@ func (Emerald) EncodeItem() (name string, meta int16) {
 	return "minecraft:emerald", 0
 }
 
+// TrimMaterial ...
+func (Emerald) TrimMaterial() string {
+	return "emerald"
+}
+
+// MaterialColor ...
+func (Emerald) MaterialColor() string {
+	return "q"
+}
+
 // PayableForBeacon ...
 func (Emerald) PayableForBeacon() bool {
 	return true

server/item/gold_ingot.go

@@ -8,6 +8,16 @@ func (GoldIngot) EncodeItem() (name string, meta int16) {
 	return "minecraft:gold_ingot", 0
 }
 
+// TrimMaterial ...
+func (GoldIngot) TrimMaterial() string {
+	return "gold"
+}
+
+// MaterialColor ...
+func (GoldIngot) MaterialColor() string {
+	return "p"
+}
+
 // PayableForBeacon ...
 func (GoldIngot) PayableForBeacon() bool {
 	return true

server/item/iron_ingot.go

@@ -8,6 +8,16 @@ func (IronIngot) EncodeItem() (name string, meta int16) {
 	return "minecraft:iron_ingot", 0
 }
 
+// TrimMaterial ...
+func (IronIngot) TrimMaterial() string {
+	return "iron"
+}
+
+// MaterialColor ...
+func (IronIngot) MaterialColor() string {
+	return "i"
+}
+
 // PayableForBeacon ...
 func (IronIngot) PayableForBeacon() bool {
 	return true

server/item/lapis_lazuli.go

@@ -7,3 +7,13 @@ type LapisLazuli struct{}
 func (LapisLazuli) EncodeItem() (name string, meta int16) {
 	return "minecraft:lapis_lazuli", 0
 }
+
+// TrimMaterial ...
+func (LapisLazuli) TrimMaterial() string {
+	return "lapis"
+}
+
+// MaterialColor ...
+func (LapisLazuli) MaterialColor() string {
+	return "t"
+}

server/item/nether_quartz.go

@@ -7,3 +7,13 @@ type NetherQuartz struct{}
 func (NetherQuartz) EncodeItem() (name string, meta int16) {
 	return "minecraft:quartz", 0
 }
+
+// TrimMaterial ...
+func (NetherQuartz) TrimMaterial() string {
+	return "quartz"
+}
+
+// MaterialColor ...
+func (NetherQuartz) MaterialColor() string {
+	return "h"
+}

server/item/netherite_ingot.go

@@ -8,6 +8,16 @@ func (NetheriteIngot) EncodeItem() (name string, meta int16) {
 	return "minecraft:netherite_ingot", 0
 }
 
+// TrimMaterial ...
+func (NetheriteIngot) TrimMaterial() string {
+	return "netherite"
+}
+
+// MaterialColor ...
+func (NetheriteIngot) MaterialColor() string {
+	return "j"
+}
+
 // PayableForBeacon ...
 func (NetheriteIngot) PayableForBeacon() bool {
 	return true

server/item/register.go

@@ -145,6 +145,10 @@ func init() {
 		world.RegisterItem(SplashPotion{Type: p})
 		world.RegisterItem(Potion{Type: p})
 	}
+	world.RegisterItem(Template{TemplateNetheriteUpgrade()})
+	for _, t := range Templates() {
+		world.RegisterItem(Template{Template: t})
+	}
 	for _, t := range ToolTiers() {
 		world.RegisterItem(Pickaxe{Tier: t})
 		world.RegisterItem(Axe{Tier: t})

server/item/stack.go

@@ -28,6 +28,8 @@ type Stack struct {
 	data map[string]any
 
 	enchantments map[EnchantmentType]Enchantment
+
+	armorTrim *ArmourTrim
 }
 
 // NewStack returns a new stack using the item type and the count passed. NewStack panics if the count passed
@@ -42,6 +44,23 @@ func NewStack(t world.Item, count int) Stack {
 	return Stack{item: t, count: count, id: newID()}
 }
 
+// WithArmourTrim returns a new stack with the ArmorTrim passed.
+// This only applies if the stack is type Armour.
+func (s Stack) WithArmourTrim(trim ArmourTrim) Stack {
+	if _, ok := s.item.(Armour); !ok {
+		return s
+	}
+
+	s.armorTrim = &trim
+	return s
+}
+
+// ArmourTrim returns the ArmourTrim.
+// if this returns nil it does not have an armor trim, or it is not an armour
+func (s Stack) ArmourTrim() *ArmourTrim {
+	return s.armorTrim
+}
+
 // Count returns the amount of items that is present on the stack. The count is guaranteed never to be
 // negative.
 func (s Stack) Count() int {

server/item/template.go

@@ -0,0 +1,16 @@
+package item
+
+// Template is an item used in smithing tables to alter tools and armor.
+// They are consumed when used, but can be duplicated using an existing template, its material and diamonds.
+type Template struct {
+	// Template the upgrade item used in smithing tables.
+	Template ArmourTrimTemplate
+}
+
+// EncodeItem ...
+func (t Template) EncodeItem() (name string, meta int16) {
+	if t.Template == TemplateNetheriteUpgrade() {
+		return "minecraft:netherite_upgrade_smithing_template", 0
+	}
+	return "minecraft:" + t.Template.Name + "_armor_trim_smithing_template", 0
+}