BlueGit

timfa questward

Files

questward / server / tests / combat-logout.test.js

combat-logout.test.js

combat-logout.test.js 13.8 KiB Download Raw
1import test from "node:test";
2import assert from "node:assert/strict";
3import { BlockType } from "../../shared/definitions/tiles.js";
4import { ItemId } from "../../shared/definitions/items.js";
5import { Component } from "../src/ecs/components.js";
6import { MobId } from "../../shared/definitions/mobs.js";
7import { mobComponents } from "../src/simulation/spawners.js";
8import { createEmptyChunkData, encodeChunkBlob, decodeChunkBlob } from "../src/world/chunkData.js";
9import { makeCharacter, makeSimulation } from "./helpers/simulationHarness.js";
10import { emptyEquipment, emptySlots, addCoinsToSlots } from "../../shared/items/inventory.js";
11import { COMBAT_LOGOUT_MS, combatLogoutCoinThreshold, cowardiceHourKey } from "../../shared/combat/combatLogout.js";
12import { combatLevelFromSkills } from "../../shared/combat/combatLevel.js";
13import { defaultPlayerSkills } from "../../shared/skills/state.js";
14import
15 {
16 CHURCH_LETTER_AUTHOR,
17 QUESTWARD_GIFT_AUTHOR,
18 QUESTWARD_GIFT_ORG,
19 formatCombatLogoutCowardiceBody,
20 formatChurchOfflineResurrectionBody
21 } from "../../shared/courier/systemLetters.js";
22import { applyDamageAndKill } from "../src/combat/service.js";
23import { WorkerMessage } from "../src/simulation/protocol.js";
24
25function componentsOf (simulation, entityId)
26{
27 const record = simulation.entityRecord(entityId);
28 const worker = simulation.workers[record.workerId];
29 const handle = worker.world.ecs.handleOf(entityId);
30 return worker.world.ecs.componentsOf(handle);
31}
32
33function placeBlock (worldDb, tileX, tileY, typeId)
34{
35 const chunkX = Math.floor(tileX / 16);
36 const chunkY = Math.floor(tileY / 16);
37 const revisionId = worldDb.getActiveRevisionId();
38 const row = worldDb.getChunkVersion(chunkX, chunkY, revisionId);
39 const data = row
40 ? decodeChunkBlob(row.data_blob, undefined, chunkX, chunkY)
41 : createEmptyChunkData();
42 data.open = true;
43 const localX = tileX - chunkX * 16;
44 const localY = tileY - chunkY * 16;
45 data.blocks[localY * 16 + localX] = { typeId, state: 0 };
46 worldDb.saveChunkVersion(chunkX, chunkY, revisionId, true, encodeChunkBlob(data));
47}
48
49function heldLetters (stateDb, characterId)
50{
51 return stateDb.listHeldCourierDeliveries(characterId)
52 .map((hold) => hold.cargo?.stack)
53 .filter((stack) => stack?.itemId === ItemId.letter);
54}
55
56function engageAndLogout (harness, character, playerId, targetEntityId)
57{
58 harness.simulation.enqueue(1, {
59 type: "attack",
60 characterId: character.character_id,
61 targetEntityId
62 });
63 harness.simulation.step();
64 assert.equal(harness.simulation.beginCombatLogout(character.character_id), true);
65 assert.equal(harness.simulation.isCombatLogout(character.character_id), true);
66 return playerId;
67}
68
69function clearCombatAndExpireQuiet (harness, characterId, entityId)
70{
71 const record = harness.simulation.entityRecord(entityId);
72 if (record)
73 {
74 harness.simulation.workers[record.workerId].call({
75 type: WorkerMessage.clearCombat,
76 entityId,
77 targetEntityId: entityId
78 });
79 }
80 const track = harness.simulation.combatTracking.get(characterId);
81 if (track)
82 {
83 track.lastCombatActivityAt = harness.now() - COMBAT_LOGOUT_MS - 1;
84 track.wasInCombat = false;
85 }
86 const logout = harness.simulation.combatLogouts.get(characterId);
87 if (logout)
88 { logout.startedAt = harness.now() - COMBAT_LOGOUT_MS - 1; }
89 for (let i = 0; i < 60; i++)
90 { harness.simulation.step(); }
91}
92
93test("combat logout keeps the character until quiet timeout", () =>
94{
95 const harness = makeSimulation({ workerCount: 1 });
96 try
97 {
98 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
99 const playerId = harness.simulation.spawnCharacter(1, character);
100 const deerId = harness.simulation.spawnEntity(mobComponents({
101 tileX: 9,
102 tileY: 8,
103 mobTypeId: MobId.deer,
104 spawnerId: null
105 }));
106 engageAndLogout(harness, character, playerId, deerId);
107
108 const worker = harness.simulation.workers[0];
109 const spells = worker.world.ecs.get(worker.world.ecs.handleOf(playerId), Component.spells);
110 assert.equal(spells.autoCast, true);
111 assert.ok(harness.simulation.isCharacterInWorld(character.character_id));
112 assert.equal(harness.simulation.isCharacterOnline(character.character_id), false);
113
114 clearCombatAndExpireQuiet(harness, character.character_id, playerId);
115 assert.equal(harness.simulation.isCharacterInWorld(character.character_id), false);
116 assert.equal(harness.simulation.isCombatLogout(character.character_id), false);
117 }
118 finally
119 { harness.close(); }
120});
121
122test("combat activity resets the combat-logout quiet timer", () =>
123{
124 const harness = makeSimulation({ workerCount: 1 });
125 try
126 {
127 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
128 const playerId = harness.simulation.spawnCharacter(1, character);
129 const deerId = harness.simulation.spawnEntity(mobComponents({
130 tileX: 9,
131 tileY: 8,
132 mobTypeId: MobId.deer,
133 spawnerId: null
134 }));
135 engageAndLogout(harness, character, playerId, deerId);
136
137 harness.advance(COMBAT_LOGOUT_MS - 5_000);
138 for (let i = 0; i < 3; i++)
139 { harness.simulation.step(); }
140 assert.equal(harness.simulation.isCharacterInWorld(character.character_id), true);
141
142 const track = harness.simulation.combatTracking.get(character.character_id);
143 track.lastCombatActivityAt = harness.now();
144 const logout = harness.simulation.combatLogouts.get(character.character_id);
145 logout.startedAt = harness.now();
146
147 harness.advance(COMBAT_LOGOUT_MS - 10_000);
148 for (let i = 0; i < 3; i++)
149 { harness.simulation.step(); }
150 assert.equal(harness.simulation.isCharacterInWorld(character.character_id), true);
151
152 clearCombatAndExpireQuiet(harness, character.character_id, playerId);
153 assert.equal(harness.simulation.isCharacterInWorld(character.character_id), false);
154 }
155 finally
156 { harness.close(); }
157});
158
159test("offline combat-logout death resurrects at altar with church letter", () =>
160{
161 const harness = makeSimulation({ workerCount: 1 });
162 try
163 {
164 placeBlock(harness.worldDb, 20, 8, BlockType.churchAltar);
165 placeBlock(harness.worldDb, 7, 8, BlockType.bank);
166 harness.simulation.reloadWorld();
167 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
168 const playerId = harness.simulation.spawnCharacter(1, character);
169 const deerId = harness.simulation.spawnEntity(mobComponents({
170 tileX: 9,
171 tileY: 8,
172 mobTypeId: MobId.deer,
173 spawnerId: null
174 }));
175 engageAndLogout(harness, character, playerId, deerId);
176
177 const worker = harness.simulation.workers[0];
178 componentsOf(harness.simulation, playerId).health.current = 1;
179 const events = applyDamageAndKill(worker.world, deerId, playerId, 999, harness.now());
180 const died = events.find((event) => event.type === "player-died");
181 assert.ok(died);
182 harness.simulation.applyPlayerDiedEvent(died);
183
184 assert.equal(harness.stateDb.getCharacter(character.character_id).is_dead, 0);
185 assert.equal(harness.simulation.isCharacterInWorld(character.character_id), false);
186 const letters = heldLetters(harness.stateDb, character.character_id);
187 assert.ok(letters.some((stack) =>
188 stack.instance?.authorDisplayName === CHURCH_LETTER_AUTHOR
189 && stack.instance?.body === formatChurchOfflineResurrectionBody()
190 ));
191 const row = harness.stateDb.getCharacter(character.character_id);
192 assert.equal(
193 Math.max(Math.abs(row.tile_x - 20), Math.abs(row.tile_y - 8)),
194 1
195 );
196 }
197 finally
198 { harness.close(); }
199});
200
201test("PvP combat-logout quiet end applies skull after hourly forgiveness", () =>
202{
203 const harness = makeSimulation({ workerCount: 1 });
204 try
205 {
206 placeBlock(harness.worldDb, 7, 8, BlockType.bank);
207 harness.simulation.reloadWorld();
208 const victim = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8, firstName: "Vic" });
209 const attacker = makeCharacter(harness.stateDb, { tileX: 9, tileY: 8, firstName: "Atk" });
210 const victimId = harness.simulation.spawnCharacter(1, victim);
211 const attackerId = harness.simulation.spawnCharacter(2, attacker);
212 engageAndLogout(harness, victim, victimId, attackerId);
213 assert.equal(
214 harness.simulation.combatLogouts.get(victim.character_id).pendingCowardice,
215 true
216 );
217
218 const skills = harness.stateDb.getSkills(victim.character_id) ?? defaultPlayerSkills();
219 const threshold = combatLogoutCoinThreshold(combatLevelFromSkills(skills));
220 const hour = cowardiceHourKey(harness.now());
221
222 clearCombatAndExpireQuiet(harness, victim.character_id, victimId);
223 assert.equal(harness.simulation.isCharacterInWorld(victim.character_id), false);
224 assert.equal(harness.stateDb.getCowardiceForgivenHour(victim.character_id), hour);
225 assert.equal(harness.stateDb.getKillCounterState(victim.character_id).killCounter, 0);
226 assert.equal(heldLetters(harness.stateDb, victim.character_id).length, 0);
227
228 const victimRow = harness.stateDb.getCharacter(victim.character_id);
229 const victimId2 = harness.simulation.spawnCharacter(1, victimRow);
230 const standIn = makeCharacter(harness.stateDb, { tileX: 10, tileY: 8, firstName: "Stand" });
231 const standId = harness.simulation.spawnCharacter(3, standIn);
232 engageAndLogout(harness, victim, victimId2, standId);
233 clearCombatAndExpireQuiet(harness, victim.character_id, victimId2);
234
235 assert.equal(
236 harness.stateDb.getKillCounterState(victim.character_id).killCounter,
237 threshold
238 );
239 const letters = heldLetters(harness.stateDb, victim.character_id);
240 assert.ok(letters.some((stack) =>
241 stack.instance?.authorDisplayName === QUESTWARD_GIFT_AUTHOR
242 && stack.instance?.authorOrganization === QUESTWARD_GIFT_ORG
243 && stack.instance?.body === formatCombatLogoutCowardiceBody()
244 ));
245 void attackerId;
246 }
247 finally
248 { harness.close(); }
249});
250
251test("reattach after PvP combat-logout applies cowardice and restores autoCast", () =>
252{
253 const harness = makeSimulation({ workerCount: 1 });
254 try
255 {
256 placeBlock(harness.worldDb, 7, 8, BlockType.bank);
257 harness.simulation.reloadWorld();
258 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
259 const playerId = harness.simulation.spawnCharacter(1, character);
260 const other = makeCharacter(harness.stateDb, { tileX: 9, tileY: 8, firstName: "Other" });
261 const otherId = harness.simulation.spawnCharacter(2, other);
262
263 const worker = harness.simulation.workers[0];
264 const spells = worker.world.ecs.get(worker.world.ecs.handleOf(playerId), Component.spells);
265 spells.autoCast = false;
266 harness.stateDb.saveSpells(character.character_id, {
267 known: spells.known ?? [],
268 favorites: spells.favorites ?? [],
269 autoCast: false,
270 castChances: spells.castChances ?? {}
271 });
272
273 engageAndLogout(harness, character, playerId, otherId);
274 assert.equal(spells.autoCast, true);
275 harness.stateDb.setCowardiceForgivenHour(character.character_id, cowardiceHourKey(harness.now()));
276
277 const reattached = harness.simulation.reattachCharacterSession(character.character_id, 99);
278 assert.equal(reattached, playerId);
279 assert.equal(harness.simulation.isCombatLogout(character.character_id), false);
280 assert.equal(spells.autoCast, false);
281
282 const skills = harness.stateDb.getSkills(character.character_id) ?? defaultPlayerSkills();
283 const threshold = combatLogoutCoinThreshold(combatLevelFromSkills(skills));
284 assert.equal(
285 harness.stateDb.getKillCounterState(character.character_id).killCounter,
286 threshold
287 );
288 assert.ok(heldLetters(harness.stateDb, character.character_id).some((stack) =>
289 stack.instance?.authorDisplayName === QUESTWARD_GIFT_AUTHOR
290 ));
291 }
292 finally
293 { harness.close(); }
294});
295
296test("offline PvP death with enough coins skips cowardice skull", () =>
297{
298 const harness = makeSimulation({ workerCount: 1 });
299 try
300 {
301 placeBlock(harness.worldDb, 20, 8, BlockType.churchAltar);
302 placeBlock(harness.worldDb, 7, 8, BlockType.bank);
303 harness.simulation.reloadWorld();
304 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
305 const skills = harness.stateDb.getSkills(character.character_id) ?? defaultPlayerSkills();
306 const threshold = combatLogoutCoinThreshold(combatLevelFromSkills(skills));
307 const funded = addCoinsToSlots(emptySlots(), threshold + 10);
308 assert.equal(funded.ok, true);
309 harness.stateDb.saveBag(character.character_id, {
310 inventory: funded.slots,
311 equipment: emptyEquipment(),
312 vault: [],
313 vaultReserved: []
314 });
315 const playerId = harness.simulation.spawnCharacter(1, character);
316 const other = makeCharacter(harness.stateDb, { tileX: 9, tileY: 8, firstName: "Foe" });
317 const otherId = harness.simulation.spawnCharacter(2, other);
318 engageAndLogout(harness, character, playerId, otherId);
319 harness.stateDb.setCowardiceForgivenHour(character.character_id, cowardiceHourKey(harness.now()));
320
321 const worker = harness.simulation.workers[0];
322 componentsOf(harness.simulation, playerId).health.current = 1;
323 const events = applyDamageAndKill(worker.world, otherId, playerId, 999, harness.now());
324 const died = events.find((event) => event.type === "player-died");
325 harness.simulation.applyPlayerDiedEvent(died);
326
327 assert.equal(harness.stateDb.getKillCounterState(character.character_id).killCounter, 0);
328 assert.ok(heldLetters(harness.stateDb, character.character_id).some((stack) =>
329 stack.instance?.authorDisplayName === CHURCH_LETTER_AUTHOR
330 ));
331 assert.equal(
332 heldLetters(harness.stateDb, character.character_id).some((stack) =>
333 stack.instance?.authorDisplayName === QUESTWARD_GIFT_AUTHOR
334 ),
335 false
336 );
337 }
338 finally
339 { harness.close(); }
340});
341
342test("leave without recent combat despawns immediately", () =>
343{
344 const harness = makeSimulation({ workerCount: 1 });
345 try
346 {
347 const character = makeCharacter(harness.stateDb, { tileX: 8, tileY: 8 });
348 harness.simulation.spawnCharacter(1, character);
349 assert.equal(harness.simulation.beginCombatLogout(character.character_id), false);
350 harness.simulation.despawnCharacter(character.character_id);
351 assert.equal(harness.simulation.isCharacterOnline(character.character_id), false);
352 }
353 finally
354 { harness.close(); }
355});
356
357test("combat logout letter copy is fixed", () =>
358{
359 assert.match(formatChurchOfflineResurrectionBody(), /priesthood found your lifeless body/);
360 assert.match(formatCombatLogoutCowardiceBody(), /cowardice in honourable combat/);
361});