BlueGit

timfa questward

Files

questward / server / src / simulation / spawners.js

spawners.js

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