BlueGit

timfa questward

Files

questward / server / src / persistence / stateDb.js

stateDb.js

stateDb.js 20.7 KiB Download Raw
1import { openDatabase } from "./database.js";
2import { emptyEquipment, emptySlots, insertStack, insertStackGrowable, normalizeVault, normalizeInventorySlots, publicSlots, migrateBagCoins, migrateInheritanceCoins } from "../../../shared/items/inventory.js";
3import { STARTER_ITEMS, ItemId, itemDefinition } from "../../../shared/definitions/items.js";
4import { normalizePlayerSkills, defaultPlayerSkills, storedSkillXp } from "../../../shared/skills/state.js";
5
6const STATE_SCHEMA = `
7CREATE TABLE IF NOT EXISTS accounts (
8 account_id INTEGER PRIMARY KEY AUTOINCREMENT,
9 auth_subject TEXT NOT NULL UNIQUE,
10 email TEXT,
11 is_admin INTEGER NOT NULL DEFAULT 0
12);
13
14CREATE TABLE IF NOT EXISTS surname_claims (
15 surname_normalized TEXT PRIMARY KEY,
16 account_id INTEGER NOT NULL
17);
18
19CREATE TABLE IF NOT EXISTS characters (
20 character_id INTEGER PRIMARY KEY AUTOINCREMENT,
21 account_id INTEGER NOT NULL,
22 first_name TEXT NOT NULL,
23 last_name TEXT NOT NULL,
24 first_normalized TEXT NOT NULL,
25 last_normalized TEXT NOT NULL,
26 sex TEXT NOT NULL,
27 tile_x INTEGER NOT NULL DEFAULT 8,
28 tile_y INTEGER NOT NULL DEFAULT 8,
29 gait TEXT NOT NULL DEFAULT 'walk',
30 deletion_scheduled_at INTEGER
31);
32CREATE TABLE IF NOT EXISTS friend_requests (
33 request_id INTEGER PRIMARY KEY AUTOINCREMENT,
34 from_character_id INTEGER NOT NULL,
35 to_character_id INTEGER NOT NULL,
36 created_at INTEGER NOT NULL,
37 UNIQUE (from_character_id, to_character_id)
38);
39
40CREATE TABLE IF NOT EXISTS friendships (
41 character_id_a INTEGER NOT NULL,
42 character_id_b INTEGER NOT NULL,
43 created_at INTEGER NOT NULL,
44 PRIMARY KEY (character_id_a, character_id_b)
45);
46
47CREATE TABLE IF NOT EXISTS persistent_entities (
48 entity_id INTEGER PRIMARY KEY,
49 tile_x INTEGER NOT NULL,
50 tile_y INTEGER NOT NULL,
51 components_blob TEXT NOT NULL
52);
53
54CREATE TABLE IF NOT EXISTS character_bags (
55 character_id INTEGER PRIMARY KEY,
56 inventory_blob TEXT NOT NULL,
57 equipment_blob TEXT NOT NULL,
58 currency INTEGER NOT NULL DEFAULT 0,
59 vault_blob TEXT NOT NULL,
60 vault_currency INTEGER NOT NULL DEFAULT 0,
61 skills_blob TEXT NOT NULL DEFAULT '{}'
62);
63
64CREATE TABLE IF NOT EXISTS account_inheritance (
65 account_id INTEGER PRIMARY KEY,
66 slots_blob TEXT NOT NULL,
67 currency INTEGER NOT NULL DEFAULT 0
68);
69
70CREATE TABLE IF NOT EXISTS ground_items (
71 ground_item_id INTEGER PRIMARY KEY,
72 tile_x INTEGER NOT NULL,
73 tile_y INTEGER NOT NULL,
74 stack_blob TEXT NOT NULL,
75 dropped_at INTEGER NOT NULL,
76 expires_at INTEGER NOT NULL,
77 source TEXT NOT NULL,
78 dropped_by_character_id INTEGER
79);
80
81CREATE TABLE IF NOT EXISTS courier_transits (
82 courier_id INTEGER PRIMARY KEY AUTOINCREMENT,
83 sender_character_id INTEGER NOT NULL,
84 destination_kind TEXT NOT NULL,
85 destination_character_id INTEGER,
86 cargo_blob TEXT NOT NULL,
87 origin_x REAL NOT NULL,
88 origin_y REAL NOT NULL,
89 dest_x REAL NOT NULL,
90 dest_y REAL NOT NULL,
91 traveled REAL NOT NULL DEFAULT 0,
92 status TEXT NOT NULL,
93 entity_id INTEGER,
94 updated_at INTEGER NOT NULL,
95 created_at INTEGER NOT NULL
96);
97`;
98
99export class StateDatabase
100{
101 constructor (filePath)
102 {
103 this.db = openDatabase(filePath);
104 this.db.exec(STATE_SCHEMA);
105 this.#migrateSchema();
106 }
107
108 #migrateSchema ()
109 {
110 const columns = this.db.prepare("PRAGMA table_info(character_bags)").all();
111 if (!columns.some((column) => column.name === "skills_blob"))
112 {
113 this.db.exec("ALTER TABLE character_bags ADD COLUMN skills_blob TEXT NOT NULL DEFAULT '{}'");
114 }
115 this.#grantLanternsToExistingCharacters();
116 }
117
118 #grantLanternsToExistingCharacters ()
119 {
120 const def = itemDefinition(ItemId.lantern);
121 if (!def)
122 { return; }
123 const rows = this.db.prepare("SELECT character_id, inventory_blob, equipment_blob FROM character_bags").all();
124 const update = this.db.prepare(`
125 UPDATE character_bags
126 SET inventory_blob = ?, equipment_blob = ?
127 WHERE character_id = ?
128 `);
129 for (const row of rows)
130 {
131 const inventory = JSON.parse(row.inventory_blob || "[]");
132 const equipment = JSON.parse(row.equipment_blob || "{}");
133 if (bagContainsItem(inventory, equipment, ItemId.lantern))
134 { continue; }
135 if (!equipment.slots?.offhand)
136 {
137 equipment.slots = equipment.slots ?? {};
138 equipment.slots.offhand = { itemId: ItemId.lantern, quantity: 1 };
139 }
140 else
141 {
142 const result = insertStack(inventory, { itemId: ItemId.lantern, quantity: 1 }, def);
143 if (!result.ok)
144 { continue; }
145 inventory.splice(0, inventory.length, ...result.slots);
146 }
147 update.run(JSON.stringify(inventory), JSON.stringify(equipment), row.character_id);
148 }
149 }
150
151 getAccountBySubject (authSubject)
152 {
153 return this.db.prepare("SELECT * FROM accounts WHERE auth_subject = ?").get(authSubject) ?? null;
154 }
155
156 createAccount (authSubject, isAdmin, email = null)
157 {
158 this.db.prepare("INSERT INTO accounts (auth_subject, email, is_admin) VALUES (?, ?, ?)").run(
159 authSubject,
160 email,
161 isAdmin ? 1 : 0
162 );
163 return this.getAccountBySubject(authSubject);
164 }
165
166 ensureAccount (authSubject, isAdmin, email = null)
167 {
168 const existing = this.getAccountBySubject(authSubject);
169 if (existing)
170 { return existing; }
171
172 return this.createAccount(authSubject, isAdmin, email);
173 }
174
175 listCharacters (accountId)
176 {
177 return this.db.prepare(`
178 SELECT * FROM characters
179 WHERE account_id = ?
180 ORDER BY character_id ASC
181 `).all(accountId);
182 }
183
184 getCharacter (characterId)
185 {
186 return this.db.prepare("SELECT * FROM characters WHERE character_id = ?").get(characterId) ?? null;
187 }
188
189 findSurnameClaim (surnameNormalized)
190 {
191 return this.db.prepare("SELECT * FROM surname_claims WHERE surname_normalized = ?").get(surnameNormalized) ?? null;
192 }
193
194 createCharacter (accountId, firstName, lastName, sex, tileX, tileY)
195 {
196 const firstNormalized = normalizeName(firstName);
197 const lastNormalized = normalizeName(lastName);
198 this.db.exec("BEGIN");
199 try
200 {
201 this.db.prepare(`
202 INSERT INTO characters (
203 account_id, first_name, last_name, first_normalized, last_normalized, sex, tile_x, tile_y
204 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
205 `).run(accountId, firstName, lastName, firstNormalized, lastNormalized, sex, tileX, tileY);
206 const characterId = Number(this.db.prepare("SELECT last_insert_rowid() AS id").get().id);
207
208 const claim = this.findSurnameClaim(lastNormalized);
209 if (!claim)
210 {
211 this.db.prepare("INSERT INTO surname_claims (surname_normalized, account_id) VALUES (?, ?)").run(
212 lastNormalized,
213 accountId
214 );
215 }
216
217 this.db.exec("COMMIT");
218 this.#ensureBag(characterId);
219 return this.getCharacter(characterId);
220 }
221 catch (error)
222 {
223 this.db.exec("ROLLBACK");
224 throw error;
225 }
226 }
227
228 scheduleDeletion (characterId, at)
229 {
230 this.db.prepare("UPDATE characters SET deletion_scheduled_at = ? WHERE character_id = ?").run(at, characterId);
231 }
232
233 cancelDeletion (characterId)
234 {
235 this.db.prepare("UPDATE characters SET deletion_scheduled_at = NULL WHERE character_id = ?").run(characterId);
236 }
237
238 deleteCharacter (characterId)
239 {
240 const character = this.getCharacter(characterId);
241 if (!character)
242 { return; }
243
244 this.db.exec("BEGIN");
245 try
246 {
247 this.#moveGoodsToInheritance(character);
248 this.db.prepare("DELETE FROM character_bags WHERE character_id = ?").run(characterId);
249 this.db.prepare("DELETE FROM characters WHERE character_id = ?").run(characterId);
250 this.db.prepare("DELETE FROM friend_requests WHERE from_character_id = ? OR to_character_id = ?").run(
251 characterId,
252 characterId
253 );
254 this.db.prepare("DELETE FROM friendships WHERE character_id_a = ? OR character_id_b = ?").run(
255 characterId,
256 characterId
257 );
258 const remaining = this.db.prepare(`
259 SELECT COUNT(*) AS count FROM characters
260 WHERE account_id = ? AND last_normalized = ?
261 `).get(character.account_id, character.last_normalized);
262 if (!remaining.count)
263 {
264 this.db.prepare("DELETE FROM surname_claims WHERE surname_normalized = ? AND account_id = ?").run(
265 character.last_normalized,
266 character.account_id
267 );
268 }
269 this.db.exec("COMMIT");
270 }
271 catch (error)
272 {
273 this.db.exec("ROLLBACK");
274 throw error;
275 }
276 }
277
278 saveCharacterPosition (characterId, tileX, tileY, gait)
279 {
280 this.db.prepare("UPDATE characters SET tile_x = ?, tile_y = ?, gait = ? WHERE character_id = ?").run(
281 tileX,
282 tileY,
283 gait,
284 characterId
285 );
286 }
287
288 listDueDeletions (now)
289 {
290 return this.db.prepare(`
291 SELECT * FROM characters
292 WHERE deletion_scheduled_at IS NOT NULL AND deletion_scheduled_at <= ?
293 `).all(now);
294 }
295
296 getCharacterByName (firstName, lastName)
297 {
298 return this.db.prepare(`
299 SELECT * FROM characters
300 WHERE first_normalized = ? AND last_normalized = ?
301 `).get(normalizeName(firstName), normalizeName(lastName)) ?? null;
302 }
303
304 listFriendRecords (characterId)
305 {
306 return this.db.prepare(`
307 SELECT
308 CASE WHEN character_id_a = ? THEN character_id_b ELSE character_id_a END AS character_id,
309 created_at
310 FROM friendships
311 WHERE character_id_a = ? OR character_id_b = ?
312 ORDER BY created_at ASC
313 `).all(characterId, characterId, characterId);
314 }
315
316 areFriends (characterId, otherId)
317 {
318 const [a, b] = pairIds(characterId, otherId);
319 return !!this.db.prepare(`
320 SELECT 1 FROM friendships WHERE character_id_a = ? AND character_id_b = ?
321 `).get(a, b);
322 }
323
324 insertFriendship (characterId, otherId)
325 {
326 const [a, b] = pairIds(characterId, otherId);
327 this.db.prepare(`
328 INSERT INTO friendships (character_id_a, character_id_b, created_at)
329 VALUES (?, ?, ?)
330 `).run(a, b, Date.now());
331 }
332
333 deleteFriendship (characterId, otherId)
334 {
335 const [a, b] = pairIds(characterId, otherId);
336 this.db.prepare(`
337 DELETE FROM friendships WHERE character_id_a = ? AND character_id_b = ?
338 `).run(a, b);
339 }
340
341 listIncomingRequests (characterId)
342 {
343 return this.db.prepare(`
344 SELECT request_id, from_character_id, to_character_id, created_at
345 FROM friend_requests
346 WHERE to_character_id = ?
347 ORDER BY created_at ASC
348 `).all(characterId);
349 }
350
351 listOutgoingRequests (characterId)
352 {
353 return this.db.prepare(`
354 SELECT request_id, from_character_id, to_character_id, created_at
355 FROM friend_requests
356 WHERE from_character_id = ?
357 ORDER BY created_at ASC
358 `).all(characterId);
359 }
360
361 getFriendRequest (fromId, toId)
362 {
363 return this.db.prepare(`
364 SELECT * FROM friend_requests
365 WHERE from_character_id = ? AND to_character_id = ?
366 `).get(fromId, toId) ?? null;
367 }
368
369 insertFriendRequest (fromId, toId)
370 {
371 this.db.prepare(`
372 INSERT INTO friend_requests (from_character_id, to_character_id, created_at)
373 VALUES (?, ?, ?)
374 `).run(fromId, toId, Date.now());
375 }
376
377 deleteFriendRequest (fromId, toId)
378 {
379 this.db.prepare(`
380 DELETE FROM friend_requests
381 WHERE from_character_id = ? AND to_character_id = ?
382 `).run(fromId, toId);
383 }
384
385 listPersistentInRegion (minX, minY, maxX, maxY)
386 {
387 return this.db.prepare(`
388 SELECT entity_id, tile_x, tile_y, components_blob
389 FROM persistent_entities
390 WHERE tile_x >= ? AND tile_x <= ? AND tile_y >= ? AND tile_y <= ?
391 `).all(minX, maxX, minY, maxY);
392 }
393
394 replacePersistentInRegion (minX, minY, maxX, maxY, entities)
395 {
396 this.db.exec("BEGIN");
397 try
398 {
399 this.db.prepare(`
400 DELETE FROM persistent_entities
401 WHERE tile_x >= ? AND tile_x <= ? AND tile_y >= ? AND tile_y <= ?
402 `).run(minX, maxX, minY, maxY);
403 const insert = this.db.prepare(`
404 INSERT INTO persistent_entities (entity_id, tile_x, tile_y, components_blob)
405 VALUES (?, ?, ?, ?)
406 `);
407 for (const entity of entities)
408 {
409 insert.run(
410 entity.entityId,
411 entity.tileX,
412 entity.tileY,
413 JSON.stringify(entity.payload?.components ?? entity.components)
414 );
415 }
416 this.db.exec("COMMIT");
417 }
418 catch (error)
419 {
420 this.db.exec("ROLLBACK");
421 throw error;
422 }
423 }
424
425 #ensureBag (characterId)
426 {
427 const existing = this.db.prepare("SELECT * FROM character_bags WHERE character_id = ?").get(characterId);
428 if (existing)
429 { return parseBag(existing, characterId); }
430 const slots = emptySlots();
431 for (const starter of STARTER_ITEMS)
432 {
433 const result = insertStack(slots, { ...starter }, itemDefinition(starter.itemId));
434 if (result.ok)
435 { slots.splice(0, slots.length, ...result.slots); }
436 }
437 const equipment = emptyEquipment();
438 equipment.slots.offhand = { itemId: ItemId.lantern, quantity: 1 };
439 this.db.prepare(`
440 INSERT INTO character_bags (
441 character_id, inventory_blob, equipment_blob, currency, vault_blob, vault_currency, skills_blob
442 ) VALUES (?, ?, ?, 0, ?, 0, ?)
443 `).run(
444 characterId,
445 JSON.stringify(slots),
446 JSON.stringify(equipment),
447 JSON.stringify({ slots: [], reserved: [] }),
448 JSON.stringify(storedSkillXp(defaultPlayerSkills()))
449 );
450 return this.getBag(characterId);
451 }
452
453 getBag (characterId)
454 {
455 const row = this.db.prepare("SELECT * FROM character_bags WHERE character_id = ?").get(characterId);
456 if (row)
457 { return parseBag(row, characterId); }
458 if (this.getCharacter(characterId))
459 { return this.#ensureBag(characterId); }
460 return null;
461 }
462
463 saveBag (characterId, bag)
464 {
465 this.#ensureBag(characterId);
466 const migrated = migrateBagCoins(bag);
467 const vault = normalizeVault(
468 migrated.vaultReserved != null
469 ? { slots: migrated.vault, reserved: migrated.vaultReserved }
470 : migrated.vault
471 );
472 this.db.prepare(`
473 UPDATE character_bags
474 SET inventory_blob = ?, equipment_blob = ?, currency = 0, vault_blob = ?, vault_currency = 0
475 WHERE character_id = ?
476 `).run(
477 JSON.stringify(normalizeInventorySlots(migrated.inventory ?? emptySlots())),
478 JSON.stringify(migrated.equipment ?? emptyEquipment()),
479 JSON.stringify({ slots: vault.slots, reserved: vault.reserved }),
480 characterId
481 );
482 }
483
484 getSkills (characterId)
485 {
486 const row = this.db.prepare("SELECT skills_blob FROM character_bags WHERE character_id = ?").get(characterId);
487 if (row)
488 { return normalizePlayerSkills(JSON.parse(row.skills_blob || "{}")); }
489 if (this.getCharacter(characterId))
490 {
491 this.#ensureBag(characterId);
492 return this.getSkills(characterId);
493 }
494 return null;
495 }
496
497 saveSkills (characterId, skills)
498 {
499 this.#ensureBag(characterId);
500 const xp = storedSkillXp(skills?.xp ? skills : { xp: skills });
501 this.db.prepare("UPDATE character_bags SET skills_blob = ? WHERE character_id = ?").run(
502 JSON.stringify({ xp }),
503 characterId
504 );
505 }
506
507 getInheritance (accountId)
508 {
509 const row = this.db.prepare("SELECT * FROM account_inheritance WHERE account_id = ?").get(accountId);
510 if (!row)
511 { return { accountId, slots: emptySlots() }; }
512 return migrateInheritanceCoins({
513 accountId,
514 slots: JSON.parse(row.slots_blob),
515 currency: row.currency
516 });
517 }
518
519 saveInheritance (accountId, inheritance)
520 {
521 const migrated = migrateInheritanceCoins(inheritance);
522 this.db.prepare(`
523 INSERT INTO account_inheritance (account_id, slots_blob, currency)
524 VALUES (?, ?, 0)
525 ON CONFLICT(account_id) DO UPDATE SET slots_blob = excluded.slots_blob, currency = 0
526 `).run(accountId, JSON.stringify(migrated.slots ?? emptySlots()));
527 }
528
529 #moveGoodsToInheritance (character)
530 {
531 const bag = this.getBag(character.character_id) ?? {
532 inventory: emptySlots(),
533 equipment: emptyEquipment(),
534 vault: [],
535 vaultReserved: []
536 };
537 const inheritance = this.getInheritance(character.account_id);
538 const vault = normalizeVault(
539 bag.vaultReserved != null
540 ? { slots: bag.vault, reserved: bag.vaultReserved }
541 : bag.vault
542 );
543 // Void outstanding cheques issued by this character: reservations return to available vault.
544 for (const reserved of vault.reserved ?? [])
545 {
546 const stack = {
547 itemId: reserved.itemId,
548 quantity: reserved.quantity,
549 origin: reserved.origin ?? null,
550 instance: reserved.instance ?? null
551 };
552 const def = itemDefinition(stack.itemId);
553 if (!def)
554 { continue; }
555 const restored = insertStackGrowable(vault.slots, stack, def);
556 vault.slots = restored.slots;
557 }
558 vault.reserved = [];
559 const incoming = [
560 ...(bag.inventory ?? []),
561 ...Object.values(bag.equipment?.slots ?? {}),
562 ...(vault.slots ?? [])
563 ].filter(Boolean);
564 let slots = inheritance.slots ?? emptySlots();
565 for (const stack of incoming)
566 {
567 const def = itemDefinition(stack.itemId);
568 if (!def)
569 { continue; }
570 const result = insertStack(slots, stack, def);
571 if (result.ok)
572 { slots = result.slots; }
573 else
574 {
575 const extra = result.slots;
576 for (const leftover of extra)
577 {
578 if (leftover)
579 { slots.push(leftover); }
580 }
581 slots.push({ ...stack, quantity: result.remainder });
582 }
583 }
584 this.saveInheritance(character.account_id, {
585 slots: publicSlots(slots)
586 });
587 }
588
589 nextGroundItemId ()
590 {
591 const row = this.db.prepare("SELECT MAX(ground_item_id) AS id FROM ground_items").get();
592 return (row?.id ?? 0) + 1;
593 }
594
595 listGroundItemsInRegion (minX, minY, maxX, maxY)
596 {
597 return this.db.prepare(`
598 SELECT * FROM ground_items
599 WHERE tile_x >= ? AND tile_x <= ? AND tile_y >= ? AND tile_y <= ?
600 `).all(minX, maxX, minY, maxY).map(parseGroundItem);
601 }
602
603 upsertGroundItem (item)
604 {
605 this.db.prepare(`
606 INSERT INTO ground_items (
607 ground_item_id, tile_x, tile_y, stack_blob, dropped_at, expires_at, source, dropped_by_character_id
608 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
609 ON CONFLICT(ground_item_id) DO UPDATE SET
610 tile_x = excluded.tile_x,
611 tile_y = excluded.tile_y,
612 stack_blob = excluded.stack_blob,
613 dropped_at = excluded.dropped_at,
614 expires_at = excluded.expires_at,
615 source = excluded.source,
616 dropped_by_character_id = excluded.dropped_by_character_id
617 `).run(
618 item.groundItemId,
619 item.tileX,
620 item.tileY,
621 JSON.stringify(item.stack),
622 item.droppedAt,
623 item.expiresAt,
624 item.source,
625 item.droppedByCharacterId ?? null
626 );
627 }
628
629 deleteGroundItem (groundItemId)
630 {
631 this.db.prepare("DELETE FROM ground_items WHERE ground_item_id = ?").run(groundItemId);
632 }
633
634 insertCourierTransit (transit)
635 {
636 const now = transit.updatedAt ?? Date.now();
637 const result = this.db.prepare(`
638 INSERT INTO courier_transits (
639 sender_character_id, destination_kind, destination_character_id, cargo_blob,
640 origin_x, origin_y, dest_x, dest_y, traveled, status, entity_id, updated_at, created_at
641 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
642 `).run(
643 transit.senderCharacterId,
644 transit.destinationKind,
645 transit.destinationCharacterId ?? null,
646 JSON.stringify(transit.cargo),
647 transit.originX,
648 transit.originY,
649 transit.destX,
650 transit.destY,
651 transit.traveled ?? 0,
652 transit.status ?? "in_transit",
653 transit.entityId ?? null,
654 now,
655 transit.createdAt ?? now
656 );
657 return this.getCourierTransit(Number(result.lastInsertRowid));
658 }
659
660 getCourierTransit (courierId)
661 {
662 const row = this.db.prepare("SELECT * FROM courier_transits WHERE courier_id = ?").get(courierId);
663 return row ? parseCourierTransit(row) : null;
664 }
665
666 listActiveCourierTransits ()
667 {
668 return this.db.prepare(`
669 SELECT * FROM courier_transits WHERE status = 'in_transit' ORDER BY courier_id ASC
670 `).all().map(parseCourierTransit);
671 }
672
673 updateCourierTransit (transit)
674 {
675 this.db.prepare(`
676 UPDATE courier_transits
677 SET traveled = ?, status = ?, entity_id = ?, updated_at = ?,
678 origin_x = ?, origin_y = ?, dest_x = ?, dest_y = ?,
679 destination_kind = ?, destination_character_id = ?
680 WHERE courier_id = ?
681 `).run(
682 transit.traveled ?? 0,
683 transit.status,
684 transit.entityId ?? null,
685 transit.updatedAt ?? Date.now(),
686 transit.originX,
687 transit.originY,
688 transit.destX,
689 transit.destY,
690 transit.destinationKind,
691 transit.destinationCharacterId ?? null,
692 transit.courierId
693 );
694 }
695
696 close ()
697 {
698 this.db.close();
699 }
700}
701
702export function normalizeName (value)
703{
704 return String(value ?? "").trim().toLocaleLowerCase();
705}
706
707function pairIds (left, right)
708{
709 return left < right ? [left, right] : [right, left];
710}
711
712function parseGroundItem (row)
713{
714 return {
715 groundItemId: row.ground_item_id,
716 tileX: row.tile_x,
717 tileY: row.tile_y,
718 stack: JSON.parse(row.stack_blob),
719 droppedAt: row.dropped_at,
720 expiresAt: row.expires_at,
721 source: row.source,
722 droppedByCharacterId: row.dropped_by_character_id
723 };
724}
725
726function bagContainsItem (inventory, equipment, itemId)
727{
728 for (const stack of inventory ?? [])
729 {
730 if (stack?.itemId === itemId)
731 { return true; }
732 }
733 for (const stack of Object.values(equipment?.slots ?? {}))
734 {
735 if (stack?.itemId === itemId)
736 { return true; }
737 }
738 return false;
739}
740
741function parseBag (row, characterId)
742{
743 const vault = normalizeVault(JSON.parse(row.vault_blob));
744 return migrateBagCoins({
745 characterId,
746 inventory: normalizeInventorySlots(JSON.parse(row.inventory_blob)),
747 equipment: JSON.parse(row.equipment_blob),
748 currency: row.currency,
749 vault: vault.slots,
750 vaultReserved: vault.reserved,
751 vaultCurrency: row.vault_currency
752 });
753}
754
755function parseCourierTransit (row)
756{
757 return {
758 courierId: row.courier_id,
759 senderCharacterId: row.sender_character_id,
760 destinationKind: row.destination_kind,
761 destinationCharacterId: row.destination_character_id,
762 cargo: JSON.parse(row.cargo_blob),
763 originX: row.origin_x,
764 originY: row.origin_y,
765 destX: row.dest_x,
766 destY: row.dest_y,
767 traveled: row.traveled,
768 status: row.status,
769 entityId: row.entity_id,
770 updatedAt: row.updated_at,
771 createdAt: row.created_at
772 };
773}