feedback1d WO: official route wherever it crosses no more floor (D5 战场#04 diagonal)
Community report: on 战场#04 活性源石 the lower-gate enemies walked two tiles left of the red gate and then straight up instead of crossing diagonally from row 9 into row 10 as in the official game. The playtest #2 road-over-floor smoothing counted the corner tiles of a diagonal step as crossed, so it bent the official (9,10) -> (10,7) into (9,10) -> (9,8) -> (10,8) although that line only brushes the corner of the floor tile (10,9). grid.js now keeps the official flow field (research 08 §3.1) and replaces a tile's pointer by the road-over-floor preference one only where its route crosses strictly fewer non-blockable tiles (or as few with a farther waypoint); a segment crosses the tiles whose interior it passes through (segmentTiles, exact geometry). 140 of the 154 stage x gate x field routes are now official (was 109); the 14 left avoid floor the official route walks over (战场#01's col-8 road of playtest #2, boss exits of 战场#01 / #02, two 联防 partner gates). data/stages.json groundPaths regenerated.
This commit is contained in:
sganggs committed
1 parent
7f134737ce
commit
d8c62a96b5
9 files changed
+460
-153
No files matched your search
@@ -1,12 +1,14 @@
|
||||
// Blockable-ground preference of the ground pathing (grid.js header; user playtest: on 战场#01 the lower-gate enemies
|
||||
// walked up the col-9 floor lane, where no operator can stand, instead of the col-8 road). Among equal-length routes the
|
||||
// flow field takes the one with the fewest non-blockable tiles, and smoothing never cuts across floor the grid route
|
||||
// does not walk. Audit: every active stage × gate × field (normal, 联防 both halves, boss both halves incl. the solo
|
||||
// `_s` templates) — the non-blockable tiles an enemy still crosses are listed and proven unavoidable (no route of equal
|
||||
// or near-equal length, up to +2 tiles, crosses fewer).
|
||||
// Blockable-ground preference of the ground pathing (grid.js header; user playtest #2: on 战场#01 the lower-gate enemies
|
||||
// walked up the col-9 floor lane, where no operator can stand, instead of the col-8 road). The flow field keeps the
|
||||
// official route unless the preference route — the fewest non-blockable tiles among equal-length chains, smoothing
|
||||
// that never cuts across floor its grid route does not walk — crosses fewer non-blockable tiles. "Crosses" = the
|
||||
// segment passes through the tile's interior (grid.js segmentTiles; brushing a corner is not crossing — the D5 report
|
||||
// after 0.1.0, test/sim/pathing-official.test.js). Audit: every active stage × gate × field (normal, 联防 both halves,
|
||||
// boss both halves incl. the solo `_s` templates) — the non-blockable tiles an enemy still crosses are listed and
|
||||
// proven unavoidable (no 4-connected route of equal or near-equal length, up to +2 tiles, crosses fewer).
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { Grid, bresenhamTiles } from '../../server/sim/grid.js';
|
||||
import { Grid, bresenhamTiles, segmentTiles } from '../../server/sim/grid.js';
|
||||
import { getDefaultSource, hasGeneratedData, normalizeRoute } from '../../server/sim/simdata.js';
|
||||
import { GEO } from '../../shared/constants.js';
|
||||
import { makeBattle, flatStage, chessRec, enemyRec } from '../helpers/battleHarness.js';
|
||||
@@ -29,7 +31,7 @@ function stageGrid(id, rect) {
|
||||
return g;
|
||||
}
|
||||
|
||||
/** Every tile the enemy's rounded position can take on the smoothed route: Bresenham tiles + diagonal-step corners. */
|
||||
/** The official line-of-sight footprint of the smoothed route: Bresenham tiles + diagonal-step corners (all walkable). */
|
||||
function covered(wp) {
|
||||
const out = [wp[0]];
|
||||
for (let i = 1; i < wp.length; i++) {
|
||||
@@ -43,12 +45,20 @@ function covered(wp) {
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Every tile the enemy's position crosses on the smoothed route (exact segments; a corner touch is not a crossing). */
|
||||
function crossed(wp) {
|
||||
const out = [wp[0]];
|
||||
for (let i = 1; i < wp.length; i++) out.push(...segmentTiles(wp[i - 1], wp[i]).slice(1));
|
||||
return out;
|
||||
}
|
||||
|
||||
/** Non-blockable tiles crossed from s to e (start and goal excluded), in route order. */
|
||||
function nbCrossed(g, s, e) {
|
||||
const wp = g.waypoints(s[0], s[1], e[0], e[1]);
|
||||
assert.ok(wp, `(${s}) → (${e}) reachable`);
|
||||
for (const [r, c] of covered(wp)) assert.ok(g.walkable(r, c), `(${s}) → (${e}) line of sight over unwalkable (${r},${c})`);
|
||||
const seen = new Set();
|
||||
for (const [r, c] of covered(wp)) {
|
||||
for (const [r, c] of crossed(wp)) {
|
||||
const k = `${r},${c}`;
|
||||
if ((r === s[0] && c === s[1]) || (r === e[0] && c === e[1]) || g.blockable(r, c)) continue;
|
||||
assert.ok(g.walkable(r, c), `(${s}) → (${e}) crosses unwalkable (${k})`);
|
||||
@@ -128,12 +138,35 @@ test('smoothing never cuts a corner across floor that the grid route does not wa
|
||||
const g = new Grid(flatStage({ rows }), GEO.NORMAL_RECT);
|
||||
for (const s of [[9, 9], [9, 10]]) {
|
||||
const wp = g.waypoints(s[0], s[1], 12, 3);
|
||||
for (const [r, c] of covered(wp)) assert.ok(g.blockable(r, c) || (r === s[0] && c === s[1]), `(${s}) → (12,3) crosses (${r},${c}): ${JSON.stringify(wp)}`);
|
||||
for (const [r, c] of crossed(wp)) assert.ok(g.blockable(r, c) || (r === s[0] && c === s[1]), `(${s}) → (12,3) crosses (${r},${c}): ${JSON.stringify(wp)}`);
|
||||
}
|
||||
// the straight line stays when it only crosses blockable ground
|
||||
assert.deepEqual(g.waypoints(9, 9, 12, 3), [[9, 9], [12, 3]]);
|
||||
});
|
||||
|
||||
test('a diagonal that only brushes a floor tile\'s corner is the official one (D5); one through the floor is not', () => {
|
||||
// col 0123456789 10
|
||||
// row 10 ##hrrrrrrf# floor (10,9) right of the road; the route turns from row 9 into row 10
|
||||
// row 9 ##Er###rrS# gate (9,10) → (9,2) via row 10
|
||||
const rows = { 12: '##hhhhhhhhh##########', 11: '##hhhhhhhhh##########', 10: '##hrrrrrrf###########', 9: '##Err###rrS##########' };
|
||||
const g = new Grid(flatStage({ rows }), GEO.NORMAL_RECT);
|
||||
const p = new Grid(flatStage({ rows }), GEO.NORMAL_RECT);
|
||||
p.unblockable.fill(0);
|
||||
// official: (9,10) → (10,7) touches (10,9) only at the corner point (8.5, 9.5)
|
||||
assert.deepEqual(g.waypoints(9, 10, 9, 2), p.waypoints(9, 10, 9, 2));
|
||||
assert.deepEqual(g.waypoints(9, 10, 9, 2)[1], [10, 7]);
|
||||
assert.deepEqual(nbCrossed(g, [9, 10], [9, 2]), []);
|
||||
// a floor column next to a road column (战场#01): the official (9,9) → (12,8) runs through the floor (10,9); the road
|
||||
// route crosses none, so it wins
|
||||
const rows1 = { 12: '##hrrrrrrrfS#########', 11: '##hhhhhhrf###########', 10: '##hhhhhhrf###########', 9: '##Er###rrS###########' };
|
||||
const g1 = new Grid(flatStage({ rows: rows1 }), GEO.NORMAL_RECT), p1 = new Grid(flatStage({ rows: rows1 }), GEO.NORMAL_RECT);
|
||||
p1.unblockable.fill(0);
|
||||
assert.deepEqual(p1.waypoints(9, 9, 12, 3), [[9, 9], [12, 8], [12, 3]], 'official');
|
||||
assert.deepEqual(nbCrossed(p1, [9, 9], [12, 3]), ['10,9'], 'the official diagonal runs through the floor (10,9)');
|
||||
assert.deepEqual(g1.waypoints(9, 9, 12, 3), [[9, 9], [9, 8], [12, 8], [12, 3]]);
|
||||
assert.deepEqual(nbCrossed(g1, [9, 9], [12, 3]), []);
|
||||
});
|
||||
|
||||
test('the preference is only a tie-break: crates keep cost 1000, route lengths stay the official ones', REAL, () => {
|
||||
// 战场#01 lower gate: a crate on the col-8 road makes the floor lane strictly shorter → it is taken again
|
||||
const g = stageGrid('act1autochess_m01', GEO.NORMAL_RECT);
|
||||
@@ -184,8 +217,8 @@ const UNAVOIDABLE = {
|
||||
act1autochess_m01: { low: '', up: '12,9', uLow: '9,10', uUp: '12,17 9,10', b5: '5,9|5,11', b2: '|' },
|
||||
act1autochess_m02: { low: '10,9 11,9', up: '12,9', uLow: '10,17 11,17 12,10 12,9', uUp: '12,17 12,10 12,9', b5: '5,9|5,11', b2: '3,9 4,9|3,11 4,11' },
|
||||
act1autochess_m03: { low: '', up: '12,9', uLow: '9,10', uUp: '12,17 9,10', b5: '5,9|5,11', b2: '|' },
|
||||
act1autochess_m04: { low: '', up: '12,9 11,9', uLow: '9,10', uUp: '12,17 11,17 9,10', b5: '5,9 4,9|5,11 4,11', b2: '|' },
|
||||
act2autochess_m01: { low: '', up: '12,9 11,9 10,9', uLow: '9,10', uUp: '12,17 11,17 10,17 9,10', b5: '5,9 4,9 3,9|5,11 4,11 3,11', b2: '|' },
|
||||
act1autochess_m04: { low: '', up: '12,9 11,9', uLow: '9,10', uUp: '12,17 11,17 9,10', b5: '4,9|4,11', b2: '|' },
|
||||
act2autochess_m01: { low: '', up: '12,9 11,9 10,9', uLow: '9,10', uUp: '12,17 11,17 10,17 9,10', b5: '4,10 3,9|4,10 3,11', b2: '|' },
|
||||
act2autochess_m02: { low: '', up: '12,9', uLow: '9,10', uUp: '12,17 9,10', b5: '5,9|5,11', b2: '|' },
|
||||
act2autochess_m03: { low: '10,9', up: '12,9', uLow: '10,17 9,10 10,9', uUp: '12,17 9,10 10,9', b5: '5,9|5,11', b2: '3,9|3,11' },
|
||||
act2autochess_m04: { low: '', up: '12,9', uLow: '9,10', uUp: '12,17 9,10', b5: '5,9|5,11', b2: '|' },
|
||||
@@ -201,7 +234,7 @@ test('audit: every active stage × gate × field — the non-blockable tiles cro
|
||||
assert.equal(got.join(' '), want, `${sid} ${what} (${s}) → (${e}): non-blockable tiles crossed`);
|
||||
const m = fewestNb(g, s, e, 2);
|
||||
assert.ok(m, `${sid} ${what}: reachable without crates`);
|
||||
assert.equal(got.length, m.min, `${sid} ${what} (${s}) → (${e}): a route of length ≤ ${m.best}+2 crosses only ${m.min}`);
|
||||
assert.ok(got.length <= m.min, `${sid} ${what} (${s}) → (${e}): a route of length ≤ ${m.best}+2 crosses only ${m.min}`);
|
||||
n++;
|
||||
};
|
||||
check(nrm, [9, 10], [9, 2], exp.low, 'normal lower gate');
|
||||
@@ -246,7 +279,8 @@ test('audit: every WALK leg of every wave template (normal / 联防 / boss / hid
|
||||
// the boss arena's central floor (rows 3–5 × cols 9–11: the (5,10) / (2,10) teleport exits, boss_8's parts and
|
||||
// patrols); a blockable detour around that floor is ≥ 2 tiles longer, and the official route length is kept.
|
||||
const arena = (t) => { const [r, c] = t.split(',').map(Number); return r >= 3 && r <= 5 && c >= 9 && c <= 11; };
|
||||
let n = 0, extra = 0, accepted = 0;
|
||||
let n = 0, extra = 0;
|
||||
const accepted = [];
|
||||
for (const sid of STAGES) {
|
||||
const grids = new Map();
|
||||
for (const { rect, from, to, id } of legs.values()) {
|
||||
@@ -258,18 +292,18 @@ test('audit: every WALK leg of every wave template (normal / 联防 / boss / hid
|
||||
if (!eq) continue;
|
||||
const got = nbCrossed(g, from, to);
|
||||
const what = `${sid} ${id} (${from}) → (${to}) crosses ${got.join(' ')}`;
|
||||
assert.equal(got.length, eq.min, `${what}, an equal-length route only ${eq.min}`);
|
||||
assert.ok(got.length <= eq.min, `${what}, an equal-length route only ${eq.min}`);
|
||||
const near = fewestNb(g, from, to, 2);
|
||||
if (near.min < got.length) {
|
||||
assert.ok(rect === GEO.BOSS_RECT && got.every(arena), `${what}: a route of length ≤ ${near.best}+2 crosses only ${near.min}`);
|
||||
accepted++;
|
||||
accepted.push(what);
|
||||
}
|
||||
extra += got.length;
|
||||
n++;
|
||||
}
|
||||
}
|
||||
assert.ok(n > 200, `${n} legs audited (${extra} unavoidable non-blockable crossings)`);
|
||||
assert.equal(accepted, 17, 'accepted boss-arena exceptions (update the count only after reviewing a new one)');
|
||||
assert.equal(accepted.length, 16, `accepted boss-arena exceptions (update the count only after reviewing a new one):\n${accepted.join('\n')}`);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------------
|
||||
@@ -323,7 +357,7 @@ test('map cards (移除全部阻隔工事 / 阻隔工事变为射击台): with t
|
||||
}
|
||||
const got = nbCrossed(g, s, e);
|
||||
const m = fewestNb(g, s, e, 0);
|
||||
assert.equal(got.length, m.min, `${sid} crates ${mode} ${kind} (${s}) → (${e}) crosses ${got.join(' ')}; an equal-length route only ${m.min}`);
|
||||
assert.ok(got.length <= m.min, `${sid} crates ${mode} ${kind} (${s}) → (${e}) crosses ${got.join(' ')}; an equal-length route only ${m.min}`);
|
||||
n++;
|
||||
}
|
||||
}
|
||||
@@ -359,7 +393,7 @@ test('deviation from the official route is bounded: same grid length everywhere,
|
||||
assert.ok(n > 2000 && longer > 0 && worst > 1, `${n} tiles, ${longer} longer, worst +${worst.toFixed(2)}`);
|
||||
});
|
||||
|
||||
test('random layouts: official lengths, fewest non-blockable tiles among equal-length chains, no off-chain floor / crate / wall on a smoothed segment', () => {
|
||||
test('random layouts: official lengths, fewest non-blockable tiles among equal-length chains, official line of sight, never more floor than the official route', () => {
|
||||
let seed = 20260929;
|
||||
const rnd = () => ((seed = (Math.imul(seed, 1103515245) + 12345) >>> 0) / 4294967296);
|
||||
const RECT = GEO.UNITE_RECT;
|
||||
@@ -387,23 +421,31 @@ test('random layouts: official lengths, fewest non-blockable tiles among equal-l
|
||||
}
|
||||
assert.equal(f.pen[k], best[k], `${what}: (${r},${c}) pen`);
|
||||
}
|
||||
// smoothed chains: strictly closer each hop; segments cross only walkable, crate-free tiles and on-chain floor
|
||||
// routes: strictly closer each hop; every segment is official line of sight (walkable, crate-free Bresenham
|
||||
// footprint); `cost` = the non-blockable tiles the route crosses; never more than the pure official route, nor than
|
||||
// the fewest-floor chain (pen); a pointer other than the official one crosses strictly less floor, or as little
|
||||
// with a farther waypoint
|
||||
assert.deepEqual([...f.official], [...fp.next], `${what}: the official pointers`);
|
||||
const nbSeg = (x, y) => segmentTiles([(x / COLS) | 0, x % COLS], [(y / COLS) | 0, y % COLS]).slice(1).filter(([r, c]) => g.unblockable[r * COLS + c]).length;
|
||||
const offNb = new Int32Array(N);
|
||||
for (const k of order) {
|
||||
if (k === dest) continue;
|
||||
const chain = new Set();
|
||||
for (let x = k; x >= 0; x = f.parent[x]) chain.add(x);
|
||||
for (let x = k; x !== dest;) {
|
||||
const y = f.next[x];
|
||||
assert.ok(y >= 0 && f.dist[y] < f.dist[x], `${what}: next of ${x}`);
|
||||
const a = [(x / COLS) | 0, x % COLS], b = [(y / COLS) | 0, y % COLS];
|
||||
const hop = Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) === 1;
|
||||
const y = f.next[k];
|
||||
assert.ok(y >= 0 && f.dist[y] < f.dist[k], `${what}: next of ${k}`);
|
||||
const a = [(k / COLS) | 0, k % COLS], b = [(y / COLS) | 0, y % COLS];
|
||||
if (Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) > 1) {
|
||||
for (const [r, c] of covered([a, b])) {
|
||||
const kk = r * COLS + c;
|
||||
if (kk === dest || hop) continue;
|
||||
assert.ok(g.walkable(r, c) && !g.isCrate(r, c), `${what}: (${a}) → (${b}) crosses (${r},${c})`);
|
||||
assert.ok(!g.unblockable[kk] || chain.has(kk), `${what}: (${a}) → (${b}) cuts across off-chain floor (${r},${c})`);
|
||||
if (r * COLS + c !== dest) assert.ok(g.walkable(r, c) && !g.isCrate(r, c), `${what}: (${a}) → (${b}) crosses (${r},${c})`);
|
||||
}
|
||||
x = y;
|
||||
}
|
||||
assert.equal(f.cost[k], nbSeg(k, y) + f.cost[y], `${what}: (${a}) cost`);
|
||||
const o = fp.next[k];
|
||||
offNb[k] = nbSeg(k, o) + offNb[o];
|
||||
assert.ok(f.cost[k] <= offNb[k], `${what}: (${a}) crosses ${f.cost[k]} non-blockable tiles, the official route ${offNb[k]}`);
|
||||
assert.ok(f.cost[k] <= f.pen[k] - g.unblockable[k] + g.unblockable[dest], `${what}: (${a}) more floor than its fewest-floor chain`);
|
||||
if (y !== o) {
|
||||
const co = nbSeg(k, o) + f.cost[o];
|
||||
assert.ok(f.cost[k] < co || (f.cost[k] === co && f.dist[y] < f.dist[o]), `${what}: (${a}) leaves the official pointer without less floor`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,11 @@
|
||||
// Adversarial cross-check of grid.js against an independent port of the official client pathing (research 08 §3.4,
|
||||
// `Torappu.Battle.SPFA`: FIFO SPFA from the destination over the WHOLE level map, UP/RIGHT/DOWN/LEFT, crates cost 1000,
|
||||
// strict improvement; row-major in-place Bresenham smoothing with the diagonal corner rule), run on the raw level files
|
||||
// in .cache/gamedata (skipped when absent), extended by our blockable-ground preference (grid.js header: equal-length
|
||||
// ties go to the chain with the fewest non-blockable tiles; a smoothed line crosses non-blockable tiles only on its own
|
||||
// raw chain):
|
||||
// in .cache/gamedata (skipped when absent), extended by our blockable-ground preference (grid.js header: a second,
|
||||
// preference field — equal-length ties to the chain with the fewest non-blockable tiles, smoothing that backs off from
|
||||
// segments through non-blockable tiles off the own raw chain — whose pointer replaces the official one where its route
|
||||
// crosses fewer non-blockable tiles, or as few with a farther waypoint; "crosses" = positive-length intersection with
|
||||
// the tile, found here by clipping the segment against each tile, independently of grid.js crossTiles):
|
||||
// * the 8 active stages with their match-start devices: the smoothed chain from EVERY walkable tile of the normal,
|
||||
// 联防 and boss rects to every goal equals the full-map reference one (the sim's rect limit changes nothing);
|
||||
// * 400 random crate / block layouts: identical chains to the same algorithm limited to the rect;
|
||||
@@ -26,9 +28,8 @@ const FOUR = [[1, 0], [0, 1], [-1, 0], [0, -1]];
|
||||
|
||||
/**
|
||||
* The official algorithm on a raw level (non-hidden crates cost 1000; platforms / mounds blocked like the sim [ASSUMED]).
|
||||
* `prefer` adds the blockable-ground preference (lexicographic (dist, non-blockable count) relaxation; smoothing lines
|
||||
* cross non-blockable tiles only on the tile's own raw chain between its ends). Returns dest → (start → chain string),
|
||||
* with `.dist(start)` / `.covered(start)` (tiles of the smoothed route incl. diagonal-step corners) on each dest.
|
||||
* `prefer` adds the blockable-ground preference (see the header). Returns dest → (start → chain string), with
|
||||
* `.dist(start)` / `.crossedNb(start)` (non-blockable tiles the route crosses, start excluded) on each dest.
|
||||
*/
|
||||
function official(sid, { crates: extraCrates = [], blocks: extraBlocks = [], rect = null, prefer = true } = {}) {
|
||||
const lv = JSON.parse(readFileSync(file(sid), 'utf8'));
|
||||
@@ -66,48 +67,94 @@ function official(sid, { crates: extraCrates = [], blocks: extraBlocks = [], rec
|
||||
}
|
||||
return clear ? out.every(([a, b]) => clear(a, b)) : out;
|
||||
};
|
||||
return (dest) => {
|
||||
const D = dest.join();
|
||||
const dist = new Map([[D, 0]]);
|
||||
const pen = new Map([[D, 0]]);
|
||||
const par = new Map();
|
||||
const q = [dest];
|
||||
const inq = new Set([D]);
|
||||
while (q.length) {
|
||||
const cur = q.shift();
|
||||
const ck = cur.join();
|
||||
inq.delete(ck);
|
||||
for (const [dr, dc] of FOUR) {
|
||||
const nb2 = [cur[0] + dr, cur[1] + dc];
|
||||
const nk = nb2.join();
|
||||
if (!passable(nb2[0], nb2[1])) continue;
|
||||
const nd = dist.get(ck) + (crates.has(nk) ? 1000 : 1);
|
||||
const np = pen.get(ck) + (nb(nb2[0], nb2[1]) ? 1 : 0);
|
||||
const better = !dist.has(nk) || nd < dist.get(nk) || (prefer && nd === dist.get(nk) && np < pen.get(nk));
|
||||
if (better) {
|
||||
dist.set(nk, nd);
|
||||
pen.set(nk, np);
|
||||
par.set(nk, cur);
|
||||
if (!inq.has(nk)) { q.push(nb2); inq.add(nk); }
|
||||
// tiles the centre-to-centre segment a → b passes through with positive length (Liang–Barsky clip per tile)
|
||||
const through = ([r0, c0], [r1, c1]) => {
|
||||
const out = [];
|
||||
for (let r = Math.min(r0, r1); r <= Math.max(r0, r1); r++) {
|
||||
for (let c = Math.min(c0, c1); c <= Math.max(c0, c1); c++) {
|
||||
let t0 = 0, t1 = 1;
|
||||
for (const [pp, qq] of [[-(c1 - c0), c0 - (c - 0.5)], [c1 - c0, c + 0.5 - c0], [-(r1 - r0), r0 - (r - 0.5)], [r1 - r0, r + 0.5 - r0]]) {
|
||||
if (pp === 0) { if (qq < 0) t1 = -1; continue; }
|
||||
if (pp < 0) t0 = Math.max(t0, qq / pp); else t1 = Math.min(t1, qq / pp);
|
||||
}
|
||||
if (t1 - t0 > 1e-9) out.push([r, c]);
|
||||
}
|
||||
}
|
||||
const nxt = new Map(par);
|
||||
for (let r = 0; r < H; r++) {
|
||||
for (let c = 0; c < W; c++) {
|
||||
const k = `${r},${c}`;
|
||||
if (!nxt.has(k)) continue;
|
||||
const chain = new Set();
|
||||
for (let x = [r, c]; x; x = par.get(x.join())) chain.add(x.join());
|
||||
const los = (a) => {
|
||||
const lo = dist.get(a.join());
|
||||
return bres([r, c], a, (y, x) => passable(y, x) && !crates.has(`${y},${x}`)
|
||||
&& (!prefer || !nb(y, x) || (chain.has(`${y},${x}`) && dist.get(`${y},${x}`) >= lo)));
|
||||
};
|
||||
let b = nxt.get(k);
|
||||
while (nxt.has(b.join()) && los(nxt.get(b.join()))) b = nxt.get(b.join());
|
||||
nxt.set(k, b);
|
||||
return out;
|
||||
};
|
||||
const key = (p) => p.join();
|
||||
const unkey = (k) => k.split(',').map(Number);
|
||||
const losClear = (y, x) => passable(y, x) && !crates.has(`${y},${x}`);
|
||||
return (dest) => {
|
||||
const D = dest.join();
|
||||
const spfa = (usePen) => {
|
||||
const dist = new Map([[D, 0]]);
|
||||
const pen = new Map([[D, 0]]);
|
||||
const par = new Map();
|
||||
const q = [dest];
|
||||
const inq = new Set([D]);
|
||||
while (q.length) {
|
||||
const cur = q.shift();
|
||||
const ck = cur.join();
|
||||
inq.delete(ck);
|
||||
for (const [dr, dc] of FOUR) {
|
||||
const nb2 = [cur[0] + dr, cur[1] + dc];
|
||||
const nk = nb2.join();
|
||||
if (!passable(nb2[0], nb2[1])) continue;
|
||||
const nd = dist.get(ck) + (crates.has(nk) ? 1000 : 1);
|
||||
const np = pen.get(ck) + (usePen && nb(nb2[0], nb2[1]) ? 1 : 0);
|
||||
if (!dist.has(nk) || nd < dist.get(nk) || (usePen && nd === dist.get(nk) && np < pen.get(nk))) {
|
||||
dist.set(nk, nd);
|
||||
pen.set(nk, np);
|
||||
par.set(nk, cur);
|
||||
if (!inq.has(nk)) { q.push(nb2); inq.add(nk); }
|
||||
}
|
||||
}
|
||||
}
|
||||
return { dist, par };
|
||||
};
|
||||
// row-major in-place smoothing; `guard`: back off to the farthest passed waypoint whose segment crosses
|
||||
// non-blockable tiles only on the tile's own raw chain
|
||||
const smooth = ({ dist, par }, guard) => {
|
||||
const nxt = new Map(par);
|
||||
for (let r = 0; r < H; r++) {
|
||||
for (let c = 0; c < W; c++) {
|
||||
const k = `${r},${c}`;
|
||||
if (!nxt.has(k)) continue;
|
||||
let b = nxt.get(k);
|
||||
const hops = [b];
|
||||
while (nxt.has(b.join()) && bres([r, c], nxt.get(b.join()), losClear)) { b = nxt.get(b.join()); hops.push(b); }
|
||||
if (guard) {
|
||||
const chain = new Set();
|
||||
for (let x = [r, c]; x; x = par.get(x.join())) chain.add(x.join());
|
||||
const ok = (a) => through([r, c], a).every(([y, x]) => !nb(y, x) || (chain.has(`${y},${x}`) && dist.get(`${y},${x}`) >= dist.get(a.join())));
|
||||
while (hops.length > 1 && !ok(hops[hops.length - 1])) hops.pop();
|
||||
b = hops[hops.length - 1];
|
||||
}
|
||||
nxt.set(k, b);
|
||||
}
|
||||
}
|
||||
return nxt;
|
||||
};
|
||||
const off = spfa(false);
|
||||
const dist = off.dist;
|
||||
const segNb = (a, b) => through(a, b).filter(([y, x]) => !(y === a[0] && x === a[1]) && nb(y, x)).length;
|
||||
let nxt = smooth(off, false);
|
||||
if (prefer) {
|
||||
// per tile in increasing distance: the preference pointer when its route crosses fewer non-blockable tiles (or as
|
||||
// few with a farther waypoint)
|
||||
const nxtP = smooth(spfa(true), true);
|
||||
const cost = new Map([[D, 0]]);
|
||||
const chosen = new Map();
|
||||
for (const k of [...dist.keys()].sort((a, b) => dist.get(a) - dist.get(b))) {
|
||||
if (k === D) continue;
|
||||
const a = unkey(k), o = nxt.get(k), p = nxtP.get(k);
|
||||
const co = segNb(a, o) + cost.get(key(o)), cp = segNb(a, p) + cost.get(key(p));
|
||||
const useP = cp < co || (cp === co && dist.get(key(p)) < dist.get(key(o)));
|
||||
chosen.set(k, useP ? p : o);
|
||||
cost.set(k, useP ? cp : co);
|
||||
}
|
||||
nxt = chosen;
|
||||
}
|
||||
const chainOf = (start) => {
|
||||
if (!dist.has(start.join())) return null;
|
||||
@@ -118,13 +165,12 @@ function official(sid, { crates: extraCrates = [], blocks: extraBlocks = [], rec
|
||||
};
|
||||
const fn = (start) => { const ch = chainOf(start); return ch ? ch.map((p) => `(${p})`).join(' ') : null; };
|
||||
fn.dist = (start) => dist.get(start.join()) ?? -1;
|
||||
fn.coveredNb = (start) => {
|
||||
fn.crossedNb = (start) => {
|
||||
const ch = chainOf(start);
|
||||
if (!ch) return null;
|
||||
const s = new Set();
|
||||
for (let i = 1; i < ch.length; i++) for (const [y, x] of bres(ch[i - 1], ch[i])) if (nb(y, x)) s.add(`${y},${x}`);
|
||||
if (nb(...ch[0])) s.add(ch[0].join());
|
||||
return s;
|
||||
let n = 0;
|
||||
for (let i = 1; i < ch.length; i++) n += segNb(ch[i - 1], ch[i]);
|
||||
return n;
|
||||
};
|
||||
return fn;
|
||||
};
|
||||
@@ -200,7 +246,7 @@ test('vs the PURE official algorithm: same route length from every tile, never m
|
||||
for (let c = rect.c0; c <= rect.c1; c++) {
|
||||
if (!g.walkable(r, c) || p.dist([r, c]) < 0) continue;
|
||||
assert.equal(f.dist[r * 21 + c], p.dist([r, c]), `${sid} (${r},${c}) → (${dest}): official length`);
|
||||
const a = p.coveredNb([r, c]).size, b = o.coveredNb([r, c]).size;
|
||||
const a = p.crossedNb([r, c]), b = o.crossedNb([r, c]);
|
||||
assert.ok(b <= a, `${sid} (${r},${c}) → (${dest}): ${b} non-blockable tiles vs official ${a}`);
|
||||
if (b < a) fewer++;
|
||||
n++;
|
||||
|
||||
@@ -0,0 +1,130 @@
|
||||
// Official route shapes (community report after 0.1.0, D5: on 战场#04 活性源石 the lower-gate enemies walked two tiles
|
||||
// straight left of the red gate and then straight up, instead of crossing diagonally from the 4th row to the 3rd as in
|
||||
// the official game). grid.js keeps the official flow field (research 08 §3.1) wherever its route crosses no more
|
||||
// non-blockable tiles (floor, gates) than the blockable-ground preference of user playtest #2 — a segment that only
|
||||
// brushes a floor tile's corner does not cross it. Audit: every stage (active or not) × gate × field against the pure
|
||||
// official algorithm; the routes that still differ are listed, each avoiding floor the official route walks over.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { Grid, segmentTiles } from '../../server/sim/grid.js';
|
||||
import { getDefaultSource, hasGeneratedData } from '../../server/sim/simdata.js';
|
||||
import { GEO } from '../../shared/constants.js';
|
||||
import { makeBattle, chessRec, enemyRec } from '../helpers/battleHarness.js';
|
||||
|
||||
const REAL = { skip: !hasGeneratedData() && 'no generated data' };
|
||||
const COLS = 21;
|
||||
const M04 = 'act1autochess_m04';
|
||||
const RECT = { normal: GEO.NORMAL_RECT, unite: GEO.UNITE_RECT, boss: GEO.BOSS_RECT };
|
||||
|
||||
/** Grid of a real stage with its match-start devices; `pure` = the official algorithm (every tile counted blockable). */
|
||||
function stageGrid(id, rect, pure = false) {
|
||||
const st = getDefaultSource().getStage(id);
|
||||
if (!st) return null;
|
||||
const g = new Grid(st, rect);
|
||||
for (const d of st.raw.devices) {
|
||||
if (!d.active || !d.pos) continue;
|
||||
if (d.role === 'crate') g.setObstacle(d.pos[0], d.pos[1], true, 'crate');
|
||||
if (d.role === 'platform' || d.role === 'mound') g.setObstacle(d.pos[0], d.pos[1], true);
|
||||
}
|
||||
if (pure) g.unblockable.fill(0);
|
||||
return g;
|
||||
}
|
||||
const str = (wp) => (wp ? wp.map((p) => p.join(',')).join(' ') : 'null');
|
||||
|
||||
test('D5 战场#04 活性源石: the lower-gate route is the official diagonal from row 9 into row 10 (normal and 联防 fields)', REAL, () => {
|
||||
const official = [[9, 10], [10, 7], [10, 4], [9, 4], [9, 2]];
|
||||
assert.deepEqual(stageGrid(M04, GEO.NORMAL_RECT, true).waypoints(9, 10, 9, 2), official, 'the pure official algorithm');
|
||||
assert.deepEqual(stageGrid(M04, GEO.NORMAL_RECT).waypoints(9, 10, 9, 2), official, 'normal field');
|
||||
assert.deepEqual(stageGrid(M04, GEO.UNITE_RECT).waypoints(9, 10, 9, 2), official, '联防 field, own lower gate');
|
||||
// the segment (9,10) → (10,7) only brushes the corner of the floor tile (10,9): it crosses no non-blockable tile
|
||||
assert.deepEqual(segmentTiles([9, 10], [10, 7]), [[9, 10], [9, 9], [10, 8], [10, 7]]);
|
||||
});
|
||||
|
||||
test('D5 real battle (act1 m04, round-1 template act1autochess_01): the 源石虫 leave the gate diagonally, never along row 9 to col 8', REAL, () => {
|
||||
const h = makeBattle({ stageId: M04, waveTemplate: 'act1autochess_01', units: [], autoFinish: false });
|
||||
let id = null, defId = null;
|
||||
const tiles = [];
|
||||
let atCol9 = null;
|
||||
h.b.on('tick', () => {
|
||||
const e = h.b.enemies.find((u) => (id == null ? u.motion === 'WALK' : u.id === id));
|
||||
if (!e) return;
|
||||
id = e.id;
|
||||
defId = e.defId;
|
||||
const k = `${Math.round(e.y)},${Math.round(e.x)}`;
|
||||
if (tiles[tiles.length - 1] !== k) tiles.push(k);
|
||||
if (atCol9 == null && e.x <= 9) atCol9 = e.y;
|
||||
});
|
||||
h.run(30);
|
||||
assert.equal(defId, 'enemy_1007_slime', 'the round-1 源石虫 of the lower gate');
|
||||
assert.deepEqual(tiles.slice(0, 5), ['9,10', '9,9', '10,8', '10,7', '10,6'], `tiles: ${tiles.join(' ')}`);
|
||||
assert.ok(!tiles.includes('9,8'), `never on (9,8): ${tiles.join(' ')}`);
|
||||
// on the official segment (9,10) → (10,7) the walker is a third of a row up when it passes the col-9 centre line
|
||||
assert.ok(Math.abs(atCol9 - (9 + 1 / 3)) < 0.02, `row ${atCol9} at col 9 (straight along row 9 would be 9.00)`);
|
||||
});
|
||||
|
||||
// Routes that differ from the official one (ours, as waypoints): each crosses fewer non-blockable tiles — user playtest
|
||||
// #2's 战场#01 col-9 floor lane (its 联防 partner routes pass the same exit), the boss exits (2,10) of 战场#01 / #02
|
||||
// that would cut across the arena's central floor, 战场#02's 联防 partner lower gate (floor (12,17)) and the inactive
|
||||
// 战场#07 (上半)'s 联防 partner upper gate (row 12 through (12,9) vs row 9). Every other route of every stage is official.
|
||||
const DEVIATIONS = {
|
||||
'act1autochess_m01 normal 9,10>9,2': '9,10 9,8 12,8 12,4 9,4 9,2',
|
||||
'act1autochess_m01 unite 9,10>9,2': '9,10 9,8 12,8 12,4 9,4 9,2',
|
||||
'act1autochess_m01 unite 9,18>9,2': '9,18 9,16 12,16 12,12 9,12 9,8 12,8 12,4 9,4 9,2',
|
||||
'act1autochess_m01 unite 12,18>9,2': '12,18 12,12 9,12 9,8 12,8 12,4 9,4 9,2',
|
||||
'act1autochess_m01 boss 2,10>1,3': '2,10 2,8 5,8 5,4 2,4 2,3 1,3',
|
||||
'act1autochess_m01 boss 2,10>2,2': '2,10 2,8 5,8 5,4 2,4 2,2',
|
||||
'act1autochess_m01 boss 2,10>1,17': '2,10 2,12 5,12 5,16 2,16 2,17 1,17',
|
||||
'act1autochess_m01 boss 2,10>2,18': '2,10 2,12 5,12 5,16 2,16 2,18',
|
||||
'act1autochess_m02 unite 9,18>9,2': '9,18 9,17 11,17 12,12 12,3 9,3 9,2',
|
||||
'act1autochess_m02 boss 2,10>1,3': '2,10 2,9 4,9 4,6 2,6 2,3 1,3',
|
||||
'act1autochess_m02 boss 2,10>2,2': '2,10 2,9 4,9 4,6 2,6 2,2',
|
||||
'act1autochess_m02 boss 2,10>1,17': '2,10 3,11 4,11 4,14 2,14 2,17 1,17',
|
||||
'act1autochess_m02 boss 2,10>2,18': '2,10 3,11 4,11 4,14 2,14 2,18',
|
||||
'act1autochess_m07 unite 12,18>9,2': '12,18 12,11 9,11 9,2',
|
||||
};
|
||||
|
||||
test('audit: every route of every stage (11, active or not) × gate × field is the official one, except the listed floor-avoiding ones', REAL, () => {
|
||||
const stages = ['act1autochess_m01', 'act1autochess_m02', 'act1autochess_m03', 'act1autochess_m04', 'act1autochess_m05', 'act1autochess_m06', 'act1autochess_m07',
|
||||
'act2autochess_m01', 'act2autochess_m02', 'act2autochess_m03', 'act2autochess_m04'];
|
||||
const legs = [
|
||||
['normal', [9, 10], [9, 2]], ['normal', [12, 10], [9, 2]],
|
||||
['unite', [9, 10], [9, 2]], ['unite', [12, 10], [9, 2]], ['unite', [9, 18], [9, 2]], ['unite', [12, 18], [9, 2]],
|
||||
...[[5, 10], [2, 10]].flatMap((s) => [[1, 3], [2, 2], [1, 17], [2, 18]].map((e) => ['boss', s, e])),
|
||||
];
|
||||
const floor = (g, wp) => {
|
||||
const out = [];
|
||||
for (let i = 1; i < wp.length; i++) for (const [r, c] of segmentTiles(wp[i - 1], wp[i]).slice(1)) if (g.unblockable[r * COLS + c]) out.push(`${r},${c}`);
|
||||
return out;
|
||||
};
|
||||
const seen = new Set();
|
||||
let official = 0;
|
||||
for (const sid of stages) {
|
||||
for (const [kind, s, e] of legs) {
|
||||
const g = stageGrid(sid, RECT[kind]), p = stageGrid(sid, RECT[kind], true);
|
||||
assert.ok(g, `${sid} in data/stages.json`);
|
||||
const ours = g.waypoints(s[0], s[1], e[0], e[1]), off = p.waypoints(s[0], s[1], e[0], e[1]);
|
||||
const key = `${sid} ${kind} ${s}>${e}`;
|
||||
assert.ok(ours && off, `${key} reachable`);
|
||||
assert.equal(g.flowField(e[0], e[1]).dist[s[0] * COLS + s[1]], p.flowField(e[0], e[1]).dist[s[0] * COLS + s[1]], `${key}: official length`);
|
||||
if (str(ours) === str(off)) { assert.ok(!(key in DEVIATIONS), `${key} is official now: drop it from DEVIATIONS`); official++; continue; }
|
||||
seen.add(key);
|
||||
assert.equal(str(ours), DEVIATIONS[key], `${key} differs from the official ${str(off)}`);
|
||||
const fo = floor(g, ours), ff = floor(g, off);
|
||||
assert.ok(fo.length < ff.length, `${key}: crosses ${fo.join(' ')}, the official route ${ff.join(' ')}`);
|
||||
}
|
||||
}
|
||||
assert.equal(seen.size, Object.keys(DEVIATIONS).length, 'every listed deviation still exists');
|
||||
assert.equal(official, stages.length * legs.length - seen.size);
|
||||
});
|
||||
|
||||
test('D5: an operator on (9,9), (9,8) or (10,8) blocks the lower-gate enemy on the official diagonal', REAL, () => {
|
||||
const guard = chessRec({ id: 't_guard', profession: 'WARRIOR', stats: { atk: 0, blockCnt: 3, maxHp: 1e6 }, skill: null });
|
||||
const walker = enemyRec({ key: 'enemy_walker', hp: 1e6, speed: 1 });
|
||||
const route = { motion: 'WALK', start: [9, 10], end: [9, 2], checkpoints: [] };
|
||||
for (const [r, c] of [[9, 9], [9, 8], [10, 8]]) {
|
||||
const h = makeBattle({ stageId: M04, defs: { chess: { t_guard: guard }, enemies: { enemy_walker: walker } },
|
||||
units: [{ chessId: 't_guard', row: r, col: c }], enemies: [{ key: 'enemy_walker', route }], content: 'none', autoFinish: false, timeLimit: 60 });
|
||||
const u = h.unit('t_guard');
|
||||
assert.ok(h.runUntil(() => h.enemies()[0]?.blockedBy === u, 30), `blocked by the operator on (${r},${c})`);
|
||||
}
|
||||
});
|
||||
@@ -108,13 +108,14 @@ test('flow fields are cached per destination and grid version', () => {
|
||||
});
|
||||
|
||||
test('real stages: the official lanes of research 08 §3.2 (crates = non-hidden level predefines, platforms blocking) + blockable-ground preference', REAL, () => {
|
||||
// m01 / m04 lower gate: equal-length choice between the col-9 floor lane and the col-8 road — the road (blockable)
|
||||
// wins (official: (9,9) → (12,8) over the floor of (10,9) / (11,9), and (9,10) → (10,7) over (10,9))
|
||||
// m01 lower gate: equal-length choice between the col-9 floor lane and the col-8 road — the road (blockable) wins
|
||||
// (official: (9,9) → (12,8) through the floor of (10,9)); m04 lower gate: the official diagonal (9,10) → (10,7) only
|
||||
// brushes the corner of the floor (10,9) and stays (community report D5, test/sim/pathing-official.test.js)
|
||||
const lanes = {
|
||||
act1autochess_m01: ['(12,10) (12,4) (9,4) (9,2)', '(9,10) (9,8) (12,8) (12,4) (9,4) (9,2)'],
|
||||
act1autochess_m02: ['(12,10) (12,3) (9,3) (9,2)', '(9,10) (9,9) (11,9) (11,6) (9,6) (9,2)'],
|
||||
act1autochess_m03: ['(12,10) (12,6) (11,6) (9,5) (9,2)', '(9,10) (9,2)'], // 射击台 on (10,3)/(10,4) block [ASSUMED]
|
||||
act1autochess_m04: ['(12,10) (12,9) (11,9) (11,4) (9,4) (9,2)', '(9,10) (9,8) (10,8) (10,4) (9,4) (9,2)'],
|
||||
act1autochess_m04: ['(12,10) (12,9) (11,9) (11,4) (9,4) (9,2)', '(9,10) (10,7) (10,4) (9,4) (9,2)'],
|
||||
act2autochess_m01: ['(12,10) (12,9) (9,9) (9,7) (12,7) (12,5) (9,5) (9,2)', '(9,10) (9,7) (12,7) (12,5) (9,5) (9,2)'],
|
||||
act2autochess_m02: ['(12,10) (12,7) (9,7) (9,2)', '(9,10) (9,2)'],
|
||||
act2autochess_m03: ['(12,10) (12,4) (9,4) (9,2)', '(9,10) (9,9) (10,9) (10,6) (9,6) (9,2)'],
|
||||
|
||||
Reference in new issue
Block a user