BlueGit

timfa questward

Files

questward / server / src / simulation / spawners.js

spawners.js

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