595 lines
23 KiB
TypeScript
595 lines
23 KiB
TypeScript
/**
|
|
* Standalone Adversarial Stress-Test Script for Milestone M2
|
|
* Diablo II Web DRLG Engine: Organic Geometry & Fractional Jitter Profiler
|
|
*
|
|
* Requirements:
|
|
* 1. Stress-test Act 2 Oasis and Act 5 Frozen Lake radial lobe perturbations across 100+ random seeds and phase variations:
|
|
* - Numerically compute P^2 / A for continuous polar contour and discrete rasterized tile cells.
|
|
* - Assert P^2 / A > 4*pi * 1.15 holds 100% of the time (zero violations).
|
|
* 2. Stress-test jitterFrac: sample 10,000 draws and assert all values strictly lie in [base - delta, base + delta].
|
|
* 3. Verify Act 4 Lava Fissure flood-fill reachability >= 90%.
|
|
* 4. Verify Act 5 Transverse Barricade palisade orientation and choke-point gate clearance.
|
|
*
|
|
* Act I's outdoor levels are generated by the DRLG port (src/game/drlg), not by generateWilderness;
|
|
* tests/drlg-act1-oracle.test.ts and tests/drlg-act1-invariants.test.ts cover them.
|
|
*
|
|
* Archetype: EMPIRICAL CHALLENGER
|
|
*/
|
|
|
|
import type { Ds1, Ds1Cell } from '../src/formats/ds1.ts'
|
|
import {
|
|
generateWilderness,
|
|
type WildernessPiece,
|
|
} from '../src/game/wilderness.ts'
|
|
import {
|
|
act2OasisRadius,
|
|
act5FrozenLakeRadius,
|
|
jitterFrac,
|
|
type Act2TopographyStats,
|
|
type Act5TopographyStats,
|
|
} from '../src/game/wilderness-acts.ts'
|
|
import { Rng } from '../src/game/rng.ts'
|
|
|
|
/* ------------------------------------------------------------------------- *
|
|
* Mathematical Helpers: Continuous & Discrete Isoperimetric Quotients
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
const ORGANIC_THRESHOLD = 4 * Math.PI * 1.15 // ~14.451326206513047
|
|
|
|
/**
|
|
* Numerically compute continuous polar contour area, perimeter, and P^2 / A.
|
|
*/
|
|
function computeContinuousPolarQuotient(
|
|
radiusFn: (theta: number) => number,
|
|
steps = 2000,
|
|
): { area: number; perimeter: number; quotient: number } {
|
|
let area = 0
|
|
let perimeter = 0
|
|
const dTheta = (2 * Math.PI) / steps
|
|
|
|
for (let i = 0; i < steps; i += 1) {
|
|
const t1 = i * dTheta
|
|
const t2 = (i + 1) * dTheta
|
|
const r1 = radiusFn(t1)
|
|
const r2 = radiusFn(t2)
|
|
|
|
// Sector area via cross product
|
|
area += 0.5 * r1 * r2 * Math.sin(dTheta)
|
|
|
|
// Arc length via Euclidean chord
|
|
const x1 = r1 * Math.cos(t1)
|
|
const y1 = r1 * Math.sin(t1)
|
|
const x2 = r2 * Math.cos(t2)
|
|
const y2 = r2 * Math.sin(t2)
|
|
perimeter += Math.hypot(x2 - x1, y2 - y1)
|
|
}
|
|
|
|
const quotient = (perimeter * perimeter) / area
|
|
return { area, perimeter, quotient }
|
|
}
|
|
|
|
/**
|
|
* Numerically compute discrete rasterized tile cells area, perimeter, and P^2 / A.
|
|
*/
|
|
function computeDiscreteRasterQuotient(
|
|
radiusFn: (theta: number) => number,
|
|
R: number,
|
|
): { area: number; perimeter: number; quotient: number } {
|
|
const maxR = Math.ceil(R * 1.5) + 3
|
|
const inside = new Set<string>()
|
|
|
|
for (let dy = -maxR; dy <= maxR; dy += 1) {
|
|
for (let dx = -maxR; dx <= maxR; dx += 1) {
|
|
const dist = Math.hypot(dx, dy)
|
|
const theta = Math.atan2(dy, dx)
|
|
const rLobe = radiusFn(theta)
|
|
if (dist <= rLobe) {
|
|
inside.add(`${dx},${dy}`)
|
|
}
|
|
}
|
|
}
|
|
|
|
const area = inside.size
|
|
let perimeter = 0
|
|
|
|
for (const key of inside) {
|
|
const comma = key.indexOf(',')
|
|
const x = Number(key.slice(0, comma))
|
|
const y = Number(key.slice(comma + 1))
|
|
|
|
if (!inside.has(`${x + 1},${y}`)) perimeter += 1
|
|
if (!inside.has(`${x - 1},${y}`)) perimeter += 1
|
|
if (!inside.has(`${x},${y + 1}`)) perimeter += 1
|
|
if (!inside.has(`${x},${y - 1}`)) perimeter += 1
|
|
}
|
|
|
|
const quotient = area > 0 ? (perimeter * perimeter) / area : 0
|
|
return { area, perimeter, quotient }
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- *
|
|
* Mock DS1 and Piece Builders for Hermetic Testing
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
function makeMockDs1(width: number, height: number): Ds1 {
|
|
const cells: Ds1Cell[][] = []
|
|
for (let y = 0; y < height; y += 1) {
|
|
const row: Ds1Cell[] = []
|
|
for (let x = 0; x < width; x += 1) {
|
|
row.push({
|
|
walls: [],
|
|
floors: [{ prop1: 2, sequence: 0, style: 1, unknown1: 0, unknown2: 0, hidden: false }],
|
|
shadows: [],
|
|
substitutions: [],
|
|
})
|
|
}
|
|
cells.push(row)
|
|
}
|
|
return {
|
|
version: 18,
|
|
width,
|
|
height,
|
|
act: 1,
|
|
substitutionType: 0,
|
|
wallLayers: 1,
|
|
floorLayers: 1,
|
|
cells,
|
|
objects: [],
|
|
npcPathOffset: null,
|
|
}
|
|
}
|
|
|
|
function makeMockBorderPieces(actPrefix: string): WildernessPiece[] {
|
|
const ds1 = makeMockDs1(8, 8)
|
|
return [
|
|
{ name: `${actPrefix} - Border 1`, border: true, levels: [ds1] },
|
|
{ name: `${actPrefix} - Border 2`, border: true, levels: [ds1] },
|
|
{ name: `${actPrefix} - Border 3`, border: true, levels: [ds1] },
|
|
{ name: `${actPrefix} - Border 4`, border: true, levels: [ds1] },
|
|
{ name: `${actPrefix} - Border 5`, border: true, levels: [ds1] },
|
|
{ name: `${actPrefix} - Border 6`, border: true, levels: [ds1] },
|
|
]
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- *
|
|
* Stress Test Harness
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
async function main() {
|
|
console.log('======================================================================')
|
|
console.log('🔥 DIABLO II WEB DRLG: STANDALONE ADVERSARIAL STRESS TEST (MILESTONE M2)')
|
|
console.log('======================================================================\n')
|
|
|
|
let totalAssertions = 0
|
|
let passedAssertions = 0
|
|
let failedAssertions = 0
|
|
const failureLog: string[] = []
|
|
|
|
function check(condition: boolean, message: string) {
|
|
totalAssertions += 1
|
|
if (condition) {
|
|
passedAssertions += 1
|
|
} else {
|
|
failedAssertions += 1
|
|
failureLog.push(message)
|
|
console.error(` ❌ FAILED: ${message}`)
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
// SECTION 1: JitterFrac Sampling (10,000 Draws)
|
|
// -------------------------------------------------------------------------
|
|
console.log('--- SECTION 1: STRESS-TESTING JitterFrac (10,000 Draws) ---')
|
|
const jitterRng = new Rng(0xbadf00d)
|
|
const testConfigs = [
|
|
{ base: 0.50, delta: 0.05, count: 2000 },
|
|
{ base: 0.35, delta: 0.04, count: 1500 },
|
|
{ base: 0.70, delta: 0.04, count: 1500 },
|
|
{ base: 0.22, delta: 0.05, count: 1500 },
|
|
{ base: 0.68, delta: 0.05, count: 1500 },
|
|
{ base: 0.40, delta: 0.05, count: 1000 },
|
|
// Boundary clamp checks
|
|
{ base: 0.03, delta: 0.05, count: 500 }, // lower clamp at 0.01
|
|
{ base: 0.97, delta: 0.05, count: 500 }, // upper clamp at 0.99
|
|
]
|
|
|
|
let totalDraws = 0
|
|
for (const cfg of testConfigs) {
|
|
const minAllowed = Math.max(0.01, cfg.base - cfg.delta)
|
|
const maxAllowed = Math.min(0.99, cfg.base + cfg.delta)
|
|
const draws: number[] = []
|
|
|
|
for (let i = 0; i < cfg.count; i += 1) {
|
|
const val = jitterFrac(jitterRng, cfg.base, cfg.delta)
|
|
totalDraws += 1
|
|
const inBounds = val >= minAllowed && val <= maxAllowed
|
|
if (!inBounds) {
|
|
check(false, `jitterFrac out of bounds: val=${val}, allowed=[${minAllowed}, ${maxAllowed}], base=${cfg.base}, delta=${cfg.delta}`)
|
|
}
|
|
draws.push(val)
|
|
}
|
|
|
|
const minObs = Math.min(...draws)
|
|
const maxObs = Math.max(...draws)
|
|
const meanObs = draws.reduce((a, b) => a + b, 0) / draws.length
|
|
check(minObs >= minAllowed && maxObs <= maxAllowed, `All ${cfg.count} draws strictly in [${minAllowed.toFixed(4)}, ${maxAllowed.toFixed(4)}]`)
|
|
|
|
console.log(
|
|
` Base: ${cfg.base.toFixed(2)} ± ${cfg.delta.toFixed(2)} (${cfg.count} draws) | ` +
|
|
`Observed: [${minObs.toFixed(4)} .. ${maxObs.toFixed(4)}] | Mean: ${meanObs.toFixed(4)} | PASSED`
|
|
)
|
|
}
|
|
check(totalDraws === 10000, `Total jitterFrac draws reached exactly 10,000 (${totalDraws})`)
|
|
console.log(` ✓ 10,000 draws sampled: 0 violations, 100% strictly bounded.\n`)
|
|
|
|
// -------------------------------------------------------------------------
|
|
// SECTION 2: Act 2 Oasis Radial Lobe Harmonic Perturbations (150+ Seeds & Phases)
|
|
// -------------------------------------------------------------------------
|
|
console.log('--- SECTION 2: STRESS-TESTING Act 2 Oasis Radial Lobes (P^2 / A > 4*pi * 1.15) ---')
|
|
const oasisRng = new Rng(0x0a515001)
|
|
const testRadiiAct2 = [4, 5, 6, 8, 10, 14, 20, 30]
|
|
let act2ContViolations = 0
|
|
let act2DiscViolations = 0
|
|
let act2TotalTests = 0
|
|
|
|
let minAct2ContQ = Infinity
|
|
let maxAct2ContQ = -Infinity
|
|
let minAct2DiscQ = Infinity
|
|
let maxAct2DiscQ = -Infinity
|
|
|
|
for (let seedIdx = 0; seedIdx < 150; seedIdx += 1) {
|
|
const phi1 = oasisRng.range(0, 2 * Math.PI)
|
|
const phi2 = oasisRng.range(0, 2 * Math.PI)
|
|
|
|
for (const R of testRadiiAct2) {
|
|
act2TotalTests += 1
|
|
const radiusFn = (theta: number) => act2OasisRadius(R, theta, phi1, phi2)
|
|
|
|
// Continuous polar contour
|
|
const cont = computeContinuousPolarQuotient(radiusFn, 2000)
|
|
if (cont.quotient < minAct2ContQ) minAct2ContQ = cont.quotient
|
|
if (cont.quotient > maxAct2ContQ) maxAct2ContQ = cont.quotient
|
|
|
|
if (cont.quotient <= ORGANIC_THRESHOLD) {
|
|
act2ContViolations += 1
|
|
check(false, `Act 2 continuous P^2/A violation: ${cont.quotient} <= ${ORGANIC_THRESHOLD} (R=${R}, phi1=${phi1}, phi2=${phi2})`)
|
|
}
|
|
|
|
// Discrete rasterized tile cells
|
|
const disc = computeDiscreteRasterQuotient(radiusFn, R)
|
|
if (disc.quotient < minAct2DiscQ) minAct2DiscQ = disc.quotient
|
|
if (disc.quotient > maxAct2DiscQ) maxAct2DiscQ = disc.quotient
|
|
|
|
if (disc.quotient <= ORGANIC_THRESHOLD) {
|
|
act2DiscViolations += 1
|
|
check(false, `Act 2 discrete P^2/A violation: ${disc.quotient} <= ${ORGANIC_THRESHOLD} (R=${R}, phi1=${phi1}, phi2=${phi2})`)
|
|
}
|
|
}
|
|
}
|
|
|
|
check(act2ContViolations === 0, `Act 2 continuous P^2/A zero violations across ${act2TotalTests} configurations`)
|
|
check(act2DiscViolations === 0, `Act 2 discrete P^2/A zero violations across ${act2TotalTests} configurations`)
|
|
console.log(` Act 2 Oasis Tested: ${act2TotalTests} configurations across 150 seeds and ${testRadiiAct2.length} radii.`)
|
|
console.log(` Continuous P^2/A range: [${minAct2ContQ.toFixed(4)} .. ${maxAct2ContQ.toFixed(4)}] (Threshold: > ${ORGANIC_THRESHOLD.toFixed(4)})`)
|
|
console.log(` Discrete P^2/A range: [${minAct2DiscQ.toFixed(4)} .. ${maxAct2DiscQ.toFixed(4)}] (Threshold: > ${ORGANIC_THRESHOLD.toFixed(4)})`)
|
|
console.log(` ✓ Act 2 Oasis: 0 violations, 100% strictly exceed isoperimetric threshold.\n`)
|
|
|
|
// -------------------------------------------------------------------------
|
|
// SECTION 3: Act 5 Frozen Lake Radial Lobe Harmonic Perturbations (150+ Seeds & Phases)
|
|
// -------------------------------------------------------------------------
|
|
console.log('--- SECTION 3: STRESS-TESTING Act 5 Frozen Lake Radial Lobes (P^2 / A > 4*pi * 1.15) ---')
|
|
const lakeRng = new Rng(0x1a7e5001)
|
|
const testRadiiAct5 = [6, 7, 8, 10, 12, 16, 22]
|
|
let act5ContViolations = 0
|
|
let act5DiscViolations = 0
|
|
let act5TotalTests = 0
|
|
|
|
let minAct5ContQ = Infinity
|
|
let maxAct5ContQ = -Infinity
|
|
let minAct5DiscQ = Infinity
|
|
let maxAct5DiscQ = -Infinity
|
|
|
|
for (let seedIdx = 0; seedIdx < 150; seedIdx += 1) {
|
|
const phi1 = lakeRng.range(0, 2 * Math.PI)
|
|
const phi2 = lakeRng.range(0, 2 * Math.PI)
|
|
|
|
for (const R of testRadiiAct5) {
|
|
act5TotalTests += 1
|
|
const radiusFn = (theta: number) => act5FrozenLakeRadius(R, theta, phi1, phi2)
|
|
|
|
// Continuous polar contour
|
|
const cont = computeContinuousPolarQuotient(radiusFn, 2000)
|
|
if (cont.quotient < minAct5ContQ) minAct5ContQ = cont.quotient
|
|
if (cont.quotient > maxAct5ContQ) maxAct5ContQ = cont.quotient
|
|
|
|
if (cont.quotient <= ORGANIC_THRESHOLD) {
|
|
act5ContViolations += 1
|
|
check(false, `Act 5 continuous P^2/A violation: ${cont.quotient} <= ${ORGANIC_THRESHOLD} (R=${R}, phi1=${phi1}, phi2=${phi2})`)
|
|
}
|
|
|
|
// Discrete rasterized tile cells
|
|
const disc = computeDiscreteRasterQuotient(radiusFn, R)
|
|
if (disc.quotient < minAct5DiscQ) minAct5DiscQ = disc.quotient
|
|
if (disc.quotient > maxAct5DiscQ) maxAct5DiscQ = disc.quotient
|
|
|
|
if (disc.quotient <= ORGANIC_THRESHOLD) {
|
|
act5DiscViolations += 1
|
|
check(false, `Act 5 discrete P^2/A violation: ${disc.quotient} <= ${ORGANIC_THRESHOLD} (R=${R}, phi1=${phi1}, phi2=${phi2})`)
|
|
}
|
|
}
|
|
}
|
|
|
|
check(act5ContViolations === 0, `Act 5 continuous P^2/A zero violations across ${act5TotalTests} configurations`)
|
|
check(act5DiscViolations === 0, `Act 5 discrete P^2/A zero violations across ${act5TotalTests} configurations`)
|
|
console.log(` Act 5 Frozen Lake Tested: ${act5TotalTests} configurations across 150 seeds and ${testRadiiAct5.length} radii.`)
|
|
console.log(` Continuous P^2/A range: [${minAct5ContQ.toFixed(4)} .. ${maxAct5ContQ.toFixed(4)}] (Threshold: > ${ORGANIC_THRESHOLD.toFixed(4)})`)
|
|
console.log(` Discrete P^2/A range: [${minAct5DiscQ.toFixed(4)} .. ${maxAct5DiscQ.toFixed(4)}] (Threshold: > ${ORGANIC_THRESHOLD.toFixed(4)})`)
|
|
console.log(` ✓ Act 5 Frozen Lake: 0 violations, 100% strictly exceed isoperimetric threshold.\n`)
|
|
|
|
// -------------------------------------------------------------------------
|
|
// SECTION 4: Real Generated Wilderness Level Audits across 100 Seeds
|
|
// -------------------------------------------------------------------------
|
|
console.log('--- SECTION 4: FULL WILDERNESS ENGINE MAP AUDITS (100 Seeds) ---')
|
|
const mapRng = new Rng(0x99887766)
|
|
const mapSeeds: number[] = [0x301cd095, 0x416d61c5, 0xdeadbeef]
|
|
for (let i = 0; i < 97; i += 1) {
|
|
mapSeeds.push(mapRng.int(100000, 99999999))
|
|
}
|
|
|
|
const act2Pieces = makeMockBorderPieces('Act 2')
|
|
const act4Pieces = makeMockBorderPieces('Act 4')
|
|
const act5Pieces = makeMockBorderPieces('Act 5')
|
|
|
|
let oasisMapChecks = 0
|
|
let frozenLakeMapChecks = 0
|
|
let fissureConnectivityChecks = 0
|
|
let barricadeChecks = 0
|
|
|
|
for (const seed of mapSeeds) {
|
|
// 1. Act 2 Far Oasis (Level 43)
|
|
const oasisResult = generateWilderness({
|
|
levelId: 43,
|
|
levelName: 'Far Oasis',
|
|
levelTypeName: 'Act 2 - Desert',
|
|
sizeX: 80,
|
|
sizeY: 80,
|
|
subType: 0,
|
|
subTheme: 0,
|
|
seed,
|
|
pieces: act2Pieces,
|
|
substitutions: [],
|
|
})
|
|
|
|
const oW = oasisResult.level.width
|
|
const oH = oasisResult.level.height
|
|
const oCells = oasisResult.level.cells
|
|
const isOasisWater = (x: number, y: number) => {
|
|
if (x < 0 || x >= oW || y < 0 || y >= oH) return false
|
|
return oCells[y]![x]!.floors.some(f => f.style === 2 && f.prop1 === 2)
|
|
}
|
|
|
|
// Find connected components of oasis water
|
|
const visitedOasis = new Set<string>()
|
|
for (let y = 4; y < oH - 4; y += 1) {
|
|
for (let x = 4; x < oW - 4; x += 1) {
|
|
const key = `${x},${y}`
|
|
if (isOasisWater(x, y) && !visitedOasis.has(key)) {
|
|
// BFS component
|
|
const comp: [number, number][] = []
|
|
const queue: [number, number][] = [[x, y]]
|
|
visitedOasis.add(key)
|
|
while (queue.length > 0) {
|
|
const [cx, cy] = queue.shift()!
|
|
comp.push([cx, cy])
|
|
for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
|
|
const nx = cx + dx
|
|
const ny = cy + dy
|
|
const nKey = `${nx},${ny}`
|
|
if (isOasisWater(nx, ny) && !visitedOasis.has(nKey)) {
|
|
visitedOasis.add(nKey)
|
|
queue.push([nx, ny])
|
|
}
|
|
}
|
|
}
|
|
|
|
if (comp.length >= 10) {
|
|
oasisMapChecks += 1
|
|
const compArea = comp.length
|
|
let compPerim = 0
|
|
for (const [cx, cy] of comp) {
|
|
if (!isOasisWater(cx + 1, cy)) compPerim += 1
|
|
if (!isOasisWater(cx - 1, cy)) compPerim += 1
|
|
if (!isOasisWater(cx, cy + 1)) compPerim += 1
|
|
if (!isOasisWater(cx, cy - 1)) compPerim += 1
|
|
}
|
|
const compQ = (compPerim * compPerim) / compArea
|
|
check(compQ > ORGANIC_THRESHOLD, `Map Far Oasis (seed ${seed}) pool P^2/A=${compQ.toFixed(2)} > ${ORGANIC_THRESHOLD.toFixed(2)}`)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Act 5 Arreat Plateau (Level 112)
|
|
const plateauResult = generateWilderness({
|
|
levelId: 112,
|
|
levelName: 'Arreat Plateau',
|
|
levelTypeName: 'Act 5 - Barricade',
|
|
sizeX: 80,
|
|
sizeY: 80,
|
|
subType: 0,
|
|
subTheme: 0,
|
|
seed,
|
|
pieces: act5Pieces,
|
|
substitutions: [],
|
|
})
|
|
|
|
const pH = plateauResult.level.height
|
|
const pW = plateauResult.level.width
|
|
const pCells = plateauResult.level.cells
|
|
const isFrozenLake = (x: number, y: number) => {
|
|
if (x < 0 || x >= pW || y < 0 || y >= pH) return false
|
|
return pCells[y]![x]!.floors.some(f => f.style === 2 && f.sequence === 0 && f.prop1 === 2)
|
|
}
|
|
|
|
let lakeArea = 0
|
|
let lakePerim = 0
|
|
for (let y = 4; y < pH - 4; y += 1) {
|
|
for (let x = 4; x < pW - 4; x += 1) {
|
|
if (isFrozenLake(x, y)) {
|
|
lakeArea += 1
|
|
if (!isFrozenLake(x + 1, y)) lakePerim += 1
|
|
if (!isFrozenLake(x - 1, y)) lakePerim += 1
|
|
if (!isFrozenLake(x, y + 1)) lakePerim += 1
|
|
if (!isFrozenLake(x, y - 1)) lakePerim += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
if (lakeArea >= 15) {
|
|
frozenLakeMapChecks += 1
|
|
const lakeQ = (lakePerim * lakePerim) / lakeArea
|
|
check(lakeQ > ORGANIC_THRESHOLD, `Map Arreat Plateau (seed ${seed}) lake P^2/A=${lakeQ.toFixed(2)} > ${ORGANIC_THRESHOLD.toFixed(2)}`)
|
|
}
|
|
|
|
// 3. Act 4 Outer Steppes (Level 104) - Lava Fissure Connectivity
|
|
const steppesResult = generateWilderness({
|
|
levelId: 104,
|
|
levelName: 'Outer Steppes',
|
|
levelTypeName: 'Act 4 - Mesa',
|
|
sizeX: 80,
|
|
sizeY: 80,
|
|
subType: 0,
|
|
subTheme: 0,
|
|
seed,
|
|
pieces: act4Pieces,
|
|
substitutions: [],
|
|
})
|
|
|
|
const sW = steppesResult.level.width
|
|
const sH = steppesResult.level.height
|
|
const sCells = steppesResult.level.cells
|
|
const isWalkable = (x: number, y: number) => {
|
|
if (x < 8 || x >= sW - 8 || y < 8 || y >= sH - 8) return false
|
|
const cell = sCells[y]![x]!
|
|
return !cell.walls.some(w => w.prop1 !== 0 || w.style !== 0)
|
|
}
|
|
|
|
let totalWalkable = 0
|
|
let startX = -1
|
|
let startY = -1
|
|
for (let y = 8; y < sH - 8; y += 1) {
|
|
for (let x = 8; x < sW - 8; x += 1) {
|
|
if (isWalkable(x, y)) {
|
|
totalWalkable += 1
|
|
if (startX === -1 && y < 16) {
|
|
startX = x
|
|
startY = y
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const visitedWalk = new Set<number>()
|
|
const walkQueue: [number, number][] = [[startX, startY]]
|
|
visitedWalk.add(startY * sW + startX)
|
|
while (walkQueue.length > 0) {
|
|
const [cx, cy] = walkQueue.shift()!
|
|
for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
|
|
const nx = cx + dx
|
|
const ny = cy + dy
|
|
const key = ny * sW + nx
|
|
if (isWalkable(nx, ny) && !visitedWalk.has(key)) {
|
|
visitedWalk.add(key)
|
|
walkQueue.push([nx, ny])
|
|
}
|
|
}
|
|
}
|
|
|
|
const reachRatio = visitedWalk.size / totalWalkable
|
|
fissureConnectivityChecks += 1
|
|
check(reachRatio >= 0.90, `Act 4 Level 104 (seed ${seed}) reachability=${(reachRatio * 100).toFixed(2)}% >= 90%`)
|
|
|
|
// 4. Act 5 Frigid Highlands (Level 111) - Transverse Barricades
|
|
const barricadeResult = generateWilderness({
|
|
levelId: 111,
|
|
levelName: 'Frigid Highlands',
|
|
levelTypeName: 'Act 5 - Barricade',
|
|
sizeX: 48,
|
|
sizeY: 160,
|
|
subType: 0,
|
|
subTheme: 0,
|
|
seed,
|
|
pieces: act5Pieces,
|
|
substitutions: [],
|
|
})
|
|
|
|
const bW = barricadeResult.level.width
|
|
const bH = barricadeResult.level.height
|
|
const bCells = barricadeResult.level.cells
|
|
const bInX = Math.floor(Math.floor(48 / 8) / 2)
|
|
const bHubX = bInX * 8 + 4
|
|
|
|
// Because height (160) > width (48), barricades must cut horizontally across X
|
|
const hBarricadeRows: number[] = []
|
|
for (let y = 8; y < bH - 8; y += 1) {
|
|
let palisadeCount = 0
|
|
for (let x = 8; x < bW - 8; x += 1) {
|
|
if (bCells[y]![x]!.walls.some(w => w.style === 2 && w.prop1 === 129)) {
|
|
palisadeCount += 1
|
|
}
|
|
}
|
|
if (palisadeCount >= 15) {
|
|
hBarricadeRows.push(y)
|
|
}
|
|
}
|
|
|
|
barricadeChecks += 1
|
|
check(hBarricadeRows.length >= 2, `Act 5 Level 111 (seed ${seed}) horizontal barricades: ${hBarricadeRows.length} >= 2`)
|
|
for (const by of hBarricadeRows) {
|
|
const gate = bCells[by]![bHubX]!
|
|
const hasWall = gate.walls.some(w => w.prop1 !== 0 || w.style !== 0)
|
|
const hasFloor = gate.floors.some(f => f.style === 5 && f.prop1 === 194)
|
|
check(!hasWall && hasFloor, `Act 5 Level 111 (seed ${seed}, y=${by}) gate at hubX=${bHubX} open`)
|
|
}
|
|
}
|
|
|
|
console.log(` Map Audits completed across 100 seeds:`)
|
|
console.log(` - Oasis pool components audited: ${oasisMapChecks} checks (all P^2/A > 14.45)`)
|
|
console.log(` - Frozen lake components audited: ${frozenLakeMapChecks} checks (all P^2/A > 14.45)`)
|
|
console.log(` - Act 4 fissure reachability audited: ${fissureConnectivityChecks} checks (all >= 90.00%)`)
|
|
console.log(` - Act 5 transverse barricade audited: ${barricadeChecks} checks (all perpendicular + open gate)`)
|
|
console.log(` ✓ Real level generation stress tests: 0 violations.\n`)
|
|
|
|
// -------------------------------------------------------------------------
|
|
// FINAL REPORT
|
|
// -------------------------------------------------------------------------
|
|
console.log('\n======================================================================')
|
|
console.log('📊 M2 ADVERSARIAL STRESS TEST RESULTS')
|
|
console.log('======================================================================')
|
|
console.log(`Total Assertions Executed: ${totalAssertions}`)
|
|
console.log(`Passed Assertions: ${passedAssertions}`)
|
|
console.log(`Failed Assertions: ${failedAssertions}`)
|
|
|
|
if (failedAssertions > 0) {
|
|
console.error('\n❌ FAILURES ENCOUNTERED:')
|
|
for (const f of failureLog) {
|
|
console.error(` - ${f}`)
|
|
}
|
|
process.exit(1)
|
|
}
|
|
|
|
console.log('\n✅ ALL MILESTONE M2 GEOMETRIC, ISOPERIMETRIC & TOPOLOGICAL INVARIANTS CONFIRMED:')
|
|
console.log('1. JitterFrac: 10,000 draws strictly in [base - delta, base + delta] with 0 violations.')
|
|
console.log(`2. Act 2 Oasis: Continuous and discrete P^2/A strictly > 4pi * 1.15 across all seeds/phases.`)
|
|
console.log(`3. Act 5 Frozen Lake: Continuous and discrete P^2/A strictly > 4pi * 1.15 across all seeds/phases.`)
|
|
console.log(`4. Full Map Generation (100 seeds): 100% of water/lake bodies satisfy P^2/A > 4pi * 1.15.`)
|
|
console.log(`5. Act 4 Lava Fissure: 100% of tested maps maintain >= 90% flood-fill reachability.`)
|
|
console.log(`6. Act 5 Barricades: Transverse direction invariance & open choke-point gates verified.`)
|
|
console.log('======================================================================\n')
|
|
}
|
|
|
|
main().catch(err => {
|
|
console.error('Fatal stress test runner error:', err)
|
|
process.exit(1)
|
|
})
|