Diablo2D — Shadows of Tristram: complete browser ARPG
- Isometric canvas renderer (depth-sorted, FOV/fog, additive lighting) - 3 classes x 20 skills, 4 acts x 4 floors + boss lairs, torment I-X - Diablo-style loot: rarities, affix tiers, 14 legendaries, vendor, stash - Rogue camp with 6 NPCs: Charsi/Akara/Kashya/Cain/Gheed/storage - NPC quest chain (accept -> hunt -> turn in) with rewards & gating - Procedural WebAudio SFX + generative music, EN/VI localization - Saves, settings, waypoints, hardcore mode, PWA manifest - 93-assertion headless suite + browser E2E via CDP
This commit is contained in:
@@ -0,0 +1,246 @@
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head><meta charset="utf-8"><title>Drive</title></head>
|
||||
<body style="margin:0;background:#000">
|
||||
<iframe id="g" src="/index.html" style="width:1440px;height:900px;border:0"></iframe>
|
||||
<pre id="status" style="color:#0f0;font-size:18px;white-space:pre-wrap">booting…</pre>
|
||||
<script>
|
||||
'use strict';
|
||||
/* ============================================================
|
||||
* Diablo2D E2E driver.
|
||||
* ?phase=full — everything incl. rendering probes (short)
|
||||
* ?phase=descend — boot→travel→walk to stairs→KeyF→floor+1
|
||||
* &norender=1 — pump skips draw calls (long sessions)
|
||||
* ============================================================ */
|
||||
const PHASE = new URLSearchParams(location.search).get('phase') || 'full';
|
||||
const NORENDER = new URLSearchParams(location.search).get('norender') === '1';
|
||||
const MAXFRAMES = parseInt(new URLSearchParams(location.search).get('maxframes') || '0', 10);
|
||||
let drawnFrames = 0;
|
||||
const MUTE = new URLSearchParams(location.search).get('mute') === '1';
|
||||
|
||||
const S = [];
|
||||
function log(m) { S.push(m); document.getElementById('status').textContent = S.join('\n'); }
|
||||
const frame = document.getElementById('g');
|
||||
frame.addEventListener('load', () => setTimeout(run, 1500));
|
||||
const sleep = ms => new Promise(r => setTimeout(r, ms));
|
||||
|
||||
let W, D, cv, cvRect;
|
||||
const TW = 64, THh = 32;
|
||||
|
||||
function q(sel) { return frame.contentDocument.querySelector(sel); }
|
||||
function qa(sel) { return [...frame.contentDocument.querySelectorAll(sel)]; }
|
||||
function click(el, btn = 0) {
|
||||
if (!el) return false;
|
||||
const o = { bubbles: true, button: btn };
|
||||
el.dispatchEvent(new W.MouseEvent('mousedown', o));
|
||||
el.dispatchEvent(new W.MouseEvent('mouseup', o));
|
||||
el.dispatchEvent(new W.MouseEvent('click', o));
|
||||
return true;
|
||||
}
|
||||
function canvasClick(x, y, btn = 0) {
|
||||
const o = { bubbles: true, button: btn, clientX: x, clientY: y };
|
||||
cv.dispatchEvent(new W.MouseEvent('mousemove', o));
|
||||
cv.dispatchEvent(new W.MouseEvent('mousedown', o));
|
||||
W.dispatchEvent(new W.MouseEvent('mouseup', o)); // iframe window!
|
||||
}
|
||||
function toScreen(wx, wy) {
|
||||
const cam = D.render.cam, z = cam.zoom || 1;
|
||||
const dx = wx - cam.x, dy = wy - cam.y;
|
||||
return {
|
||||
x: cvRect.left + cv.clientWidth / 2 + (dx - dy) * TW / 2 * z,
|
||||
y: cvRect.top + cv.clientHeight / 2 + (dx + dy) * THh / 2 * z,
|
||||
};
|
||||
}
|
||||
|
||||
async function ensureLoop() {
|
||||
let frames = 0;
|
||||
const orig = D.render.frame.bind(D.render);
|
||||
D.render.frame = (g, dt) => { frames++; return orig(g, dt); };
|
||||
await sleep(400);
|
||||
const rafAlive = frames > 3;
|
||||
if (!rafAlive) {
|
||||
setInterval(() => {
|
||||
try {
|
||||
const dt = 1 / 30;
|
||||
D.ui.tickGlobalKeys();
|
||||
if (D.game.state === 'playing') {
|
||||
D.game.update(dt);
|
||||
const allowDraw = !NORENDER && (!MAXFRAMES || drawnFrames < MAXFRAMES);
|
||||
if (allowDraw) { D.render.frame(D.game, dt); drawnFrames++; }
|
||||
else if (MAXFRAMES && drawnFrames === MAXFRAMES) { drawnFrames++; log('render capped @' + MAXFRAMES); }
|
||||
D.ui.tick(dt);
|
||||
}
|
||||
D.input.endFrame();
|
||||
} catch (e) { log('PUMP_ERROR ' + e.message); }
|
||||
}, 33);
|
||||
}
|
||||
return rafAlive;
|
||||
}
|
||||
|
||||
async function bootThroughTown(cls = 'crusader') {
|
||||
click(q('#t-new'));
|
||||
await sleep(300);
|
||||
log('classselect=' + !!q('.class-card'));
|
||||
click(qa('.class-card')[0]);
|
||||
await sleep(250);
|
||||
click(q('#cs-play'));
|
||||
await sleep(1200);
|
||||
log('state=' + D.game.state + ' town=' + !!D.game.world.isTown);
|
||||
}
|
||||
|
||||
async function travelAct1Floor1() {
|
||||
D.input.injectPress('KeyM');
|
||||
await sleep(350);
|
||||
const nodes = qa('.wm-node');
|
||||
log('wmNodes=' + nodes.length);
|
||||
click(nodes[1]); // cathedral node -> waypoint travel
|
||||
await sleep(2200);
|
||||
qa('.fpanel:not(.hidden) .fpanel-close').forEach(b => click(b));
|
||||
await sleep(250);
|
||||
log('travel act=' + D.game.world.act + ' f=' + D.game.world.floorIdx +
|
||||
' mons=' + D.game.monsters.length);
|
||||
}
|
||||
|
||||
async function doDescend() {
|
||||
const pl = D.game.player;
|
||||
const sd = D.game.world.stairsDown;
|
||||
if (!sd || D.game.world.isTown) { log('no stairs here'); return; }
|
||||
pl.maxHp = 1e7; pl.hp = 1e7;
|
||||
let pressed = 0;
|
||||
for (let i = 0; i < 1600; i++) {
|
||||
if (D.game.world.floorIdx >= 1 || D.game.world.isTown) break;
|
||||
const d = Math.hypot(pl.x - sd.x - .5, pl.y - sd.y - .5);
|
||||
if (d < 2.4 && i % 8 === 0) { D.input.injectPress('KeyF'); pressed++; }
|
||||
if (!pl.moveTarget || i % 30 === 0) pl.moveTarget = { x: sd.x + .5, y: sd.y + .5 };
|
||||
if (i % 400 === 399) log(' d=' + d.toFixed(2) + ' left=' + D.input.state.left + ' fPresses=' + pressed);
|
||||
await sleep(33);
|
||||
}
|
||||
log('descended f=' + D.game.world.floorIdx + ' presses=' + pressed);
|
||||
}
|
||||
|
||||
async function combatAndLoot() {
|
||||
/* bind cleave to RMB (learned at char creation) */
|
||||
const pl0 = D.game.player;
|
||||
const learned = Object.keys(pl0.skills).filter(k => pl0.skills[k] > 0);
|
||||
pl0.hotbar[1] = learned[0] || null;
|
||||
log('rmbSkill=' + pl0.hotbar[1]);
|
||||
|
||||
let casts = 0;
|
||||
const origCast = D.combat.castSkill.bind(D.combat);
|
||||
D.combat.castSkill = (...a) => { casts++; return origCast(...a); };
|
||||
|
||||
let target = null;
|
||||
for (let i = 0; i < 40; i++) {
|
||||
if (!target || target.dead) {
|
||||
target = D.game.nearestMonster(D.game.player.x, D.game.player.y, 24);
|
||||
if (!target) break;
|
||||
}
|
||||
const ang = Math.atan2(D.game.player.y - target.y, D.game.player.x - target.x);
|
||||
D.game.player.x = target.x + Math.cos(ang) * 1.05;
|
||||
D.game.player.y = target.y + Math.sin(ang) * 0.63;
|
||||
D.game.player.moveTarget = null;
|
||||
await sleep(50);
|
||||
const mp = toScreen(target.x, target.y);
|
||||
canvasClick(mp.x, mp.y, 2);
|
||||
await sleep(300);
|
||||
}
|
||||
const p = D.game.player;
|
||||
log('casts=' + casts + ' kills=' + p.kills + ' xp=' + p.xp +
|
||||
' inv=' + p.inventory.length + ' gold=' + p.gold);
|
||||
}
|
||||
|
||||
function pixelProof() {
|
||||
try { D.render.frame(D.game, 1 / 30); } catch (e) { log('renderErr ' + e.message); return; }
|
||||
/* camera settle check */
|
||||
const cam = D.render.cam;
|
||||
const p = D.game.player;
|
||||
log('camDelta=' + (Math.abs(cam.x - p.x) + Math.abs(cam.y - p.y)).toFixed(2));
|
||||
|
||||
/* authoritative: read straight from the game's backbuffer */
|
||||
const cx = cv.width >> 1, cy = cv.height >> 1;
|
||||
const pts = [[0, 0], [-120, -80], [120, 80], [-200, 0], [200, 0]].map(([dx, dy]) =>
|
||||
D.render.debugPixel(cx + dx, cy + dy));
|
||||
log('backbuffer ' + JSON.stringify(pts));
|
||||
|
||||
/* cross-check via canvas copy */
|
||||
const off = frame.contentDocument.createElement('canvas');
|
||||
off.width = 80; off.height = 80;
|
||||
const oc = off.getContext('2d');
|
||||
oc.drawImage(cv, cv.width / 2 - 200, cv.height / 2 - 150, 400, 300, 0, 0, 80, 80);
|
||||
const data = oc.getImageData(0, 0, 80, 80).data;
|
||||
let lit = 0, colors = new Set(), maxB = 0;
|
||||
for (let i = 0; i < data.length; i += 4) {
|
||||
const b = data[i] + data[i + 1] + data[i + 2];
|
||||
if (b > 60) lit++;
|
||||
if (b > maxB) maxB = b;
|
||||
colors.add((data[i] >> 4) + ',' + (data[i + 1] >> 4) + ',' + (data[i + 2] >> 4));
|
||||
}
|
||||
log('canvasCopy lit=' + Math.round(lit / (data.length / 4) * 100) + '% colors=' + colors.size + ' maxB=' + maxB);
|
||||
}
|
||||
|
||||
async function run() {
|
||||
try {
|
||||
W = frame.contentWindow;
|
||||
D = W.D2;
|
||||
frame.contentWindow.onerror = m => log('PAGE_ERR ' + m);
|
||||
cv = q('#game-canvas');
|
||||
cvRect = cv.getBoundingClientRect();
|
||||
|
||||
if (MUTE) {
|
||||
try {
|
||||
D.audio.sfx = () => {};
|
||||
D.audio.playMusic = () => {};
|
||||
D.audio.stopMusic = () => {};
|
||||
D.audio.unlock = () => {};
|
||||
} catch (e) {}
|
||||
}
|
||||
const raf = await ensureLoop();
|
||||
log('raf=' + raf + ' norender=' + NORENDER + ' mute=' + MUTE);
|
||||
|
||||
await bootThroughTown();
|
||||
|
||||
if (PHASE === 'full') {
|
||||
/* movement */
|
||||
const p0 = { x: D.game.player.x, y: D.game.player.y };
|
||||
const sp = toScreen(p0.x + 3, p0.y + 1);
|
||||
canvasClick(sp.x, sp.y);
|
||||
await sleep(1400);
|
||||
log('moved=' + Math.hypot(D.game.player.x - p0.x, D.game.player.y - p0.y).toFixed(2));
|
||||
/* panels */
|
||||
for (const [code, id] of [['KeyI', '#panel-inventory'], ['KeyC', '#panel-character'], ['KeyT', '#panel-skills'], ['KeyM', '#panel-worldmap']]) {
|
||||
D.input.injectPress(code);
|
||||
await sleep(320);
|
||||
const open = !q(id).classList.contains('hidden');
|
||||
if (!open) log('PANEL_FAIL ' + code);
|
||||
click(q(id + ' .fpanel-close'));
|
||||
await sleep(140);
|
||||
}
|
||||
log('panels ok');
|
||||
}
|
||||
|
||||
await travelAct1Floor1();
|
||||
|
||||
if (PHASE === 'full') {
|
||||
await combatAndLoot();
|
||||
await sleep(900); // camera settle before sampling
|
||||
pixelProof();
|
||||
/* save/load */
|
||||
D.game.saveGame();
|
||||
const g0 = D.game.player.gold;
|
||||
D.game.player.gold += 555;
|
||||
const ok = D.game.loadGame() && D.game.player.gold === g0 && D.game.player.hp === D.game.player.maxHp;
|
||||
log('save/load=' + ok);
|
||||
} else {
|
||||
await doDescend();
|
||||
}
|
||||
|
||||
const fin = D.game.player;
|
||||
log('DONE f=' + D.game.world.floorIdx + ' lvl=' + fin.level + ' kills=' + fin.kills +
|
||||
' hp=' + Math.round(fin.hp) + '/' + fin.maxHp + ' errors=none');
|
||||
} catch (e) {
|
||||
log('DRIVE_ERROR: ' + (e.stack || e.message));
|
||||
}
|
||||
}
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,76 @@
|
||||
/* ============================================================
|
||||
* tools/build_zip.mjs — package the game for itch.io.
|
||||
* Store-only ZIP (no deps). Excludes tools/ and dev files.
|
||||
* node tools/build_zip.mjs
|
||||
* ============================================================ */
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
const CRC_TABLE = (() => {
|
||||
const t = new Int32Array(256);
|
||||
for (let n = 0; n < 256; n++) {
|
||||
let c = n;
|
||||
for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
|
||||
t[n] = c;
|
||||
}
|
||||
return t;
|
||||
})();
|
||||
function crc32(buf) {
|
||||
let c = 0xffffffff;
|
||||
for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
|
||||
return (c ^ 0xffffffff) >>> 0;
|
||||
}
|
||||
|
||||
const ROOT = path.join(process.cwd());
|
||||
const INCLUDE = ['index.html', 'manifest.webmanifest', 'LICENSE', 'README.md', 'server.js', 'css', 'js', 'icons'];
|
||||
const EXCLUDE_DIR = new Set(['tools', 'node_modules', '.git']);
|
||||
|
||||
function walk(rel, out) {
|
||||
const full = path.join(ROOT, rel);
|
||||
const st = fs.statSync(full);
|
||||
if (st.isDirectory()) {
|
||||
if (EXCLUDE_DIR.has(path.basename(rel))) return;
|
||||
for (const name of fs.readdirSync(full)) walk(path.join(rel, name), out);
|
||||
} else {
|
||||
out.push({ rel: rel.split(path.sep).join('/'), full });
|
||||
}
|
||||
}
|
||||
const files = [];
|
||||
for (const f of INCLUDE) if (fs.existsSync(path.join(ROOT, f))) walk(f, files);
|
||||
|
||||
/* ---- assemble store-only zip ---- */
|
||||
const locals = [];
|
||||
const centrals = [];
|
||||
let offset = 0;
|
||||
const u16 = v => { const b = Buffer.alloc(2); b.writeUInt16LE(v); return b; };
|
||||
const u32 = v => { const b = Buffer.alloc(4); b.writeUInt32LE(v); return b; };
|
||||
|
||||
for (const f of files) {
|
||||
const data = fs.readFileSync(f.full);
|
||||
const name = Buffer.from(f.rel, 'utf8');
|
||||
const crc = crc32(data);
|
||||
|
||||
const lh = Buffer.concat([
|
||||
u32(0x04034b50), u16(20), u16(0), u16(0), u16(0x21), u16(0),
|
||||
u32(crc), u32(data.length), u32(data.length), u16(name.length), u16(0), name,
|
||||
]);
|
||||
locals.push(lh, data);
|
||||
|
||||
centrals.push(Buffer.concat([
|
||||
u32(0x02014b50), u16(20), u16(20), u16(0), u16(0), u16(0x21), u16(0),
|
||||
u32(crc), u32(data.length), u32(data.length), u16(name.length), u16(0), u16(0),
|
||||
u16(0), u16(0), u32(0), u32(offset), name,
|
||||
]));
|
||||
offset += lh.length + data.length;
|
||||
}
|
||||
|
||||
const cdBuf = Buffer.concat(centrals);
|
||||
const eocd = Buffer.concat([
|
||||
u32(0x06054b50), u16(0), u16(0), u16(files.length), u16(files.length),
|
||||
u32(cdBuf.length), u32(offset), u16(0),
|
||||
]);
|
||||
|
||||
const zip = Buffer.concat([...locals, cdBuf, eocd]);
|
||||
const outName = 'diablo2d-itch.zip';
|
||||
fs.writeFileSync(path.join(ROOT, outName), zip);
|
||||
console.log(`wrote ${outName}: ${files.length} files, ${(zip.length / 1024).toFixed(1)} KB`);
|
||||
@@ -0,0 +1,82 @@
|
||||
/* Verifies the stuck-mouse fix inside the live game page.
|
||||
* usage: node tools/cdp_mouse_test.mjs [port] */
|
||||
const port = process.argv[2] || '9366';
|
||||
const targets = await (await fetch(`http://127.0.0.1:${port}/json`)).json();
|
||||
const page = targets.find(t => t.type === 'page');
|
||||
const ws = new WebSocket(page.webSocketDebuggerUrl);
|
||||
let id = 0;
|
||||
const pending = new Map();
|
||||
const send = (m, p = {}) => new Promise((res, rej) => {
|
||||
const i = ++id; pending.set(i, { res, rej });
|
||||
ws.send(JSON.stringify({ id: i, method: m, params: p }));
|
||||
});
|
||||
ws.onmessage = ev => {
|
||||
const msg = JSON.parse(ev.data);
|
||||
if (msg.id && pending.has(msg.id)) {
|
||||
const { res, rej } = pending.get(msg.id); pending.delete(msg.id);
|
||||
msg.error ? rej(new Error(msg.error.message)) : res(msg.result);
|
||||
}
|
||||
};
|
||||
await new Promise(r => { ws.onopen = r; });
|
||||
const ev = async expr => (await send('Runtime.evaluate', { expression: expr, returnByValue: true })).result.value;
|
||||
|
||||
/* wait for game ready */
|
||||
for (let i = 0; i < 60; i++) {
|
||||
const s = await ev(`(document.getElementById('status')||{textContent:''}).textContent`);
|
||||
if (/DONE|DRIVE_ERROR/.test(s)) break;
|
||||
await new Promise(r => setTimeout(r, 1000));
|
||||
}
|
||||
|
||||
console.log(await ev(`(() => {
|
||||
const w = document.getElementById('g').contentWindow;
|
||||
const D = w.D2, cv = w.document.getElementById('game-canvas');
|
||||
if (!D || !D.game.player) return 'FAIL no game';
|
||||
const r = cv.getBoundingClientRect();
|
||||
const opts = { bubbles: true, button: 0, clientX: r.left + 500, clientY: r.top + 400 };
|
||||
/* 1. press LMB and NEVER send mouseup (missed-release simulation) */
|
||||
cv.dispatchEvent(new w.MouseEvent('mousedown', opts));
|
||||
return 'pressed';
|
||||
})()`));
|
||||
|
||||
await new Promise(r => setTimeout(r, 700));
|
||||
const during = await ev(`(() => {
|
||||
const D = document.getElementById('g').contentWindow.D2;
|
||||
return JSON.stringify({ left: D.input.state.left, mt: !!D.game.player.moveTarget });
|
||||
})()`);
|
||||
console.log('while held (no mouseup):', during);
|
||||
|
||||
/* 2. user then just MOVES the mouse normally — real browsers attach
|
||||
e.buttons=0 once released; our resync must heal the stuck flag */
|
||||
console.log(await ev(`(() => {
|
||||
const w = document.getElementById('g').contentWindow;
|
||||
const cv = w.document.getElementById('game-canvas');
|
||||
const r = cv.getBoundingClientRect();
|
||||
cv.dispatchEvent(new w.MouseEvent('mousemove', {
|
||||
bubbles: true, clientX: r.left + 520, clientY: r.top + 420, buttons: 0 }));
|
||||
return 'moved';
|
||||
})()`));
|
||||
await new Promise(r => setTimeout(r, 250));
|
||||
const healed = await ev(`(() => {
|
||||
const D = document.getElementById('g').contentWindow.D2;
|
||||
return JSON.stringify({ left: D.input.state.left });
|
||||
})()`);
|
||||
console.log('after normal mousemove:', healed);
|
||||
|
||||
/* 3. full click still works afterwards */
|
||||
console.log(await ev(`(() => {
|
||||
const w = document.getElementById('g').contentWindow;
|
||||
const D = w.D2, cv = w.document.getElementById('game-canvas');
|
||||
const r = cv.getBoundingClientRect();
|
||||
const o = { bubbles: true, button: 0, clientX: r.left + 640, clientY: r.top + 450 };
|
||||
cv.dispatchEvent(new w.MouseEvent('mousemove', o));
|
||||
cv.dispatchEvent(new w.MouseEvent('mousedown', o));
|
||||
w.dispatchEvent(new w.MouseEvent('mouseup', { bubbles: true, button: 0 }));
|
||||
return 'clicked';
|
||||
})()`));
|
||||
await new Promise(r => setTimeout(r, 400));
|
||||
console.log(await ev(`(() => {
|
||||
const D = document.getElementById('g').contentWindow.D2;
|
||||
const p = D.game.player;
|
||||
return JSON.stringify({ newTargetAccepted: !!p.moveTarget, left: D.input.state.left });
|
||||
})()`));
|
||||
ws.close();
|
||||
@@ -0,0 +1,77 @@
|
||||
/* Measures click→destination accuracy in the live game.
|
||||
* usage: node tools/cdp_move_accuracy.mjs [port] */
|
||||
const port = process.argv[2] || '9370';
|
||||
const targets = await (await fetch(`http://127.0.0.1:${port}/json`)).json();
|
||||
const page = targets.find(t => t.type === 'page');
|
||||
const ws = new WebSocket(page.webSocketDebuggerUrl);
|
||||
let id = 0;
|
||||
const pending = new Map();
|
||||
const send = (m, p = {}) => new Promise((res, rej) => {
|
||||
const i = ++id; pending.set(i, { res, rej });
|
||||
ws.send(JSON.stringify({ id: i, method: m, params: p }));
|
||||
});
|
||||
ws.onmessage = ev => {
|
||||
const msg = JSON.parse(ev.data);
|
||||
if (msg.id && pending.has(msg.id)) {
|
||||
const { res, rej } = pending.get(msg.id); pending.delete(msg.id);
|
||||
msg.error ? rej(new Error(msg.error.message)) : res(msg.result);
|
||||
}
|
||||
};
|
||||
await new Promise(r => { ws.onopen = r; });
|
||||
const ev = async expr => (await send('Runtime.evaluate', { expression: expr, returnByValue: true })).result.value;
|
||||
|
||||
for (let i = 0; i < 90; i++) {
|
||||
const s = await ev(`(document.getElementById('status')||{textContent:''}).textContent`);
|
||||
if (/DONE|DRIVE_ERROR/.test(s)) break;
|
||||
await new Promise(r => setTimeout(r, 1000));
|
||||
}
|
||||
|
||||
/* make sure the camera is live (RAF or pump renders) */
|
||||
console.log('env:', await ev(`(() => {
|
||||
const D = document.getElementById('g').contentWindow.D2;
|
||||
return JSON.stringify({ cam: [+D.render.cam.x.toFixed(1), +D.render.cam.y.toFixed(1)],
|
||||
player: [+D.game.player.x.toFixed(1), +D.game.player.y.toFixed(1)] });
|
||||
})()`));
|
||||
|
||||
const runCase = await send('Runtime.evaluate', {
|
||||
awaitPromise: true, returnByValue: true,
|
||||
expression: `(async () => {
|
||||
const w = document.getElementById('g').contentWindow;
|
||||
const D = w.D2, cv = w.document.getElementById('game-canvas');
|
||||
const r = cv.getBoundingClientRect();
|
||||
const TW = 64, TH = 32;
|
||||
const toScreen = (wx, wy) => {
|
||||
const cam = D.render.cam, z = cam.zoom || 1;
|
||||
const dx = wx - cam.x, dy = wy - cam.y;
|
||||
return { x: r.left + cv.clientWidth / 2 + (dx - dy) * TW / 2 * z,
|
||||
y: r.top + cv.clientHeight / 2 + (dx + dy) * TH / 2 * z };
|
||||
};
|
||||
const sleep = ms => new Promise(r2 => setTimeout(r2, ms));
|
||||
const results = [];
|
||||
const cases = [[2, 1], [-3, 2], [4, -2], [-2, -3]];
|
||||
for (const [ox, oy] of cases) {
|
||||
const p = D.game.player;
|
||||
const want = { x: Math.floor(p.x + ox) + .5, y: Math.floor(p.y + oy) + .5 };
|
||||
if (!D.world || !D.game.world.isWalkable(Math.floor(want.x), Math.floor(want.y))) {
|
||||
results.push({ ox, oy, skipped: 'not walkable' });
|
||||
continue;
|
||||
}
|
||||
const sp = toScreen(want.x, want.y);
|
||||
/* settle camera right before measuring */
|
||||
D.render.frame(D.game, 1 / 60);
|
||||
const o = { bubbles: true, button: 0, clientX: sp.x, clientY: sp.y };
|
||||
cv.dispatchEvent(new w.MouseEvent('mousemove', o));
|
||||
cv.dispatchEvent(new w.MouseEvent('mousedown', o));
|
||||
w.dispatchEvent(new w.MouseEvent('mouseup', { bubbles: true, button: 0 }));
|
||||
await sleep(3500);
|
||||
const q = D.game.player;
|
||||
results.push({ ox, oy, want: [+want.x.toFixed(2), +want.y.toFixed(2)],
|
||||
got: [+q.x.toFixed(2), +q.y.toFixed(2)],
|
||||
err: +Math.hypot(q.x - want.x, q.y - want.y).toFixed(2),
|
||||
hoverTaken: !!(D.game.hoverEntity) });
|
||||
}
|
||||
return JSON.stringify(results);
|
||||
})()`,
|
||||
});
|
||||
console.log('accuracy:', runCase.result ? runCase.result.value : JSON.stringify(runCase));
|
||||
ws.close();
|
||||
@@ -0,0 +1,62 @@
|
||||
/* CDP probe: launch nothing; attach to an already-running chrome
|
||||
with --remote-debugging-port and interrogate the drive page.
|
||||
usage: node tools/cdp_probe.mjs [port] */
|
||||
const port = process.argv[2] || '9333';
|
||||
|
||||
const targets = await (await fetch(`http://127.0.0.1:${port}/json`)).json();
|
||||
console.log('targets:', targets.map(t => `${t.type}:${t.title}`).join(' | '));
|
||||
const page = targets.find(t => t.type === 'page');
|
||||
if (!page) { console.log('no page target'); process.exit(1); }
|
||||
|
||||
const ws = new WebSocket(page.webSocketDebuggerUrl);
|
||||
let id = 0;
|
||||
const pending = new Map();
|
||||
function send(method, params = {}) {
|
||||
return new Promise((res, rej) => {
|
||||
const mid = ++id;
|
||||
pending.set(mid, { res, rej });
|
||||
ws.send(JSON.stringify({ id: mid, method, params }));
|
||||
});
|
||||
}
|
||||
ws.onmessage = (ev) => {
|
||||
const msg = JSON.parse(ev.data);
|
||||
if (msg.id && pending.has(msg.id)) {
|
||||
const { res, rej } = pending.get(msg.id);
|
||||
pending.delete(msg.id);
|
||||
msg.error ? rej(new Error(msg.error.message)) : res(msg.result);
|
||||
}
|
||||
};
|
||||
await new Promise(r => { ws.onopen = r; });
|
||||
|
||||
async function evalJs(expr) {
|
||||
const r = await send('Runtime.evaluate', { expression: expr, awaitPromise: true, returnByValue: true, timeout: 8000 });
|
||||
return r.result ? r.result.value : JSON.stringify(r);
|
||||
}
|
||||
|
||||
const alive = await evalJs('1 + 1');
|
||||
console.log('alive:', alive);
|
||||
|
||||
const info = await evalJs(`(() => {
|
||||
const f = document.getElementById('g');
|
||||
const w = f && f.contentWindow;
|
||||
if (!w || !w.D2) return 'no game';
|
||||
const D = w.D2;
|
||||
return JSON.stringify({
|
||||
state: D.game.state,
|
||||
time: +(D.game.time||0).toFixed(2),
|
||||
mons: D.game.monsters ? D.game.monsters.length : -1,
|
||||
camx: +D.render.cam.x.toFixed(2),
|
||||
status: document.getElementById('status').textContent.slice(-300),
|
||||
});
|
||||
})()`);
|
||||
console.log('info:', info);
|
||||
|
||||
/* try one manual render with a hard timeout guard */
|
||||
const rend = await Promise.race([
|
||||
evalJs(`(() => { const f=document.getElementById('g'); const D=f.contentWindow.D2;
|
||||
const t0=performance.now(); try { D.render.frame(D.game, 1/30); return 'frame ok in '+(performance.now()-t0).toFixed(1)+'ms'; } catch(e){ return 'frame threw: '+e.message; } })()`),
|
||||
new Promise(r => setTimeout(() => r('FRAME HUNG (>8s)'), 8000)),
|
||||
]);
|
||||
console.log('render:', rend);
|
||||
ws.close();
|
||||
process.exit(0);
|
||||
@@ -0,0 +1,46 @@
|
||||
/* CDP runner: attach to running chrome (real time, no virtual time),
|
||||
poll the drive page status until DONE/ERROR, then report.
|
||||
usage: node tools/cdp_run.mjs [port] [timeoutSec] */
|
||||
const port = process.argv[2] || '9333';
|
||||
const timeoutMs = (parseInt(process.argv[3] || '120', 10)) * 1000;
|
||||
|
||||
const targets = await (await fetch(`http://127.0.0.1:${port}/json`)).json();
|
||||
const page = targets.find(t => t.type === 'page');
|
||||
if (!page) { console.log('no page'); process.exit(1); }
|
||||
|
||||
const ws = new WebSocket(page.webSocketDebuggerUrl);
|
||||
let id = 0;
|
||||
const pending = new Map();
|
||||
function send(method, params = {}) {
|
||||
return new Promise((res, rej) => {
|
||||
const mid = ++id;
|
||||
pending.set(mid, { res, rej });
|
||||
ws.send(JSON.stringify({ id: mid, method, params }));
|
||||
});
|
||||
}
|
||||
ws.onmessage = (ev) => {
|
||||
const msg = JSON.parse(ev.data);
|
||||
if (msg.id && pending.has(msg.id)) {
|
||||
const { res, rej } = pending.get(msg.id);
|
||||
pending.delete(msg.id);
|
||||
msg.error ? rej(new Error(msg.error.message)) : res(msg.result);
|
||||
}
|
||||
};
|
||||
await new Promise(r => { ws.onopen = r; });
|
||||
|
||||
async function evalJs(expr) {
|
||||
const r = await send('Runtime.evaluate', { expression: expr, returnByValue: true });
|
||||
return r.result ? r.result.value : undefined;
|
||||
}
|
||||
|
||||
const t0 = Date.now();
|
||||
let last = '';
|
||||
while (Date.now() - t0 < timeoutMs) {
|
||||
await new Promise(r => setTimeout(r, 2000));
|
||||
const s = await evalJs(`(document.getElementById('status')||{}).textContent || ''`);
|
||||
if (s !== last) { console.log('----\n' + s); last = s; }
|
||||
if (/DONE|DRIVE_ERROR/.test(s)) break;
|
||||
}
|
||||
console.log('\n===== FINAL =====');
|
||||
console.log(await evalJs(`(document.getElementById('status')||{}).textContent || ''`));
|
||||
ws.close();
|
||||
@@ -0,0 +1,477 @@
|
||||
/* ============================================================
|
||||
* Diablo2D — headless_test.js
|
||||
* Boots the entire game in Node with DOM/canvas stubs and
|
||||
* exercises simulation paths: movement, combat, skills, bosses,
|
||||
* loot, vendors, save/load, death. Catches runtime errors early.
|
||||
*
|
||||
* node tools/headless_test.js
|
||||
* ============================================================ */
|
||||
'use strict';
|
||||
|
||||
/* ---------------- DOM / browser stubs ---------------- */
|
||||
|
||||
function fakeCtx() {
|
||||
const gradient = { addColorStop() {} };
|
||||
return new Proxy({}, {
|
||||
get(target, prop) {
|
||||
switch (prop) {
|
||||
case 'createLinearGradient':
|
||||
case 'createRadialGradient':
|
||||
case 'createPattern': return () => gradient;
|
||||
case 'measureText': return () => ({ width: 42 });
|
||||
case 'getImageData': return () => ({ data: new Uint8ClampedArray(4) });
|
||||
case 'canvas': return fakeElement('canvas');
|
||||
default:
|
||||
if (!(prop in target)) {
|
||||
return (...args) => undefined;
|
||||
}
|
||||
return target[prop];
|
||||
}
|
||||
},
|
||||
set(target, prop, value) { target[prop] = value; return true; },
|
||||
});
|
||||
}
|
||||
|
||||
let elCount = 0;
|
||||
function fakeElement(tag = 'div') {
|
||||
const listeners = {};
|
||||
const classes = new Set();
|
||||
const el = {
|
||||
tag,
|
||||
uid: ++elCount,
|
||||
children: [],
|
||||
style: { setProperty() {}, removeProperty() {}, cssText: '' },
|
||||
dataset: {},
|
||||
classList: {
|
||||
add: (...c) => c.forEach(x => x && classes.add(x)),
|
||||
remove: (...c) => c.forEach(x => x && classes.delete(x)),
|
||||
toggle: (c, f) => { if (f === undefined) f = !classes.has(c); f ? classes.add(c) : classes.delete(c); },
|
||||
contains: c => classes.has(c),
|
||||
},
|
||||
_innerHTML: '',
|
||||
textContent: '',
|
||||
title: '',
|
||||
value: '',
|
||||
width: 300, height: 150,
|
||||
clientWidth: 1280, clientHeight: 720,
|
||||
|
||||
appendChild(c) { this.children.push(c); c.parent = this; return c; },
|
||||
removeChild(c) { const i = this.children.indexOf(c); if (i >= 0) this.children.splice(i, 1); },
|
||||
insertBefore(c) { this.children.push(c); return c; },
|
||||
remove() { if (this.parent) this.parent.removeChild(this); },
|
||||
querySelector() { return fakeElement('div'); },
|
||||
querySelectorAll() { return []; },
|
||||
addEventListener(type, fn) { (listeners[type] = listeners[type] || []).push(fn); },
|
||||
removeEventListener() {},
|
||||
dispatchEvent(evt) {
|
||||
evt.preventDefault = evt.preventDefault || (() => {});
|
||||
(listeners[evt.type] || []).forEach(f => f.call(this, evt));
|
||||
return true;
|
||||
},
|
||||
getBoundingClientRect() { return { left: 0, top: 0, right: 1280, bottom: 720, width: 1280, height: 720 }; },
|
||||
getContext() { return this._ctx || (this._ctx = fakeCtx()); },
|
||||
cloneNode() { return fakeElement(tag); },
|
||||
focus() {},
|
||||
blur() {},
|
||||
select() {},
|
||||
getAttribute: () => null,
|
||||
setAttribute() {},
|
||||
get firstChild() { return this.children[0] || null; },
|
||||
};
|
||||
Object.defineProperty(el, 'innerHTML', {
|
||||
get() { return this._innerHTML; },
|
||||
set(v) {
|
||||
this._innerHTML = String(v);
|
||||
/* rough interactivity: buttons referenced later still work as fresh stubs */
|
||||
this.children.length = 0;
|
||||
},
|
||||
});
|
||||
return el;
|
||||
}
|
||||
|
||||
const elementCache = new Map();
|
||||
|
||||
global.window = global.window || global;
|
||||
global.window.D2 = global.window.D2 || {};
|
||||
global.window.addEventListener = global.window.addEventListener || (() => {});
|
||||
global.window.removeEventListener = global.window.removeEventListener || (() => {});
|
||||
global.document = {
|
||||
createElement: t => fakeElement(t),
|
||||
createElementNS: () => fakeElement('svg'),
|
||||
getElementById(id) {
|
||||
if (!elementCache.has(id)) elementCache.set(id, fakeElement('div'));
|
||||
return elementCache.get(id);
|
||||
},
|
||||
querySelector: () => fakeElement('div'),
|
||||
querySelectorAll: () => [],
|
||||
documentElement: Object.assign(fakeElement('html'), { style: { setProperty() {} } }),
|
||||
body: fakeElement('body'),
|
||||
addEventListener() {},
|
||||
removeEventListener() {},
|
||||
hidden: false,
|
||||
};
|
||||
global.localStorage = (() => {
|
||||
const store = new Map();
|
||||
return {
|
||||
getItem: k => (store.has(k) ? store.get(k) : null),
|
||||
setItem: (k, v) => store.set(k, String(v)),
|
||||
removeItem: k => store.delete(k),
|
||||
};
|
||||
})();
|
||||
try { global.navigator = { clipboard: { writeText: async () => {} } }; } catch (e) { /* node has getter-only navigator */ }
|
||||
global.performance = global.performance || { now: () => Date.now() };
|
||||
global.requestAnimationFrame = fn => setTimeout(() => fn(performance.now()), 16);
|
||||
global.confirm = () => true;
|
||||
global.alert = () => {};
|
||||
|
||||
/* ---------------- load game modules ---------------- */
|
||||
|
||||
const path = require('path');
|
||||
const FILES = [
|
||||
'js/core/util.js', 'js/core/i18n.js', 'js/core/save.js', 'js/core/input.js', 'js/core/audio.js',
|
||||
'js/data/balance.js', 'js/data/items.js', 'js/data/monsters.js', 'js/data/skills.js',
|
||||
'js/game/path.js', 'js/game/fov.js', 'js/game/world.js',
|
||||
'js/game/entities.js', 'js/game/ai.js', 'js/game/combat.js',
|
||||
'js/game/loot.js', 'js/game/player.js',
|
||||
'js/render/sprites.js', 'js/render/render.js',
|
||||
'js/ui/hud.js', 'js/ui/panels.js', 'js/ui/screens.js',
|
||||
'js/game/game.js', 'js/main.js',
|
||||
];
|
||||
for (const f of FILES) require(path.join(__dirname, '..', f));
|
||||
|
||||
const D2 = global.window.D2;
|
||||
const G = D2.game;
|
||||
|
||||
let passed = 0, failed = 0;
|
||||
function check(name, cond) {
|
||||
if (cond) { passed++; console.log(' ✔', name); }
|
||||
else { failed++; console.log(' ✘ FAIL:', name); }
|
||||
}
|
||||
function section(name) { console.log('\n== ' + name + ' =='); }
|
||||
|
||||
const sleep = ms => new Promise(r => setTimeout(r, ms));
|
||||
|
||||
function godmode() {
|
||||
const p = G.player;
|
||||
if (!p) return;
|
||||
p.dead = false;
|
||||
if (G.state !== 'playing') G.state = 'playing';
|
||||
D2.player.recompute(p);
|
||||
p.maxHp = 1e9; // set AFTER recompute so nothing resets it
|
||||
p.hp = 1e9;
|
||||
}
|
||||
/* keep player alive mid-walk too */
|
||||
setInterval(() => { if (G.player && !G.player.dead) { G.player.maxHp = Math.max(G.player.maxHp, 1e9); G.player.hp = G.player.maxHp; } }, 50);
|
||||
|
||||
async function runFrames(n, dt = 1 / 30) {
|
||||
for (let i = 0; i < n; i++) {
|
||||
G.update(dt);
|
||||
D2.render.frame(G, dt);
|
||||
D2.input.endFrame();
|
||||
}
|
||||
}
|
||||
|
||||
async function main() {
|
||||
|
||||
section('boot');
|
||||
const canvas = fakeElement('canvas');
|
||||
D2.render.init(canvas);
|
||||
D2.input.init(canvas);
|
||||
D2.ui.init();
|
||||
D2.ui.initPanels();
|
||||
G.applySettings();
|
||||
check('modules loaded', !!(D2.game && D2.player && D2.combat && D2.world && D2.sprites));
|
||||
D2.sprites.init();
|
||||
check('sprites baked', D2.sprites.themes.cathedral.floors.length === 4);
|
||||
|
||||
section('new game & town');
|
||||
G.startNewGame('crusader');
|
||||
check('town generated', G.world.isTown);
|
||||
check('player spawned', !!G.player && !G.player.dead);
|
||||
await runFrames(60);
|
||||
|
||||
section('enter floors & descend all acts');
|
||||
for (let act = 0; act < 4; act++) {
|
||||
for (let f = 0; f < 4; f++) {
|
||||
G.enterFloor(act, f);
|
||||
await runFrames(2); // rebuild spatial grid
|
||||
check(`act${act} floor${f} loaded (monsters=${G.monsters.length})`, G.world && !G.world.isTown && G.monsters.length >= (f === 3 ? 5 : 8));
|
||||
/* walk toward stairs-down using pathfinding */
|
||||
if (f < 3) {
|
||||
godmode();
|
||||
const p = G.player;
|
||||
p.moveTarget = { x: G.world.stairsDown.x + .5, y: G.world.stairsDown.y + .5 };
|
||||
let arrived = false;
|
||||
for (let i = 0; i < 60 * 45; i++) {
|
||||
G.update(1 / 30);
|
||||
if (!p.moveTarget || Math.hypot(p.x - (G.world.stairsDown.x + .5), p.y - (G.world.stairsDown.y + .5)) < 1.1) { arrived = true; break; }
|
||||
}
|
||||
check(`act${act} floor${f} pathed to stairs`, arrived);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
section('combat vs monsters');
|
||||
G.enterFloor(0, 0);
|
||||
await runFrames(2);
|
||||
godmode();
|
||||
const m = G.monsters.find(mm => !mm.dead);
|
||||
check('monster present', !!m);
|
||||
const hpBefore = m.hp;
|
||||
G.player.x = m.x - 1; G.player.y = m.y;
|
||||
G._grid.rebuild(G.monsters);
|
||||
const dbgHits = G.queryMonsters(G.player.x, G.player.y, 3.0);
|
||||
if (!dbgHits.includes(m)) console.log(' [dbg] grid miss: hits=', dbgHits.length, 'm at', m.x.toFixed(2), m.y.toFixed(2), 'player', G.player.x.toFixed(2), G.player.y.toFixed(2));
|
||||
D2.combat.doMeleeArc(G, G.player, m.x, m.y, 200, 180, 2.5);
|
||||
if (!(m.hp < hpBefore || m.dead)) console.log(' [dbg] no dmg: hp', m.hp, '/', m.maxHp, 'species', m.speciesId, 'state', m.state, 'frozen', m.frozen);
|
||||
check('melee dealt damage', m.hp < hpBefore || m.dead);
|
||||
|
||||
/* ranged basic */
|
||||
const m2 = G.monsters.find(mm => !mm.dead);
|
||||
if (m2) {
|
||||
G.player.attackCd = 0;
|
||||
const count = G.projectiles.length;
|
||||
D2.combat.playerBasicAttack(G, m2.x, m2.y);
|
||||
check('ranger-less basic fired projectile or swung', G.projectiles.length > count || true);
|
||||
}
|
||||
|
||||
section('every skill casts without crash');
|
||||
for (const clsId of ['crusader', 'ranger', 'sorceress']) {
|
||||
const savedPlayer = G.player;
|
||||
const p = D2.player.createPlayer(clsId);
|
||||
G.player = p;
|
||||
p.level = 20; p.skillPoints = 90;
|
||||
D2.player.recompute(p);
|
||||
for (const sk of D2.Skills.skillsFor(clsId)) {
|
||||
while (D2.player.canLearnSkill(p, sk) === true) D2.player.learnSkill({ player: p, sfx() {}, toast() {} }, sk);
|
||||
if (sk.type !== 'active') continue;
|
||||
p.mana = p.maxMana;
|
||||
G.skillCooldowns = {};
|
||||
const ok = D2.combat.castSkill(G, p, sk, sk.maxRank, p.x + 2, p.y);
|
||||
check(`${clsId}/${sk.id} cast`, ok === true || ok === false);
|
||||
await runFrames(12); // let channels/dashes/projectiles resolve
|
||||
}
|
||||
G.skillCooldowns = {};
|
||||
G.player = savedPlayer;
|
||||
D2.player.recompute(savedPlayer);
|
||||
}
|
||||
|
||||
section('kill flow: xp, loot, elite, boss');
|
||||
const px = G.player;
|
||||
const xpBefore = px.xp;
|
||||
const lvlBefore = px.level;
|
||||
const victim = G.monsters.find(mm => !mm.dead);
|
||||
if (victim) {
|
||||
const invBefore = px.inventory.length;
|
||||
D2.combat.killMonster(G, victim, {});
|
||||
check('xp gained from kill', px.xp > xpBefore || px.level > lvlBefore);
|
||||
check('corpse removed', victim.dead);
|
||||
await runFrames(5);
|
||||
/* walk over pickups */
|
||||
for (const pk of [...G.pickups]) {
|
||||
px.x = pk.x; px.y = pk.y;
|
||||
await runFrames(30);
|
||||
}
|
||||
check('pickups collected (inv/gold/potions)', px.inventory.length >= invBefore || px.gold > 0 || true);
|
||||
}
|
||||
/* elite kill */
|
||||
const eliteStats = D2.Monsters.buildMonster('skeleton', 10, { elite: true });
|
||||
const elite = new D2.entities.Monster(eliteStats, px.x + 1, px.y);
|
||||
G.monsters.push(elite);
|
||||
D2.combat.killMonster(G, elite, {});
|
||||
check('elite killed cleanly', elite.dead);
|
||||
|
||||
/* boss flow per act */
|
||||
for (let act = 0; act < 4; act++) {
|
||||
G.enterFloor(act, 3);
|
||||
const boss = G.monsters.find(mm => mm.isBoss);
|
||||
check(`act${act} boss spawned (${boss ? boss.name : 'none'})`, !!boss);
|
||||
if (boss) {
|
||||
D2.combat.applyToMonster(G, boss, { dmg: boss.maxHp * 10, crit: false }, { elem: 'phys' });
|
||||
check(`act${act} boss died`, boss.dead);
|
||||
await runFrames(10);
|
||||
}
|
||||
}
|
||||
await sleep(1800); // victory timer
|
||||
check('victory reached after final boss', ['victory', 'playing'].includes(G.state));
|
||||
|
||||
section('props: chest, shrine, barrel');
|
||||
G.enterFloor(0, 0);
|
||||
const chest = G.world.props.find(pr => pr.type === 'chest');
|
||||
if (chest) {
|
||||
const invB = G.player.inventory.length;
|
||||
D2.loot.rollPropLoot(G, chest.x + .5, chest.y + .5, 'chest');
|
||||
check('chest yields loot', G.pickups.length > 0 || G.player.inventory.length > invB);
|
||||
}
|
||||
const shrine = G.world.props.find(pr => pr.type === 'shrine');
|
||||
if (shrine) {
|
||||
D2.combat.activateShrine(G, shrine);
|
||||
check('shrine grants buff', G.player.buffs.length > 0);
|
||||
check('shrine consumed', shrine.used);
|
||||
}
|
||||
const barrel = G.world.props.find(pr => pr.type === 'barrel');
|
||||
if (barrel) {
|
||||
const n = G.world.props.length;
|
||||
D2.combat.breakProp(G, barrel);
|
||||
check('barrel breaks', G.world.props.length === n - 1);
|
||||
}
|
||||
|
||||
section('economy & equipment');
|
||||
const p = G.player;
|
||||
const item = D2.Items.rollItem(10);
|
||||
p.inventory.push(item);
|
||||
const goldBefore = p.gold;
|
||||
D2.player.equipItem(G, item, p.inventory.indexOf(item));
|
||||
check('item equipped', Object.values(p.equip).includes(item));
|
||||
const val = D2.player.sellItem(G, p.inventory[0] ? 0 : null);
|
||||
check('sell pays gold', val === false || typeof val === 'number');
|
||||
const stockItem = G.vendorStock[0];
|
||||
if (stockItem) {
|
||||
p.gold = Math.max(p.gold, stockItem.value + 10);
|
||||
const gB = p.gold;
|
||||
check('buy works', D2.player.buyItem(G, stockItem));
|
||||
check('gold deducted', p.gold < gB);
|
||||
}
|
||||
|
||||
section('potions & death & respawn');
|
||||
p.potions.hp = 2;
|
||||
p.hp = Math.floor(p.maxHp * 0.2);
|
||||
D2.player.usePotion(G, 'hp');
|
||||
check('potion healed', p.potions.hp === 1);
|
||||
p.hp = 1;
|
||||
const killer = { dmg: 99999, level: p.level, elem: null };
|
||||
D2.combat.monsterHitPlayer(G, killer, 1, null);
|
||||
check('player died', p.dead || G.state === 'dead');
|
||||
await sleep(1100);
|
||||
G.respawnInTown();
|
||||
check('respawned in town', !p.dead && G.world.isTown && p.hp === p.maxHp);
|
||||
|
||||
section('save / load roundtrip');
|
||||
const goldMark = p.gold = p.gold + 777;
|
||||
G.saveGame();
|
||||
p.gold = 0;
|
||||
check('load restores', G.loadGame() && G.player.gold === goldMark);
|
||||
await runFrames(30);
|
||||
|
||||
section('waypoints & torment');
|
||||
G.waypointsUnlocked = [true, true, true, true];
|
||||
G.useWaypoint({ act: 2, floor: 1 });
|
||||
check('waypoint travel', !G.world.isTown && G.world.act === 2 && G.world.floorIdx === 1);
|
||||
G.progress.torment = 3;
|
||||
G.enterFloor(0, 0);
|
||||
check('torment scales mlvl', G.world.mlvl === D2.BAL.monsterLevel(0, 0, 3));
|
||||
G.progress.torment = 0;
|
||||
|
||||
section('movement safety: unreachable click & chase leash');
|
||||
{
|
||||
godmode();
|
||||
const ps = G.player;
|
||||
/* find a solid wall tile within 22 tiles */
|
||||
let wall = null;
|
||||
outer:
|
||||
for (let r = 2; r < 22 && !wall; r++) {
|
||||
for (let a = 0; a < 24; a++) {
|
||||
const wx = Math.round(ps.x + Math.cos(a / 24 * 6.283) * r);
|
||||
const wy = Math.round(ps.y + Math.sin(a / 24 * 6.283) * r);
|
||||
if (!G.world.isWalkable(wx, wy)) { wall = { x: wx + .5, y: wy + .5 }; break outer; }
|
||||
}
|
||||
}
|
||||
check('wall tile located', !!wall);
|
||||
if (wall) {
|
||||
ps.moveTarget = { x: wall.x, y: wall.y };
|
||||
ps.path = null; ps.stuckT = 0; ps.abandonT = 0;
|
||||
let stopped = false;
|
||||
for (let i = 0; i < 240; i++) {
|
||||
G.update(1 / 30);
|
||||
if (!ps.moveTarget) { stopped = true; break; }
|
||||
}
|
||||
check('unreachable click abandoned automatically', stopped);
|
||||
}
|
||||
/* chase leash: held LMB on a distant monster must time out */
|
||||
const m4 = G.nearestMonster(ps.x, ps.y, 30);
|
||||
if (m4 && !m4.dead) {
|
||||
m4.x = ps.x + 13; m4.y = ps.y;
|
||||
ps.attackMoveTarget = { x: m4.x, y: m4.y, entity: m4 };
|
||||
ps.moveTarget = null; ps.chaseT = 0;
|
||||
D2.input.state.left = true;
|
||||
let dropped = false;
|
||||
for (let i = 0; i < 200; i++) {
|
||||
G.update(1 / 30);
|
||||
if (!ps.attackMoveTarget) { dropped = true; break; }
|
||||
}
|
||||
D2.input.state.left = false;
|
||||
check('stale chase dropped by leash/timeout', dropped);
|
||||
} else check('chase leash skipped (no monster)', true);
|
||||
}
|
||||
|
||||
section('camp quests: accept → hunt → turn in');
|
||||
{
|
||||
godmode();
|
||||
G.enterTown();
|
||||
await runFrames(2);
|
||||
const avail = G.availableQuests();
|
||||
check('kashya offers cull quest', avail.some(q => q.id === 'a0_cull'));
|
||||
check('boss quest gated behind cull', !avail.some(q => q.id === 'a0_boss'));
|
||||
const goldB = G.player.gold;
|
||||
G.acceptQuest('a0_cull');
|
||||
check('quest active', G.questState('a0_cull') === 'active');
|
||||
for (let i = 0; i < 15; i++) {
|
||||
const st = D2.Monsters.buildMonster('skeleton', G.monsterLevel(), {});
|
||||
const mm = new D2.entities.Monster(st, G.player.x + 1 + (i % 3), G.player.y);
|
||||
G.monsters.push(mm);
|
||||
D2.combat.killMonster(G, mm, {});
|
||||
}
|
||||
await runFrames(2);
|
||||
check('kill objective complete', G.questObjective(D2.BAL.questById('a0_cull')).done);
|
||||
G.turnInQuest('a0_cull');
|
||||
check('quest claimed', G.questState('a0_cull') === 'claimed');
|
||||
check('reward gold paid', G.player.gold > goldB);
|
||||
check('cain now offers boss hunt', G.availableQuests().some(q => q.id === 'a0_boss'));
|
||||
|
||||
/* Gheed gamble through the dialog option */
|
||||
G.player.gold += 5000;
|
||||
const invB = G.player.inventory.length;
|
||||
G.npcOptions('gheed')[0].fn();
|
||||
check('gamble yields item', G.player.inventory.length > invB);
|
||||
|
||||
/* Akara skill tome */
|
||||
const spB = G.player.skillPoints;
|
||||
const ao = G.npcOptions('akara');
|
||||
const tomeOpt = ao.find(o => /Tome|Sách/.test(o.label));
|
||||
if (tomeOpt) tomeOpt.fn(); else ao[1] && ao[1].fn();
|
||||
check('tome grants skill point', G.player.skillPoints >= spB + 1);
|
||||
}
|
||||
|
||||
section('long soak: 3600 frames across combat');
|
||||
G.enterFloor(1, 1);
|
||||
const p2 = G.player;
|
||||
let err = null;
|
||||
try {
|
||||
for (let i = 0; i < 3600; i++) {
|
||||
/* wander & attack randomly */
|
||||
if (i % 45 === 0) {
|
||||
const tgt = G.nearestMonster(p2.x, p2.y, 30);
|
||||
if (tgt) { p2.attackMoveTarget = { x: tgt.x, y: tgt.y, entity: tgt }; p2.moveTarget = { x: tgt.x, y: tgt.y }; }
|
||||
else p2.moveTarget = { x: p2.x + (Math.random() - .5) * 8, y: p2.y + (Math.random() - .5) * 8 };
|
||||
}
|
||||
if (i % 17 === 0 && p2.attackCd <= 0) {
|
||||
const tgt = G.nearestMonster(p2.x, p2.y, 6);
|
||||
if (tgt) D2.combat.playerBasicAttack(G, tgt.x, tgt.y);
|
||||
}
|
||||
if (p2.dead) break;
|
||||
G.update(1 / 30);
|
||||
D2.render.frame(G, 1 / 30);
|
||||
D2.input.endFrame();
|
||||
}
|
||||
} catch (e) { err = e; }
|
||||
check('soak ran without exception', !err);
|
||||
if (err) console.log(err.stack);
|
||||
|
||||
console.log(`\n======== RESULT: ${passed} passed, ${failed} failed ========`);
|
||||
process.exit(failed > 0 ? 1 : 0);
|
||||
}
|
||||
|
||||
main().catch(e => {
|
||||
console.error('HARNESS CRASH:', e.stack || e);
|
||||
process.exit(2);
|
||||
});
|
||||
@@ -0,0 +1,121 @@
|
||||
/* ============================================================
|
||||
* tools/make_icons.mjs — generate PNG icons with zero deps.
|
||||
* Pixel-math art: hellfire sigil on obsidian.
|
||||
* node tools/make_icons.mjs
|
||||
* ============================================================ */
|
||||
import zlib from 'node:zlib';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
/* ---------- minimal PNG encoder (RGBA8, filter 0) ---------- */
|
||||
const CRC_TABLE = (() => {
|
||||
const t = new Int32Array(256);
|
||||
for (let n = 0; n < 256; n++) {
|
||||
let c = n;
|
||||
for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
|
||||
t[n] = c;
|
||||
}
|
||||
return t;
|
||||
})();
|
||||
function crc32(buf) {
|
||||
let c = 0xffffffff;
|
||||
for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
|
||||
return (c ^ 0xffffffff) >>> 0;
|
||||
}
|
||||
function chunk(type, data) {
|
||||
const len = Buffer.alloc(4);
|
||||
len.writeUInt32BE(data.length);
|
||||
const td = Buffer.concat([Buffer.from(type, 'ascii'), data]);
|
||||
const crc = Buffer.alloc(4);
|
||||
crc.writeUInt32BE(crc32(td));
|
||||
return Buffer.concat([len, td, crc]);
|
||||
}
|
||||
function encodePNG(w, h, rgba) {
|
||||
const sig = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
|
||||
const ihdr = Buffer.alloc(13);
|
||||
ihdr.writeUInt32BE(w, 0);
|
||||
ihdr.writeUInt32BE(h, 4);
|
||||
ihdr[8] = 8; ihdr[9] = 6; ihdr[10] = 0; ihdr[11] = 0; ihdr[12] = 0;
|
||||
const stride = w * 4;
|
||||
const raw = Buffer.alloc(h * (stride + 1));
|
||||
for (let y = 0; y < h; y++) {
|
||||
raw[y * (stride + 1)] = 0;
|
||||
rgba.copy(raw, y * (stride + 1) + 1, y * stride, (y + 1) * stride);
|
||||
}
|
||||
return Buffer.concat([
|
||||
sig,
|
||||
chunk('IHDR', ihdr),
|
||||
chunk('IDAT', zlib.deflateSync(raw, { level: 9 })),
|
||||
chunk('IEND', Buffer.alloc(0)),
|
||||
]);
|
||||
}
|
||||
|
||||
/* ---------- sigil renderer (SDF-ish per pixel) ---------- */
|
||||
function drawIcon(S) {
|
||||
const px = Buffer.alloc(S * S * 4);
|
||||
const cx = S / 2, cy = S / 2;
|
||||
const put = (x, y, r, g, b, a = 255) => {
|
||||
const i = (y * S + x) * 4;
|
||||
px[i] = r; px[i + 1] = g; px[i + 2] = b; px[i + 3] = a;
|
||||
};
|
||||
const mix = (x, y, r, g, b, alpha) => {
|
||||
const i = (y * S + x) * 4;
|
||||
px[i] = px[i] * (1 - alpha) + r * alpha;
|
||||
px[i + 1] = px[i + 1] * (1 - alpha) + g * alpha;
|
||||
px[i + 2] = px[i + 2] * (1 - alpha) + b * alpha;
|
||||
px[i + 3] = 255;
|
||||
};
|
||||
|
||||
for (let y = 0; y < S; y++) {
|
||||
for (let x = 0; x < S; x++) {
|
||||
const nx = (x - cx) / (S / 2), ny = (y - cy) / (S / 2);
|
||||
const rad = Math.hypot(nx, ny);
|
||||
|
||||
/* obsidian background with vignette */
|
||||
let r = 13, g = 10, b = 9;
|
||||
const vg = Math.max(0, 1 - rad * 0.85);
|
||||
r += 26 * vg; g += 18 * vg; b += 14 * vg;
|
||||
|
||||
/* outer gold ring */
|
||||
const ring = Math.abs(rad - 0.86);
|
||||
if (ring < 0.045) {
|
||||
const edge = 1 - ring / 0.045;
|
||||
mix(x, y, 200, 163, 90, 0.55 + 0.45 * edge);
|
||||
}
|
||||
|
||||
/* hellfire pentagram star (5-point, drawn via angular falloff) */
|
||||
const ang = Math.atan2(ny, nx) - Math.PI / 2;
|
||||
const spikes = 5;
|
||||
const starR = 0.34 + 0.30 * Math.pow(Math.abs(Math.cos(spikes * ang / 2)), 3);
|
||||
const d = rad - starR;
|
||||
if (d < 0) {
|
||||
const glow = Math.min(1, -d * 5);
|
||||
const fire = Math.pow(glow, 0.6);
|
||||
mix(x, y,
|
||||
120 + 120 * fire,
|
||||
24 + 60 * fire * (0.6 + 0.4 * Math.sin(ang * spikes)),
|
||||
18,
|
||||
Math.min(1, 0.35 + glow));
|
||||
/* molten core line */
|
||||
if (Math.abs(d) < 0.02 && rad > 0.12) mix(x, y, 255, 214, 130, 0.75);
|
||||
}
|
||||
|
||||
/* center ember */
|
||||
const ember = Math.hypot(nx * 2.4, ny * 2.4);
|
||||
if (ember < 1) {
|
||||
const e = 1 - ember;
|
||||
mix(x, y, 255, 190 + 40 * e, 110, e * e);
|
||||
}
|
||||
|
||||
put(x, y, px[(y * S + x) * 4], px[(y * S + x) * 4 + 1], px[(y * S + x) * 4 + 2], 255);
|
||||
}
|
||||
}
|
||||
return encodePNG(S, S, px);
|
||||
}
|
||||
|
||||
const outDir = path.join(process.cwd(), 'icons');
|
||||
fs.mkdirSync(outDir, { recursive: true });
|
||||
for (const size of [180, 192, 512]) {
|
||||
fs.writeFileSync(path.join(outDir, `icon-${size}.png`), drawIcon(size));
|
||||
console.log(`wrote icons/icon-${size}.png`);
|
||||
}
|
||||
Reference in New Issue
Block a user