BlueGit

timfa questward

Files

questward / shared / crafting / stationRecipes.js

stationRecipes.js

stationRecipes.js 6.9 KiB Download Raw
1import { CraftingStationId } from "../definitions/craftingStations.js";
2import { ItemId } from "../definitions/items.js";
3import { CraftingItemId } from "../definitions/craftingItems.js";
4import {
5 MetalItemId,
6 PICKAXE_HEAD_ITEM_BY_METAL,
7 PICKAXE_ITEM_BY_METAL,
8 AXE_HEAD_ITEM_BY_METAL,
9 AXE_ITEM_BY_METAL
10} from "../definitions/metalItems.js";
11import {
12 WOOD_TIER_ORDER,
13 MaterialTier,
14 GatherMaterialId,
15 MATERIAL_TIER_ORDER,
16 woodTierForMetal,
17 tierSmeltSkillLevel,
18 tierCraftSkillLevel
19} from "../definitions/materialTiers.js";
20import {
21 logItemIdForWood,
22 handleItemIdForWood
23} from "../definitions/woodItems.js";
24
25/**
26 * Craft recipe schema (shared client + server):
27 *
28 * - recipeId: stable string id
29 * - stationId | stationIds: where the recipe appears
30 * - output: { itemId, quantity }
31 * - inputs: [{ itemId, quantity }, ...]
32 * - minSkillLevel: minimum linked station skill (default 1)
33 * - xpMaterial: tier id for duration + XP scaling
34 */
35
36function smelt (tier, recipeId, inputs, outputItemId)
37{
38 return Object.freeze({
39 recipeId,
40 stationId: CraftingStationId.furnace,
41 output: { itemId: outputItemId, quantity: 1 },
42 inputs,
43 minSkillLevel: tierSmeltSkillLevel(tier),
44 skillId: "smithing",
45 xpMaterial: tier
46 });
47}
48
49function handleRecipe (woodTier)
50{
51 const logId = logItemIdForWood(woodTier);
52 const handleId = handleItemIdForWood(woodTier);
53 return Object.freeze({
54 recipeId: `handle-${woodTier}`,
55 stationId: CraftingStationId.woodworkingBench,
56 output: { itemId: handleId, quantity: 1 },
57 inputs: [{ itemId: logId, quantity: 1 }],
58 minSkillLevel: tierCraftSkillLevel(woodTier),
59 skillId: "crafting",
60 xpMaterial: woodTier
61 });
62}
63
64function pickaxeHeadRecipe (metalTier, barItemId, headItemId)
65{
66 return Object.freeze({
67 recipeId: `pickaxe-head-${metalTier}`,
68 stationId: CraftingStationId.anvil,
69 output: { itemId: headItemId, quantity: 1 },
70 inputs: [{ itemId: barItemId, quantity: 1 }],
71 minSkillLevel: tierSmeltSkillLevel(metalTier),
72 skillId: "smithing",
73 xpMaterial: metalTier
74 });
75}
76
77function pickaxeAssembleRecipe (metalTier, handleItemId, headItemId, pickaxeItemId)
78{
79 return Object.freeze({
80 recipeId: `pickaxe-${metalTier}`,
81 stationId: CraftingStationId.craftingBench,
82 output: { itemId: pickaxeItemId, quantity: 1 },
83 inputs: [
84 { itemId: handleItemId, quantity: 1 },
85 { itemId: headItemId, quantity: 1 }
86 ],
87 minSkillLevel: tierCraftSkillLevel(metalTier),
88 skillId: "crafting",
89 xpMaterial: metalTier
90 });
91}
92
93function axeHeadRecipe (metalTier, barItemId, headItemId)
94{
95 return Object.freeze({
96 recipeId: `axe-head-${metalTier}`,
97 stationId: CraftingStationId.anvil,
98 output: { itemId: headItemId, quantity: 1 },
99 inputs: [{ itemId: barItemId, quantity: 1 }],
100 minSkillLevel: tierSmeltSkillLevel(metalTier),
101 skillId: "smithing",
102 xpMaterial: metalTier
103 });
104}
105
106function axeAssembleRecipe (metalTier, handleItemId, headItemId, axeItemId)
107{
108 return Object.freeze({
109 recipeId: `axe-${metalTier}`,
110 stationId: CraftingStationId.craftingBench,
111 output: { itemId: axeItemId, quantity: 1 },
112 inputs: [
113 { itemId: handleItemId, quantity: 1 },
114 { itemId: headItemId, quantity: 1 }
115 ],
116 minSkillLevel: tierCraftSkillLevel(metalTier),
117 skillId: "crafting",
118 xpMaterial: metalTier
119 });
120}
121
122const BAR_BY_METAL = Object.freeze({
123 [MaterialTier.bronze]: CraftingItemId.bronzeBar,
124 [MaterialTier.iron]: MetalItemId.ironBar,
125 [MaterialTier.steel]: MetalItemId.steelBar,
126 [MaterialTier.mithril]: MetalItemId.mithrilBar,
127 [MaterialTier.adamantium]: MetalItemId.adamantiumBar,
128 [MaterialTier.orichalcum]: MetalItemId.orichalcumBar,
129 [MaterialTier.dragon]: MetalItemId.dragonBar
130});
131
132const PICKAXE_BY_METAL = Object.freeze({
133 [MaterialTier.bronze]: CraftingItemId.bronzePickaxe,
134 ...PICKAXE_ITEM_BY_METAL
135});
136
137const AXE_BY_METAL = Object.freeze({
138 [MaterialTier.bronze]: CraftingItemId.bronzeAxe,
139 ...AXE_ITEM_BY_METAL
140});
141
142const WOOD_HANDLE_RECIPES = WOOD_TIER_ORDER.map((tier) => handleRecipe(tier));
143
144const PICKAXE_HEAD_RECIPES = MATERIAL_TIER_ORDER.map((tier) =>
145 pickaxeHeadRecipe(tier, BAR_BY_METAL[tier], PICKAXE_HEAD_ITEM_BY_METAL[tier]));
146
147const PICKAXE_ASSEMBLE_RECIPES = MATERIAL_TIER_ORDER.map((tier) =>
148{
149 const wood = woodTierForMetal(tier);
150 return pickaxeAssembleRecipe(
151 tier,
152 handleItemIdForWood(wood),
153 PICKAXE_HEAD_ITEM_BY_METAL[tier],
154 PICKAXE_BY_METAL[tier]
155 );
156});
157
158const AXE_HEAD_RECIPES = MATERIAL_TIER_ORDER.map((tier) =>
159 axeHeadRecipe(tier, BAR_BY_METAL[tier], AXE_HEAD_ITEM_BY_METAL[tier]));
160
161const AXE_ASSEMBLE_RECIPES = MATERIAL_TIER_ORDER.map((tier) =>
162{
163 const wood = woodTierForMetal(tier);
164 return axeAssembleRecipe(
165 tier,
166 handleItemIdForWood(wood),
167 AXE_HEAD_ITEM_BY_METAL[tier],
168 AXE_BY_METAL[tier]
169 );
170});
171
172/** @type {ReadonlyArray<object>} */
173export const CRAFT_RECIPES = Object.freeze([
174 Object.freeze({
175 recipeId: "dev-stick-from-paper",
176 stationId: CraftingStationId.craftingBench,
177 output: { itemId: ItemId.stick, quantity: 1 },
178 inputs: [{ itemId: ItemId.paper, quantity: 2 }],
179 minSkillLevel: 1
180 }),
181
182 smelt(MaterialTier.bronze, "smelt-bronze", [
183 { itemId: CraftingItemId.tinOre, quantity: 1 },
184 { itemId: CraftingItemId.copperOre, quantity: 1 }
185 ], CraftingItemId.bronzeBar),
186
187 smelt(MaterialTier.iron, "smelt-iron", [
188 { itemId: MetalItemId.ironOre, quantity: 1 }
189 ], MetalItemId.ironBar),
190
191 smelt(MaterialTier.steel, "smelt-steel", [
192 { itemId: MetalItemId.ironOre, quantity: 1 },
193 { itemId: MetalItemId.coal, quantity: 1 }
194 ], MetalItemId.steelBar),
195
196 smelt(GatherMaterialId.silver, "smelt-silver", [
197 { itemId: MetalItemId.silverOre, quantity: 1 }
198 ], MetalItemId.silverBar),
199
200 smelt(GatherMaterialId.gold, "smelt-gold", [
201 { itemId: MetalItemId.goldOre, quantity: 1 }
202 ], MetalItemId.goldBar),
203
204 smelt(MaterialTier.mithril, "smelt-mithril", [
205 { itemId: MetalItemId.mithrilOre, quantity: 1 }
206 ], MetalItemId.mithrilBar),
207
208 smelt(MaterialTier.adamantium, "smelt-adamantium", [
209 { itemId: MetalItemId.adamantiumOre, quantity: 1 },
210 { itemId: MetalItemId.coal, quantity: 1 }
211 ], MetalItemId.adamantiumBar),
212
213 smelt(MaterialTier.orichalcum, "smelt-orichalcum", [
214 { itemId: MetalItemId.orichalcumOre, quantity: 1 },
215 { itemId: MetalItemId.coal, quantity: 3 }
216 ], MetalItemId.orichalcumBar),
217
218 smelt(MaterialTier.dragon, "smelt-dragon", [
219 { itemId: MetalItemId.dragonOre, quantity: 1 },
220 { itemId: MetalItemId.coal, quantity: 5 }
221 ], MetalItemId.dragonBar),
222
223 ...WOOD_HANDLE_RECIPES,
224 ...PICKAXE_HEAD_RECIPES,
225 ...PICKAXE_ASSEMBLE_RECIPES,
226 ...AXE_HEAD_RECIPES,
227 ...AXE_ASSEMBLE_RECIPES
228]);
229
230const RECIPE_BY_ID = new Map(CRAFT_RECIPES.map((recipe) => [recipe.recipeId, recipe]));
231
232export function recipeDefinition (recipeId)
233{
234 return RECIPE_BY_ID.get(recipeId) ?? null;
235}
236
237export function recipeStationIds (recipe)
238{
239 if (!recipe)
240 { return []; }
241 if (Array.isArray(recipe.stationIds))
242 { return recipe.stationIds; }
243 if (recipe.stationId)
244 { return [recipe.stationId]; }
245 return [];
246}
247
248export function recipesForStation (stationId)
249{
250 return CRAFT_RECIPES.filter((recipe) => recipeStationIds(recipe).includes(stationId));
251}