BlueGit

timfa questward

Files

questward / server / src / simulation / spawners.js

spawners.js

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