BlueGit

timfa questward

Files

questward / server / src / simulation / spawners.js

spawners.js

spawners.js 17.7 KiB Download Raw
1import { GAIT, CHUNK_SIZE } from "../../../shared/protocol/constants.js";
2import
3 {
4 mobCanFight,
5 mobSkillLevels,
6 mobHealthForLevel,
7 mobSpellCastChancePercent
8 } from "../../../shared/definitions/mobCombat.js";
9import
10 {
11 normalizeSpawnerConfig,
12 listAmbientMobTypes,
13 mobDefinition,
14 mobSpriteName,
15 MobId,
16 spawnerEquipmentSlot,
17 isTownGuardMob,
18 isHumanoidMob
19 } from "../../../shared/definitions/mobs.js";
20import { isItemSpawnerConfig } from "../../../shared/definitions/itemSpawners.js";
21import { spellDefinition, spellMinMagicLevel, SPRITE_BOLT_SPELL_BY_ELEMENT } from "../../../shared/definitions/spells.js";
22import { MAGIC_ELEMENT_ORDER, magicElementTint } from "../../../shared/definitions/attackTypes.js";
23import { essenceElementDisplayName } from "../../../shared/definitions/essenceItems.js";
24import { LeatherItemId } from "../../../shared/definitions/leatherItems.js";
25import { CENTRAL_EXCHANGE_STAFF } from "../../../shared/market/exchange.js";
26import { emptyEquipment } from "../../../shared/items/inventory.js";
27import { itemDefinition } from "../../../shared/definitions/items.js";
28import { appearanceHairFields, hairFromNameSeed, randomNpcHairColor, randomBrightOrPastelColor } from "../../../shared/appearance/hair.js";
29import { npcDefaultEquipment } from "../../../shared/appearance/npcEquipment.js";
30import { Component } from "../ecs/components.js";
31import { tileToChunk, tileToRegion, parseChunkKey } from "../world/coordinates.js";
32import { OVERWORLD_ID, normalizeDimensionId } from "../../../shared/world/dimensions.js";
33
34export function collectSpawnRequests (world, now = Date.now())
35{
36 const requests = [];
37 const counts = countBySpawner(world);
38 const staffAlive = staffNamesBySpawner(world);
39 const reserved = new Set();
40 ensurePendingRespawns(world);
41 for (const [key, chunk] of world.chunks)
42 {
43 if (chunk.replica || !chunk.simulating || !chunk.data.open)
44 { continue; }
45 const { chunkX, chunkY, dimensionId: keyDimensionId } = parseChunkKey(key);
46 const dimensionId = normalizeDimensionId(chunk.dimensionId ?? keyDimensionId ?? OVERWORLD_ID);
47 for (const entry of chunk.data.spawners ?? [])
48 {
49 const localX = entry.localX;
50 const localY = entry.localY;
51 const index = localY * CHUNK_SIZE + localX;
52 const rawSpawnerId = typeof entry.config?.spawnerId === "string" && entry.config.spawnerId
53 ? entry.config.spawnerId
54 : `${chunkX}:${chunkY}:${index}`;
55 const scopedSpawnerId = rawSpawnerId.startsWith(`${dimensionId}:`)
56 ? rawSpawnerId
57 : `${dimensionId}:${rawSpawnerId}`;
58 const config = normalizeSpawnerConfig(entry.config, scopedSpawnerId);
59 config.spawnerId = scopedSpawnerId;
60 if (isItemSpawnerConfig(config))
61 { continue; }
62 const flying = !!mobDefinition(config.mobTypeId)?.flying;
63 const originX = chunkX * CHUNK_SIZE + localX;
64 const originY = chunkY * CHUNK_SIZE + localY;
65 const persistent = !!mobDefinition(config.mobTypeId)?.persistent;
66 const delayMs = Math.max(0, (config.respawnDelaySeconds | 0) * 1000);
67
68 if (config.centralExchange)
69 {
70 const alive = staffAlive.get(config.spawnerId) ?? new Set();
71 for (const staff of CENTRAL_EXCHANGE_STAFF)
72 {
73 if (alive.has(staff.name))
74 { continue; }
75 if ((counts.get(config.spawnerId) ?? 0) >= config.maxAlive)
76 { break; }
77 if (!consumeSpawnSlot(world, config.spawnerId, delayMs, now))
78 { break; }
79 const tile = pickSpawnTile(
80 world,
81 originX,
82 originY,
83 config.spawnRangeTiles,
84 flying,
85 reserved,
86 dimensionId
87 );
88 if (!tile)
89 { break; }
90 reserved.add(`${tile.tileX},${tile.tileY}`);
91 alive.add(staff.name);
92 staffAlive.set(config.spawnerId, alive);
93 requests.push({
94 ...tile,
95 dimensionId,
96 mobTypeId: MobId.centralExchange,
97 spawnerId: config.spawnerId,
98 originTileX: originX,
99 originTileY: originY,
100 wanderRangeTiles: config.maxWanderRangeTiles,
101 level: config.level,
102 bounty: config.bounty,
103 aggressive: !!config.aggressive,
104 passive: !!config.passive,
105 spells: config.spells,
106 persistent,
107 sex: staff.sex,
108 displayName: staff.name,
109 equipment: config.equipment,
110 sells: [],
111 drops: config.drops,
112 buysItems: false,
113 hiddenDiscount: config.hiddenDiscount,
114 centralExchange: true,
115 townGuard: false,
116 dialogueId: config.dialogueId || null,
117 respawnDelaySeconds: config.respawnDelaySeconds
118 });
119 counts.set(config.spawnerId, (counts.get(config.spawnerId) ?? 0) + 1);
120 }
121 continue;
122 }
123
124 while ((counts.get(config.spawnerId) ?? 0) < config.maxAlive)
125 {
126 if (!consumeSpawnSlot(world, config.spawnerId, delayMs, now))
127 { break; }
128 const tile = pickSpawnTile(
129 world,
130 originX,
131 originY,
132 config.spawnRangeTiles,
133 flying,
134 reserved,
135 dimensionId
136 );
137 if (!tile)
138 { break; }
139 reserved.add(`${tile.tileX},${tile.tileY}`);
140 requests.push({
141 ...tile,
142 dimensionId,
143 mobTypeId: config.mobTypeId,
144 spawnerId: config.spawnerId,
145 originTileX: originX,
146 originTileY: originY,
147 wanderRangeTiles: config.maxWanderRangeTiles,
148 level: config.level,
149 bounty: config.bounty,
150 aggressive: isHumanoidMob(config.mobTypeId) || config.townGuard
151 ? !!config.aggressive
152 : undefined,
153 passive: !!config.passive,
154 spells: config.spells,
155 persistent,
156 sex: config.sex,
157 displayName: config.displayName,
158 equipment: config.equipment,
159 sells: config.sells,
160 drops: config.drops,
161 buysItems: config.buysItems,
162 hiddenDiscount: config.hiddenDiscount,
163 centralExchange: false,
164 townGuard: !!config.townGuard || isTownGuardMob(config.mobTypeId),
165 dialogueId: config.dialogueId || null,
166 respawnDelaySeconds: config.respawnDelaySeconds
167 });
168 counts.set(config.spawnerId, (counts.get(config.spawnerId) ?? 0) + 1);
169 }
170 }
171 }
172 requests.push(...collectAmbientRequests(world, reserved));
173 return requests;
174}
175
176function ensurePendingRespawns (world)
177{
178 if (!world.pendingSpawnerRespawns)
179 { world.pendingSpawnerRespawns = new Map(); }
180 return world.pendingSpawnerRespawns;
181}
182
183/**
184 * Schedule a delayed refill slot after a spawned mob dies.
185 * Delay 0 means the next collect pass may refill immediately (no pending entry).
186 */
187export function scheduleSpawnerRespawn (world, spawnerId, respawnDelaySeconds, now = Date.now())
188{
189 if (!spawnerId)
190 { return; }
191 const delayMs = Math.max(0, (respawnDelaySeconds | 0) * 1000);
192 if (delayMs <= 0)
193 { return; }
194 const pending = ensurePendingRespawns(world);
195 const list = pending.get(spawnerId) ?? [];
196 list.push(now + delayMs);
197 list.sort((a, b) => a - b);
198 pending.set(spawnerId, list);
199}
200
201/**
202 * Decide whether one more mob may spawn for this spawner right now.
203 * - delay 0 / empty pending: allow (initial populate + instant refill)
204 * - otherwise: only if a pending timer is due; consume one due timer
205 */
206function consumeSpawnSlot (world, spawnerId, delayMs, now)
207{
208 if (delayMs <= 0)
209 { return true; }
210 const pending = ensurePendingRespawns(world);
211 const list = pending.get(spawnerId);
212 if (!list?.length)
213 {
214 // No death timers yet — first populate / recovery after unload.
215 return true;
216 }
217 const readyIndex = list.findIndex((readyAt) => readyAt <= now);
218 if (readyIndex < 0)
219 { return false; }
220 list.splice(readyIndex, 1);
221 if (!list.length)
222 { pending.delete(spawnerId); }
223 else
224 { pending.set(spawnerId, list); }
225 return true;
226}
227
228export function mobComponents (request)
229{
230 const def = mobDefinition(request.mobTypeId) ?? mobDefinition("deer");
231 const sex = request.sex === "female" || request.sex === "male"
232 ? request.sex
233 : (def.sex ?? "male");
234 const displayName = String(request.displayName || def.displayName || "NPC").trim() || def.displayName;
235 const level = Math.max(1, Math.min(99, Number(request.level) || 1)) | 0;
236 const appearance = {
237 sex,
238 firstName: displayName,
239 lastName: ""
240 };
241 if (def.usePlayerBody)
242 {
243 Object.assign(appearance, appearanceHairFields(hairFromNameSeed(displayName, sex)));
244 }
245 else
246 {
247 const fleeceState = def.shearable?.fleeceState ?? null;
248 const sprite = mobSpriteName(def.mobTypeId, fleeceState);
249 if (sprite)
250 { appearance.sprite = sprite; }
251 }
252
253 if (def.dualChannelAppearance || def.mobTypeId === MobId.fairy)
254 {
255 appearance.dualTint = {
256 /** Red channel — shirt. */
257 shaft: randomBrightOrPastelColor(),
258 /** Blue channel — skirt. */
259 tip: randomBrightOrPastelColor(),
260 /** Green channel — hair. */
261 coat: randomNpcHairColor()
262 };
263 appearance.bloomBody = !!def.bloomBody;
264 }
265
266 let element = request.element ?? null;
267 if ((def.randomElementOnSpawn || def.mobTypeId === MobId.sprite) && !element)
268 {
269 element = MAGIC_ELEMENT_ORDER[Math.floor(Math.random() * MAGIC_ELEMENT_ORDER.length)];
270 }
271 if (element)
272 {
273 const tint = magicElementTint(element);
274 appearance.tint = { r: tint.r, g: tint.g, b: tint.b };
275 appearance.bloomBody = !!def.bloomBody;
276 if ((def.mobTypeId === MobId.sprite || def.randomElementOnSpawn)
277 && !String(request.displayName || "").trim())
278 {
279 const label = essenceElementDisplayName(element);
280 appearance.firstName = `${label} Sprite`;
281 appearance.lastName = "";
282 }
283 }
284 else if (def.bloomBody)
285 { appearance.bloomBody = true; }
286
287 const maxHp = mobHealthForLevel(def, level);
288 const components = {
289 position: {
290 tileX: request.tileX,
291 tileY: request.tileY,
292 dimensionId: normalizeDimensionId(request.dimensionId ?? OVERWORLD_ID)
293 },
294 movement: { gait: def.gait ?? GAIT.walk, walkCarry: 0 },
295 path: { tiles: [] },
296 appearance,
297 creature: {
298 mobTypeId: def.mobTypeId,
299 level,
300 ...(element ? { element } : {}),
301 ...(def.lightRadiusTiles ? { lightRadiusTiles: def.lightRadiusTiles } : {}),
302 ...(def.shearable
303 ? {
304 fleeceState: def.shearable.fleeceState,
305 woolReadyAt: null
306 }
307 : {})
308 },
309 health: { current: maxHp, max: maxHp }
310 };
311 if (request.spawnerId)
312 {
313 const aggressive = request.aggressive != null
314 ? !!request.aggressive
315 : !!def.aggressive;
316 // Passive only when Aggressive is off (config + resolved flag).
317 const passive = !aggressive && !!request.passive;
318 // Humanoid Aggressive flag forces bounty 0; wildlife can be aggressive and still pay kill bounty.
319 const bounty = request.aggressive === true
320 ? 0
321 : (Math.max(0, Number(request.bounty) || 0) | 0);
322 components.spawnOrigin = {
323 spawnerId: request.spawnerId,
324 originTileX: request.originTileX ?? request.tileX,
325 originTileY: request.originTileY ?? request.tileY,
326 wanderRangeTiles: request.wanderRangeTiles ?? 4,
327 bounty,
328 level,
329 aggressive,
330 passive,
331 centralExchange: !!request.centralExchange,
332 townGuard: !!request.townGuard || isTownGuardMob(def.mobTypeId),
333 stationTileX: null,
334 stationTileY: null,
335 dialogueId: request.dialogueId ? String(request.dialogueId) : null,
336 drops: Array.isArray(request.drops) ? request.drops : [],
337 respawnDelaySeconds: Math.max(0, request.respawnDelaySeconds | 0)
338 };
339 }
340 if (def.persistent)
341 { components.persistent = {}; }
342 if (def.freeFlight)
343 {
344 components.flight = {
345 x: request.tileX + 0.5,
346 y: request.tileY + 0.5,
347 targetX: request.tileX + 0.5,
348 targetY: request.tileY + 0.5,
349 speed: def.flightSpeedTilesPerSec ?? 2.5,
350 nextPickAt: 0,
351 lastAt: 0
352 };
353 }
354 if (mobCanFight(def))
355 {
356 components.combat = { targetEntityId: null, nextSwingAt: 0, seekCover: false, fleeFrom: null };
357 components.skills = { levels: mobSkillLevels(def, level) };
358 }
359
360 const knownSpells = normalizeMobSpells(request.spells, level);
361 if (def.randomElementSpell)
362 {
363 /** Fairies know every elemental sprite bolt and pick one at random each cast. */
364 for (const boltId of Object.values(SPRITE_BOLT_SPELL_BY_ELEMENT))
365 {
366 if (!knownSpells.some((entry) => entry.spellId === boltId))
367 { knownSpells.push({ spellId: boltId }); }
368 }
369 }
370 else if (element && SPRITE_BOLT_SPELL_BY_ELEMENT[element])
371 {
372 const boltId = SPRITE_BOLT_SPELL_BY_ELEMENT[element];
373 if (!knownSpells.some((entry) => entry.spellId === boltId))
374 { knownSpells.push({ spellId: boltId }); }
375 }
376 if (knownSpells.length)
377 {
378 const castChance = (element || def.randomElementSpell) ? 100 : mobSpellCastChancePercent(level);
379 components.spells = {
380 known: knownSpells.map((entry) => entry.spellId),
381 favorites: [],
382 autoCast: false,
383 castChances: Object.fromEntries(knownSpells.map((entry) => [entry.spellId, castChance]))
384 };
385 components.spellcasting = {
386 armedSpellId: null,
387 repeatSpellId: null,
388 repeatTargetEntityId: null,
389 nextCastAt: 0,
390 pendingCast: null
391 };
392 }
393
394 const equipmentSlots = emptyEquipment().slots;
395 const authored = request.equipment ?? {};
396 const defaults = def.usePlayerBody ? npcDefaultEquipment(displayName, sex) : null;
397 for (const slot of Object.keys(equipmentSlots))
398 {
399 const authoredEntry = authored[slot];
400 let { itemId, dyeColor } = spawnerEquipmentSlot(authoredEntry);
401 if (!itemId && defaults?.[slot])
402 {
403 itemId = defaults[slot].itemId;
404 dyeColor = defaults[slot].dyeColor ?? null;
405 }
406 if (!itemId)
407 { continue; }
408 const itemDef = itemDefinition(itemId);
409 if (!itemDef?.equipment || itemDef.equipment.slot !== slot)
410 { continue; }
411 const stack = { itemId, quantity: 1 };
412 if (dyeColor && itemDef.dyeable)
413 { stack.instance = { kind: "clothing", dyeColor }; }
414 equipmentSlots[slot] = stack;
415 }
416 if (def.usePlayerBody || Object.values(equipmentSlots).some(Boolean))
417 { components.equipment = { slots: equipmentSlots }; }
418
419 const catalog = Array.isArray(request.sells)
420 ? request.sells.map((entry) =>
421 {
422 if (entry && typeof entry === "object")
423 {
424 return {
425 itemId: entry.itemId | 0,
426 quantity: Math.max(0, entry.quantity | 0 || 0)
427 };
428 }
429 return { itemId: entry | 0, quantity: 0 };
430 }).filter((line) => line.itemId > 0)
431 : [];
432 const buysItems = !!request.buysItems;
433 const isExchange = !!request.centralExchange || def.centralExchange;
434 if (!isExchange && (catalog.length || buysItems || def.talkable))
435 {
436 components.shop = {
437 catalog,
438 buysItems,
439 hiddenDiscount: Number(request.hiddenDiscount) || 0.9,
440 displayName,
441 remaining: Object.create(null),
442 boughtStock: Object.create(null),
443 restockDay: null
444 };
445 }
446 return components;
447}
448
449function normalizeMobSpells (raw, level)
450{
451 if (!Array.isArray(raw))
452 { return []; }
453 const out = [];
454 const seen = new Set();
455 const lv = Math.max(1, level | 0 || 1);
456 for (const entry of raw)
457 {
458 if (!entry || typeof entry !== "object")
459 { continue; }
460 const spellId = String(entry.spellId ?? "").trim();
461 if (!spellId || seen.has(spellId))
462 { continue; }
463 const def = spellDefinition(spellId);
464 if (!def)
465 { continue; }
466 const minLevel = spellMinMagicLevel(def);
467 if (lv < minLevel)
468 { continue; }
469 seen.add(spellId);
470 out.push({ spellId });
471 }
472 return out;
473}
474
475function collectAmbientRequests (world, reserved = new Set())
476{
477 const requests = [];
478 const ambientTypes = listAmbientMobTypes();
479 if (!ambientTypes.length)
480 { return requests; }
481
482 const loaders = world.ecs.query(Component.position, Component.chunkLoader);
483 if (!loaders.length)
484 { return requests; }
485
486 for (const def of ambientTypes)
487 {
488 const maxPerLoader = Math.max(0, def.ambientMaxPerLoader ?? 1);
489 const alive = countCreatures(world, def.mobTypeId);
490 const budget = maxPerLoader * loaders.length;
491 if (alive >= budget)
492 { continue; }
493
494 for (const loader of loaders)
495 {
496 if (requests.length + alive >= budget)
497 { break; }
498 const dim = normalizeDimensionId(loader.position.dimensionId ?? OVERWORLD_ID);
499 const tile = pickSpawnTile(
500 world,
501 loader.position.tileX,
502 loader.position.tileY,
503 8,
504 !!def.flying,
505 reserved,
506 dim
507 );
508 if (!tile)
509 { continue; }
510 reserved.add(`${tile.tileX},${tile.tileY}`);
511 requests.push({
512 ...tile,
513 dimensionId: dim,
514 mobTypeId: def.mobTypeId,
515 spawnerId: null,
516 level: 1,
517 bounty: 0,
518 spells: [],
519 persistent: false
520 });
521 }
522 }
523 return requests;
524}
525
526function countBySpawner (world)
527{
528 const counts = new Map();
529 for (const entity of world.ecs.query(Component.spawnOrigin))
530 {
531 const id = entity.spawnOrigin.spawnerId;
532 counts.set(id, (counts.get(id) ?? 0) + 1);
533 }
534 return counts;
535}
536
537function staffNamesBySpawner (world)
538{
539 const map = new Map();
540 for (const entity of world.ecs.query(Component.spawnOrigin, Component.appearance))
541 {
542 if (!entity.spawnOrigin?.centralExchange)
543 { continue; }
544 const id = entity.spawnOrigin.spawnerId;
545 const name = entity.appearance?.firstName;
546 if (!id || !name)
547 { continue; }
548 const set = map.get(id) ?? new Set();
549 set.add(name);
550 map.set(id, set);
551 }
552 return map;
553}
554
555function countCreatures (world, mobTypeId)
556{
557 let count = 0;
558 for (const entity of world.ecs.query(Component.creature))
559 {
560 if (entity.creature.mobTypeId === mobTypeId)
561 { count += 1; }
562 }
563 return count;
564}
565
566function pickSpawnTile (world, originX, originY, range, flying = false, reserved = null, dimensionId = OVERWORLD_ID)
567{
568 const dim = normalizeDimensionId(dimensionId);
569 const radius = Math.max(0, range | 0);
570 const tryTile = (tileX, tileY) =>
571 {
572 const key = `${tileX},${tileY}`;
573 if (reserved?.has(key))
574 { return null; }
575 if (!world.ownsRegion(tileToRegion(tileX), tileToRegion(tileY), dim))
576 { return null; }
577 if (flying)
578 {
579 if (!chunkIsOpen(world, tileX, tileY, dim))
580 { return null; }
581 return { tileX, tileY, dimensionId: dim };
582 }
583 if (!world.isEnterable(tileX, tileY, dim) || world.occupied(tileX, tileY, dim))
584 { return null; }
585 return { tileX, tileY, dimensionId: dim };
586 };
587 if (radius === 0)
588 { return tryTile(originX, originY); }
589 for (let attempt = 0; attempt < 48; attempt++)
590 {
591 const tile = tryTile(
592 originX + randInt(-radius, radius),
593 originY + randInt(-radius, radius)
594 );
595 if (tile)
596 { return tile; }
597 }
598 return null;
599}
600
601function chunkIsOpen (world, tileX, tileY, dimensionId = OVERWORLD_ID)
602{
603 const data = world.chunkData(tileToChunk(tileX), tileToChunk(tileY), dimensionId);
604 return !!data?.open;
605}
606
607function randInt (min, max)
608{
609 return min + Math.floor(Math.random() * (max - min + 1));
610}