feaT: more work (#32)

.artifactsmmo-engine.yaml.example

@@ -1,19 +1,48 @@
 token: foo-bar
-log_level: 0
+log_level: -4
+orders:
+  - item:
+      code: copper_dagger
+      quantity: 50
+    concurrency: 5
+  - item:
+      code: wooden_staff
+      quantity: 50
+    concurrency: 5
+  - item:
+      code: copper_helmet
+      quantity: 50
+    concurrency: 5
+  - item:
+      code: copper_boots
+      quantity: 50
+    concurrency: 5
+  - item:
+      code: copper_ring
+      quantity: 50
+    concurrency: 5
+  - item:
+      code: wooden_shield
+      quantity: 50
+    concurrency: 5
 characters:
   - name: Milnor
     actions:
-      - gather
+      - forage
+      - refine
   - name: Bilnor
     actions:
-      - gather
+      - forage
+      - refine
   - name: Wilnor
     actions:
-      - gather
+      - forage
+      - refine
   - name: Jilnor
     actions:
-      - gather
+      - forage
+      - refine
   - name: Vilnor
     actions:
-      - gather
+      - forage
       - refine

cmd/engine/main.go

@@ -69,7 +69,7 @@ func main() {
 	}
 	ctx := context.Background()
 
-	orders := make(chan models.Order, 10)
+	orders := make(chan models.Order, 100)
 	for _, o := range cfg.Orders {
 		for n := 0; n < o.Concurrency; n++ {
 			slog.Debug("adding order to queue", "order", o)

internal/engine/decision.go

@@ -70,6 +70,8 @@ func Execute(ctx context.Context, r *actions.Runner, character string, actions [
 				if ShouldFulfilOrder(ctx, r, c, o) {
 					l.Debug("order incomplete, re-queueing", "order", o)
 					orders <- o
+				} else {
+					l.Debug("order complete!", "order", o)
 				}
 			}
 		default:

internal/engine/order.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	"github.com/promiseofcake/artifactsmmo-engine/internal/actions"
 	"github.com/promiseofcake/artifactsmmo-engine/internal/logging"
@@ -13,6 +14,12 @@ import (
 // ShouldFulfilOrder determines if this order is still relevant / should be fulfilled
 // it's based upon the quantity on hand in bank, not counting items in flight
 func ShouldFulfilOrder(ctx context.Context, r *actions.Runner, c models.Character, order models.Order) bool {
+	// refresh char data
+	c, err := r.GetMyCharacterInfo(ctx, c.Name)
+	if err != nil {
+		return false
+	}
+
 	// determine what's in the bank
 	items, err := r.GetBankItems(ctx)
 	if err != nil {
@@ -88,11 +95,12 @@ func FulfilOrder(ctx context.Context, r *actions.Runner, character string, order
 		if err != nil {
 			return nil, fmt.Errorf("get item craft schema: %w", err)
 		}
-		// items
+		item.Skill = string(*cs.Skill)
 
-		var reqs []models.Order
+		// items
+		var newOrders []models.Order
+		var materials []models.Order
 		for _, input := range *cs.Items {
-
 			io := models.Order{
 				Item: models.SimpleItem{
 					Code:     input.Code,
@@ -104,21 +112,69 @@ func FulfilOrder(ctx context.Context, r *actions.Runner, character string, order
 
 			if ShouldFulfilOrder(ctx, r, c, io) {
 				l.Debug("missing required item for crafting", "order", io)
-				reqs = append(reqs, io)
+				newOrders = append(newOrders, io)
+			} else {
+				materials = append(materials, io)
 			}
 		}
 
-		if len(reqs) > 0 {
-			return reqs, errors.New("requirements not met")
+		if len(newOrders) > 0 {
+			return newOrders, errors.New("requirements not met")
 		}
 
 		l.Debug("all items present for crafting!")
 
+		// check inventory
+
 		// go to bank
+
+		tErr := Travel(ctx, r, character, models.Location{
+			Code: "bank",
+			Type: "bank",
+		})
+		if tErr != nil {
+			return nil, tErr
+		}
+
+		// deposit all
+		dErr := DepositAll(ctx, r, character)
+		if dErr != nil {
+			return nil, fmt.Errorf("failed to deposit all: %w", dErr)
+		}
+
 		// withdraw items
+		for _, mat := range materials {
+			l.Info("withdrawing item", "code", mat.Item.Code, "qty", mat.Item.Quantity)
+			resp, wErr := r.Withdraw(ctx, character, mat.Item.Code, mat.Item.Quantity)
+			if wErr != nil {
+				return nil, wErr
+			}
+			cooldown := time.Until(resp.CooldownSchema.Expiration)
+			c.CharacterSchema = resp.CharacterResponse.CharacterSchema
+			time.Sleep(cooldown)
+		}
+
 		// craft items
+		l.Info("traveling to workshop", "skill", item.Skill)
+		err = Travel(ctx, r, character, models.Location{
+			Code: item.Skill,
+			Type: "workshop",
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		skillresp, err := r.Craft(ctx, character, order.Item.Code, order.Item.Quantity)
+		if err != nil {
+			return nil, fmt.Errorf("failed to craft %s, %d, code: %w", order.Item.Code, order.Item.Quantity, err)
+		}
+		l.Info("skill response", "response", skillresp.SkillInfo)
+
+		cooldown := time.Until(skillresp.Response.CooldownSchema.Expiration)
+		c.CharacterSchema = skillresp.Response.CharacterResponse.CharacterSchema
+		time.Sleep(cooldown)
 
-		return nil, errors.New("failed to implemnet crafting")
+		return nil, nil
 	}
 
 	return nil, nil

internal/engine/refine.go

@@ -165,7 +165,14 @@ func Refine(ctx context.Context, r *actions.Runner, character string) error {
 	}
 
 	resourceToRefine := available[0]
-
+	l.Info("traveling to workshop", "skill", resourceToRefine.Skill)
+	err = Travel(ctx, r, character, models.Location{
+		Code: resourceToRefine.Skill,
+		Type: "workshop",
+	})
+	if err != nil {
+		return err
+	}
 	for _, mat := range resourceToRefine.CraftMaterials {
 		qty := resourceToRefine.Quantity * mat.CostPerResource
 		l.Info("withdrawing item", "code", mat.RequiredCode, "qty", qty)
@@ -182,14 +189,6 @@ func Refine(ctx context.Context, r *actions.Runner, character string) error {
 	l.Info("preparing to refine", "resource", resourceToRefine.Name, "qty", resourceToRefine.Quantity)
 
 	// need to travel to refinement location
-	l.Info("traveling to workshop", "skill", resourceToRefine.Skill)
-	err = Travel(ctx, r, character, models.Location{
-		Code: resourceToRefine.Skill,
-		Type: "workshop",
-	})
-	if err != nil {
-		return err
-	}
 
 	// need to refine the item
 	skillresp, err := r.Craft(ctx, character, resourceToRefine.Code, resourceToRefine.Quantity)

internal/models/character.go

@@ -52,6 +52,11 @@ func (c Character) ChooseWeakestSkill() CharacterSkill {
 		},
 	}
 
+	// if maxed out, do mining
+	if c.FishingLevel == 35 && c.MiningLevel == 35 && c.WoodcuttingLevel == 35 {
+		return skills[1]
+	}
+
 	slices.SortFunc(skills, func(a, b CharacterSkill) int {
 		return cmp.Compare(a.CurrentLevel, b.CurrentLevel)
 	})