BlueGit

timfa questward

Files

questward / shared / crafting / tierRecipes.js

tierRecipes.js

8c314ec0 History
tierRecipes.js 14.4 KiB Download Raw
1import { CraftingStationId } from "../definitions/craftingStations.js";
2import { ItemId } from "../definitions/items.js";
3import { ItemFamilyId } from "../definitions/tierFamilies.js";
4import { familyItemId } from "../definitions/familyItemIds.js";
5import { WoodItemId } from "../definitions/woodItems.js";
6import
7 {
8 WOOD_TIER_ORDER,
9 MATERIAL_TIER_ORDER,
10 CLOTH_TIER_ORDER,
11 LEATHER_TIER_ORDER,
12 MATERIAL_DISPLAY_NAME,
13 MaterialTier,
14 WoodTier,
15 woodTierForMetal,
16 leatherTierForMetal,
17 clothTierForWood,
18 tierSmeltSkillLevel,
19 tierCraftSkillLevel,
20 tierMinSkillLevel
21 } from "../definitions/materialTiers.js";
22import
23 {
24 ARMOUR_CRAFT_PIECES,
25 armourItemIdForTier
26 } from "../definitions/armourItems.js";
27import { RangedItemId } from "../definitions/rangedItems.js";
28import { yarnItemId } from "../definitions/clothItems.js";
29import { leatherMaterialItemId, leatherShoesItemId } from "../definitions/leatherItems.js";
30import { leatherArmourRecipes } from "../definitions/leatherArmourItems.js";
31
32/**
33 * Tier-scaled craft recipes generated from {@link ItemFamilyId} templates.
34 * Adding a tier to materialTiers + item id maps extends every matching recipe chain.
35 */
36
37function tierRecipe ({
38 recipeId,
39 stationId,
40 outputFamily,
41 outputTier,
42 outputQty = 1,
43 inputs,
44 minSkillLevel,
45 skillId,
46 xpMaterial,
47 craftGroup,
48 craftGroupLabel
49})
50{
51 const outputItemId = familyItemId(outputFamily, outputTier);
52 if (!outputItemId)
53 { throw new Error(`Missing output item for ${outputFamily}@${outputTier}`); }
54 return Object.freeze({
55 recipeId,
56 stationId,
57 output: { itemId: outputItemId, quantity: outputQty },
58 inputs,
59 minSkillLevel,
60 skillId,
61 xpMaterial,
62 ...(craftGroup ? { craftGroup, craftGroupLabel } : {})
63 });
64}
65
66function handleRecipes ()
67{
68 return WOOD_TIER_ORDER.map((woodTier) => tierRecipe({
69 recipeId: `handle-${woodTier}`,
70 craftGroup: "tool-handle",
71 craftGroupLabel: "Handle",
72 stationId: CraftingStationId.woodworkingBench,
73 outputFamily: ItemFamilyId.handle,
74 outputTier: woodTier,
75 inputs: [{ itemId: familyItemId(ItemFamilyId.log, woodTier), quantity: 1 }],
76 minSkillLevel: tierCraftSkillLevel(woodTier),
77 skillId: "woodworking",
78 xpMaterial: woodTier
79 }));
80}
81
82function stickAndQuarterstaffRecipes ()
83{
84 const recipes = [
85 Object.freeze({
86 recipeId: "stick-pine",
87 craftGroup: "stick",
88 craftGroupLabel: "Stick",
89 stationId: CraftingStationId.woodworkingBench,
90 output: { itemId: ItemId.stick, quantity: 1 },
91 inputs: [{ itemId: WoodItemId.pineLog, quantity: 1 }],
92 minSkillLevel: 1,
93 skillId: "woodworking",
94 xpMaterial: WoodTier.pine
95 })
96 ];
97 for (const woodTier of WOOD_TIER_ORDER)
98 {
99 if (woodTier === WoodTier.pine)
100 { continue; }
101 recipes.push(tierRecipe({
102 recipeId: `quarterstaff-${woodTier}`,
103 craftGroup: "quarterstaff",
104 craftGroupLabel: "Quarterstaff",
105 stationId: CraftingStationId.woodworkingBench,
106 outputFamily: ItemFamilyId.quarterstaff,
107 outputTier: woodTier,
108 inputs: [{ itemId: familyItemId(ItemFamilyId.log, woodTier), quantity: 1 }],
109 minSkillLevel: tierCraftSkillLevel(woodTier),
110 skillId: "woodworking",
111 xpMaterial: woodTier
112 }));
113 }
114 return recipes;
115}
116
117function pickaxeHeadRecipes ()
118{
119 return MATERIAL_TIER_ORDER.map((metalTier) => tierRecipe({
120 recipeId: `pickaxe-head-${metalTier}`,
121 craftGroup: "pickaxe-head",
122 craftGroupLabel: "Pickaxe head",
123 stationId: CraftingStationId.anvil,
124 outputFamily: ItemFamilyId.pickaxeHead,
125 outputTier: metalTier,
126 inputs: [{ itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: 1 }],
127 minSkillLevel: tierSmeltSkillLevel(metalTier),
128 skillId: "smithing",
129 xpMaterial: metalTier
130 }));
131}
132
133function pickaxeAssembleRecipes ()
134{
135 return MATERIAL_TIER_ORDER.map((metalTier) =>
136 {
137 const woodTier = woodTierForMetal(metalTier);
138 return tierRecipe({
139 recipeId: `pickaxe-${metalTier}`,
140 craftGroup: "pickaxe",
141 craftGroupLabel: "Pickaxe",
142 stationId: CraftingStationId.craftingBench,
143 outputFamily: ItemFamilyId.pickaxe,
144 outputTier: metalTier,
145 inputs: [
146 { itemId: familyItemId(ItemFamilyId.handle, woodTier), quantity: 1 },
147 { itemId: familyItemId(ItemFamilyId.pickaxeHead, metalTier), quantity: 1 }
148 ],
149 minSkillLevel: tierCraftSkillLevel(metalTier),
150 skillId: "crafting",
151 xpMaterial: metalTier
152 });
153 });
154}
155
156function axeHeadRecipes ()
157{
158 return MATERIAL_TIER_ORDER.map((metalTier) => tierRecipe({
159 recipeId: `axe-head-${metalTier}`,
160 craftGroup: "axe-head",
161 craftGroupLabel: "Axe head",
162 stationId: CraftingStationId.anvil,
163 outputFamily: ItemFamilyId.axeHead,
164 outputTier: metalTier,
165 inputs: [{ itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: 1 }],
166 minSkillLevel: tierSmeltSkillLevel(metalTier),
167 skillId: "smithing",
168 xpMaterial: metalTier
169 }));
170}
171
172function axeAssembleRecipes ()
173{
174 return MATERIAL_TIER_ORDER.map((metalTier) =>
175 {
176 const woodTier = woodTierForMetal(metalTier);
177 return tierRecipe({
178 recipeId: `axe-${metalTier}`,
179 craftGroup: "axe",
180 craftGroupLabel: "Axe",
181 stationId: CraftingStationId.craftingBench,
182 outputFamily: ItemFamilyId.axe,
183 outputTier: metalTier,
184 inputs: [
185 { itemId: familyItemId(ItemFamilyId.handle, woodTier), quantity: 1 },
186 { itemId: familyItemId(ItemFamilyId.axeHead, metalTier), quantity: 1 }
187 ],
188 minSkillLevel: tierCraftSkillLevel(metalTier),
189 skillId: "crafting",
190 xpMaterial: metalTier
191 });
192 });
193}
194
195function plantClippersRecipes ()
196{
197 return MATERIAL_TIER_ORDER.map((metalTier) =>
198 {
199 const leatherId = leatherMaterialItemId(leatherTierForMetal(metalTier));
200 return tierRecipe({
201 recipeId: `plant-clippers-${metalTier}`,
202 craftGroup: "plant-clippers",
203 craftGroupLabel: "Plant clippers",
204 stationId: CraftingStationId.anvil,
205 outputFamily: ItemFamilyId.plantClippers,
206 outputTier: metalTier,
207 inputs: [
208 { itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: 1 },
209 { itemId: leatherId, quantity: 1 }
210 ],
211 minSkillLevel: tierSmeltSkillLevel(metalTier),
212 skillId: "smithing",
213 xpMaterial: metalTier
214 });
215 });
216}
217
218function shearsRecipes ()
219{
220 /** Bronze mirrors cotton; wool (sheep) is the lowest shearable tier → iron+. */
221 return MATERIAL_TIER_ORDER
222 .filter((metalTier) => metalTier !== MaterialTier.bronze)
223 .map((metalTier) => tierRecipe({
224 recipeId: `shears-${metalTier}`,
225 craftGroup: "shears",
226 craftGroupLabel: "Shears",
227 stationId: CraftingStationId.anvil,
228 outputFamily: ItemFamilyId.shears,
229 outputTier: metalTier,
230 inputs: [{ itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: 1 }],
231 minSkillLevel: tierSmeltSkillLevel(metalTier),
232 skillId: "smithing",
233 xpMaterial: metalTier
234 }));
235}
236
237function swordBladeRecipes ()
238{
239 return MATERIAL_TIER_ORDER.map((metalTier) => tierRecipe({
240 recipeId: `sword-blade-${metalTier}`,
241 craftGroup: "sword-blade",
242 craftGroupLabel: "Sword blade",
243 stationId: CraftingStationId.anvil,
244 outputFamily: ItemFamilyId.swordBlade,
245 outputTier: metalTier,
246 inputs: [{ itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: 2 }],
247 minSkillLevel: tierSmeltSkillLevel(metalTier),
248 skillId: "smithing",
249 xpMaterial: metalTier
250 }));
251}
252
253function swordAssembleRecipes ()
254{
255 return MATERIAL_TIER_ORDER.map((metalTier) =>
256 {
257 const woodTier = woodTierForMetal(metalTier);
258 const leatherTier = leatherTierForMetal(metalTier);
259 const leatherId = leatherMaterialItemId(leatherTier);
260 return tierRecipe({
261 recipeId: `sword-${metalTier}`,
262 craftGroup: "sword",
263 craftGroupLabel: "Sword",
264 stationId: CraftingStationId.craftingBench,
265 outputFamily: ItemFamilyId.sword,
266 outputTier: metalTier,
267 inputs: [
268 { itemId: familyItemId(ItemFamilyId.swordBlade, metalTier), quantity: 1 },
269 { itemId: familyItemId(ItemFamilyId.handle, woodTier), quantity: 1 },
270 { itemId: leatherId, quantity: 1 }
271 ],
272 minSkillLevel: tierCraftSkillLevel(metalTier),
273 skillId: "crafting",
274 xpMaterial: metalTier
275 });
276 });
277}
278
279function warAxeHeadRecipes ()
280{
281 return MATERIAL_TIER_ORDER.map((metalTier) => tierRecipe({
282 recipeId: `war-axe-head-${metalTier}`,
283 craftGroup: "war-axe-head",
284 craftGroupLabel: "War axe head",
285 stationId: CraftingStationId.anvil,
286 outputFamily: ItemFamilyId.warAxeHead,
287 outputTier: metalTier,
288 inputs: [{ itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: 3 }],
289 minSkillLevel: tierSmeltSkillLevel(metalTier),
290 skillId: "smithing",
291 xpMaterial: metalTier
292 }));
293}
294
295function warAxeAssembleRecipes ()
296{
297 return MATERIAL_TIER_ORDER.map((metalTier) =>
298 {
299 const woodTier = woodTierForMetal(metalTier);
300 return tierRecipe({
301 recipeId: `war-axe-${metalTier}`,
302 craftGroup: "war-axe",
303 craftGroupLabel: "War axe",
304 stationId: CraftingStationId.craftingBench,
305 outputFamily: ItemFamilyId.warAxe,
306 outputTier: metalTier,
307 inputs: [
308 { itemId: familyItemId(ItemFamilyId.handle, woodTier), quantity: 1 },
309 { itemId: familyItemId(ItemFamilyId.warAxeHead, metalTier), quantity: 1 }
310 ],
311 minSkillLevel: tierCraftSkillLevel(metalTier),
312 skillId: "crafting",
313 xpMaterial: metalTier
314 });
315 });
316}
317
318function arrowShaftRecipes ()
319{
320 return WOOD_TIER_ORDER.map((woodTier) => tierRecipe({
321 recipeId: `arrow-shafts-${woodTier}`,
322 craftGroup: "arrow-shafts",
323 craftGroupLabel: "Arrow shafts",
324 stationId: CraftingStationId.woodworkingBench,
325 outputFamily: ItemFamilyId.arrowShaft,
326 outputTier: woodTier,
327 outputQty: 15,
328 inputs: [{ itemId: familyItemId(ItemFamilyId.log, woodTier), quantity: 1 }],
329 minSkillLevel: tierMinSkillLevel(woodTier),
330 skillId: "woodworking",
331 xpMaterial: woodTier
332 }));
333}
334
335function arrowTipRecipes ()
336{
337 return MATERIAL_TIER_ORDER.map((metalTier) => tierRecipe({
338 recipeId: `arrow-tips-${metalTier}`,
339 craftGroup: "arrow-tips",
340 craftGroupLabel: "Arrow tips",
341 stationId: CraftingStationId.anvil,
342 outputFamily: ItemFamilyId.arrowTip,
343 outputTier: metalTier,
344 outputQty: 15,
345 inputs: [{ itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: 1 }],
346 minSkillLevel: tierMinSkillLevel(metalTier),
347 skillId: "smithing",
348 xpMaterial: metalTier
349 }));
350}
351
352function arrowAssembleRecipes ()
353{
354 return MATERIAL_TIER_ORDER.map((metalTier) =>
355 {
356 const woodTier = woodTierForMetal(metalTier);
357 return tierRecipe({
358 recipeId: `arrow-${metalTier}`,
359 craftGroup: "arrow",
360 craftGroupLabel: "Arrow",
361 stationId: CraftingStationId.craftingBench,
362 outputFamily: ItemFamilyId.arrow,
363 outputTier: metalTier,
364 inputs: [
365 { itemId: RangedItemId.feather, quantity: 1 },
366 { itemId: familyItemId(ItemFamilyId.arrowShaft, woodTier), quantity: 1 },
367 { itemId: familyItemId(ItemFamilyId.arrowTip, metalTier), quantity: 1 }
368 ],
369 minSkillLevel: tierMinSkillLevel(metalTier),
370 skillId: "crafting",
371 xpMaterial: metalTier
372 });
373 });
374}
375
376function unstrungBowRecipes ()
377{
378 return WOOD_TIER_ORDER.map((woodTier) => tierRecipe({
379 recipeId: `unstrung-bow-${woodTier}`,
380 craftGroup: "unstrung-bow",
381 craftGroupLabel: "Unstrung bow",
382 stationId: CraftingStationId.woodworkingBench,
383 outputFamily: ItemFamilyId.unstrungBow,
384 outputTier: woodTier,
385 inputs: [{ itemId: familyItemId(ItemFamilyId.log, woodTier), quantity: 1 }],
386 minSkillLevel: tierMinSkillLevel(woodTier),
387 skillId: "woodworking",
388 xpMaterial: woodTier
389 }));
390}
391
392function bowstringRecipes ()
393{
394 return CLOTH_TIER_ORDER.map((clothTier) => tierRecipe({
395 recipeId: `bowstring-${clothTier}`,
396 craftGroup: "bowstring",
397 craftGroupLabel: "Bowstring",
398 stationId: CraftingStationId.spinningWheel,
399 outputFamily: ItemFamilyId.bowstring,
400 outputTier: clothTier,
401 inputs: [{ itemId: yarnItemId(clothTier), quantity: 1 }],
402 minSkillLevel: tierMinSkillLevel(clothTier),
403 skillId: "tailoring",
404 xpMaterial: clothTier
405 }));
406}
407
408function bowAssembleRecipes ()
409{
410 return WOOD_TIER_ORDER.map((woodTier) =>
411 {
412 const clothTier = clothTierForWood(woodTier);
413 return tierRecipe({
414 recipeId: `bow-${woodTier}`,
415 craftGroup: "bow",
416 craftGroupLabel: "Bow",
417 stationId: CraftingStationId.craftingBench,
418 outputFamily: ItemFamilyId.bow,
419 outputTier: woodTier,
420 inputs: [
421 { itemId: familyItemId(ItemFamilyId.unstrungBow, woodTier), quantity: 1 },
422 { itemId: familyItemId(ItemFamilyId.bowstring, clothTier), quantity: 1 }
423 ],
424 minSkillLevel: tierMinSkillLevel(woodTier),
425 skillId: "crafting",
426 xpMaterial: woodTier
427 });
428 });
429}
430
431function armourRecipes ()
432{
433 return MATERIAL_TIER_ORDER.flatMap((metalTier) =>
434 ARMOUR_CRAFT_PIECES.map((piece) =>
435 {
436 const inputs = [{ itemId: familyItemId(ItemFamilyId.bar, metalTier), quantity: piece.ingots }];
437 if (piece.needsBone)
438 { inputs.push({ itemId: ItemId.bones, quantity: 1 }); }
439 if (piece.needsLeather)
440 {
441 const leatherId = leatherMaterialItemId(leatherTierForMetal(metalTier));
442 if (leatherId != null)
443 { inputs.push({ itemId: leatherId, quantity: 1 }); }
444 }
445 const label = piece.label.charAt(0).toUpperCase() + piece.label.slice(1);
446 return Object.freeze({
447 recipeId: `armour-${piece.suffix}-${metalTier}`,
448 craftGroup: `armour-${piece.suffix}`,
449 craftGroupLabel: label,
450 stationId: CraftingStationId.anvil,
451 output: { itemId: armourItemIdForTier(metalTier, piece.idKey), quantity: 1 },
452 inputs,
453 minSkillLevel: tierSmeltSkillLevel(metalTier),
454 skillId: "smithing",
455 xpMaterial: metalTier
456 });
457 }));
458}
459
460function leatherShoesRecipes ()
461{
462 return LEATHER_TIER_ORDER.map((leatherTier) =>
463 {
464 const leatherId = leatherMaterialItemId(leatherTier);
465 const shoesId = leatherShoesItemId(leatherTier);
466 if (leatherId == null || shoesId == null)
467 { throw new Error(`Missing leather shoes recipe ids for ${leatherTier}`); }
468 return Object.freeze({
469 recipeId: `leather-shoes-${leatherTier}`,
470 craftGroup: "leather-shoes",
471 craftGroupLabel: "Shoes",
472 stationId: CraftingStationId.leatherworkingStation,
473 output: { itemId: shoesId, quantity: 1 },
474 inputs: [{ itemId: leatherId, quantity: 2 }],
475 minSkillLevel: tierCraftSkillLevel(leatherTier),
476 skillId: "leatherworking",
477 xpMaterial: leatherTier
478 });
479 });
480}
481
482/** All recipes driven by tier families (tools, wood/metal intermediates, ranged). */
483export const TIER_FAMILY_RECIPES = Object.freeze([
484 ...handleRecipes(),
485 ...stickAndQuarterstaffRecipes(),
486 ...pickaxeHeadRecipes(),
487 ...pickaxeAssembleRecipes(),
488 ...axeHeadRecipes(),
489 ...axeAssembleRecipes(),
490 ...plantClippersRecipes(),
491 ...shearsRecipes(),
492 ...swordBladeRecipes(),
493 ...swordAssembleRecipes(),
494 ...warAxeHeadRecipes(),
495 ...warAxeAssembleRecipes(),
496 ...arrowShaftRecipes(),
497 ...arrowTipRecipes(),
498 ...arrowAssembleRecipes(),
499 ...unstrungBowRecipes(),
500 ...bowstringRecipes(),
501 ...bowAssembleRecipes(),
502 ...armourRecipes(),
503 ...leatherShoesRecipes(),
504 ...leatherArmourRecipes()
505]);