refactor: removed separate crafting recipes and combined them into item YAML

1 files changed, 49 insertions, 61 deletions

diff --git a/internal/game/action_fletch.go b/internal/game/action_fletch.go
index 3d8c30f..52de86b 100644
--- a/internal/game/action_fletch.go
+++ b/internal/game/action_fletch.go
@@ -6,43 +6,45 @@ import (
 	"thehouseoficarus/internal/action"
 	"thehouseoficarus/internal/engine"
 	"thehouseoficarus/internal/net"
+	"thehouseoficarus/internal/object"
 	"thehouseoficarus/internal/player"
 )
 
-func (g *Game) startFletchAction(sess *net.Session, p *player.Player, recipe *action.RecipeDef, count int) {
+func (g *Game) startFletchAction(sess *net.Session, p *player.Player, item *object.ItemDef, count int) {
 	p.EnsureFlags()
-	p.Flags["last_fletch"] = recipe.ID
+	p.Flags["last_fletch"] = item.ID
 	g.AccountStore.SaveCharacter(p)
 
-	if recipe.Wait <= 0 {
-		g.doInstantFletch(sess, p, recipe, count)
+	if item.FirstCraft().Wait <= 0 {
+		g.doInstantFletch(sess, p, item, count)
 		return
 	}
 
-	g.startTimedFletch(sess, p, recipe, count)
+	g.startTimedFletch(sess, p, item, count)
 }
 
-func (g *Game) doInstantFletch(sess *net.Session, p *player.Player, recipe *action.RecipeDef, count int) {
-	outDef, _ := g.ItemStore.Load(recipe.Output)
-	outputQty := recipe.OutputQty
+func (g *Game) doInstantFletch(sess *net.Session, p *player.Player, item *object.ItemDef, count int) {
+	c := item.FirstCraft()
+	outputQty := c.OutputQty
 	if outputQty <= 0 {
 		outputQty = 1
 	}
 
 	batches := 0
 	totalOutput := 0
-	skill := player.SkillName(recipe.EffectiveSkill())
+	skill := player.SkillName(c.EffectiveSkill())
+	tmpItem := &object.ItemDef{Craft: object.CraftList{*c}}
 	for {
-		if !g.canDoFletchRecipe(p, recipe) {
+		if !g.canDoFletchItem(p, tmpItem) {
 			break
 		}
 
 		placed := false
-		if outDef != nil && outDef.Stackable {
+		if item.Stackable {
 			for i := 0; i < 28; i++ {
 				slot := p.InvSlot(i)
-				if slot != nil && slot.ItemID == recipe.Output {
-					recipe.ConsumeAll(p.HasItem, p.RemoveItem)
+				if slot != nil && slot.ItemID == item.ID {
+					craftConsumeAll(c, p.HasItem, p.RemoveItem)
 					slot.Quantity += outputQty
 					placed = true
 					break
@@ -50,16 +52,16 @@ func (g *Game) doInstantFletch(sess *net.Session, p *player.Player, recipe *acti
 			}
 		}
 		if !placed {
-			recipe.ConsumeAll(p.HasItem, p.RemoveItem)
+			craftConsumeAll(c, p.HasItem, p.RemoveItem)
 			freeSlot := p.FirstFreeSlot()
 			if freeSlot == -1 {
 				break
 			}
-			p.SetInvSlot(freeSlot, &player.InventorySlot{ItemID: recipe.Output, Quantity: outputQty})
+			p.SetInvSlot(freeSlot, &player.InventorySlot{ItemID: item.ID, Quantity: outputQty})
 		}
 
-		if recipe.XP > 0 {
-			g.awardSkillXP(sess, p, skill, recipe.XP)
+		if c.XP > 0 {
+			g.awardSkillXP(sess, p, skill, c.XP)
 		}
 
 		batches++
@@ -80,57 +82,47 @@ func (g *Game) doInstantFletch(sess *net.Session, p *player.Player, recipe *acti
 
 	g.AccountStore.SaveCharacter(p)
 
-	outputName := recipe.Output
-	if outDef != nil {
-		outputName = outDef.Name
-	}
-
-	msg := fmt.Sprintf("You fletch %d %s.", totalOutput, outputName)
-	if p.OptionBool("xp_drops") && recipe.XP > 0 {
-		totalXP := recipe.XP * batches
+	msg := fmt.Sprintf("You fletch %d %s.", totalOutput, item.Name)
+	if p.OptionBool("xp_drops") && c.XP > 0 {
+		totalXP := c.XP * batches
 		abbr := player.SkillAbbr[skill]
 		msg += g.colorize(sess, "xp", fmt.Sprintf(" (+%dxp %s)", totalXP, abbr))
 	}
 	sess.WriteLine(msg)
 }
 
-func (g *Game) startTimedFletch(sess *net.Session, p *player.Player, recipe *action.RecipeDef, count int) {
-	outDef, _ := g.ItemStore.Load(recipe.Output)
-	outputName := recipe.Output
-	if outDef != nil {
-		outputName = outDef.Name
-	}
-
+func (g *Game) startTimedFletch(sess *net.Session, p *player.Player, item *object.ItemDef, count int) {
 	p.BackgroundAction = &action.Action{
 		Type:       "fletch",
-		TargetID:   recipe.ID,
-		TargetName: outputName,
+		TargetID:   item.ID,
+		TargetName: item.Name,
 		Data: map[string]any{
-			"recipe_id": recipe.ID,
+			"item_id":   item.ID,
 			"phase":     0,
-			"wait":      recipe.Wait,
+			"wait":      item.FirstCraft().Wait,
 			"remaining": count,
 		},
 		WaitLeft: engine.ToTicks(1),
 	}
-	p.BackgroundActionState = &ActionState{Type: ActionFletching, TargetName: outputName}
+	p.BackgroundActionState = &ActionState{Type: ActionFletching, TargetName: item.Name}
 
 	g.broadcastAction(sess, "\n%s starts fletching.", p.Name)
 
-	sess.WriteLine(fmt.Sprintf("\nYou begin fletching %s.", outputName))
+	sess.WriteLine(fmt.Sprintf("\nYou begin fletching %s.", item.Name))
 }
 
 func (g *Game) advanceFletch(sess *net.Session, p *player.Player) {
-	recipeID, _ := p.BackgroundAction.Data["recipe_id"].(string)
+	itemID, _ := p.BackgroundAction.Data["item_id"].(string)
 	phase, _ := p.BackgroundAction.Data["phase"].(int)
 	wait, _ := p.BackgroundAction.Data["wait"].(float64)
 	remaining, _ := p.BackgroundAction.Data["remaining"].(int)
 
-	recipe := g.loadRecipe(recipeID)
-	if recipe == nil {
+	item := g.loadCraftItem(itemID)
+	if item == nil {
 		g.cancelBgAction(p)
 		return
 	}
+	c := item.FirstCraft()
 
 	if phase == 0 {
 		p.BackgroundAction.Data["phase"] = 1
@@ -138,26 +130,26 @@ func (g *Game) advanceFletch(sess *net.Session, p *player.Player) {
 		return
 	}
 
-	if !g.canDoFletchRecipe(p, recipe) {
+	tmpItem := &object.ItemDef{Craft: object.CraftList{*c}}
+	if !g.canDoFletchItem(p, tmpItem) {
 		sess.WriteLine("\nYou've run out of fletching materials.")
 		g.cancelBgAction(p)
 		return
 	}
 
-	outDef, _ := g.ItemStore.Load(recipe.Output)
-	outputQty := recipe.OutputQty
+	outputQty := c.OutputQty
 	if outputQty <= 0 {
 		outputQty = 1
 	}
 
-	skill := player.SkillName(recipe.EffectiveSkill())
+	skill := player.SkillName(c.EffectiveSkill())
 
 	placed := false
-	if outDef != nil && outDef.Stackable {
+	if item.Stackable {
 		for i := 0; i < 28; i++ {
 			slot := p.InvSlot(i)
-			if slot != nil && slot.ItemID == recipe.Output {
-				recipe.ConsumeAll(p.HasItem, p.RemoveItem)
+			if slot != nil && slot.ItemID == item.ID {
+				craftConsumeAll(c, p.HasItem, p.RemoveItem)
 				slot.Quantity += outputQty
 				placed = true
 				break
@@ -165,32 +157,28 @@ func (g *Game) advanceFletch(sess *net.Session, p *player.Player) {
 		}
 	}
 	if !placed {
-		recipe.ConsumeAll(p.HasItem, p.RemoveItem)
+		craftConsumeAll(c, p.HasItem, p.RemoveItem)
 		freeSlot := p.FirstFreeSlot()
 		if freeSlot == -1 {
 			sess.WriteLine("\nYour inventory is too full!")
 			g.cancelBgAction(p)
 			return
 		}
-		p.SetInvSlot(freeSlot, &player.InventorySlot{ItemID: recipe.Output, Quantity: outputQty})
+		p.SetInvSlot(freeSlot, &player.InventorySlot{ItemID: item.ID, Quantity: outputQty})
 	}
 
-	if recipe.XP > 0 {
-		g.awardSkillXP(sess, p, skill, recipe.XP)
+	if c.XP > 0 {
+		g.awardSkillXP(sess, p, skill, c.XP)
 	}
 	g.AccountStore.SaveCharacter(p)
 
-	outputName := recipe.Output
-	if outDef != nil {
-		outputName = outDef.Name
-	}
-	msg := recipe.Message
+	msg := c.Message
 	if msg == "" {
-		msg = fmt.Sprintf("You fletch %s.", outputName)
+		msg = fmt.Sprintf("You fletch %s.", item.Name)
 	}
-	if p.OptionBool("xp_drops") && recipe.XP > 0 {
+	if p.OptionBool("xp_drops") && c.XP > 0 {
 		abbr := player.SkillAbbr[skill]
-		msg += g.colorize(sess, "xp", fmt.Sprintf(" (+%dxp %s)", recipe.XP, abbr))
+		msg += g.colorize(sess, "xp", fmt.Sprintf(" (+%dxp %s)", c.XP, abbr))
 	}
 	sess.WriteLine(msg)
 
@@ -204,7 +192,7 @@ func (g *Game) advanceFletch(sess *net.Session, p *player.Player) {
 		}
 	}
 
-	if !g.canContinueProduction(p, recipe) {
+	if !g.canContinueProduction(p, item) {
 		sess.WriteLine("\nYou've run out of fletching materials.")
 		g.cancelBgAction(p)
 		return