BlueGit

timfa questward

Files

questward / client / src / play / main.js

main.js

main.js 18.5 KiB Download Raw
1import { MessageType, GAIT, CHUNK_SIZE } from "/shared/protocol/constants.js";
2import { BlockType } from "/shared/definitions/tiles.js";
3import { GameSocket, defaultSocketUrl } from "../net/socket.js";
4import { loadSpriteCatalog, preloadCatalogImages, applySpriteSheets, useNearestNeighbour } from "../render/sprites.js";
5import { WorldView } from "../render/worldView.js";
6import { initSocial } from "./social.js";
7import { initChat } from "./chat.js";
8import { initInventory } from "./inventory.js";
9import { initSkills } from "./skills.js";
10import { initCrafting } from "./crafting.js";
11import { initContextMenu } from "./contextMenu.js";
12import { initDeath } from "./death.js";
13import { CraftingStationId } from "/shared/definitions/craftingStations.js";
14import { formatQuantity } from "/shared/items/formatQuantity.js";
15
16const game = new Game();
17const hud = document.getElementById("hud");
18const overlay = document.getElementById("overlay");
19const statusEl = document.getElementById("status");
20const characterList = document.getElementById("character-list");
21const errorEl = document.getElementById("error");
22
23let socket;
24let session = null;
25let playing = false;
26let view = null;
27let scene = null;
28let gait = GAIT.walk;
29let catalog = { grounds: {}, blocks: {} };
30let social;
31let chat;
32let inventory;
33let skills;
34let crafting;
35let contextMenu;
36let death;
37let pendingPickup = null;
38/** @type {{ kind: "bank", tileX: number, tileY: number, getCheques?: boolean } | { kind: "talk", targetEntityId: number } | null } */
39let pendingInteract = null;
40/** Framework can report mousePressed for two frames; latch so one physical click is one command. */
41let leftClickConsumed = false;
42
43function showError (message)
44{
45 errorEl.textContent = message ?? "";
46}
47
48function renderCharacters (characters)
49{
50 characterList.innerHTML = "";
51 for (const character of characters)
52 {
53 const row = document.createElement("div");
54 row.className = "character-row";
55 const pending = character.deletionScheduledAt
56 ? ` (deleting ${new Date(character.deletionScheduledAt).toLocaleString()})`
57 : "";
58 row.innerHTML = `<strong>${character.firstName} ${character.lastName}</strong> · ${character.sex}${pending}`;
59 const play = document.createElement("button");
60 play.textContent = "Play";
61 play.disabled = !!character.deletionScheduledAt;
62 play.addEventListener("click", () => socket.send({ type: MessageType.selectCharacter, characterId: character.characterId }));
63 const del = document.createElement("button");
64 del.textContent = character.deletionScheduledAt ? "Cancel delete" : "Delete";
65 del.addEventListener("click", () =>
66 {
67 socket.send({
68 type: character.deletionScheduledAt ? MessageType.cancelDeleteCharacter : MessageType.scheduleDeleteCharacter,
69 characterId: character.characterId
70 });
71 });
72 row.append(play, del);
73 characterList.append(row);
74 }
75}
76
77function uiBlocked ()
78{
79 return !!(social?.isBlocking() || chat?.isBlocking() || inventory?.isBlocking()
80 || crafting?.isBlocking() || contextMenu?.isOpen() || death?.isBlocking());
81}
82
83function clearPendingPickup ()
84{
85 pendingPickup = null;
86}
87
88function clearPendingInteract ()
89{
90 pendingInteract = null;
91}
92
93function clearAllPendingActions ()
94{
95 clearPendingPickup();
96 clearPendingInteract();
97}
98
99function approachAdjacentTile (tileX, tileY)
100{
101 const local = view.entities.get(view.localEntityId);
102 if (local && chebyshev(local.tileX, local.tileY, tileX, tileY) <= 1)
103 { return true; }
104 let best = null;
105 let bestDist = Infinity;
106 for (let dy = -1; dy <= 1; dy++)
107 {
108 for (let dx = -1; dx <= 1; dx++)
109 {
110 if (dx === 0 && dy === 0)
111 { continue; }
112 const destX = tileX + dx;
113 const destY = tileY + dy;
114 const dist = local
115 ? chebyshev(local.tileX, local.tileY, destX, destY)
116 : 0;
117 if (dist < bestDist)
118 {
119 bestDist = dist;
120 best = { tileX: destX, tileY: destY };
121 }
122 }
123 }
124 if (best)
125 { socket.send({ type: MessageType.moveTo, tileX: best.tileX, tileY: best.tileY }); }
126 return false;
127}
128
129function requestOpenBank (tileX, tileY, { getCheques = false } = {})
130{
131 clearPendingPickup();
132 pendingInteract = { kind: "bank", tileX, tileY, getCheques: !!getCheques };
133 if (approachAdjacentTile(tileX, tileY))
134 { flushPendingInteract(); }
135}
136
137function requestTalk (targetEntityId)
138{
139 clearPendingPickup();
140 pendingInteract = { kind: "talk", targetEntityId };
141 const target = view.entities.get(targetEntityId);
142 if (!target)
143 {
144 clearPendingInteract();
145 return;
146 }
147 if (approachAdjacentTile(target.tileX, target.tileY))
148 { flushPendingInteract(); }
149}
150
151function flushPendingInteract ()
152{
153 if (!pendingInteract || !view)
154 { return; }
155 const local = view.entities.get(view.localEntityId);
156 if (!local)
157 { return; }
158
159 if (pendingInteract.kind === "bank")
160 {
161 if (chebyshev(local.tileX, local.tileY, pendingInteract.tileX, pendingInteract.tileY) > 1)
162 { return; }
163 const getCheques = !!pendingInteract.getCheques;
164 socket.send({ type: MessageType.openBank });
165 if (getCheques)
166 { inventory?.getBlankCheques(); }
167 clearPendingInteract();
168 return;
169 }
170
171 if (pendingInteract.kind === "talk")
172 {
173 const target = view.entities.get(pendingInteract.targetEntityId);
174 if (!target)
175 {
176 clearPendingInteract();
177 return;
178 }
179 if (chebyshev(local.tileX, local.tileY, target.tileX, target.tileY) > 1)
180 {
181 // Target may have moved — keep chasing.
182 approachAdjacentTile(target.tileX, target.tileY);
183 return;
184 }
185 socket.send({ type: MessageType.interact, targetEntityId: pendingInteract.targetEntityId });
186 clearPendingInteract();
187 }
188}
189
190function requestPickup (ground)
191{
192 if (!ground)
193 { return; }
194 clearPendingInteract();
195 pendingPickup = {
196 groundItemId: ground.groundItemId,
197 tileX: ground.tileX,
198 tileY: ground.tileY
199 };
200 const local = view.entities.get(view.localEntityId);
201 if (local && local.tileX === ground.tileX && local.tileY === ground.tileY)
202 {
203 flushPendingPickup();
204 return;
205 }
206 socket.send({ type: MessageType.moveTo, tileX: ground.tileX, tileY: ground.tileY });
207}
208
209function flushPendingPickup ()
210{
211 if (!pendingPickup || !view)
212 { return; }
213 const item = view.groundItems.get(pendingPickup.groundItemId);
214 if (!item)
215 {
216 clearPendingPickup();
217 return;
218 }
219 const local = view.entities.get(view.localEntityId);
220 if (!local)
221 { return; }
222 if (local.tileX !== pendingPickup.tileX || local.tileY !== pendingPickup.tileY)
223 { return; }
224 socket.send({ type: MessageType.pickupItem, groundItemId: pendingPickup.groundItemId });
225 clearPendingPickup();
226}
227
228function requestAttack (targetEntityId)
229{
230 clearAllPendingActions();
231 socket.send({ type: MessageType.attack, targetEntityId });
232}
233
234function isAttackableEntity (entity)
235{
236 if (!entity || entity.untargetable)
237 { return false; }
238 if (entity.canFight)
239 { return true; }
240 // Snapshots can omit canFight; mobs are still attackable via LMB.
241 return !!entity.mobTypeId && !entity.talkable;
242}
243
244function handleLeftClick (mouseX, mouseY)
245{
246 const entity = view.entityAtScreen(mouseX, mouseY);
247 if (entity && entity.entityId !== view.localEntityId && !entity.untargetable)
248 {
249 clearPendingPickup();
250 if (entity.characterId)
251 {
252 clearPendingInteract();
253 social.inspect(entity);
254 return;
255 }
256 if (entity.talkable)
257 {
258 requestTalk(entity.entityId);
259 return;
260 }
261 if (isAttackableEntity(entity))
262 {
263 requestAttack(entity.entityId);
264 return;
265 }
266 // Clicked an entity we don't act on — do not fall through to walk (that cancels combat).
267 return;
268 }
269
270 const tile = view.screenToTile(mouseX, mouseY);
271 const ground = view.groundItemAtTile(tile.tileX, tile.tileY);
272 if (ground)
273 { requestPickup(ground); }
274 else if (isBankTile(view, tile.tileX, tile.tileY))
275 { requestOpenBank(tile.tileX, tile.tileY); }
276 else
277 {
278 clearAllPendingActions();
279 socket.send({ type: MessageType.moveTo, tileX: tile.tileX, tileY: tile.tileY });
280 }
281}
282
283function handleRightClick (event, mouseX, mouseY)
284{
285 event.preventDefault();
286 const tile = view.screenToTile(mouseX, mouseY);
287 const items = [];
288 const walkTileX = tile.tileX;
289 const walkTileY = tile.tileY;
290
291 items.push({
292 label: "Walk here",
293 onSelect: () =>
294 {
295 clearAllPendingActions();
296 socket.send({ type: MessageType.moveTo, tileX: walkTileX, tileY: walkTileY });
297 }
298 });
299
300 for (const entity of view.entitiesAtTile(tile.tileX, tile.tileY))
301 {
302 if (entity.entityId === view.localEntityId)
303 { continue; }
304 const targetName = entityLabel(entity);
305 items.push({
306 label: `Follow ${targetName}`,
307 onSelect: () =>
308 {
309 clearAllPendingActions();
310 socket.send({ type: MessageType.follow, targetEntityId: entity.entityId });
311 }
312 });
313 if (entity.untargetable)
314 { continue; }
315 if (entity.talkable)
316 {
317 items.push({
318 label: `Talk to ${targetName}`,
319 onSelect: () => requestTalk(entity.entityId)
320 });
321 }
322 if (entity.characterId)
323 {
324 items.push({
325 label: `${targetName} info`,
326 onSelect: () =>
327 {
328 clearAllPendingActions();
329 social.inspect(entity);
330 }
331 });
332 }
333 items.push({
334 label: `Attack ${targetName}`,
335 onSelect: () => requestAttack(entity.entityId)
336 });
337 }
338
339 for (const ground of view.groundItemsAtTile(tile.tileX, tile.tileY))
340 {
341 const name = groundLabel(ground);
342 items.push({
343 label: `Pick up ${name}`,
344 onSelect: () => requestPickup(ground)
345 });
346 }
347
348 if (isBankTile(view, tile.tileX, tile.tileY))
349 {
350 items.push({
351 label: "Bank",
352 onSelect: () => requestOpenBank(tile.tileX, tile.tileY)
353 });
354 items.push({
355 label: "Get Blank Cheques",
356 onSelect: () => requestOpenBank(tile.tileX, tile.tileY, { getCheques: true })
357 });
358 }
359
360 contextMenu.show(event.clientX, event.clientY, items);
361}
362
363function entityLabel (entity)
364{
365 const first = (entity?.firstName ?? "").trim();
366 const last = (entity?.lastName ?? "").trim();
367 if (first && last)
368 { return `${first} ${last}`; }
369 return first || "target";
370}
371
372function groundLabel (ground)
373{
374 const name = (ground?.displayName ?? "").trim() || "item";
375 const qty = ground?.quantity ?? 1;
376 if (qty <= 1)
377 { return name; }
378 return `${name} (${formatQuantity(qty)})`;
379}
380
381function startPlay (payload)
382{
383 playing = true;
384 overlay.hidden = true;
385 hud.hidden = false;
386 document.getElementById("you").textContent = `${payload.firstName} ${payload.lastName} (${session.authSubject})`;
387 gait = payload.gait ?? GAIT.walk;
388 document.getElementById("gait").textContent = gait;
389 if (!scene)
390 {
391 scene = new Scene(0, 0, window.innerWidth, window.innerHeight);
392 game.loadScene(scene);
393 useNearestNeighbour(scene, game.images);
394 view = new WorldView(game, scene, catalog);
395 const ticker = new GameObject(0, 0, null, 10);
396 ticker.update = (dt) =>
397 {
398 const leftPressed = GameInput.mousePressed(GameInput.MouseButtons.Left);
399 const leftHeld = GameInput.mouseHeld(GameInput.MouseButtons.Left);
400 if (!leftPressed && !leftHeld)
401 { leftClickConsumed = false; }
402 else if (!leftClickConsumed && playing && !uiBlocked())
403 {
404 leftClickConsumed = true;
405 const canvas = scene.canvas;
406 const rect = canvas.getBoundingClientRect();
407 const mouseX = GameInput.mousePosition.x - rect.left;
408 const mouseY = GameInput.mousePosition.y - rect.top;
409 handleLeftClick(mouseX, mouseY);
410 }
411 if (GameInput.isPressed(82) && !uiBlocked())
412 {
413 gait = gait === GAIT.run ? GAIT.walk : GAIT.run;
414 socket.send({ type: MessageType.setGait, gait });
415 document.getElementById("gait").textContent = gait;
416 }
417 if (playing && !death?.isBlocking())
418 {
419 flushPendingPickup();
420 flushPendingInteract();
421 social?.updateNametag(view, scene, view.localEntityId);
422 chat?.update(view, scene);
423 }
424 view.update(dt);
425 };
426 scene.addObject(ticker);
427 window.addEventListener("resize", () =>
428 {
429 scene.size.x = window.innerWidth;
430 scene.size.y = window.innerHeight;
431 scene.g_fixSize();
432 useNearestNeighbour(scene, game.images);
433 });
434 window.addEventListener("wheel", (event) =>
435 {
436 if (!playing || uiBlocked())
437 { return; }
438 view.setZoom(view.zoom + (event.deltaY < 0 ? 0.25 : -0.25));
439 document.getElementById("zoom").textContent = `${view.zoom.toFixed(2)}×`;
440 }, { passive: true });
441 scene.canvas.addEventListener("contextmenu", (event) =>
442 {
443 if (!playing || uiBlocked())
444 { return; }
445 const rect = scene.canvas.getBoundingClientRect();
446 handleRightClick(event, event.clientX - rect.left, event.clientY - rect.top);
447 });
448 }
449 view.setSettings(payload.settings ?? view.settings);
450 chat?.syncSettings();
451 view.worldHour = payload.worldTime?.hour ?? 12;
452 view.setLocalEntity(
453 payload.entityId,
454 payload.tileX,
455 payload.tileY,
456 payload.gait,
457 payload.sex,
458 payload.firstName,
459 payload.lastName,
460 payload.characterId,
461 payload.layers
462 );
463}
464
465async function main ()
466{
467 catalog = await loadSpriteCatalog();
468 await preloadCatalogImages(game, catalog);
469 applySpriteSheets(game.images, catalog);
470 social = initSocial({
471 socket: { send (payload) { socket.send(payload); } },
472 MessageType
473 });
474 contextMenu = initContextMenu();
475 inventory = initInventory({
476 socket: { send (payload) { socket.send(payload); } },
477 MessageType,
478 contextMenu,
479 resolveSpriteUrl (name)
480 {
481 return catalog?.images?.find((entry) => entry.name === name)?.url ?? null;
482 },
483 getFriends ()
484 {
485 return social?.getFriends?.() ?? [];
486 },
487 getLocalName ()
488 {
489 const you = document.getElementById("you")?.textContent ?? "";
490 return you.split("(")[0].trim() || "Unknown";
491 }
492 });
493 skills = initSkills();
494 crafting = initCrafting({
495 socket: { send (payload) { socket.send(payload); } },
496 MessageType,
497 getInventorySlots ()
498 {
499 return inventory?.getInventorySlots?.() ?? [];
500 },
501 getSkillLevel (skillId)
502 {
503 return skills?.skillLevel?.(skillId) ?? 1;
504 }
505 });
506 chat = initChat({
507 socket: { send (payload) { socket.send(payload); } },
508 MessageType,
509 getSettings: () => view?.settings
510 });
511 death = initDeath({
512 socket: { send (payload) { socket.send(payload); } },
513 MessageType
514 });
515 game.startGame();
516
517 socket = new GameSocket(defaultSocketUrl(), (message) =>
518 {
519 switch (message.type)
520 {
521 case MessageType.session:
522 session = message;
523 statusEl.textContent = `Signed in as ${message.authSubject} (stub admin)`;
524 renderCharacters(message.characters);
525 break;
526 case MessageType.characterList:
527 renderCharacters(message.characters);
528 if (!playing)
529 { overlay.hidden = false; }
530 break;
531 case MessageType.enterWorld:
532 startPlay(message);
533 inventory?.setLocalCharacterId(message.characterId);
534 break;
535 case MessageType.chunkSnapshot:
536 view?.applySnapshot(message);
537 break;
538 case MessageType.unsubscribeChunk:
539 view?.removeChunk(message.chunkX, message.chunkY);
540 break;
541 case MessageType.entitySpawn:
542 view?.spawnEntity(message);
543 break;
544 case MessageType.entityMove:
545 view?.moveEntity(message);
546 if (message.entityId === view?.localEntityId && message.gait)
547 {
548 gait = message.gait;
549 document.getElementById("gait").textContent = gait;
550 }
551 break;
552 case MessageType.entityDespawn:
553 view?.despawnEntity(message.entityId);
554 break;
555 case MessageType.entityAppearance:
556 view?.setAppearance(message);
557 break;
558 case MessageType.groundItemAppear:
559 view?.upsertGroundItem(message);
560 break;
561 case MessageType.groundItemDespawn:
562 view?.despawnGroundItem(message.groundItemId);
563 break;
564 case MessageType.inventory:
565 inventory?.handleInventory(message);
566 crafting?.refresh();
567 break;
568 case MessageType.skills:
569 skills?.render(message.skills);
570 crafting?.refresh();
571 break;
572 case MessageType.bankSnapshot:
573 inventory?.handleBank(message);
574 break;
575 case MessageType.pigeonDispatched:
576 inventory?.handlePigeonDispatched(message);
577 break;
578 case MessageType.pigeonDelivered:
579 inventory?.handlePigeonDelivered(message);
580 break;
581 case MessageType.characterSearchResult:
582 inventory?.handleCharacterSearch(message);
583 break;
584 case MessageType.craftResult:
585 crafting?.handleCraftResult(message);
586 break;
587 case MessageType.worldStatus:
588 if (view)
589 {
590 view.setSettings(message.settings ?? view.settings);
591 view.worldHour = message.worldTime?.hour ?? view.worldHour;
592 chat?.syncSettings();
593 }
594 break;
595 case MessageType.chatBubble:
596 chat?.showBubble(message);
597 break;
598 case MessageType.friends:
599 social?.handleFriends(message);
600 break;
601 case MessageType.combatSwing:
602 view?.spawnCombatSwing(message);
603 break;
604 case MessageType.combatHit:
605 view?.updateEntityHealth(message.targetId, message.health, message.maxHealth);
606 view?.flashDamage(message.targetId);
607 view?.spawnDamageNumber(message.targetId, message.damage);
608 break;
609 case MessageType.playerDied:
610 clearAllPendingActions();
611 contextMenu?.hide();
612 death?.show();
613 break;
614 case MessageType.playerRespawned:
615 death?.hide();
616 view?.updateEntityHealth(message.entityId, message.health, message.maxHealth);
617 break;
618 case MessageType.error:
619 showError(message.message);
620 social?.showError(message.message);
621 break;
622 case MessageType.forceLogout:
623 returnToMenu(message.reason);
624 break;
625 }
626 }, {
627 onClose (event)
628 {
629 if (playing)
630 { returnToMenu(event.reason || "Disconnected from server."); }
631 }
632 });
633 await socket.connect();
634 if (typeof window !== "undefined")
635 {
636 window.__craftDev = (stationId = CraftingStationId.craftingBench) =>
637 {
638 crafting?.openStation(stationId);
639 };
640 }
641}
642
643function returnToMenu (reason = "")
644{
645 playing = false;
646 clearAllPendingActions();
647 social?.reset();
648 chat?.reset();
649 inventory?.reset();
650 crafting?.reset();
651 skills?.hide();
652 contextMenu?.hide();
653 death?.reset();
654 if (view)
655 {
656 for (const key of [...(view.chunks?.keys?.() ?? [])])
657 {
658 const [chunkX, chunkY] = key.split(",").map(Number);
659 view.removeChunk(chunkX, chunkY);
660 }
661 }
662 overlay.hidden = false;
663 hud.hidden = true;
664 if (reason)
665 { statusEl.textContent = reason; }
666}
667
668document.getElementById("create-form").addEventListener("submit", (event) =>
669{
670 event.preventDefault();
671 showError("");
672 socket.send({
673 type: MessageType.createCharacter,
674 firstName: document.getElementById("first-name").value,
675 lastName: document.getElementById("last-name").value,
676 sex: document.getElementById("sex").value
677 });
678});
679
680document.getElementById("leave").addEventListener("click", () =>
681{
682 socket.send({ type: MessageType.leaveWorld });
683 returnToMenu();
684});
685
686main().catch((error) =>
687{
688 showError(error.message);
689 console.error(error);
690});
691
692function isBankTile (view, tileX, tileY)
693{
694 const chunkX = Math.floor(tileX / CHUNK_SIZE);
695 const chunkY = Math.floor(tileY / CHUNK_SIZE);
696 const snapshot = view.chunks.get(`${chunkX},${chunkY}`);
697 if (!snapshot)
698 { return false; }
699 const localX = tileX - chunkX * CHUNK_SIZE;
700 const localY = tileY - chunkY * CHUNK_SIZE;
701 return snapshot.blocks[localY * CHUNK_SIZE + localX]?.typeId === BlockType.bank;
702}
703
704function chebyshev (ax, ay, bx, by)
705{
706 return Math.max(Math.abs(ax - bx), Math.abs(ay - by));
707}