troytt
/
diablo2-web
1
0
Fork 0
Code Issues 96 Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: troytt:b6fc2512d4b5585f36e72ef896033e3281e52a93
Branches Tags
troytt:main
..
compare: troytt:bad680600f618014dd77c11741f4babc43f05beb
Branches Tags
troytt:main

No commits in common. "b6fc2512d4b5585f36e72ef896033e3281e52a93" and "bad680600f618014dd77c11741f4babc43f05beb" have entirely different histories.
b6fc2512d4 ... bad680600f

76 changed files with 15509 additions and 7133 deletions
Show Stats Expand all files Collapse all files

805
scripts/audit-levels-browser.ts
View File

@ -1,805 +0,0 @@
/**
* Headless browser audit of every baked level: all 136 Levels.txt ids, every copy the pack holds.
*
* Each index entry is opened as `acts.html?act=<act>&level=<label>&pack=<pack>` in a fresh tab of a
* headless Chrome (SwiftShader WebGL2), served by a Vite dev server over the working tree. The
* verdicts come from the page's published state (`window.__d2webAct`), the DevTools event stream,
* the screenshot and the pack's own scene.json, never from looking at pictures. Every entry must
* pass all of these:
*
* 1. Boot: the scene reaches `ready` with no `error` and shows the entry that was asked for (act and
* label, loaded from the pack); the simulation ticks and the renderer has drawn frames.
* 2. Clean page: no uncaught exception, no console error or failed assertion, no failed request, no
* HTTP error status. The only exception is the short, fixed KNOWN_ABSENT list (Chrome's favicon
* probe and four missiles the runtime aliases on purpose), which is reported instead.
* 3. Rendering: the map has floor tiles, every atlas page arrives, the screenshot is not blank, and
* every monster the level plans has its art (a monster without art is drawn as a red box).
* 4. Pack integrity: no missing tile, no unresolved tile reference, no unplaced link edge.
* 5. Spawn: the player stands on a walkable sub-tile of a cell that has a floor tile, inside the
* largest connected walkable region that holds floor (largestWalkableRegionWithFloors, the region
* finder the bake and the runtime use), so never in the void and never in a sealed pocket.
* 6. Stability: the level does not switch by itself while the page settles (no spawn on a warp).
*
* Screenshots of the chosen levels (default: the Act I outdoor levels the DRLG port generates) are
* kept in --out, next to report.json.
*
* Usage:
* npx tsx scripts/audit-levels-browser.ts [--pack=samples/d2-packs] [--out=/tmp/level-audit]
* [--jobs=6] [--act=N] [--levels=2-7,17,39] [--shots=2-7,17,39|all|none] [--timeout=180]
* [--chrome=/path/to/chrome]
*
* --pack must lie inside the repository: the dev server serves only the working tree.
*/
import { spawn, type ChildProcess } from 'node:child_process'
import { once } from 'node:events'
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join, relative, resolve, sep } from 'node:path'
import { inflateSync } from 'node:zlib'
import { createServer } from 'vite'
import { subTileAt, type CollisionGrid } from '../src/game/d2map.ts'
import { largestWalkableRegionWithFloors } from '../src/game/level-links.ts'
import { SUB_TILES_PER_TILE } from '../src/game/map.ts'
const ROOT = resolve(import.meta.dirname, '..')
/**
* Playwright's Chromium comes first: a plain build without the managed policies and extensions the
* workstation's google-chrome brings along.
*/
const CHROME_CANDIDATES = [
join(process.env.HOME ?? '', '.cache/ms-playwright/chromium-1228/chrome-linux64/chrome'),
'/root/.cache/ms-playwright/chromium-1223/chrome-linux64/chrome',
'/usr/bin/google-chrome',
]
/** Longest wait for one DevTools command; a hung command fails its entry instead of the audit. */
const COMMAND_TIMEOUT_MS = 60_000
/** Levels.txt ids the audit screenshots by default: the Act I outdoor levels of the DRLG port. */
const DEFAULT_SHOTS = '2-7,17,39'
/** Levels.txt ids 1..136: every level of the game. */
const LEVEL_COUNT = 136
const WINDOW = { width: 1280, height: 840 } as const
/** How long a ready page is watched for late errors or a level switch. */
const SETTLE_MS = 1500
const POLL_MS = 250
/**
* A screenshot counts as blank when fewer than this share of the sampled pixels is lit, or when it
* has fewer distinct colours than this. A drawn map clears both by a wide margin; a black canvas, a
* clear colour or a single placeholder fails both.
*/
const MIN_LIT_SHARE = 0.1
const MIN_COLOURS = 64
/** The bottom part of the window holds the HUD, which draws even when the map does not. */
const MAP_SHARE_OF_HEIGHT = 0.75
const sleep = (ms: number): Promise<void> => new Promise(done => setTimeout(done, ms))
interface IndexEntry {
readonly act: number
readonly levelId: number
readonly label: string
readonly path: string
readonly missingTiles?: number
readonly unplacedEdges?: number
}
interface SceneJson {
readonly cellsX: number
readonly cellsY: number
readonly originX: number
readonly originY: number
readonly floors: readonly (readonly number[])[]
readonly collision: {
readonly width: number
readonly height: number
readonly runs: readonly (readonly number[])[]
}
readonly stats: {
readonly missingTiles: number
readonly missingRefs?: readonly unknown[]
readonly unplacedEdges?: readonly unknown[]
}
}
/** The part of `window.__d2webAct` the audit reads. */
interface PageState {
readonly ready: boolean
readonly error: string | null
readonly source: string
readonly act: number
readonly variant: string
readonly cellsX: number
readonly cellsY: number
readonly floors: number
readonly walls: number
readonly frames: number
readonly pagesLoaded: number
readonly pagesTotal: number
readonly pagesAtFirstFrame: number
readonly drawCalls: number
readonly quadsDrawn: number
readonly tick: number
readonly x: number
readonly y: number
readonly missingMonsterArt: readonly string[]
readonly monsterArtErrors: number
readonly monsterArtLayerFailures: number
readonly monstersPlanned: number
readonly loadMs: number
}
const STATE_EXPRESSION = `(() => {
const s = window.__d2webAct
if (!s) return null
return {
ready: s.ready, error: s.error ?? null, source: s.source, act: s.act, variant: s.variant,
cellsX: s.cellsX, cellsY: s.cellsY, floors: s.floors, walls: s.walls, frames: s.frames,
pagesLoaded: s.pagesLoaded, pagesTotal: s.pagesTotal, pagesAtFirstFrame: s.pagesAtFirstFrame,
drawCalls: s.drawCalls, quadsDrawn: s.quadsDrawn, tick: s.tick, x: s.x, y: s.y,
missingMonsterArt: [...(s.missingMonsterArt ?? [])], monsterArtErrors: s.monsterArtErrors,
monsterArtLayerFailures: s.monsterArtLayerFailures, monstersPlanned: s.monstersPlanned, loadMs: s.loadMs,
}
})()`
interface SpawnCheck {
readonly subX: number
readonly subY: number
readonly inBounds: boolean
readonly walkable: boolean
readonly floor: boolean
readonly inMainRegion: boolean
/** Sub-tiles of the walkable component the player stands in (0 when standing on a blocked one). */
readonly component: number
/** Sub-tiles of the largest walkable region that holds floor. */
readonly mainRegion: number
}
interface ScreenStats {
readonly litShare: number
readonly colours: number
}
interface Verdict {
readonly label: string
readonly act: number
readonly levelId: number
readonly ok: boolean
readonly problems: readonly string[]
readonly state: PageState | null
readonly spawn: SpawnCheck | null
readonly screen: ScreenStats | null
readonly screenshot: string | null
readonly ms: number
/** Known-absent URLs the page asked for ({@link KNOWN_ABSENT}); reported, not failed. */
readonly knownAbsent: readonly string[]
}
interface AuditContext {
readonly baseUrl: string
readonly packDir: string
readonly packPath: string
readonly outDir: string
readonly timeoutMs: number
readonly shots: 'all' | ReadonlySet<number>
}
// ---------------------------------------------------------------------------------------------
// DevTools protocol
interface CdpEvent {
readonly method: string
readonly params: Record<string, unknown>
}
interface CdpReply {
readonly id?: number
readonly method?: string
readonly params?: Record<string, unknown>
readonly result?: unknown
readonly error?: { readonly message: string }
}
/** One DevTools WebSocket: numbered commands and an event stream. */
class CdpSession {
private nextId = 1
private readonly pending = new Map<number, { resolve: (value: unknown) => void; reject: (error: Error) => void }>()
private listener: ((event: CdpEvent) => void) | null = null
private constructor(private readonly socket: WebSocket) {
socket.onmessage = message => {
const reply = JSON.parse(String(message.data)) as CdpReply
if (reply.id !== undefined) {
const waiter = this.pending.get(reply.id)
if (waiter === undefined) return
this.pending.delete(reply.id)
if (reply.error !== undefined) waiter.reject(new Error(reply.error.message))
else waiter.resolve(reply.result)
} else if (reply.method !== undefined) {
this.listener?.({ method: reply.method, params: reply.params ?? {} })
}
}
socket.onclose = () => {
for (const waiter of this.pending.values()) waiter.reject(new Error('the DevTools socket closed'))
this.pending.clear()
}
}
static async connect(url: string): Promise<CdpSession> {
const socket = new WebSocket(url)
await new Promise<void>((done, fail) => {
socket.onopen = () => done()
socket.onerror = () => fail(new Error(`cannot open ${url}`))
})
return new CdpSession(socket)
}
onEvent(listener: (event: CdpEvent) => void): void {
this.listener = listener
}
send<T>(method: string, params: Record<string, unknown> = {}): Promise<T> {
const id = this.nextId++
return new Promise<T>((done, fail) => {
const timer = setTimeout(() => {
this.pending.delete(id)
fail(new Error(`${method} got no answer within ${String(COMMAND_TIMEOUT_MS / 1000)} s`))
}, COMMAND_TIMEOUT_MS)
this.pending.set(id, {
resolve: value => { clearTimeout(timer); done(value as T) },
reject: error => { clearTimeout(timer); fail(error) },
})
this.socket.send(JSON.stringify({ id, method, params }))
})
}
close(): void {
this.socket.close()
}
}
/** A headless Chrome with its own profile; every audited entry gets a fresh tab. */
class Browser {
private constructor(
private readonly child: ChildProcess,
private readonly profile: string,
private readonly port: number,
) {}
static async launch(bin: string): Promise<Browser> {
const profile = mkdtempSync(join(tmpdir(), 'level-audit-'))
const child = spawn(bin, [
'--headless=new', '--no-sandbox', '--disable-dev-shm-usage', '--no-first-run', '--no-default-browser-check',
`--window-size=${String(WINDOW.width)},${String(WINDOW.height)}`, '--force-device-scale-factor=1',
// Software WebGL2: there is no GPU here, and SwiftShader runs the real renderer path.
'--use-angle=swiftshader', '--use-gl=angle', '--enable-unsafe-swiftshader', '--ignore-gpu-blocklist',
// A tab must keep animating while the next one opens.
'--disable-background-timer-throttling', '--disable-renderer-backgrounding', '--disable-backgrounding-occluded-windows',
// gLinux routes even 127.0.0.1 through its PAC proxy unless told otherwise (scripts/browser/README.md).
'--no-proxy-server',
// Without this every HTTP request hangs before it is sent: the cookie store waits for the OS
// keyring (Secret Service over D-Bus), which never answers a headless session. The netlog shows
// the main-frame request stop after COMPUTED_PRIVACY_MODE; data: URLs, which need no cookies,
// still load. The basic store keeps the cookie key in the profile.
'--password-store=basic',
// Nothing but the page under audit: no extension may sit between the tab and the dev server.
'--disable-extensions', '--disable-component-extensions-with-background-pages',
`--user-data-dir=${profile}`, '--remote-debugging-port=0', 'about:blank',
], { stdio: ['ignore', 'ignore', 'pipe'] })
let stderr = ''
child.stderr?.on('data', (chunk: Buffer) => { stderr += chunk.toString() })
const portFile = join(profile, 'DevToolsActivePort')
for (let attempt = 0; attempt < 200; attempt += 1) {
await sleep(100)
if (child.exitCode !== null) throw new Error(`Chrome exited with ${String(child.exitCode)}: ${stderr.slice(-400)}`)
if (!existsSync(portFile)) continue
const port = Number(readFileSync(portFile, 'utf8').split('\n')[0])
if (Number.isInteger(port) && port > 0) return new Browser(child, profile, port)
}
child.kill('SIGKILL')
throw new Error(`Chrome opened no DevTools port within 20 s: ${stderr.slice(-400)}`)
}
async openTab(): Promise<{ readonly id: string; readonly session: CdpSession }> {
const response = await fetch(`http://127.0.0.1:${String(this.port)}/json/new?about:blank`, {
method: 'PUT', signal: AbortSignal.timeout(COMMAND_TIMEOUT_MS),
})
if (!response.ok) throw new Error(`DevTools /json/new answered HTTP ${String(response.status)}`)
const target = await response.json() as { id: string; webSocketDebuggerUrl: string }
return { id: target.id, session: await CdpSession.connect(target.webSocketDebuggerUrl) }
}
async closeTab(id: string): Promise<void> {
const response = await fetch(`http://127.0.0.1:${String(this.port)}/json/close/${id}`, { signal: AbortSignal.timeout(COMMAND_TIMEOUT_MS) })
if (!response.ok) throw new Error(`DevTools /json/close answered HTTP ${String(response.status)}`)
}
async close(): Promise<void> {
if (this.child.exitCode === null) {
const exited = once(this.child, 'exit')
this.child.kill('SIGKILL')
await exited
}
rmSync(this.profile, { recursive: true, force: true })
}
}
// ---------------------------------------------------------------------------------------------
// Checks
function text(value: unknown): string {
return typeof value === 'string' ? value : JSON.stringify(value)
}
/**
* Requests that fail on every page by design and belong to no level: Chrome's own favicon probe,
* and the missile art loadMissileArtMap (src/scene/act-scene.ts) looks for under each of its three
* candidate bases before it aliases exactly these four missiles to the firebolt / lightningstrike
* art (no pack bakes them). They are counted in the report instead of failing the entry; any other
* failed request still fails it.
*/
const KNOWN_ABSENT = /\/favicon\.ico$|\/missiles\/(?:hydra|hydrafire|lightning|lightningbolt)\.(?:json|png)$/
/** Record whatever the page reports as broken: exceptions, console errors, failed or erroring requests. */
function collectPageError(event: CdpEvent, requests: Map<string, string>, errors: Set<string>, knownAbsent: Set<string>): void {
const params = event.params
switch (event.method) {
case 'Network.requestWillBeSent': {
const request = params.request as { url?: string } | undefined
requests.set(text(params.requestId), request?.url ?? '')
break
}
case 'Network.responseReceived': {
const response = params.response as { status?: number; url?: string } | undefined
if (response?.status !== undefined && response.status >= 400) {
const url = response.url ?? ''
if (response.status === 404 && KNOWN_ABSENT.test(url)) knownAbsent.add(url)
else errors.add(`HTTP ${String(response.status)} ${url}`)
}
break
}
case 'Network.loadingFailed':
if (params.canceled !== true) {
errors.add(`request failed (${text(params.errorText)}): ${requests.get(text(params.requestId)) ?? text(params.requestId)}`)
}
break
case 'Runtime.exceptionThrown': {
const details = params.exceptionDetails as { text?: string; exception?: { description?: string } } | undefined
const description = details?.exception?.description ?? details?.text ?? 'exception'
errors.add(`uncaught ${description.split('\n').slice(0, 2).join(' | ').slice(0, 400)}`)
break
}
case 'Runtime.consoleAPICalled':
if (params.type === 'error' || params.type === 'assert') {
const args = (params.args as { value?: unknown; description?: string; type?: string }[] | undefined) ?? []
const message = args.map(arg => arg.value !== undefined ? text(arg.value) : arg.description ?? arg.type ?? '').join(' ')
errors.add(`console.${text(params.type)}: ${message.slice(0, 400)}`)
}
break
case 'Log.entryAdded': {
const entry = params.entry as { level?: string; source?: string; text?: string; url?: string } | undefined
if (entry?.level !== 'error') break
// Chrome's console line for a 404 already counted above.
if (entry.source === 'network' && entry.url !== undefined && KNOWN_ABSENT.test(entry.url) && entry.text?.includes('status of 404') === true) {
knownAbsent.add(entry.url)
break
}
errors.add(`${entry.source ?? 'log'}: ${entry.text ?? ''}${entry.url ? ` (${entry.url})` : ''}`)
break
}
default:
break
}
}
async function readState(session: CdpSession): Promise<PageState | null> {
const reply = await session.send<{ result: { value?: PageState | null }; exceptionDetails?: unknown }>(
'Runtime.evaluate', { expression: STATE_EXPRESSION, returnByValue: true },
)
if (reply.exceptionDetails !== undefined) throw new Error(`reading the scene state threw: ${text(reply.exceptionDetails).slice(0, 300)}`)
return reply.result.value ?? null
}
async function waitForState(
session: CdpSession,
done: (state: PageState) => boolean,
deadline: number,
): Promise<PageState | null> {
let state = await readState(session)
while ((state === null || !done(state)) && Date.now() < deadline) {
await sleep(POLL_MS)
state = await readState(session)
}
return state
}
function decodeCollision(collision: SceneJson['collision']): Uint8Array {
const blocked = new Uint8Array(collision.width * collision.height)
let at = 0
for (const run of collision.runs) {
const value = run[0]!
const length = run[1]!
if (value !== 0) blocked.fill(value, at, Math.min(at + length, blocked.length))
at += length
}
if (at !== blocked.length) throw new Error(`collision runs cover ${String(at)} sub-tiles, the grid has ${String(blocked.length)}`)
return blocked
}
/** Where the player stands, judged on the scene's own collision map and floor list. */
function checkSpawn(scene: SceneJson, x: number, y: number): SpawnCheck {
const width = scene.collision.width
const height = scene.collision.height
if (width !== scene.cellsX * SUB_TILES_PER_TILE || height !== scene.cellsY * SUB_TILES_PER_TILE) {
throw new Error(`collision grid ${String(width)}x${String(height)} does not match ${String(scene.cellsX)}x${String(scene.cellsY)} cells`)
}
const blocked = decodeCollision(scene.collision)
const floorCells = new Uint8Array(scene.cellsX * scene.cellsY)
for (const row of scene.floors) {
const cellX = row[3]!
const cellY = row[4]!
if (cellX >= 0 && cellX < scene.cellsX && cellY >= 0 && cellY < scene.cellsY) floorCells[cellY * scene.cellsX + cellX] = 1
}
const hasFloor = (cellX: number, cellY: number): boolean =>
cellX >= 0 && cellX < scene.cellsX && cellY >= 0 && cellY < scene.cellsY && floorCells[cellY * scene.cellsX + cellX] === 1
const grid: CollisionGrid = {
originX: scene.originX, originY: scene.originY, cellsX: scene.cellsX, cellsY: scene.cellsY, blocked, gridWidth: width,
}
const { subX, subY, inBounds } = subTileAt(grid, x, y)
const region = largestWalkableRegionWithFloors({ cellsX: scene.cellsX, cellsY: scene.cellsY, gridWidth: width, gridHeight: height, blocked }, hasFloor)
let mainRegion = 0
for (const inside of region) mainRegion += inside
const at = subY * width + subX
const walkable = inBounds && blocked[at] === 0
// The component the player stands in, four-connected like the region finder.
let component = 0
if (walkable) {
const seen = new Uint8Array(blocked.length)
const stack = [at]
seen[at] = 1
while (stack.length > 0) {
const here = stack.pop()!
component += 1
const hx = here % width
const neighbours = [
hx > 0 ? here - 1 : -1,
hx < width - 1 ? here + 1 : -1,
here >= width ? here - width : -1,
here + width < blocked.length ? here + width : -1,
]
for (const next of neighbours) {
if (next >= 0 && seen[next] === 0 && blocked[next] === 0) {
seen[next] = 1
stack.push(next)
}
}
}
}
return {
subX,
subY,
inBounds,
walkable,
floor: inBounds && hasFloor(Math.floor(subX / SUB_TILES_PER_TILE), Math.floor(subY / SUB_TILES_PER_TILE)),
inMainRegion: walkable && region[at] === 1,
component,
mainRegion,
}
}
/** Decode an 8-bit, non-interlaced RGB or RGBA PNG (what Page.captureScreenshot returns). */
function decodePng(png: Buffer): { width: number; height: number; channels: number; pixels: Uint8Array } {
const signature = [137, 80, 78, 71, 13, 10, 26, 10]
if (signature.some((byte, at) => png[at] !== byte)) throw new Error('the screenshot is not a PNG')
let width = 0
let height = 0
let bitDepth = 0
let colourType = -1
let interlace = 0
const chunks: Buffer[] = []
for (let offset = 8; offset < png.length;) {
const length = png.readUInt32BE(offset)
const type = png.toString('latin1', offset + 4, offset + 8)
const data = png.subarray(offset + 8, offset + 8 + length)
if (type === 'IHDR') {
width = data.readUInt32BE(0)
height = data.readUInt32BE(4)
bitDepth = data[8]!
colourType = data[9]!
interlace = data[12]!
} else if (type === 'IDAT') {
chunks.push(data)
} else if (type === 'IEND') {
break
}
offset += 12 + length
}
if (bitDepth !== 8 || interlace !== 0 || (colourType !== 2 && colourType !== 6)) {
throw new Error(`unsupported screenshot PNG: depth ${String(bitDepth)}, colour type ${String(colourType)}, interlace ${String(interlace)}`)
}
const channels = colourType === 6 ? 4 : 3
const raw = inflateSync(Buffer.concat(chunks))
const stride = width * channels
if (raw.length !== height * (stride + 1)) throw new Error('truncated screenshot PNG')
const pixels = new Uint8Array(height * stride)
for (let row = 0; row < height; row += 1) {
const filter = raw[row * (stride + 1)]!
const src = row * (stride + 1) + 1
const dst = row * stride
for (let i = 0; i < stride; i += 1) {
const left = i >= channels ? pixels[dst + i - channels]! : 0
const up = row > 0 ? pixels[dst - stride + i]! : 0
const upLeft = row > 0 && i >= channels ? pixels[dst - stride + i - channels]! : 0
const value = raw[src + i]!
let out: number
switch (filter) {
case 0: out = value; break
case 1: out = value + left; break
case 2: out = value + up; break
case 3: out = value + ((left + up) >> 1); break
case 4: {
const estimate = left + up - upLeft
const dLeft = Math.abs(estimate - left)
const dUp = Math.abs(estimate - up)
const dUpLeft = Math.abs(estimate - upLeft)
out = value + (dLeft <= dUp && dLeft <= dUpLeft ? left : dUp <= dUpLeft ? up : upLeft)
break
}
default: throw new Error(`bad PNG filter ${String(filter)}`)
}
pixels[dst + i] = out & 0xff
}
}
return { width, height, channels, pixels }
}
/** How much of the map area of a screenshot is lit, and how many colours it shows. */
function screenStats(png: Buffer): ScreenStats {
const image = decodePng(png)
const rows = Math.floor(image.height * MAP_SHARE_OF_HEIGHT)
const colours = new Set<number>()
let lit = 0
let sampled = 0
for (let row = 0; row < rows; row += 2) {
for (let column = 0; column < image.width; column += 2) {
const at = (row * image.width + column) * image.channels
const r = image.pixels[at]!
const g = image.pixels[at + 1]!
const b = image.pixels[at + 2]!
sampled += 1
if (Math.max(r, g, b) > 24) lit += 1
colours.add(((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3))
}
}
return { litShare: lit / sampled, colours: colours.size }
}
async function auditEntry(browser: Browser, entry: IndexEntry, context: AuditContext): Promise<Verdict> {
const started = Date.now()
const deadline = started + context.timeoutMs
const problems: string[] = []
const pageErrors = new Set<string>()
const knownAbsent = new Set<string>()
const requests = new Map<string, string>()
let state: PageState | null = null
let spawnCheck: SpawnCheck | null = null
let screen: ScreenStats | null = null
let screenshot: string | null = null
const scene = JSON.parse(readFileSync(join(context.packDir, entry.path, 'scene.json'), 'utf8')) as SceneJson
if ((entry.missingTiles ?? 0) !== 0 || scene.stats.missingTiles !== 0) problems.push(`missing tiles: index ${String(entry.missingTiles)}, scene ${String(scene.stats.missingTiles)}`)
if ((scene.stats.missingRefs?.length ?? 0) !== 0) problems.push(`unresolved tile references: ${text(scene.stats.missingRefs).slice(0, 300)}`)
if ((entry.unplacedEdges ?? 0) !== 0 || (scene.stats.unplacedEdges?.length ?? 0) !== 0) problems.push(`unplaced link edges: ${text(scene.stats.unplacedEdges).slice(0, 300)}`)
const { id, session } = await browser.openTab()
try {
session.onEvent(event => collectPageError(event, requests, pageErrors, knownAbsent))
await session.send('Runtime.enable')
await session.send('Log.enable')
await session.send('Network.enable')
await session.send('Page.enable')
const query = new URLSearchParams({ act: String(entry.act), level: entry.label, pack: context.packPath, lighting: 'noon' })
await session.send('Page.navigate', { url: `${context.baseUrl}/acts.html?${query.toString()}` })
const atReady = await waitForState(session, s => s.ready || s.error !== null, deadline)
if (atReady === null) {
problems.push('the page never published window.__d2webAct')
} else if (atReady.error !== null) {
problems.push(`scene error: ${atReady.error}`)
} else if (!atReady.ready) {
problems.push(`not ready after ${String(context.timeoutMs / 1000)} s`)
} else {
if (atReady.source !== 'pack') problems.push(`loaded from "${atReady.source}", not from the pack`)
if (atReady.act !== entry.act || atReady.variant !== entry.label) problems.push(`showed act ${String(atReady.act)} "${atReady.variant}"`)
const drawn = await waitForState(
session,
s => s.error !== null || (s.pagesLoaded >= s.pagesTotal && s.pagesAtFirstFrame >= 0 && s.tick > 0 && s.drawCalls > 0),
deadline,
)
// The spawn is read from the first ticked state: `ready` is published before the frame loop
// first writes the player position (state.x/y are written together with state.tick).
if (drawn === null || drawn.tick <= 0) {
problems.push('no simulation tick, so no spawn position to check')
} else {
spawnCheck = checkSpawn(scene, drawn.x, drawn.y)
if (!spawnCheck.inBounds) problems.push(`spawn outside the map at (${String(drawn.x)}, ${String(drawn.y)})`)
else if (!spawnCheck.walkable) problems.push(`spawn on a blocked sub-tile (${String(spawnCheck.subX)}, ${String(spawnCheck.subY)})`)
else if (!spawnCheck.inMainRegion) problems.push(`spawn in a walkable pocket of ${String(spawnCheck.component)} sub-tiles, outside the main region of ${String(spawnCheck.mainRegion)}`)
if (spawnCheck.inBounds && !spawnCheck.floor) problems.push(`spawn on a cell without a floor tile (sub-tile ${String(spawnCheck.subX)}, ${String(spawnCheck.subY)})`)
}
await sleep(SETTLE_MS)
state = await readState(session)
if (state === null) {
problems.push('the scene state disappeared')
} else {
if (state.error !== null) problems.push(`scene error after ready: ${state.error}`)
if (state.act !== entry.act || state.variant !== entry.label) problems.push(`switched by itself to act ${String(state.act)} "${state.variant}"`)
if (drawn === null || state.pagesLoaded < state.pagesTotal) problems.push(`atlas pages loaded ${String(state.pagesLoaded)}/${String(state.pagesTotal)}`)
if (state.pagesAtFirstFrame < 0) problems.push('no frame drawn')
if (state.tick <= 0) problems.push('the simulation does not tick')
if (state.drawCalls <= 0 || state.quadsDrawn <= 0) problems.push(`nothing drawn (draw calls ${String(state.drawCalls)}, quads ${String(state.quadsDrawn)})`)
if (state.floors <= 0 || state.frames <= 0) problems.push(`empty map (floors ${String(state.floors)}, frames ${String(state.frames)})`)
if (state.cellsX !== scene.cellsX || state.cellsY !== scene.cellsY) problems.push(`page shows ${String(state.cellsX)}x${String(state.cellsY)} cells, the scene has ${String(scene.cellsX)}x${String(scene.cellsY)}`)
if (state.missingMonsterArt.length > 0) problems.push(`monsters without art: ${state.missingMonsterArt.join(', ')}`)
if (state.monsterArtErrors !== 0 || state.monsterArtLayerFailures !== 0) problems.push(`monster art failures: ${String(state.monsterArtErrors)} loads, ${String(state.monsterArtLayerFailures)} layers`)
}
const shot = await session.send<{ data: string }>('Page.captureScreenshot', { format: 'png' })
const png = Buffer.from(shot.data, 'base64')
screen = screenStats(png)
if (screen.litShare < MIN_LIT_SHARE || screen.colours < MIN_COLOURS) {
problems.push(`blank screen (lit ${(screen.litShare * 100).toFixed(1)}%, ${String(screen.colours)} colours)`)
}
if (context.shots === 'all' || context.shots.has(entry.levelId) || problems.length > 0 || pageErrors.size > 0) {
screenshot = join(context.outDir, `${entry.label}.png`)
writeFileSync(screenshot, png)
}
}
if (state === null) state = atReady
} finally {
session.close()
await browser.closeTab(id)
}
for (const error of pageErrors) problems.push(error)
return {
label: entry.label,
act: entry.act,
levelId: entry.levelId,
ok: problems.length === 0,
problems,
state,
spawn: spawnCheck,
screen,
screenshot,
ms: Date.now() - started,
knownAbsent: [...knownAbsent].sort(),
}
}
// ---------------------------------------------------------------------------------------------
// Driver
function parseIds(spec: string): Set<number> {
const ids = new Set<number>()
for (const part of spec.split(',')) {
const range = /^(\d+)(?:-(\d+))?$/.exec(part.trim())
if (range === null) throw new Error(`bad level list "${spec}"`)
const from = Number(range[1])
const to = range[2] === undefined ? from : Number(range[2])
if (to < from) throw new Error(`bad level range "${part}"`)
for (let levelId = from; levelId <= to; levelId += 1) ids.add(levelId)
}
return ids
}
function parseArgs(argv: readonly string[]): Map<string, string> {
const known = new Set(['pack', 'out', 'jobs', 'act', 'levels', 'shots', 'timeout', 'chrome'])
const args = new Map<string, string>()
for (const arg of argv) {
const match = /^--([a-z]+)=(.+)$/.exec(arg)
if (match === null || !known.has(match[1]!)) throw new Error(`unknown argument ${arg} (options: ${[...known].map(key => `--${key}=`).join(' ')})`)
args.set(match[1]!, match[2]!)
}
return args
}
function positiveInteger(value: string, name: string): number {
const number = Number(value)
if (!Number.isInteger(number) || number < 1) throw new Error(`--${name} must be a positive integer, got ${value}`)
return number
}
async function main(): Promise<void> {
const args = parseArgs(process.argv.slice(2))
const packDir = resolve(ROOT, args.get('pack') ?? 'samples/d2-packs')
const packPath = relative(ROOT, packDir).split(sep).join('/')
if (packPath === '' || packPath.startsWith('..')) throw new Error(`--pack must be a directory inside ${ROOT}: the dev server serves only the repository`)
const index = JSON.parse(readFileSync(join(packDir, 'index.json'), 'utf8')) as { levels: IndexEntry[] }
const jobs = positiveInteger(args.get('jobs') ?? '6', 'jobs')
const timeoutMs = positiveInteger(args.get('timeout') ?? '180', 'timeout') * 1000
const outDir = resolve(args.get('out') ?? '/tmp/level-audit')
mkdirSync(outDir, { recursive: true })
const act = args.has('act') ? positiveInteger(args.get('act')!, 'act') : undefined
const levels = args.has('levels') ? parseIds(args.get('levels')!) : undefined
const shotsSpec = args.get('shots') ?? DEFAULT_SHOTS
const shots = shotsSpec === 'all' ? 'all' : shotsSpec === 'none' ? new Set<number>() : parseIds(shotsSpec)
const chrome = args.get('chrome') ?? CHROME_CANDIDATES.find(candidate => existsSync(candidate))
if (chrome === undefined || !existsSync(chrome)) throw new Error(`no Chrome binary; tried ${CHROME_CANDIDATES.join(', ')} (pass --chrome=)`)
const entries = index.levels.filter(entry => (act === undefined || entry.act === act) && (levels === undefined || levels.has(entry.levelId)))
if (entries.length === 0) throw new Error('no index entry matches the filters')
const coverageProblems: string[] = []
if (act === undefined && levels === undefined) {
const present = new Set(entries.map(entry => entry.levelId))
const absent: number[] = []
for (let levelId = 1; levelId <= LEVEL_COUNT; levelId += 1) if (!present.has(levelId)) absent.push(levelId)
if (absent.length > 0) coverageProblems.push(`the pack has no map for level ids ${absent.join(', ')}`)
}
const server = await createServer({
root: ROOT,
configFile: join(ROOT, 'vite.config.ts'),
logLevel: 'error',
clearScreen: false,
server: { host: '127.0.0.1', port: 5600 + Math.floor(Math.random() * 300), strictPort: false },
})
await server.listen()
const address = server.httpServer?.address()
if (address === null || address === undefined || typeof address === 'string') throw new Error('the dev server has no TCP address')
const context: AuditContext = { baseUrl: `http://127.0.0.1:${String(address.port)}`, packDir, packPath, outDir, timeoutMs, shots }
console.log(`auditing ${String(entries.length)} maps of ${packPath} (${String(new Set(entries.map(entry => entry.levelId)).size)} level ids) with ${String(jobs)} browsers; dev server ${context.baseUrl}; Chrome ${chrome}`)
const browsers: Browser[] = []
const verdicts: Verdict[] = []
const started = Date.now()
try {
for (let i = 0; i < Math.min(jobs, entries.length); i += 1) browsers.push(await Browser.launch(chrome))
const queue = [...entries]
const report = (verdict: Verdict): void => {
verdicts.push(verdict)
const tail = verdict.ok ? `${(verdict.ms / 1000).toFixed(1)} s` : verdict.problems.join(' ; ')
console.log(`[${String(verdicts.length).padStart(3)}/${String(entries.length)}] ${verdict.ok ? 'ok ' : 'FAIL'} ${verdict.label.padEnd(44)} ${tail}`)
}
const run = async (browser: Browser, entry: IndexEntry): Promise<void> => {
try {
report(await auditEntry(browser, entry, context))
} catch (error) {
report({
label: entry.label, act: entry.act, levelId: entry.levelId, ok: false,
problems: [`audit error: ${(error as Error).message}`], state: null, spawn: null, screen: null, screenshot: null, ms: 0,
knownAbsent: [],
})
}
}
// One page first: it makes the dev server transform the modules once instead of in every tab.
await run(browsers[0]!, queue.shift()!)
await Promise.all(browsers.map(async browser => {
for (let entry = queue.shift(); entry !== undefined; entry = queue.shift()) await run(browser, entry)
}))
} finally {
for (const browser of browsers) await browser.close()
await server.close()
}
const order = new Map(entries.map((entry, at) => [entry.label, at]))
verdicts.sort((a, b) => order.get(a.label)! - order.get(b.label)!)
const failed = verdicts.filter(verdict => !verdict.ok)
const failedIds = new Set(failed.map(verdict => verdict.levelId))
const knownAbsent = [...new Set(verdicts.flatMap(verdict => verdict.knownAbsent))].sort()
writeFileSync(join(outDir, 'report.json'), JSON.stringify({
pack: packPath,
generated: new Date().toISOString(),
maps: verdicts.length,
levelIds: new Set(verdicts.map(verdict => verdict.levelId)).size,
failedMaps: failed.length,
coverageProblems,
knownAbsent,
verdicts: verdicts.map(verdict => ({ ...verdict, knownAbsent: verdict.knownAbsent.length })),
}, null, 1))
console.log(`\n${String(verdicts.length - failed.length)}/${String(verdicts.length)} maps passed, ${String(new Set(verdicts.map(v => v.levelId)).size - failedIds.size)}/${String(new Set(verdicts.map(v => v.levelId)).size)} level ids clean, in ${((Date.now() - started) / 1000).toFixed(0)} s; report ${join(outDir, 'report.json')}`)
if (knownAbsent.length > 0) console.log(`known-absent requests (reported, not failed): ${knownAbsent.join(', ')}`)
for (const problem of coverageProblems) console.log(`COVERAGE: ${problem}`)
for (const verdict of failed) console.log(`FAIL ${verdict.label}: ${verdict.problems.join(' ; ')}`)
if (failed.length > 0 || coverageProblems.length > 0) process.exitCode = 1
}
await main()

37
scripts/drlg-fixtures.ts
View File

@ -1,37 +0,0 @@
/**
* Regenerates the committed native-oracle fixtures of tests/drlg-act1-oracle.test.ts.
*
* Each fixture is the D2MOO oracle's dump (tools/d2moo-oracle, schema 3) of the Act I outdoor levels
* for one game seed: difficulty 0, one shared act, every room activated through
* DRLGROOMTILE_AddRoomMapTiles. The test diffs the TypeScript port against them without needing the
* native binary.
*
* Usage: npx tsx scripts/drlg-fixtures.ts [output-directory]
*/
import { mkdirSync, writeFileSync } from 'node:fs'
import { join, resolve } from 'node:path'
import { gzipSync } from 'node:zlib'
import { act1OutdoorLevelIds } from '../src/game/drlg/drlg-map.ts'
import { loadDrlgTables } from '../src/game/drlg/drlg-tables.ts'
import { fsDrlgSource, ORACLE_DATA, runOracle } from './lib/drlg-oracle.ts'
/** The seeds the test pins: an arbitrary one plus the three Act I layouts the bake ships (0x5eed0100 + v). */
export const DRLG_FIXTURE_SEEDS: readonly number[] = [0x12345678, 0x5eed0100, 0x5eed0101, 0x5eed0102]
function main(): void {
const outDir = resolve(process.argv[2] ?? join(import.meta.dirname, '../tests/fixtures/d2moo-oracle'))
mkdirSync(outDir, { recursive: true })
const levels = act1OutdoorLevelIds(loadDrlgTables(fsDrlgSource(ORACLE_DATA)))
for (const seed of DRLG_FIXTURE_SEEDS) {
const { doc } = runOracle({ seed, levels, difficulty: 0, isolated: false })
if (doc.schema !== 3) throw new Error(`oracle wrote schema ${String(doc.schema)}, expected 3 (rebuild it with tools/d2moo-oracle/build.sh)`)
const json = JSON.stringify(doc)
const path = join(outDir, `act1-seed-${(seed >>> 0).toString(16).padStart(8, '0')}.json.gz`)
const gz = gzipSync(json, { level: 9 })
writeFileSync(path, gz)
console.log(`${path}: ${(json.length / 1048576).toFixed(1)} MB JSON, ${(gz.length / 1024).toFixed(0)} KB gzip`)
}
}
if (import.meta.url === `file://${process.argv[1]}`) main()

165
scripts/lib/drlg-mpq-source.ts
View File

@ -1,165 +0,0 @@
/**
* MPQ-backed game data for the DRLG port (offline bake and tooling).
*
* The port reads its inputs synchronously, exactly like D2Common does from the mounted archives
* (see src/game/drlg/drlg-source.ts). MPQ reads are asynchronous, so this module preloads every file
* the port can open for one act and serves them from memory:
* - the compiled tables `data\global\excel\<name>.bin` ({@link DRLG_TABLE_NAMES});
* - every DS1 the tables reference (LvlPrest File1..6, LvlSub File), for all acts, because level
* generation behind warps (sub_6FD77BB0 -> DRLG_InitLevel) opens presets of any level it reaches;
* - the DT1 libraries of the act's level types (LvlTypes File1..32, loaded by
* DRLGROOMTILE_LoadDT1FilesForRoom for activated rooms) plus the hardcoded libraries of
* DRLGROOMTILE_LoadDT1FilesForRoom (DrlgRoomTile.cpp:1249-1256) and DRLG_AllocDrlg
* (DrlgDrlg.cpp:47-76).
* Anything else is not loaded and reading it throws (memoryDrlgSource), so a gap fails the bake
* instead of silently changing the generated map. The file list is the same one
* scripts/extract-d2moo-tables.ts extracts for the native oracle (the DT1 list restricted to the act),
* and the reads use the game's archive priority, so the bake and the oracle consume identical bytes.
*/
import { decodeDt1, type Dt1 } from '../../src/formats/dt1.ts'
import { cell, type D2Table } from '../../src/game/acts.ts'
import type { DrlgLevelInput } from '../../src/game/drlg/drlg-map.ts'
import { loadDrlgTables, type DrlgDataSource, type DrlgTableName, type DrlgTables } from '../../src/game/drlg/drlg-tables.ts'
import { DRLG_TABLE_NAMES, drlgReferencedDs1Files, memoryDrlgSource, normalizeDrlgPath } from '../../src/game/drlg/drlg-source.ts'
/**
* DT1 libraries D2Common opens by hardcoded name (full archive paths, as the port requests them):
* the three universal libraries of DRLGROOMTILE_LoadDT1FilesForRoom (Blank, InvisWal, Warp) and the
* act libraries of DRLG_AllocDrlg.
*/
export const DRLG_HARDCODED_DT1_FILES: readonly string[] = [
'DATA\\GLOBAL\\TILES\\Act1\\Outdoors\\Blank.dt1',
'DATA\\GLOBAL\\TILES\\Act1\\Barracks\\InvisWal.dt1',
'DATA\\GLOBAL\\TILES\\Act1\\Barracks\\Warp.dt1',
'DATA\\GLOBAL\\TILES\\Act1\\Town\\Floor.dt1',
'DATA\\GLOBAL\\TILES\\Act2\\Town\\Ground.dt1',
'DATA\\GLOBAL\\TILES\\ACT3\\Kurast\\sets.dt1',
]
/** Reads one archive member (backslash path, case-insensitive), throwing when it does not exist. */
export type ArchiveReader = (mpqPath: string) => Promise<Uint8Array>
export interface DrlgMpqData {
/** Synchronous source over the preloaded bytes (throws for anything not preloaded). */
readonly source: DrlgDataSource
/** The parsed tables (immutable; pass them to createDrlgEnv to avoid re-parsing). */
readonly tables: DrlgTables
/** Archive paths of the preloaded DS1 and DT1 files. */
readonly ds1Files: readonly string[]
readonly dt1Files: readonly string[]
}
/**
* DT1 libraries of every level type of one act: the non-placeholder LvlTypes File columns of the rows
* whose `Act` (D2LvlTypesTxt.nAct, 1-based as in LvlTypes.txt) is `act1Based`, plus
* {@link DRLG_HARDCODED_DT1_FILES}.
*/
export function drlgActDt1Files(t: DrlgTables, act1Based: number): string[] {
if (!Number.isInteger(act1Based) || act1Based < 1 || act1Based > 5) {
throw new Error(`drlgActDt1Files: act ${act1Based} is not 1..5`)
}
const out = new Map<string, string>()
const add = (path: string): void => {
const key = normalizeDrlgPath(path)
if (!out.has(key)) out.set(key, path)
}
let rows = 0
for (const rec of t.lvlTypes) {
if (rec.nAct !== act1Based) continue
rows += 1
// DATATBLS_LoadLevelTypesTxt leaves names of one character or less ("0", "") unprefixed: they are
// unused slots that DRLGROOMTILE_LoadDT1FilesForRoom never opens.
for (const f of rec.szFile) if (f.length > 1) add(f)
}
if (rows === 0) throw new Error(`drlgActDt1Files: LvlTypes has no rows for act ${act1Based}`)
for (const f of DRLG_HARDCODED_DT1_FILES) add(f)
return [...out.values()].sort((a, b) => normalizeDrlgPath(a).localeCompare(normalizeDrlgPath(b)))
}
/** The compiled tables `data\global\excel\<name>.bin` of {@link DRLG_TABLE_NAMES}. */
async function readDrlgTableBytes(read: ArchiveReader): Promise<Map<DrlgTableName, Uint8Array>> {
const tableBytes = new Map<DrlgTableName, Uint8Array>()
for (const name of DRLG_TABLE_NAMES) {
tableBytes.set(name, await read(`data\\global\\excel\\${name}.bin`))
}
return tableBytes
}
/**
* Load only the compiled tables: enough to map a generated level (src/game/drlg/drlg-map.ts), not to
* generate one.
*
* @param read - archive reader with the game's priority (e.g. MountedArchives.read).
*/
export async function loadDrlgMpqTables(read: ArchiveReader): Promise<DrlgTables> {
return loadDrlgTables(memoryDrlgSource(await readDrlgTableBytes(read), new Map()))
}
/**
* Preload the DRLG inputs for one act from the archives.
*
* @param read - archive reader with the game's priority (e.g. MountedArchives.read).
* @param act1Based - the act whose level types' DT1 libraries are loaded (1..5).
*/
export async function loadDrlgMpqData(read: ArchiveReader, act1Based: number): Promise<DrlgMpqData> {
const tableBytes = await readDrlgTableBytes(read)
const tables = loadDrlgTables(memoryDrlgSource(tableBytes, new Map()))
const files = new Map<string, Uint8Array>()
const ds1Files = drlgReferencedDs1Files(tables)
const dt1Files = drlgActDt1Files(tables, act1Based)
for (const path of [...ds1Files, ...dt1Files]) {
const key = normalizeDrlgPath(path)
if (!files.has(key)) files.set(key, await read(path))
}
return { source: memoryDrlgSource(tableBytes, files), tables, ds1Files, dt1Files }
}
/**
* SuperUniques.txt `Superunique` ids in record order: the landmark ids of SuperUnique preset units
* (src/game/drlg/drlg-map.ts `DrlgMapContext.superUniqueIds`).
*
* The compiled table has no record for the text file's `Expansion` separator row, so the text rows are
* filtered the same way; each remaining row's `hcIdx` must equal its record index and the row count
* must equal the compiled table's.
*
* @param superuniques - SuperUniques.txt.
* @param tables - the compiled tables the DRLG uses.
* @returns the ids, by SuperUniques record.
*/
export function drlgSuperUniqueIds(superuniques: D2Table, tables: DrlgTables): string[] {
const ids = superuniques.rows
.filter(row => cell(superuniques, row, 'Superunique') !== 'Expansion')
.map((row, at) => {
const hcIdx = Number(cell(superuniques, row, 'hcIdx'))
if (hcIdx !== at) throw new Error(`SuperUniques.txt record ${String(at)} has hcIdx ${String(hcIdx)}`)
return cell(superuniques, row, 'Superunique').trim()
})
if (ids.length !== tables.nSuperUniquesTxtRecordCount) {
throw new Error(`SuperUniques.txt has ${String(ids.length)} records, superuniques.bin ${String(tables.nSuperUniquesTxtRecordCount)}`)
}
return ids
}
/**
* The decoded DT1 libraries the tiles of one generated level come from, read through a synchronous
* DRLG source (the same bytes the generator loaded).
*
* @param input - the level, from src/game/drlg/drlg-map.ts `drlgLevelInputFromDump`.
* @param source - the DRLG data source the level was generated from.
* @param cache - decoded libraries by normalized path, shared across levels.
* @returns the libraries the level's tiles name, by normalized path.
*/
export function drlgLevelDt1s(input: DrlgLevelInput, source: DrlgDataSource, cache: Map<string, Dt1>): Map<string, Dt1> {
const out = new Map<string, Dt1>()
for (const t of input.tiles) {
if (t.tile === null || out.has(t.tile.library)) continue
let lib = cache.get(t.tile.library)
if (lib === undefined) {
lib = decodeDt1(source.readFile(t.tile.library))
cache.set(t.tile.library, lib)
}
out.set(t.tile.library, lib)
}
return out
}

388
scripts/pack-act-assets.ts
View File

@ -34,7 +34,7 @@ import { performance } from 'node:perf_hooks'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { MountedArchives } from '../src/mpq/mount.ts'
import { cell, loadActTables, parseTable, resolveLevel, resolveLevelLibraries, tileMemberPath, townLevelForAct, ACT_TOWNS } from '../src/game/acts.ts'
import { cell, loadActTables, parseTable, resolveLevel, resolveLevelLibraries, tileMemberPath, ACT_TOWNS } from '../src/game/acts.ts'
import type { ActTables, LevelInfo, D2Table } from '../src/game/acts.ts'
import { decodeDs1 } from '../src/formats/ds1.ts'
import type { Ds1 } from '../src/formats/ds1.ts'
@ -58,20 +58,6 @@ import { generateWilderness } from '../src/game/wilderness.ts'
import type { PlannedGate, WildernessEntrance, WildernessPiece, WildernessSubstitution } from '../src/game/wilderness.ts'
import { generatePreset } from '../src/game/preset.ts'
import type { PresetPiece } from '../src/game/preset.ts'
import { act1OutdoorLevelIds, buildDrlgLevelMap, drlgLevelInputFromDump } from '../src/game/drlg/drlg-map.ts'
import type { DrlgEntrance, DrlgLevelInput } from '../src/game/drlg/drlg-map.ts'
import { dumpAct1 } from '../src/game/drlg/drlg-dump.ts'
import { createDrlgEnv } from '../src/game/drlg/drlg-source.ts'
import type { DrlgTables } from '../src/game/drlg/drlg-tables.ts'
import { WorldVariants } from '../src/game/act-variants.ts'
import type { ActLayout, VariantEntry, VariantIndex } from '../src/game/act-variants.ts'
import { drlgSuperUniqueIds, loadDrlgMpqData, loadDrlgMpqTables } from './lib/drlg-mpq-source.ts'
/**
* An entrance a generator reports: the wilderness generator's, or the DRLG adapter's (seams carry a
* span) with the display label the bake gives it.
*/
type GeneratorEntrance = WildernessEntrance | (DrlgEntrance & { readonly label: string })
export interface MazeWarp {
readonly room: number
readonly direction: 'up' | 'down'
@ -451,128 +437,6 @@ function levelNameOf(levelId: number): string {
return worldGraph.levels.get(levelId)?.name ?? `level ${String(levelId)}`
}
/* ------------------------------------------------------------------------- *
* DRLG port (Act I outdoor levels)
* ------------------------------------------------------------------------- */
/** Copies the bake makes of every act the DRLG port generates, one game seed each. */
const DRLG_ACT_VARIANTS = 3
/**
* The game seed copy `variant` of `act` is generated from.
*
* D2 generates a whole act from one seed (DRLG_AllocDrlg -> DRLGOUTPLACE_CreateLevelConnections ->
* DRLG_InitLevel), so the seed belongs to the (act, copy) pair, never to a level. Act I's three are the
* seeds of the committed oracle fixtures (tests/fixtures/d2moo-oracle/act1-seed-5eed010{0,1,2}), so every
* baked copy is one the native D2MOO oracle generates identically.
*
* @param act - act number (1..5).
* @param variant - copy number (0-based, the index entries' `actVariant`).
* @returns the game seed.
*/
function actGameSeed(act: number, variant: number): number {
return (0x5eed_0000 + act * 0x100 + variant) >>> 0
}
/**
* The levels of an act the DRLG port generates: Act I's outdoor levels (Levels.txt DrlgType 3). The
* other acts still bake through the legacy generators.
*
* @param t - the DRLG tables.
* @param act - act number (1..5).
* @returns level ids, ascending.
*/
function drlgLevelsOf(t: DrlgTables, act: number): readonly number[] {
return act === 1 ? act1OutdoorLevelIds(t) : []
}
/** One DRLG-generated copy of an act: its index record and the adapter input of each generated level. */
interface DrlgActCopy {
readonly layout: ActLayout
readonly inputs: ReadonlyMap<number, DrlgLevelInput>
}
let drlgTablesPromise: Promise<DrlgTables> | undefined
/**
* The DRLG's compiled tables, loaded once per thread (the adapter maps a level with them).
*
* @returns the tables.
*/
function drlgTables(): Promise<DrlgTables> {
drlgTablesPromise ??= loadDrlgMpqTables(member => archives.read(member))
return drlgTablesPromise
}
/**
* Generate every copy of every DRLG act that has a level to bake, on the main thread.
*
* One DRLG run per copy, as in D2: the act's outdoor levels, their seams and the town's gate come out
* of the same run, so the copy is recorded as a whole (`index.json` `actLayouts`) and the runtime uses
* one copy per act (src/game/act-variants.ts). The whole act is generated even when a filter asks for a
* single level, because no level of it exists without the others.
*
* @param wanted - whether the bake's filters select a level.
* @returns the copies by act; acts without a selected DRLG level are absent.
*/
async function generateDrlgActs(wanted: (act: number, levelId: number) => boolean): Promise<Map<number, DrlgActCopy[]>> {
const out = new Map<number, DrlgActCopy[]>()
const t = await drlgTables()
for (let act = 1; act <= 5; act += 1) {
const levels = drlgLevelsOf(t, act)
if (!levels.some(levelId => wanted(act, levelId))) continue
const data = await loadDrlgMpqData(member => archives.read(member), act)
const town = townLevelForAct(act)
const copies: DrlgActCopy[] = []
for (let variant = 0; variant < DRLG_ACT_VARIANTS; variant += 1) {
const gameSeed = actGameSeed(act, variant)
const dump = dumpAct1(createDrlgEnv(data.source, data.tables), gameSeed, levels)
const townFile = dump.act.find(level => level.id === town)?.preset?.map?.file
if (townFile === undefined || townFile === '') {
throw new Error(`act ${String(act)} seed 0x${gameSeed.toString(16)}: the generated act picked no DS1 for its town (level ${String(town)})`)
}
copies.push({
layout: { variant, gameSeed, levels: [...levels], presets: [{ levelId: town, ds1: townFile.replace(/\//g, '\\') }] },
inputs: new Map(levels.map(levelId => [levelId, drlgLevelInputFromDump(dump, levelId, data.tables)])),
})
console.log(`DRLG act ${String(act)} copy ${String(variant)} (seed 0x${gameSeed.toString(16)}): town ${townFile}`)
}
out.set(act, copies)
}
return out
}
/**
* Check that every DRLG act copy in the (merged) index resolves the way the runtime resolves it: each
* generated level has exactly one copy per variant, the town file the copy fixed is baked, and no
* other copy of a generated level is left over (e.g. from a legacy bake merged in by a filtered run).
*
* @param index - the index about to be written.
*/
function validateActLayouts(index: VariantIndex<VariantEntry>): void {
for (const [actKey, layouts] of Object.entries(index.actLayouts ?? {})) {
const act = Number(actKey)
const generated = new Set(layouts.flatMap(layout => layout.levels))
for (const entry of index.levels) {
if (entry.act === act && entry.levelId !== undefined && generated.has(entry.levelId) && entry.actVariant === undefined) {
throw new Error(`index: ${entry.label} is a copy of DRLG level ${String(entry.levelId)} without an actVariant; bake the whole act`)
}
}
for (const layout of layouts) {
// A fresh selection per copy, pinned to it the way opening one of its levels pins it.
const variants = new WorldVariants(index)
const member = index.levels.find(entry => entry.act === act && entry.actVariant === layout.variant)
if (member === undefined) throw new Error(`actLayouts[${actKey}] copy ${String(layout.variant)}: no baked level belongs to it`)
variants.pin(member)
for (const levelId of [...layout.levels, ...layout.presets.map(preset => preset.levelId)]) {
if (variants.entryForLevel(levelId) === null) {
throw new Error(`actLayouts[${actKey}] copy ${String(layout.variant)}: level ${String(levelId)} is not baked`)
}
}
if (variants.startEntry(act) === null) throw new Error(`actLayouts[${actKey}] copy ${String(layout.variant)}: no start level`)
}
}
}
/**
* The border seams an outdoor level must cut, as the generator wants them.
*
@ -607,8 +471,6 @@ function gatesFor(levelId: number): PlannedGate[] {
* @param region - the level's main walkable region when there is a meaningful
* one, keeping the arrival point out of sealed pockets; undefined for
* generated levels, where the unstamped void would be the largest region.
* @param subTile - the warp's exact sub-tile when the generator knows it (the
* DRLG's UNIT_TILE preset unit); the anchor cell's centre otherwise.
* @returns the warp.
*/
function makeWarp(
@ -619,12 +481,11 @@ function makeWarp(
grid: IsoMapScene,
source: SceneWarp['source'],
region: WalkableRegion | undefined,
subTile?: { readonly x: number; readonly y: number },
): SceneWarp {
const warpId = edge.warps[0] ?? -1
const geometry = warpId < 0 ? undefined : findWarpGeometry(warpGeometry, warpId)
let x = subTile?.x ?? cellToSubTile(cellX)
let y = subTile?.y ?? cellToSubTile(cellY)
let x = cellToSubTile(cellX)
let y = cellToSubTile(cellY)
const fullSpan = Math.max(grid.gridWidth, grid.gridHeight)
if (region !== undefined && !triggerableFrom(grid, region, x, y, WARP_TRIGGER_SUBTILES)) {
const snapped = nearestWalkable(grid, x, y, fullSpan, region)
@ -682,16 +543,9 @@ function makeWarp(
* @param kind - how it was built.
* @param ds1 - the assembled map, for its warp markers.
* @param grid - the baked collision map.
* @param entrances - `stats.entrances` from the wilderness generator, or the
* DRLG adapter's entrances, if any.
* @param entrances - `stats.entrances` from the wilderness generator, if any.
* @param mazeWarps - `stats.warps` from the maze generator, if any.
* @param waypointCells - waypoint objects found in the artwork, in sub-tiles.
* @param mazeWaypoints - `stats.waypoints` from the maze generator, if any.
* @param options - `exactLinks`: the generator reports every seam and warp of
* the level exactly (the DRLG port). Nothing is then inferred: warp markers,
* staircase rooms, border scans and fallback warps are not used, every seam
* must carry the stretch of edge it opens on, and any disagreement with the
* world graph throws.
* @returns the links, plus anything the graph wanted that could not be placed.
*/
function buildSceneLinks(
@ -699,13 +553,11 @@ function buildSceneLinks(
kind: LevelKind,
ds1: Ds1,
grid: IsoMapScene,
entrances: readonly GeneratorEntrance[],
entrances: readonly WildernessEntrance[],
mazeWarps: readonly MazeWarp[],
waypointCells: readonly { x: number; y: number }[],
mazeWaypoints?: readonly MazeWaypoint[],
options: { readonly exactLinks?: boolean } = {},
): SceneLinks {
const exactLinks = options.exactLinks === true
const outEntrances: SceneEntrance[] = []
const outWarps: SceneWarp[] = []
const unplaced: { toLevelId: number; reason: string }[] = []
@ -765,10 +617,8 @@ function buildSceneLinks(
(townDistance.get(toLevelId) ?? Number.MAX_SAFE_INTEGER) < here ? 'up' : 'down'
// 1. The staircases the artwork declares. Authoritative for every kind of
// level, because the slot identifies the destination outright. Skipped
// when the generator reports its warps exactly: the DRLG port hands over
// the UNIT_TILE warp units D2 itself creates for them.
for (const tile of exactLinks ? [] : findWarpTiles(ds1)) {
// level, because the slot identifies the destination outright.
for (const tile of findWarpTiles(ds1)) {
const edge = warpEdgeBySlot.get(tile.slot)
// A marker for a slot this level does not use: the piece was drawn for a
// level that connects there and reused here. Ignore it rather than invent
@ -783,36 +633,6 @@ function buildSceneLinks(
// 2. Outdoor levels: the generator already cut the seams, and knows where the
// interior presets it stamped sit.
for (const anchor of entrances) {
const span = 'span' in anchor ? anchor.span : undefined
if (anchor.kind === 'gate' && anchor.side !== null && anchor.toLevelId >= 0 && span !== undefined) {
// A DRLG seam: the level link names the stretch of this edge that opens
// onto the neighbour (the open border block, or the whole shared edge
// for the town and the Monastery approach), so the walkable gap is
// searched there and nowhere else.
const range = { from: span.from * SUB_TILES_PER_TILE, to: span.to * SUB_TILES_PER_TILE }
const opening = findBorderOpening(grid, anchor.side, region, undefined, range)
if (opening === null) {
throw new Error(`level ${String(levelId)}: no reachable opening on the ${anchor.side} edge in tiles `
+ `${String(span.from)}..${String(span.to)} for the seam to level ${String(anchor.toLevelId)}`)
}
if (placedSeams.has(anchor.toLevelId)) {
throw new Error(`level ${String(levelId)}: two seams lead to level ${String(anchor.toLevelId)}`)
}
outEntrances.push({
toLevelId: anchor.toLevelId,
side: anchor.side,
label: anchor.label,
x: opening.x,
y: opening.y,
arriveX: opening.arriveX,
arriveY: opening.arriveY,
})
placedSeams.add(anchor.toLevelId)
continue
}
if (exactLinks && anchor.kind === 'gate') {
throw new Error(`level ${String(levelId)}: seam to level ${String(anchor.toLevelId)} has no side and span`)
}
if (anchor.kind === 'gate' && anchor.side !== null && anchor.toLevelId >= 0) {
// The anchor the generator hands over is the border *piece*, and the
// centre of that cell is wall; on some outdoor variants the border
@ -837,43 +657,11 @@ function buildSceneLinks(
}
// A preset's mouth: the cave, tower or crypt that opens off this level.
const edge = anchor.toLevelId < 0 ? undefined : warpEdgeTo.get(anchor.toLevelId)
const warp = 'warp' in anchor ? anchor.warp : undefined
if (exactLinks) {
if (edge === undefined) {
throw new Error(`level ${String(levelId)}: the generator has a warp to level ${String(anchor.toLevelId)}, the world graph does not`)
}
if (placedWarps.has(edge.to)) {
throw new Error(`level ${String(levelId)}: two warps lead to level ${String(anchor.toLevelId)}`)
}
if (warp === undefined) {
throw new Error(`level ${String(levelId)}: warp to level ${String(anchor.toLevelId)} has no warp unit position`)
}
}
if (edge === undefined || placedWarps.has(edge.to)) continue
outWarps.push(makeWarp(edge, 'in', anchor.x, anchor.y, grid, 'tile', region,
warp === undefined ? undefined : { x: warp.subX, y: warp.subY }))
outWarps.push(makeWarp(edge, 'in', anchor.x, anchor.y, grid, 'tile', region))
placedWarps.add(anchor.toLevelId)
}
if (exactLinks) {
// The generator's links and the world graph are two readings of the same
// Levels.txt rows (Vis0..7 / Warp0..7); any difference is a bug in one of
// them, never something to paper over with a guessed opening.
for (const edge of edgesFrom(worldGraph, levelId)) {
if (edge.kind === 'seamless' && !placedSeams.has(edge.to)) {
throw new Error(`level ${String(levelId)}: the world graph has a seam to level ${String(edge.to)}, the generator does not`)
}
if (edge.kind === 'warp' && !placedWarps.has(edge.to)) {
throw new Error(`level ${String(levelId)}: the world graph has a warp to level ${String(edge.to)}, the generator does not`)
}
}
for (const to of placedSeams) {
if (!edgesFrom(worldGraph, levelId).some(edge => edge.kind === 'seamless' && edge.to === to)) {
throw new Error(`level ${String(levelId)}: the generator has a seam to level ${String(to)}, the world graph does not`)
}
}
}
// 3. Mazes: staircase rooms, for pieces whose artwork carries no marker.
if (kind === 'maze') {
const leftover = [...edgesFrom(worldGraph, levelId)]
@ -1011,29 +799,17 @@ function buildSceneLinks(
}
}
// Waypoints. The artwork wins when it has one. The DRLG port's levels always
// do (DRLGOUTDOORS_SpawnAct12Waypoint puts the object in the level), so for
// them a missing or unreachable waypoint is a bug and throws. Legacy
// generators do not run that pass, so their levels get a stand-in: a
// waypoint the network knows about but the map does not show is worse than
// Waypoints. The artwork wins when it has one; otherwise the level gets a
// stand-in, because `DRLGOUTDOORS_SpawnAct12Waypoint` is not implemented and
// a waypoint the network knows about but the map does not show is worse than
// an approximate position.
const waypointId = worldGraph.levels.get(levelId)?.waypoint ?? 255
const waypoints: SceneWaypoint[] = []
if (exactLinks && waypointId === 255 && waypointCells.length > 0) {
throw new Error(`level ${String(levelId)}: the generator placed a waypoint, Levels.txt has none`)
}
if (waypointId !== 255) {
if (exactLinks && waypointCells.length !== 1) {
throw new Error(`level ${String(levelId)}: the generator placed ${String(waypointCells.length)} waypoints for waypoint ${String(waypointId)}`)
}
const fromArt = waypointCells[0] ?? (mazeWaypoints?.[0] ? { x: mazeWaypoints[0].entityX, y: mazeWaypoints[0].entityY } : undefined)
const spot = fromArt ?? findWaypointSpot(grid, region)
if (spot !== null && spot !== undefined) {
const reached = nearestWalkable(grid, spot.x + 2, spot.y + 2, 16, region)
if (exactLinks && reached === null) {
throw new Error(`level ${String(levelId)}: waypoint at ${String(spot.x)},${String(spot.y)} is not next to the main walkable region`)
}
const arrive = reached ?? spot
const arrive = nearestWalkable(grid, spot.x + 2, spot.y + 2, 16, region) ?? spot
waypoints.push({
waypointId,
x: spot.x,
@ -1278,11 +1054,30 @@ function themeValues(table: D2Table, row: readonly string[], prefix: string): nu
return values
}
/**
* The LvlPrest families the legacy outdoor generator draws its pieces from, by level type. Act I is not
* here: its outdoor levels bake only through the DRLG port ('drlg' jobs, see generateDrlgActs).
*/
const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
'Act 1 - Wilderness': [
'Act 1 - Wild',
'Act 1 - Town 1 Transition',
'Act 1 - DOE Entrance',
'Act 1 - Cave Entrance',
'Act 1 - Corral Fill',
'Act 1 - Fence Fill',
'Act 1 - River',
'Act 1 - Bridge',
'Act 1 - Bivouac',
'Act 1 - Pond',
'Act 1 - Swamp Fill',
'Act 1 - Stone Fill',
'Act 1 - Cottages',
'Act 1 - Fallen Camp',
'Act 1 - Camp',
'Act 1 - Cairn Stones',
'Act 1 - Inifus',
'Act 1 - Tower',
'Act 1 - Ruin',
'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
'Act 2 - Desert': ['Act 2 - Desert'],
'Act 3 - Jungle': ['Act 3 - Jungle', 'Act 3 - Clearing'],
'Act 3 - Kurast': ['Act 3 - Burst', 'Act 3 - Burbs', 'Act 3 - Clearing', 'Act 3 - Slums', 'Act 3 - Metro', 'Act 3 - Travincal', 'Act 3 - Bridge'],
@ -1363,7 +1158,7 @@ function getWildernessPieces(levelTypeName: string, subType?: number, levelName?
}
const levels = await rowDs1s(tables.lvlprest, row)
if (levels.length === 0) continue
const isBorder = /border|cliff|ravine/i.test(name)
const isBorder = levelTypeName === 'Act 1 - Wilderness' ? /\bBorder\b/i.test(name) : /border|cliff|ravine/i.test(name)
const animSpeedRaw = parseInt(cell(tables.lvlprest, row, 'Animate'), 10) || 0
const animSpeed = animSpeedRaw > 0 ? animSpeedRaw : undefined
pieces.push({ name, levels, border: isBorder, ...(animSpeed !== undefined ? { animSpeed } : {}) })
@ -1416,14 +1211,11 @@ async function getPalette(paletteName: string): Promise<Uint8Array> {
interface SceneJob {
readonly jobId: number
readonly entry: LevelJob
readonly type: 'preset-ds1' | 'preset-chaos' | 'maze' | 'wilderness' | 'drlg'
readonly type: 'preset-ds1' | 'preset-chaos' | 'maze' | 'wilderness'
readonly ds1Name?: string
/** Copy number: 1-based for the legacy generators, the 0-based act copy (`actVariant`) for 'drlg'. */
readonly variant?: number
readonly label: string
readonly seed: number
/** 'drlg' jobs: the level as the main thread's DRLG run of the act copy generated it. */
readonly drlg?: { readonly gameSeed: number; readonly input: DrlgLevelInput }
}
interface SceneResult {
@ -1457,20 +1249,12 @@ async function bakeDs1Variant(
* from the collision map instead.
*/
generatorLinks: {
readonly entrances: readonly GeneratorEntrance[]
readonly entrances: readonly WildernessEntrance[]
readonly mazeWarps: readonly MazeWarp[]
readonly mazeWaypoints?: readonly MazeWaypoint[]
readonly landmarks?: readonly { readonly id: string; readonly tileX: number; readonly tileY: number }[]
readonly notes?: readonly string[] | undefined
readonly animSpeed?: number | undefined
/** The generator reports every seam and warp exactly (see buildSceneLinks). */
readonly exactLinks?: boolean
/**
* `'layout'`: every room, tile (style, sequence, type, DT1 library) and preset unit is D2's own
* (the DRLG port); only the variant within a tile's (style, sequence) is the renderer's pick.
* Unset: the generator approximates the level.
*/
readonly fidelity?: 'layout'
} = { entrances: [], mazeWarps: [] },
animSpeedOverride?: number,
): Promise<SceneResult> {
@ -1512,7 +1296,6 @@ async function bakeDs1Variant(
generatorLinks.mazeWarps,
waypointCells,
generatorLinks.mazeWaypoints,
{ exactLinks: generatorLinks.exactLinks === true },
)
const spawn = findIsoSpawn(scene, { warps: sceneLinks.warps, entrances: sceneLinks.entrances })
@ -1810,7 +1593,7 @@ async function bakeDs1Variant(
const sceneJson = {
version: 1,
fidelity: entry.kind === 'preset' ? 'exact' : generatorLinks.fidelity ?? 'approximation',
fidelity: entry.kind === 'preset' ? 'exact' : 'approximation',
act: entry.act,
levelId: entry.levelId,
levelName,
@ -2049,45 +1832,6 @@ async function bakeSceneJob(job: SceneJob): Promise<SceneResult> {
)
}
if (job.type === 'drlg') {
const drlg = job.drlg
if (drlg === undefined || job.variant === undefined) {
throw new Error(`${job.label}: a DRLG job must carry its generated level and act copy`)
}
const t = await drlgTables()
// The libraries of the tiles D2 picked, for their (style, sequence, type) headers.
const dt1 = new Map<string, Dt1>()
for (const tile of drlg.input.tiles) {
if (tile.tile !== null && !dt1.has(tile.tile.library)) dt1.set(tile.tile.library, await libraryOf(tile.tile.library))
}
const map = buildDrlgLevelMap(drlg.input, { tables: t, dt1, superUniqueIds: drlgSuperUniqueIds(tables.superuniques, t) })
const libraries: Dt1[] = []
for (const name of map.dt1Names) libraries.push(await libraryOf(name))
const entrances: GeneratorEntrance[] = map.entrances.map(entrance => ({
...entrance,
label: entrance.kind === 'gate' ? `${levelNameOf(entrance.toLevelId)} Seam` : levelNameOf(entrance.toLevelId),
}))
const s = map.stats
const result = await bakeDs1Variant(
job.jobId,
job.entry, job.entry.name, palette, paletteName, map.dt1Names, libraries,
map.ds1, `generated:${job.label}`, job.label, job.seed,
{
entrances,
mazeWarps: [],
landmarks: map.landmarks,
exactLinks: true,
fidelity: 'layout',
notes: [
`DRLG port: act ${String(job.entry.act)} copy ${String(job.variant)}, game seed 0x${drlg.gameSeed.toString(16)}`,
`DRLG tiles: ${String(s.walls)} walls, ${String(s.floors)} floors, ${String(s.shadows)} shadows, `
+ `${String(s.withoutTile)} without a DT1 tile; units: ${String(s.objects)} objects, ${String(s.monsters)} monsters`,
],
},
)
return { ...result, indexEntry: { ...result.indexEntry, actVariant: job.variant } }
}
if (job.type === 'wilderness') {
const type = levelType(levelRow)
const sizeX = Number(cell(tables.levels, levelRow, 'SizeX'))
@ -2145,14 +1889,11 @@ async function bakeSceneJob(job: SceneJob): Promise<SceneResult> {
*
* @param filterLevels - optional filter set of level IDs.
* @param filterAct - optional filter for a specific act.
* @param drlgActs - the DRLG-generated act copies ({@link generateDrlgActs}); their levels bake one
* 'drlg' job per copy instead of going through the legacy wilderness generator.
* @returns ordered array of scene jobs with sequential jobIds (0..N-1).
*/
async function collectSceneJobs(
filterLevels: Set<number> | null,
filterAct: number | null,
drlgActs: ReadonlyMap<number, readonly DrlgActCopy[]>,
): Promise<SceneJob[]> {
const jobs: SceneJob[] = []
let jobId = 0
@ -2211,25 +1952,6 @@ async function collectSceneJobs(
})
}
} else if (entry.kind === 'wilderness') {
const copies = drlgActs.get(entry.act)
if (copies !== undefined && copies.some(copy => copy.layout.levels.includes(entry.levelId))) {
for (const copy of copies) {
const input = copy.inputs.get(entry.levelId)
if (input === undefined) {
throw new Error(`act ${String(entry.act)} copy ${String(copy.layout.variant)} did not generate level ${String(entry.levelId)}`)
}
jobs.push({
jobId: jobId++,
entry,
type: 'drlg',
variant: copy.layout.variant,
label: `${entry.slug}-var${String(copy.layout.variant + 1)}`,
seed: 0x5eed_1000 + entry.levelId * 10 + copy.layout.variant + 1,
drlg: { gameSeed: copy.layout.gameSeed, input },
})
}
continue
}
const type = levelType(levelRow)
const subType = Number(cell(tables.levels, levelRow, 'SubType'))
const pieces = await getWildernessPieces(type.name, subType, entry.name)
@ -2250,19 +1972,6 @@ async function collectSceneJobs(
}
}
// Every selected level of a generated act must bake from the DRLG copies: a level whose Levels.txt
// kind disagreed with the DRLG's DrlgType would otherwise vanish from the act without a word.
for (const [act, copies] of drlgActs) {
for (const levelId of copies[0]?.layout.levels ?? []) {
if (filterLevels !== null && !filterLevels.has(levelId)) continue
if (filterAct !== null && act !== filterAct) continue
const baked = jobs.filter(job => job.type === 'drlg' && job.entry.levelId === levelId).length
if (baked !== copies.length) {
throw new Error(`DRLG level ${String(levelId)} of act ${String(act)} has ${String(baked)} bake jobs, expected ${String(copies.length)}`)
}
}
}
return jobs
}
@ -2420,9 +2129,7 @@ async function main(): Promise<void> {
await mkdir(join(outDir, `act${String(act)}`), { recursive: true })
}
const drlgActs = await generateDrlgActs((act, levelId) =>
(filterLevels === null || filterLevels.has(levelId)) && (filterAct === null || act === filterAct))
const sceneJobs = await collectSceneJobs(filterLevels, filterAct, drlgActs)
const sceneJobs = await collectSceneJobs(filterLevels, filterAct)
if (sceneJobs.length === 0) {
console.log('No scenes matched filter criteria.')
return
@ -2457,20 +2164,12 @@ async function main(): Promise<void> {
skippedMissingArtSpawns += res.skippedMissingArtSpawns
}
// The DRLG act copies the generated levels belong to (src/game/act-variants.ts reads them).
const actLayouts: Record<string, ActLayout[]> = {}
for (const [act, copies] of drlgActs) actLayouts[String(act)] = copies.map(copy => copy.layout)
if (Object.keys(actLayouts).length > 0) index.actLayouts = actLayouts
const indexPath = join(outDir, 'index.json')
if (filterLevel !== undefined || filterAct !== null) {
try {
const { readFile } = await import('node:fs/promises')
const existingRaw = await readFile(indexPath, 'utf8')
const existing = JSON.parse(existingRaw) as {
levels?: Array<{ label?: string }>
actLayouts?: Record<string, ActLayout[]>
}
const existing = JSON.parse(existingRaw) as { levels?: Array<{ label?: string }> }
if (Array.isArray(existing.levels)) {
const updatedByLabel = new Map<string, unknown>()
for (const item of index.levels as Array<{ label: string }>) {
@ -2491,16 +2190,11 @@ async function main(): Promise<void> {
}
index.levels = merged
}
// An act this run generated replaces its old copies whole; other acts keep theirs.
if (existing.actLayouts !== undefined) index.actLayouts = { ...existing.actLayouts, ...actLayouts }
} catch {
// No existing index.json or unreadable; write fresh index
}
}
// Outside the merge's catch-all: an act copy the runtime could not resolve must fail the bake.
validateActLayouts(index as unknown as VariantIndex<VariantEntry>)
// Atomic writes from main thread
await writeJsonAtomic(indexPath, index)

390
scripts/render-drlg-compare.ts
View File

@ -1,390 +0,0 @@
/**
* Side-by-side proof that the baked Act I outdoor maps are the maps D2MOO generates.
*
* For one game seed, the native D2MOO oracle (tools/d2moo-oracle) and the TypeScript port
* (src/game/drlg, fed from the MPQs exactly as scripts/pack-act-assets.ts feeds it) each generate
* Act I. Both dumps then take the same road to pixels: drlgLevelInputFromDump -> buildDrlgLevelMap
* (the bake's adapter) -> buildIsoMapScene (the bake's scene builder) -> the renderers below. For
* every requested level it writes
*
* <name>_d2moo_blueprint.png / <name>_port_blueprint.png / <name>_xor_blueprint.png
* <name>_d2moo_iso.png / <name>_port_iso.png / <name>_xor_iso.png
*
* and fails (exit 1) unless both XOR images are empty. The iso XOR is computed at full resolution
* on palette indices and the shadow layer; the written iso images are downscaled previews (a block
* of the XOR preview is lit when any of its pixels differs).
*
* It also prints the DT1-mask ambiguity audit of every level (auditDrlgDt1Ambiguity: references whose
* candidate tiles under their cell's DT1 mask are variants, or span more than one library) and writes
* everything to summary.json.
*
* Blueprint colours (one 3x3-pixel block per sub-tile): walkable sub-tile green, blocked sub-tile
* tan, cell without any tile near-black, 8x8-tile room grid dark lines, level links and warps red,
* preset monsters (landmarks) yellow.
*
* Usage:
* npx tsx scripts/render-drlg-compare.ts [--copy=0] [--seed=0x5eed0100] [--levels=2,3,4]
* [--out=DIR] [--scale=4]
*
* --copy picks the bake's act copy (0..2): the game seed of that copy (actGameSeed in
* pack-act-assets.ts) and the scene seed the bake gives its levels. --seed overrides the game seed.
*/
import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
import { join, resolve } from 'node:path'
import { decodeDt1, type Dt1 } from '../src/formats/dt1.ts'
import { decodePal } from '../src/formats/pal.ts'
import { cell, parseTable } from '../src/game/acts.ts'
import { buildIsoMapScene, type IsoDraw, type IsoMapScene } from '../src/game/d2map.ts'
import { dumpAct1, type DrlgDump } from '../src/game/drlg/drlg-dump.ts'
import { act1OutdoorLevelIds, auditDrlgDt1Ambiguity, buildDrlgLevelMap, drlgLevelInputFromDump, type DrlgDt1Ambiguity, type DrlgLevelMap } from '../src/game/drlg/drlg-map.ts'
import { createDrlgEnv } from '../src/game/drlg/drlg-source.ts'
import { SUB_TILES_PER_TILE } from '../src/game/map.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { MountedArchives } from '../src/mpq/mount.ts'
import { drlgLevelDt1s, drlgSuperUniqueIds, loadDrlgMpqData, type DrlgMpqData } from './lib/drlg-mpq-source.ts'
import { firstDiff, formatDiff, ORACLE_BIN, runOracle } from './lib/drlg-oracle.ts'
import { encodeIndexedPng, encodeRgbaPng } from './png.ts'
const ROOT = resolve(import.meta.dirname, '..')
const ARCHIVE_DIR = join(ROOT, 'samples/d2')
const MOUNTS = ['d2char.mpq', 'd2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq'] as const
const SUPERUNIQUES_TXT = 'data\\global\\excel\\SuperUniques.txt'
const LEVELS_TXT = 'data\\global\\excel\\Levels.txt'
const ACT1_PALETTE = 'data\\global\\palette\\act1\\pal.dat'
/** Blueprint pixels per sub-tile. */
const BLUEPRINT_SCALE = 3
/** Tiles per side of an outdoor room (DRLG grid cell), for the blueprint grid lines. */
const ROOM_TILES = 8
/** Shadow layer darkening in the iso previews. */
const SHADOW_FACTOR = 0.5
/** Blueprint palette indices. */
const BP = { void: 0, walkable: 1, blocked: 2, grid: 3, link: 4, landmark: 5 } as const
const BLUEPRINT_PALETTE: readonly (readonly [number, number, number])[] = [
[12, 16, 22], [36, 78, 44], [198, 158, 86], [24, 40, 30], [240, 70, 70], [255, 226, 90],
]
/** The bake's act-copy game seed (scripts/pack-act-assets.ts actGameSeed, act 1). */
function act1GameSeed(copy: number): number {
return (0x5eed_0000 + 1 * 0x100 + copy) >>> 0
}
/** The seed the bake gives the scene of a DRLG level copy (scripts/pack-act-assets.ts, job type 'drlg'). */
function bakeSceneSeed(levelId: number, copy: number): number {
return 0x5eed_1000 + levelId * 10 + copy + 1
}
function slug(name: string): string {
return name.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '')
}
interface Args {
readonly copy: number
readonly seed: number
readonly levels: readonly number[]
readonly out: string
readonly scale: number
}
function parseArgs(argv: readonly string[]): Args {
const known = new Set(['copy', 'seed', 'levels', 'out', 'scale'])
const values = new Map<string, string>()
for (const arg of argv) {
const match = /^--([a-z]+)=(.+)$/.exec(arg)
if (match === null || !known.has(match[1]!)) throw new Error(`unknown argument ${arg} (options: ${[...known].map(k => `--${k}=`).join(' ')})`)
values.set(match[1]!, match[2]!)
}
const copy = Number(values.get('copy') ?? '0')
if (!Number.isInteger(copy) || copy < 0 || copy > 2) throw new Error('--copy must be 0, 1 or 2')
const seedText = values.get('seed')
const seed = seedText === undefined ? act1GameSeed(copy) : Number(seedText) >>> 0
if (seedText !== undefined && !/^(0x[0-9a-f]+|\d+)$/i.test(seedText)) throw new Error(`bad --seed ${seedText}`)
const levels = (values.get('levels') ?? '2,3,4').split(',').map(Number)
if (levels.some(id => !Number.isInteger(id) || id <= 0)) throw new Error(`bad --levels ${values.get('levels') ?? ''}`)
const scale = Number(values.get('scale') ?? '4')
if (!Number.isInteger(scale) || scale < 1) throw new Error('--scale must be a positive integer')
const out = resolve(values.get('out') ?? '/tmp/drlg-compare')
return { copy, seed, levels, out, scale }
}
// ---------------------------------------------------------------------------------------------
// Renderers
interface IsoRender {
readonly width: number
readonly height: number
/** Palette index per pixel (0 where nothing was drawn). */
readonly index: Uint8Array
/** 1 where the shadow layer darkens the pixel. */
readonly shade: Uint8Array
/** 1 where anything was drawn. */
readonly drawn: Uint8Array
}
/**
* Paint a scene the way the engine layers it: floors, then shadows (darkening), then walls and roofs
* in their painter's order. Full resolution, palette indices.
*/
function renderIso(scene: IsoMapScene): IsoRender {
const width = scene.widthPx
const height = scene.heightPx
const index = new Uint8Array(width * height)
const shade = new Uint8Array(width * height)
const drawn = new Uint8Array(width * height)
const paint = (draws: readonly IsoDraw[], mode: 'opaque' | 'shadow'): void => {
for (const draw of draws) {
const frame = scene.frames[draw.frameIndex]
if (frame === undefined) throw new Error(`draw at cell ${String(draw.cellX)},${String(draw.cellY)} names frame ${String(draw.frameIndex)} of ${String(scene.frames.length)}`)
for (let fy = 0; fy < frame.height; fy += 1) {
const py = draw.y + fy
if (py < 0 || py >= height) continue
for (let fx = 0; fx < frame.width; fx += 1) {
const px = draw.x + fx
if (px < 0 || px >= width) continue
const at = fy * frame.width + fx
if (frame.mask[at] !== 1) continue
const to = py * width + px
if (mode === 'shadow') {
shade[to] = 1
} else {
index[to] = frame.indices[at]!
shade[to] = 0
drawn[to] = 1
}
}
}
}
}
paint(scene.floors, 'opaque')
paint(scene.shadows, 'shadow')
paint(scene.walls, 'opaque')
paint(scene.roofs, 'opaque')
return { width, height, index, shade, drawn }
}
/** A downscaled RGBA preview of an iso render (nearest sample of each block). */
function isoPreview(render: IsoRender, rgb: Uint8Array, scale: number): Uint8Array {
const width = Math.ceil(render.width / scale)
const height = Math.ceil(render.height / scale)
const pixels = new Uint8Array(width * height * 4)
for (let y = 0; y < height; y += 1) {
for (let x = 0; x < width; x += 1) {
const from = (y * scale) * render.width + x * scale
const to = (y * width + x) * 4
if (render.drawn[from] !== 1) {
pixels[to + 3] = 255
continue
}
const factor = render.shade[from] === 1 ? SHADOW_FACTOR : 1
const colour = render.index[from]! * 3
pixels[to] = Math.round(rgb[colour]! * factor)
pixels[to + 1] = Math.round(rgb[colour + 1]! * factor)
pixels[to + 2] = Math.round(rgb[colour + 2]! * factor)
pixels[to + 3] = 255
}
}
return encodeRgbaPng({ width, height, pixels })
}
/** Differing pixels of two iso renders, and a downscaled mask of them (a block lights up if any pixel in it differs). */
function isoXor(a: IsoRender, b: IsoRender, scale: number): { differing: number; png: Uint8Array } {
if (a.width !== b.width || a.height !== b.height) {
throw new Error(`iso renders differ in size: ${String(a.width)}x${String(a.height)} vs ${String(b.width)}x${String(b.height)}`)
}
const width = Math.ceil(a.width / scale)
const height = Math.ceil(a.height / scale)
const pixels = new Uint8Array(width * height)
let differing = 0
for (let y = 0; y < a.height; y += 1) {
for (let x = 0; x < a.width; x += 1) {
const at = y * a.width + x
if (a.index[at] !== b.index[at] || a.shade[at] !== b.shade[at] || a.drawn[at] !== b.drawn[at]) {
differing += 1
pixels[Math.floor(y / scale) * width + Math.floor(x / scale)] = 1
}
}
}
const palette = new Uint8Array(256 * 3)
palette.set([255, 0, 255], 3)
return { differing, png: encodeIndexedPng({ width, height, pixels, palette }) }
}
interface Blueprint {
readonly width: number
readonly height: number
readonly pixels: Uint8Array
}
/** The level's collision, cells, room grid, links and landmarks, one block per sub-tile. */
function renderBlueprint(map: DrlgLevelMap, scene: IsoMapScene): Blueprint {
const { gridWidth, gridHeight } = scene
const width = gridWidth * BLUEPRINT_SCALE
const height = gridHeight * BLUEPRINT_SCALE
const pixels = new Uint8Array(width * height).fill(BP.void)
const block = (subX: number, subY: number, colour: number): void => {
for (let dy = 0; dy < BLUEPRINT_SCALE; dy += 1) {
for (let dx = 0; dx < BLUEPRINT_SCALE; dx += 1) {
const px = subX * BLUEPRINT_SCALE + dx
const py = subY * BLUEPRINT_SCALE + dy
if (px >= 0 && px < width && py >= 0 && py < height) pixels[py * width + px] = colour
}
}
}
for (let subY = 0; subY < gridHeight; subY += 1) {
for (let subX = 0; subX < gridWidth; subX += 1) {
const cell = map.ds1.cells[Math.floor(subY / SUB_TILES_PER_TILE)]?.[Math.floor(subX / SUB_TILES_PER_TILE)]
const hasTile = cell !== undefined && (cell.floors.some(f => f.prop1 !== 0) || cell.walls.some(w => w.prop1 !== 0))
if (!hasTile) continue
block(subX, subY, scene.blocked[subY * gridWidth + subX] === 0 ? BP.walkable : BP.blocked)
}
}
const step = ROOM_TILES * SUB_TILES_PER_TILE * BLUEPRINT_SCALE
for (let py = 0; py < height; py += step) pixels.fill(BP.grid, py * width, (py + 1) * width)
for (let px = 0; px < width; px += step) for (let py = 0; py < height; py += 1) pixels[py * width + px] = BP.grid
const marker = (subX: number, subY: number, colour: number): void => {
for (let dy = -1; dy <= 1; dy += 1) for (let dx = -1; dx <= 1; dx += 1) block(subX + dx, subY + dy, colour)
}
const centre = Math.floor(SUB_TILES_PER_TILE / 2)
for (const entrance of map.entrances) {
if (entrance.warp !== undefined) marker(entrance.warp.subX, entrance.warp.subY, BP.link)
else marker(entrance.x * SUB_TILES_PER_TILE + centre, entrance.y * SUB_TILES_PER_TILE + centre, BP.link)
}
for (const landmark of map.landmarks) marker(landmark.subX, landmark.subY, BP.landmark)
return { width, height, pixels }
}
function blueprintPng(blueprint: Blueprint): Uint8Array {
const palette = new Uint8Array(256 * 3)
BLUEPRINT_PALETTE.forEach((colour, at) => palette.set(colour, at * 3))
return encodeIndexedPng({ width: blueprint.width, height: blueprint.height, pixels: blueprint.pixels, palette })
}
function blueprintXor(a: Blueprint, b: Blueprint): { differing: number; png: Uint8Array } {
if (a.width !== b.width || a.height !== b.height) {
throw new Error(`blueprints differ in size: ${String(a.width)}x${String(a.height)} vs ${String(b.width)}x${String(b.height)}`)
}
const pixels = new Uint8Array(a.pixels.length)
let differing = 0
for (let at = 0; at < pixels.length; at += 1) {
if (a.pixels[at] !== b.pixels[at]) {
pixels[at] = 1
differing += 1
}
}
const palette = new Uint8Array(256 * 3)
palette.set([255, 0, 255], 3)
return { differing, png: encodeIndexedPng({ width: a.width, height: a.height, pixels, palette }) }
}
// ---------------------------------------------------------------------------------------------
// Driver
interface Side {
readonly map: DrlgLevelMap
readonly scene: IsoMapScene
readonly iso: IsoRender
readonly blueprint: Blueprint
}
async function main(): Promise<void> {
const args = parseArgs(process.argv.slice(2))
if (!existsSync(ORACLE_BIN)) throw new Error(`${ORACLE_BIN} is missing: run ./tools/d2moo-oracle/build.sh`)
const missing = MOUNTS.filter(name => !existsSync(join(ARCHIVE_DIR, name)))
if (missing.length > 0) throw new Error(`the 1.13c archives are required in ${ARCHIVE_DIR}; missing ${missing.join(', ')}`)
mkdirSync(args.out, { recursive: true })
const archives = new MountedArchives()
for (const name of MOUNTS) archives.add(name, await MpqArchive.open(await fileSource(join(ARCHIVE_DIR, name))))
const data: DrlgMpqData = await loadDrlgMpqData(member => archives.read(member), 1)
const superUniqueIds = drlgSuperUniqueIds(parseTable(await archives.read(SUPERUNIQUES_TXT)), data.tables)
const palette = decodePal(await archives.read(ACT1_PALETTE))
const levelsTxt = parseTable(await archives.read(LEVELS_TXT))
const levelName = (levelId: number): string => {
const row = levelsTxt.rows.find(r => Number(cell(levelsTxt, r, 'Id')) === levelId)
if (row === undefined) throw new Error(`Levels.txt has no row with Id ${String(levelId)}`)
return cell(levelsTxt, row, 'LevelName')
}
// The bake generates the whole act's outdoor list in one run; so do both sides here.
const actLevels = act1OutdoorLevelIds(data.tables)
for (const levelId of args.levels) {
if (!actLevels.includes(levelId)) throw new Error(`level ${String(levelId)} is not an Act I outdoor level (${actLevels.join(', ')})`)
}
const seedHex = `0x${args.seed.toString(16).padStart(8, '0')}`
console.log(`game seed ${seedHex} (act copy ${String(args.copy)}), levels ${args.levels.join(', ')} of [${actLevels.join(', ')}]`)
const oracle: DrlgDump = runOracle({ seed: args.seed, levels: actLevels, difficulty: 0, isolated: false }).doc
delete oracle.oracle
const port: DrlgDump = dumpAct1(createDrlgEnv(data.source, data.tables), args.seed, actLevels, { difficulty: 0, isolated: false })
const dumpDiff = firstDiff(oracle, port, '$')
console.log(dumpDiff === null ? 'dumps: identical' : `dumps: DIFFER at ${formatDiff(dumpDiff)}`)
const dt1Cache = new Map<string, Dt1>()
const library = (name: string): Dt1 => {
let dt1 = dt1Cache.get(name)
if (dt1 === undefined) {
dt1 = decodeDt1(data.source.readFile(name))
dt1Cache.set(name, dt1)
}
return dt1
}
const side = (dump: DrlgDump, levelId: number): Side => {
const input = drlgLevelInputFromDump(dump, levelId, data.tables)
const map = buildDrlgLevelMap(input, { tables: data.tables, dt1: drlgLevelDt1s(input, data.source, dt1Cache), superUniqueIds })
const scene = buildIsoMapScene(map.ds1, map.dt1Names.map(library), bakeSceneSeed(levelId, args.copy))
return { map, scene, iso: renderIso(scene), blueprint: renderBlueprint(map, scene) }
}
const summary: Record<string, unknown>[] = []
const ambiguityTotal = { refs: 0, variantGroups: 0, crossLibrary: 0, crossLibraryLevelWide: 0 }
let failed = dumpDiff !== null
for (const levelId of args.levels) {
const name = slug(levelName(levelId))
const d2moo = side(oracle, levelId)
const ours = side(port, levelId)
const iso = isoXor(d2moo.iso, ours.iso, args.scale)
const bp = blueprintXor(d2moo.blueprint, ours.blueprint)
const ambiguity: DrlgDt1Ambiguity = auditDrlgDt1Ambiguity(ours.map, ours.map.dt1Names.map(library))
ambiguityTotal.refs += ambiguity.refs
ambiguityTotal.variantGroups += ambiguity.variantGroups
ambiguityTotal.crossLibrary += ambiguity.crossLibrary
ambiguityTotal.crossLibraryLevelWide += ambiguity.crossLibraryLevelWide
const write = (file: string, png: Uint8Array): void => writeFileSync(join(args.out, `${name}_${file}.png`), png)
write('d2moo_blueprint', blueprintPng(d2moo.blueprint))
write('port_blueprint', blueprintPng(ours.blueprint))
write('xor_blueprint', bp.png)
write('d2moo_iso', isoPreview(d2moo.iso, palette.rgb, args.scale))
write('port_iso', isoPreview(ours.iso, palette.rgb, args.scale))
write('xor_iso', iso.png)
const s = ours.map.stats
const row = {
levelId,
name,
canvas: `${String(ours.map.ds1.width)}x${String(ours.map.ds1.height)}`,
walls: s.walls,
floors: s.floors,
shadows: s.shadows,
objects: s.objects,
monsters: s.monsters,
entrances: ours.map.entrances.length,
landmarks: ours.map.landmarks.length,
isoPx: `${String(ours.iso.width)}x${String(ours.iso.height)}`,
isoDiffering: iso.differing,
blueprintDiffering: bp.differing,
dt1Ambiguity: ambiguity,
}
summary.push(row)
console.log(`L${String(levelId)} ${name}: canvas ${row.canvas}, ${String(s.walls)} walls / ${String(s.floors)} floors / ${String(s.shadows)} shadows, `
+ `${String(row.entrances)} links, ${String(row.landmarks)} landmarks; iso ${row.isoPx} px, differing ${String(iso.differing)}; blueprint differing ${String(bp.differing)}`)
console.log(` DT1 ambiguity: ${String(ambiguity.libraries)} libraries, ${String(ambiguity.refs)} refs, ${String(ambiguity.variantGroups)} with variants, `
+ `${String(ambiguity.crossLibrary)} cross-library under cell masks (${String(ambiguity.crossLibraryLevelWide)} with one level-wide pool)`)
if (iso.differing !== 0 || bp.differing !== 0) failed = true
}
console.log(`DT1 ambiguity total: ${String(ambiguityTotal.refs)} refs, ${String(ambiguityTotal.variantGroups)} with variants, `
+ `${String(ambiguityTotal.crossLibrary)} cross-library under cell masks (${String(ambiguityTotal.crossLibraryLevelWide)} with one level-wide pool)`)
writeFileSync(join(args.out, 'summary.json'), JSON.stringify({ seed: seedHex, copy: args.copy, dumpsIdentical: dumpDiff === null, dt1Ambiguity: ambiguityTotal, levels: summary }, null, 1))
console.log(failed ? 'FAIL: the D2MOO and port images differ' : `OK: every XOR image is empty; images in ${args.out}`)
if (failed) process.exitCode = 1
}
await main()

276
scripts/render-new-ts-blood-moor.ts Normal file
View File

@ -0,0 +1,276 @@
import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
import { join } from 'node:path'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { MountedArchives } from '../src/mpq/mount.ts'
import { decodeDs1, type Ds1 } from '../src/formats/ds1.ts'
import { decodeDt1, type Dt1 } from '../src/formats/dt1.ts'
import { decodePal } from '../src/formats/pal.ts'
import { loadActTables, parseTable, cell, tileMemberPath, type D2Table } from '../src/game/acts.ts'
import { buildIsoMapScene, COLLIDE_WALL, COLLIDE_DOOR } from '../src/game/d2map.ts'
import { encodeIndexedPng } from './png.ts'
import {
generateWilderness,
type WildernessPiece,
type WildernessSubstitution,
type WildernessResult,
} from '../src/game/wilderness.ts'
const d2DataDir = '/usr/local/google/home/taodao/d2-data'
const artifactDir = '/usr/local/google/home/taodao/.gemini/jetski/brain/a4f9163c-a011-4161-b169-7f361b1ed57e'
mkdirSync(artifactDir, { recursive: true })
async function main() {
const mpqNames = ['Patch_D2.mpq', 'd2exp.mpq', 'd2data.mpq']
const archives = new MountedArchives()
const rawMpqs: MpqArchive[] = []
for (const name of mpqNames) {
const archive = await MpqArchive.open(await fileSource(join(d2DataDir, name)))
archives.add(name, archive)
rawMpqs.push(archive)
}
async function readMpqFile(mpqPath: string): Promise<Uint8Array | null> {
const norm = mpqPath.replace(/\//g, '\\')
for (const mpq of rawMpqs) {
const entry = mpq.find(norm)
if (entry !== undefined) {
return await mpq.read(entry)
}
}
return null
}
const actTables = await loadActTables(archives)
const lvlsubTable = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
const ds1Cache = new Map<string, Ds1>()
async function loadDs1(relative: string): Promise<Ds1> {
const member = tileMemberPath(relative)
const cached = ds1Cache.get(member)
if (cached !== undefined) return cached
const decoded = decodeDs1(await archives.read(member))
ds1Cache.set(member, decoded)
return decoded
}
async function rowDs1s(table: D2Table, row: readonly string[]): Promise<Ds1[]> {
const levels: Ds1[] = []
for (let slot = 1; slot <= 6; slot += 1) {
const val = cell(table, row, `File${String(slot)}`)
if (val === '' || val === '0') continue
levels.push(await loadDs1(val))
}
return levels
}
const WILDERNESS_PIECE_FAMILIES = [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
]
const act1Pieces: WildernessPiece[] = []
for (const row of actTables.lvlprest.rows) {
const name = cell(actTables.lvlprest, row, 'Name')
if (!WILDERNESS_PIECE_FAMILIES.some(fam => name.startsWith(fam))) continue
const levels = await rowDs1s(actTables.lvlprest, row)
if (levels.length === 0) continue
act1Pieces.push({ name, levels, border: /\bBorder\b/i.test(name) })
}
const act1Subs: WildernessSubstitution[] = []
for (const row of lvlsubTable.rows) {
const subType = Number(cell(lvlsubTable, row, 'Type'))
if (subType !== 0 && subType !== 1 && subType !== 6) continue
const file = cell(lvlsubTable, row, 'File')
if (file === '' || file === '0') continue
const levels = [await loadDs1(file)]
act1Subs.push({
name: cell(lvlsubTable, row, 'Name'),
type: subType,
gridSize: Number(cell(lvlsubTable, row, 'GridSize')) || 1,
bordType: Number(cell(lvlsubTable, row, 'BordType')),
dt1Mask: Number(cell(lvlsubTable, row, 'Dt1Mask')) || 0,
prob: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Prob${String(i)}`)) || 0),
trials: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Trials${String(i)}`)) || 0),
max: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Max${String(i)}`)) || 0),
levels,
})
}
// Load DT1 libraries for Act 1 Wilderness (LevelType = 2) + 3 universal DT1s
const dt1Libraries: Dt1[] = []
const universalFiles = [
'data\\global\\tiles\\act1\\outdoors\\blank.dt1',
'data\\global\\tiles\\act1\\outdoors\\inviswal.dt1',
'data\\global\\tiles\\act1\\outdoors\\warp.dt1',
]
for (const uf of universalFiles) {
const bytes = await readMpqFile(uf)
if (bytes) dt1Libraries.push(decodeDt1(bytes))
}
const lvlTypesBytes = await readMpqFile('data\\global\\excel\\LvlTypes.txt')
const lvlTypesLines = new TextDecoder().decode(lvlTypesBytes!).split(/\r?\n/)
const lvlTypesHeader = lvlTypesLines[0]!.split('\t')
const lvlTypeIdIdx = lvlTypesHeader.indexOf('Id')
const fileCols = Array.from({ length: 32 }, (_, i) => lvlTypesHeader.indexOf(`File ${i + 1}`))
const typeRow = lvlTypesLines.slice(1).map(l => l.split('\t')).find(c => Number(c[lvlTypeIdIdx]) === 2)
if (typeRow) {
for (let i = 0; i < 32; i++) {
const colIdx = fileCols[i]!
const fName = (typeRow[colIdx] ?? '').trim()
if (!fName || fName === '0') continue
const bytes = await readMpqFile(`data\\global\\tiles\\${fName}`)
if (bytes) dt1Libraries.push(decodeDt1(bytes))
}
}
const seed = 0x12345678
console.log(`Generating Blood Moor with new TypeScript wilderness generator (Seed: 0x${seed.toString(16)})...`)
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed,
pieces: act1Pieces,
substitutions: act1Subs,
dt1Libraries,
})
const ds1 = result.level
console.log(`Generated Level DS1: ${ds1.width}x${ds1.height} tiles, ${ds1.objects.length} objects`)
const scene = buildIsoMapScene(ds1, dt1Libraries, seed)
console.log(`Scene built: ${scene.gridWidth}x${scene.gridHeight} subtiles, ${scene.widthPx}x${scene.heightPx} px, ${scene.frames.length} frames`)
const palBytes = await readMpqFile('data\\global\\palette\\act1\\pal.dat')
const palette = decodePal(palBytes!)
// 1) Render High-Res Blueprint
const scale = 3
const mapW = scene.gridWidth * scale
const mapH = scene.gridHeight * scale
const mapPixels = new Uint8Array(mapW * mapH)
const mapPal = new Uint8Array(256 * 3)
const setColor = (idx: number, r: number, g: number, b: number) => {
mapPal[idx * 3] = r
mapPal[idx * 3 + 1] = g
mapPal[idx * 3 + 2] = b
}
setColor(1, 12, 16, 22) // Void
setColor(2, 42, 68, 46) // Outdoor 8x8 Grid Line
setColor(3, 36, 78, 44) // Walkable Grass Moorland
setColor(4, 198, 158, 86) // Solid Wall / Cliff / Fence / River Bank
setColor(5, 176, 132, 78) // Dirt Road Path
setColor(6, 240, 84, 84) // Preset Landmark Outline
setColor(7, 88, 166, 255) // River Boundary
setColor(8, 255, 230, 100) // DS1 Object
mapPixels.fill(1)
for (let sy = 0; sy < scene.gridHeight; sy++) {
for (let sx = 0; sx < scene.gridWidth; sx++) {
const cellX = Math.floor(sx / 5)
const cellY = Math.floor(sy / 5)
const c = ds1.cells[cellY]?.[cellX]
const hasFloor = c && c.floors.some(f => f.prop1 !== 0)
const hasWall = c && c.walls.some(w => w.prop1 !== 0)
if (!hasFloor && !hasWall) continue
const mask = scene.collisionMasks[sy * scene.gridWidth + sx]!
let color = 3
const isRoad = c?.floors.some(f => f.style === 1 || f.style === 30 || (f.style === 0 && f.sequence > 0))
if (isRoad) color = 5
if ((mask & COLLIDE_WALL) !== 0) color = 4
for (let dy = 0; dy < scale; dy++) {
for (let dx = 0; dx < scale; dx++) {
mapPixels[(sy * scale + dy) * mapW + (sx * scale + dx)] = color
}
}
}
}
// Draw 8x8 Room Grid Lines
for (let by = 0; by <= ds1.height; by += 8) {
const py = by * 5 * scale
if (py >= 0 && py < mapH) {
for (let px = 0; px < mapW; px++) {
mapPixels[py * mapW + px] = 2
}
}
}
for (let bx = 0; bx <= ds1.width; bx += 8) {
const px = bx * 5 * scale
if (px >= 0 && px < mapW) {
for (let py = 0; py < mapH; py++) {
mapPixels[py * mapW + px] = 2
}
}
}
// Draw Objects
for (const obj of ds1.objects) {
const ox = obj.x * scale
const oy = obj.y * scale
for (let dy = -2; dy <= 2; dy++) {
for (let dx = -2; dx <= 2; dx++) {
const px = ox + dx
const py = oy + dy
if (px >= 0 && px < mapW && py >= 0 && py < mapH) {
mapPixels[py * mapW + px] = 8
}
}
}
}
const blueprintOut = join(artifactDir, 'new_ts_blood_moor_blueprint.png')
writeFileSync(blueprintOut, encodeIndexedPng({ width: mapW, height: mapH, pixels: mapPixels, palette: mapPal }))
console.log(`Saved Blueprint: ${blueprintOut}`)
// 2) Render Full Isometric DT1 Scene
const isoScale = scene.widthPx > 4000 ? 2 : 1
const isoW = Math.ceil(scene.widthPx / isoScale)
const isoH = Math.ceil(scene.heightPx / isoScale)
const isoPixels = new Uint8Array(isoW * isoH)
const drawPass = (draws: typeof scene.floors) => {
for (const d of draws) {
const frame = scene.frames[d.frameIndex]
if (!frame) continue
for (let fy = 0; fy < frame.height; fy += isoScale) {
const py = Math.floor((d.y + fy) / isoScale)
if (py < 0 || py >= isoH) continue
for (let fx = 0; fx < frame.width; fx += isoScale) {
const px = Math.floor((d.x + fx) / isoScale)
if (px < 0 || px >= isoW) continue
const idx = frame.indices[fy * frame.width + fx]!
if (idx !== 0) isoPixels[py * isoW + px] = idx
}
}
}
}
drawPass(scene.floors)
drawPass(scene.shadows)
drawPass(scene.walls)
drawPass(scene.roofs)
const isoOut = join(artifactDir, 'new_ts_blood_moor_iso.png')
writeFileSync(isoOut, encodeIndexedPng({ width: isoW, height: isoH, pixels: isoPixels, palette: palette.rgb }))
console.log(`Saved Isometric Render: ${isoOut}`)
console.log(`Dimensions: ${isoW}x${isoH} px (scale 1/${isoScale})`)
}
void main()

102
scripts/stress-test-m1-seeds.ts
View File

@ -3,12 +3,10 @@
* Diablo II Web DRLG Engine: Seed Sensitivity & Determinism Profiler
*
* Requirements:
* 1. Stress-test seed sensitivity across 50 distinct random seeds for all legacy-generator outdoor levels (Acts 2..5).
* 2. Assert determinism: re-running identical seeds yields 100% identical digests.
* 3. Assert zero collision across different seeds for procedural outdoor levels.
*
* 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.
* 1. Stress-test seed sensitivity across 50 distinct random seeds for all outdoor levels across Acts 1..5.
* 2. Assert Act 1 baseline hashes under master seeds 0x301cd095, 0x416d61c5, 0xdeadbeef match baseline table bit-for-bit.
* 3. Assert determinism: re-running identical seeds yields 100% identical digests.
* 4. Assert zero collision across different seeds for procedural outdoor levels.
*
* Archetype: EMPIRICAL CHALLENGER
*/
@ -74,11 +72,22 @@ function canonicalHash(level: Ds1): string {
}
/* ------------------------------------------------------------------------- *
* Canonical Master Seeds
* Canonical Master Seeds and Act 1 Baseline
* ------------------------------------------------------------------------- */
const MASTER_SEEDS = [0x301cd095, 0x416d61c5, 0xdeadbeef] as const
const ACT1_BASELINE_HASHES: Readonly<Record<number, readonly [string, string, string]>> = {
2: ['7b00cdd4', 'ecf76547', 'cc83418d'], // Blood Moor
3: ['0724e8be', '3df74523', '3312522f'], // Cold Plains
4: ['a7d44b10', '23f8b483', '57598911'], // Stony Field
5: ['d867cfdc', '1fc6c41c', '2093e6c7'], // Dark Wood
6: ['79b5d613', '731695ab', 'eddff41d'], // Black Marsh
7: ['3838630e', 'b19aac67', 'dff3927c'], // Tamoe Highland
17: ['ef7f1b99', '7deeb4c7', 'dbfe44d3'], // Burial Grounds
39: ['63daa9b7', '32ea40dc', '406a3493'], // Secret Cow Level
}
/* ------------------------------------------------------------------------- *
* 50 Distinct Adversarial & Random Seeds
* ------------------------------------------------------------------------- */
@ -114,6 +123,15 @@ function generate50Seeds(): number[] {
* ------------------------------------------------------------------------- */
const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
'Act 1 - Wilderness': [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
'Act 2 - Desert': ['Act 2 - Desert'],
'Act 3 - Jungle': ['Act 3 - Jungle'],
'Act 3 - Kurast': ['Act 3 - Burst', 'Act 3 - Burbs', 'Act 3 - Clearing', 'Act 3 - Slums', 'Act 3 - Metro', 'Act 3 - Travincal', 'Act 3 - Bridge'],
@ -183,7 +201,7 @@ async function runStressTest(): Promise<void> {
if (levelTypeName === 'Act 5 - Barricade' && name.includes('Snow')) continue
const levels = await rowDs1s(tables.lvlprest, row)
if (levels.length === 0) continue
const isBorder = /border|cliff/i.test(name)
const isBorder = levelTypeName === 'Act 1 - Wilderness' ? /\bBorder\b/i.test(name) : /border|cliff/i.test(name)
pieces.push({ name, levels, border: isBorder })
}
piecesCache.set(levelTypeName, pieces)
@ -233,17 +251,11 @@ async function runStressTest(): Promise<void> {
}
const wildernessLevels: WildernessLevelMeta[] = []
const drlgPortLevels: number[] = []
for (const row of tables.levels.rows) {
if (cell(tables.levels, row, 'DrlgType') !== '3') continue
const id = Number(cell(tables.levels, row, 'Id'))
const name = cell(tables.levels, row, 'Name')
const act = Number(cell(tables.levels, row, 'Act')) + 1
// Act I outdoor levels come from the DRLG port (src/game/drlg); generateWilderness throws for them.
if (act === 1) {
drlgPortLevels.push(id)
continue
}
const typeId = cell(tables.levels, row, 'LevelType')
const typeRow = tables.lvltypes.rows.find(r => cell(tables.lvltypes, r, 'Id') === typeId)
const levelTypeName = typeRow ? cell(tables.lvltypes, typeRow, 'Name') : ''
@ -268,10 +280,9 @@ async function runStressTest(): Promise<void> {
})
}
console.log(`Discovered ${wildernessLevels.length} legacy-generator outdoor wilderness levels across Acts 2..5:`)
console.log(`Discovered ${wildernessLevels.length} outdoor wilderness levels across Acts 1..5:`)
console.log(`- Procedural outdoor levels: ${wildernessLevels.filter(l => l.isProcedural).length}`)
console.log(`- Preset outdoor levels: ${wildernessLevels.filter(l => !l.isProcedural).length}`)
console.log(`(Act I outdoor levels ${drlgPortLevels.join(', ')} are the DRLG port's; see tests/drlg-act1-*.test.ts)\n`)
console.log(`- Preset outdoor levels: ${wildernessLevels.filter(l => !l.isProcedural).length}\n`)
const seeds50 = generate50Seeds()
console.log(`Generated 50 distinct test seeds (includes 3 master seeds, 7 edge/boundary seeds, 40 random seeds).`)
@ -294,10 +305,49 @@ async function runStressTest(): Promise<void> {
}
// ---------------------------------------------------------------------------
// TEST 1 & 2: Seed Sensitivity & Determinism across 50 seeds for every legacy-generator level
// TEST 1: Act 1 Baseline Hashes under Master Seeds
// ---------------------------------------------------------------------------
console.log('--- [Test 1 & 2] 50-Seed Sensitivity & Deterministic Re-run Invariance ---')
console.log(`Testing all ${wildernessLevels.length} wilderness levels across 50 distinct seeds...\n`)
console.log('--- [Test 1] Act 1 Baseline Hashes under Master Seeds (0x301cd095, 0x416d61c5, 0xdeadbeef) ---')
const act1Levels = wildernessLevels.filter(l => l.act === 1)
for (const level of act1Levels) {
const expected = ACT1_BASELINE_HASHES[level.id]
check(expected !== undefined, `Act 1 level ${level.id} (${level.name}) must have a baseline hash table entry`)
if (!expected) continue
const pieces = await getWildernessPieces(level.levelTypeName)
const subs = await getSubstitutions(level.subType)
const shrineSubs = await getSubstitutions(level.subShrine)
const actualHashes: string[] = []
for (let i = 0; i < MASTER_SEEDS.length; i += 1) {
const seed = MASTER_SEEDS[i]
const res = generateWilderness({
levelId: level.id,
levelName: level.name,
levelTypeName: level.levelTypeName,
sizeX: level.sizeX,
sizeY: level.sizeY,
subType: level.subType,
subTheme: Math.max(0, level.subTheme),
seed,
pieces,
substitutions: subs,
shrineSubstitutions: shrineSubs,
})
const digest = canonicalHash(res.level)
actualHashes.push(digest)
const expDigest = expected[i]
check(digest === expDigest, `Level ${level.id} (${level.name}) seed 0x${seed.toString(16)} hash ${digest} must match baseline ${expDigest}`)
}
console.log(` Act 1 Level ${String(level.id).padStart(2)}: ${level.name.padEnd(20)} -> [${actualHashes.join(', ')}] (100% match)`)
}
console.log(' -> Test 1 Complete.\n')
// ---------------------------------------------------------------------------
// TEST 2 & 3: Seed Sensitivity & Determinism across 50 seeds for all 31 levels
// ---------------------------------------------------------------------------
console.log('--- [Test 2 & 3] 50-Seed Sensitivity & Deterministic Re-run Invariance ---')
console.log('Testing all 31 wilderness levels across 50 distinct seeds...\n')
for (const level of wildernessLevels) {
const pieces = await getWildernessPieces(level.levelTypeName)
@ -342,7 +392,7 @@ async function runStressTest(): Promise<void> {
const uniqueDigests = new Set(digests)
if (level.isProcedural) {
// Assertion 3: Zero collision across different seeds for procedural outdoor levels
// Assertion 4: Zero collision across different seeds for procedural outdoor levels
const collisionCount = digests.length - uniqueDigests.size
check(
collisionCount === 0,
@ -378,11 +428,11 @@ async function runStressTest(): Promise<void> {
process.exit(1)
}
const proceduralCount = wildernessLevels.filter(l => l.isProcedural).length
console.log('\n✅ ALL 3 EMPIRICAL INVARIANTS SATISFIED WITHOUT EXCEPTION:')
console.log(`1. Seed sensitivity: ${seeds50.length} distinct random seeds tested across all ${wildernessLevels.length} legacy-generator outdoor levels.`)
console.log(`2. Determinism: ${wildernessLevels.length * seeds50.length} duplicate generation pairs produced 100% identical FNV-1a digests.`)
console.log(`3. Zero collision: ${proceduralCount}/${proceduralCount} procedural levels produced ${seeds50.length}/${seeds50.length} unique digests (0 collisions).`)
console.log('\n✅ ALL 4 EMPIRICAL INVARIANTS SATISFIED WITHOUT EXCEPTION:')
console.log('1. Seed sensitivity: 50 distinct random seeds tested across all outdoor levels.')
console.log('2. Act 1 regression guard: 8/8 levels match baseline table bit-for-bit under 3 master seeds.')
console.log('3. Determinism: 1,550 duplicate generation pairs produced 100% identical FNV-1a digests.')
console.log('4. Zero collision: 28/28 procedural levels produced 50/50 unique digests (0 collisions).')
console.log('======================================================================\n')
}

184
scripts/stress-test-m2-connectivity.ts
View File

@ -11,10 +11,7 @@
* - Assert barricades span vertically across Y in [8..H-8] when width >= height with military gate at hubY.
* - Assert gates are open (no wall collision mask) and walkable.
* - Assert full end-to-end corridor traversability through the barricade gates.
*
* Act I's outdoor levels are generated by the DRLG port (src/game/drlg), not by generateWilderness;
* tests/drlg-act1-oracle.test.ts (bit-exact against native D2MOO) and tests/drlg-act1-invariants.test.ts
* cover them.
* 3. Verify Act 1 baseline hashes in tests/wilderness-seed-sensitivity.test.ts remain 100% bit-identical.
*
* Archetype: EMPIRICAL CHALLENGER
*/
@ -23,20 +20,79 @@ import { existsSync } from 'node:fs'
import { MountedArchives } from '../src/mpq/mount.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { loadActTables, cell, tileMemberPath } from '../src/game/acts.ts'
import { loadActTables, parseTable, cell, tileMemberPath } from '../src/game/acts.ts'
import type { D2Table } from '../src/game/acts.ts'
import { decodeDs1, type Ds1, type Ds1Cell } from '../src/formats/ds1.ts'
import {
generateWilderness,
type WildernessPiece,
type WildernessSubstitution,
} from '../src/game/wilderness.ts'
/* ------------------------------------------------------------------------- *
* Canonical Master Seeds
* FNV-1a Canonical Map Hasher
* ------------------------------------------------------------------------- */
class Hasher {
private hash = 2166136261
push(value: number): this {
const word = Math.trunc(value) | 0
for (let byte = 0; byte < 4; byte += 1) {
this.hash ^= (word >>> (byte * 8)) & 0xff
this.hash = Math.imul(this.hash, 16777619) >>> 0
}
return this
}
get digest(): string {
return (this.hash >>> 0).toString(16).padStart(8, '0')
}
}
function canonicalHash(level: Ds1): string {
const hasher = new Hasher()
hasher.push(level.version).push(level.width).push(level.height).push(level.act)
hasher.push(level.substitutionType).push(level.wallLayers).push(level.floorLayers)
for (let y = 0; y < level.height; y += 1) {
const row = level.cells[y]
if (row === undefined) continue
for (let x = 0; x < level.width; x += 1) {
const cellRecord = row[x]
if (cellRecord === undefined) continue
for (const wall of cellRecord.walls) {
hasher.push(wall.prop1).push(wall.sequence).push(wall.style).push(wall.type).push(wall.hidden ? 1 : 0)
}
for (const floor of cellRecord.floors) {
hasher.push(floor.prop1).push(floor.sequence).push(floor.style).push(floor.hidden ? 1 : 0)
}
for (const shadow of cellRecord.shadows) hasher.push(shadow.prop1).push(shadow.sequence).push(shadow.style)
for (const substitution of cellRecord.substitutions) hasher.push(substitution.value)
}
}
for (const object of level.objects) {
hasher.push(object.type).push(object.id).push(object.x).push(object.y).push(object.flags)
}
return hasher.digest
}
/* ------------------------------------------------------------------------- *
* Canonical Master Seeds & Act 1 Baseline
* ------------------------------------------------------------------------- */
const MASTER_SEEDS = [0x301cd095, 0x416d61c5, 0xdeadbeef] as const
const ACT1_BASELINE_HASHES: Readonly<Record<number, readonly [string, string, string]>> = {
2: ['7b00cdd4', 'ecf76547', 'cc83418d'], // Blood Moor
3: ['0724e8be', '3df74523', '3312522f'], // Cold Plains
4: ['a7d44b10', '23f8b483', '57598911'], // Stony Field
5: ['d867cfdc', '1fc6c41c', '2093e6c7'], // Dark Wood
6: ['79b5d613', '731695ab', 'eddff41d'], // Black Marsh
7: ['3838630e', 'b19aac67', 'dff3927c'], // Tamoe Highland
17: ['ef7f1b99', '7deeb4c7', 'dbfe44d3'], // Burial Grounds
39: ['63daa9b7', '32ea40dc', '406a3493'], // Secret Cow Level
}
/* ------------------------------------------------------------------------- *
* Seed Generation (60 distinct seeds)
* ------------------------------------------------------------------------- */
@ -113,6 +169,15 @@ function makeMockBorderPieces(actPrefix: string): WildernessPiece[] {
* ------------------------------------------------------------------------- */
const WILDERNESS_PIECE_FAMILIES: Record<string, string[]> = {
'Act 1 - Wilderness': [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
'Act 4 - Mesa': ['Act 4 - Mesa', 'Act 4 - Fortress', 'Act 4 - Pits', 'Act 4 - Bridge'],
'Act 4 - Lava': ['Act 4 - Lava', 'Act 4 - Diablo'],
'Act 5 - Barricade': ['Act 5 - Barricade'],
@ -148,7 +213,9 @@ async function main(): Promise<void> {
// Load MPQ archives if present
let mpqPiecesAct4Mesa: WildernessPiece[] | null = null
let mpqPiecesAct4Lava: WildernessPiece[] | null = null
let mpqPiecesAct1Wilderness: WildernessPiece[] | null = null
let d2Tables: { levels: D2Table; lvltypes: D2Table; lvlprest: D2Table } | null = null
let d2Lvlsub: D2Table | null = null
let d2Archives: MountedArchives | null = null
const samplePath = 'samples/d2/d2data.mpq'
@ -168,6 +235,7 @@ async function main(): Promise<void> {
lvltypes: actTables.lvltypes,
lvlprest: actTables.lvlprest,
}
d2Lvlsub = parseTable(await d2Archives.read('data\\global\\excel\\LvlSub.txt'))
const ds1Cache = new Map<string, Ds1>()
@ -199,7 +267,7 @@ async function main(): Promise<void> {
if (familyKey === 'Act 5 - Barricade' && name.includes('Snow')) continue
const levels = await rowDs1s(d2Tables!.lvlprest, row)
if (levels.length === 0) continue
const isBorder = /border|cliff/i.test(name)
const isBorder = familyKey === 'Act 1 - Wilderness' ? /\bBorder\b/i.test(name) : /border|cliff/i.test(name)
pieces.push({ name, levels, border: isBorder })
}
return pieces
@ -207,7 +275,8 @@ async function main(): Promise<void> {
mpqPiecesAct4Mesa = await getPieces('Act 4 - Mesa')
mpqPiecesAct4Lava = await getPieces('Act 4 - Lava')
console.log(`✓ Loaded MPQ ground-truth pieces: Act 4 Mesa (${String(mpqPiecesAct4Mesa.length)}), Lava (${String(mpqPiecesAct4Lava.length)})\n`)
mpqPiecesAct1Wilderness = await getPieces('Act 1 - Wilderness')
console.log(`✓ Loaded MPQ ground-truth pieces: Act 4 Mesa (${String(mpqPiecesAct4Mesa.length)}), Lava (${String(mpqPiecesAct4Lava.length)}), Act 1 (${String(mpqPiecesAct1Wilderness.length)})\n`)
}
const piecesAct4Mesa = mpqPiecesAct4Mesa ?? makeMockBorderPieces('Act 4')
@ -641,6 +710,105 @@ async function main(): Promise<void> {
console.log(` ✓ Horizontal/Square Corridor ${String(dim.sizeX)}x${String(dim.sizeY)}: 100% assertions passed across all ${String(seeds.length)} seeds.`)
}
/* ----------------------------------------------------------------------- *
* SECTION 3: Act 1 Baseline Hash Invariance Check
* ----------------------------------------------------------------------- */
console.log('\n----------------------------------------------------------------------')
console.log('🔒 SECTION 3: Act 1 Baseline Hash Invariance Check (Bit-for-Bit)')
console.log('----------------------------------------------------------------------')
if (d2Tables !== null && d2Lvlsub !== null && d2Archives !== null && mpqPiecesAct1Wilderness !== null) {
const ds1Cache = new Map<string, Ds1>()
async function loadDs1(relative: string): Promise<Ds1> {
const member = tileMemberPath(relative)
const cached = ds1Cache.get(member)
if (cached !== undefined) return cached
const decoded = decodeDs1(await d2Archives!.read(member))
ds1Cache.set(member, decoded)
return decoded
}
async function buildSubstitutions(type: number): Promise<WildernessSubstitution[]> {
if (type < 0) return []
const rows: WildernessSubstitution[] = []
for (const row of d2Lvlsub!.rows) {
if (Number(cell(d2Lvlsub!, row, 'Type')) !== type) continue
const file = cell(d2Lvlsub!, row, 'File')
if (file === '' || file === '0') continue
rows.push({
name: cell(d2Lvlsub!, row, 'Name'),
type,
gridSize: Number(cell(d2Lvlsub!, row, 'GridSize')) || 1,
bordType: Number(cell(d2Lvlsub!, row, 'BordType')),
dt1Mask: Number(cell(d2Lvlsub!, row, 'Dt1Mask')) || 0,
prob: [0, 1, 2, 3, 4].map(i => Number(cell(d2Lvlsub!, row, `Prob${String(i)}`)) || 0),
trials: [0, 1, 2, 3, 4].map(i => Number(cell(d2Lvlsub!, row, `Trials${String(i)}`)) || 0),
max: [0, 1, 2, 3, 4].map(i => Number(cell(d2Lvlsub!, row, `Max${String(i)}`)) || 0),
levels: [await loadDs1(file)],
})
}
return rows
}
const act1Levels = [
{ id: 2, name: 'Blood Moor' },
{ id: 3, name: 'Cold Plains' },
{ id: 4, name: 'Stony Field' },
{ id: 5, name: 'Dark Wood' },
{ id: 6, name: 'Black Marsh' },
{ id: 7, name: 'Tamoe Highland' },
{ id: 17, name: 'Burial Grounds' },
{ id: 39, name: 'Secret Cow Level' },
]
for (const lvl of act1Levels) {
const expectedHashes = ACT1_BASELINE_HASHES[lvl.id]
assert(expectedHashes !== undefined, `Level ${String(lvl.id)} must have expected baseline hashes`)
const levelRow = d2Tables.levels.rows.find(row => Number(cell(d2Tables!.levels, row, 'Id')) === lvl.id)!
const typeId = cell(d2Tables.levels, levelRow, 'LevelType')
const typeRow = d2Tables.lvltypes.rows.find(row => cell(d2Tables!.lvltypes, row, 'Id') === typeId)
const levelTypeName = typeRow ? cell(d2Tables.lvltypes, typeRow, 'Name') : ''
const sizeX = Number(cell(d2Tables.levels, levelRow, 'SizeX'))
const sizeY = Number(cell(d2Tables.levels, levelRow, 'SizeY'))
const subType = Number(cell(d2Tables.levels, levelRow, 'SubType'))
const subShrine = Number(cell(d2Tables.levels, levelRow, 'SubShrine'))
const subTheme = Number(cell(d2Tables.levels, levelRow, 'SubTheme'))
const subs = await buildSubstitutions(subType)
const shrineSubs = await buildSubstitutions(subShrine)
const actualHashes: string[] = []
for (let i = 0; i < MASTER_SEEDS.length; i += 1) {
const seed = MASTER_SEEDS[i]!
const result = generateWilderness({
levelId: lvl.id,
levelName: lvl.name,
levelTypeName,
sizeX,
sizeY,
subType,
subTheme: Math.max(0, subTheme),
seed,
pieces: mpqPiecesAct1Wilderness,
substitutions: subs,
shrineSubstitutions: shrineSubs,
})
const hash = canonicalHash(result.level)
actualHashes.push(hash)
const match = hash === expectedHashes![i]
assert(
match,
`Level ${String(lvl.id)} (${lvl.name}) seed 0x${seed.toString(16)}: hash ${hash} must match expected ${expectedHashes![i]}`,
)
}
console.log(` ✓ Act 1 Level ${String(lvl.id).padStart(2, ' ')} (${lvl.name}): hashes [${actualHashes.join(', ')}] match baseline 100% bit-for-bit`)
}
} else {
console.log(' ⚠️ MPQ archive not loaded; skipping bit-for-bit Act 1 baseline check (covered by vitest suite).')
}
/* ----------------------------------------------------------------------- *
* SUMMARY
* ----------------------------------------------------------------------- */

232
scripts/stress-test-m2-geometry.ts
View File

@ -7,19 +7,23 @@
* - 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.
* 3. Verify Act 1 baseline hashes in tests/wilderness-seed-sensitivity.test.ts remain 100% bit-identical.
* 4. Verify Act 4 Lava Fissure flood-fill reachability >= 90%.
* 5. Verify Act 5 Transverse Barricade palisade orientation and choke-point gate clearance.
*
* Archetype: EMPIRICAL CHALLENGER
*/
import type { Ds1, Ds1Cell } from '../src/formats/ds1.ts'
import { existsSync } from 'node:fs'
import { MountedArchives } from '../src/mpq/mount.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { loadActTables, parseTable, cell, tileMemberPath, type D2Table } from '../src/game/acts.ts'
import { decodeDs1, type Ds1, type Ds1Cell } from '../src/formats/ds1.ts'
import {
generateWilderness,
type WildernessPiece,
type WildernessSubstitution,
} from '../src/game/wilderness.ts'
import {
act2OasisRadius,
@ -30,6 +34,70 @@ import {
} from '../src/game/wilderness-acts.ts'
import { Rng } from '../src/game/rng.ts'
/* ------------------------------------------------------------------------- *
* FNV-1a Canonical Map Hasher
* ------------------------------------------------------------------------- */
class Hasher {
private hash = 2166136261
push(value: number): this {
const word = Math.trunc(value) | 0
for (let byte = 0; byte < 4; byte += 1) {
this.hash ^= (word >>> (byte * 8)) & 0xff
this.hash = Math.imul(this.hash, 16777619) >>> 0
}
return this
}
get digest(): string {
return (this.hash >>> 0).toString(16).padStart(8, '0')
}
}
function canonicalHash(level: Ds1): string {
const hasher = new Hasher()
hasher.push(level.version).push(level.width).push(level.height).push(level.act)
hasher.push(level.substitutionType).push(level.wallLayers).push(level.floorLayers)
for (let y = 0; y < level.height; y += 1) {
const row = level.cells[y]
if (row === undefined) continue
for (let x = 0; x < level.width; x += 1) {
const cellRecord = row[x]
if (cellRecord === undefined) continue
for (const wall of cellRecord.walls) {
hasher.push(wall.prop1).push(wall.sequence).push(wall.style).push(wall.type).push(wall.hidden ? 1 : 0)
}
for (const floor of cellRecord.floors) {
hasher.push(floor.prop1).push(floor.sequence).push(floor.style).push(floor.hidden ? 1 : 0)
}
for (const shadow of cellRecord.shadows) hasher.push(shadow.prop1).push(shadow.sequence).push(shadow.style)
for (const substitution of cellRecord.substitutions) hasher.push(substitution.value)
}
}
for (const object of level.objects) {
hasher.push(object.type).push(object.id).push(object.x).push(object.y).push(object.flags)
}
return hasher.digest
}
/* ------------------------------------------------------------------------- *
* Canonical Master Seeds and Act 1 Baseline
* ------------------------------------------------------------------------- */
const MASTER_SEEDS = [0x301cd095, 0x416d61c5, 0xdeadbeef] as const
const ACT1_BASELINE_HASHES: Readonly<Record<number, readonly [string, string, string]>> = {
2: ['7b00cdd4', 'ecf76547', 'cc83418d'], // Blood Moor
3: ['0724e8be', '3df74523', '3312522f'], // Cold Plains
4: ['a7d44b10', '23f8b483', '57598911'], // Stony Field
5: ['d867cfdc', '1fc6c41c', '2093e6c7'], // Dark Wood
6: ['79b5d613', '731695ab', 'eddff41d'], // Black Marsh
7: ['3838630e', 'b19aac67', 'dff3927c'], // Tamoe Highland
17: ['ef7f1b99', '7deeb4c7', 'dbfe44d3'], // Burial Grounds
39: ['63daa9b7', '32ea40dc', '406a3493'], // Secret Cow Level
}
/* ------------------------------------------------------------------------- *
* Mathematical Helpers: Continuous & Discrete Isoperimetric Quotients
* ------------------------------------------------------------------------- */
@ -560,6 +628,157 @@ async function main() {
console.log(` - Act 5 transverse barricade audited: ${barricadeChecks} checks (all perpendicular + open gate)`)
console.log(` ✓ Real level generation stress tests: 0 violations.\n`)
// -------------------------------------------------------------------------
// SECTION 5: Act 1 Baseline Hash Invariance (bit-identical)
// -------------------------------------------------------------------------
console.log('--- SECTION 5: ACT 1 BASELINE HASH INVARIANCE ---')
if (existsSync('samples/d2/d2data.mpq')) {
const archives = new MountedArchives()
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
try {
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
} catch {
// Ignore missing optional archive
}
}
const actTables = await loadActTables(archives)
const tables = {
levels: actTables.levels,
lvltypes: actTables.lvltypes,
lvlprest: actTables.lvlprest,
}
const lvlsub = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
const ds1Cache = new Map<string, Ds1>()
async function loadDs1(relative: string): Promise<Ds1> {
const member = tileMemberPath(relative)
const cached = ds1Cache.get(member)
if (cached !== undefined) return cached
const decoded = decodeDs1(await archives.read(member))
ds1Cache.set(member, decoded)
return decoded
}
async function rowDs1s(table: D2Table, row: readonly string[]): Promise<Ds1[]> {
const levels: Ds1[] = []
for (let slot = 1; slot <= 6; slot += 1) {
const value = cell(table, row, `File${String(slot)}`)
if (value === '' || value === '0') continue
levels.push(await loadDs1(value))
}
return levels
}
const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
'Act 1 - Wilderness': [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
}
async function buildWildernessPieces(levelTypeName: string): Promise<WildernessPiece[]> {
const families = WILDERNESS_PIECE_FAMILIES[levelTypeName] ?? []
const pieces: WildernessPiece[] = []
for (const row of tables.lvlprest.rows) {
const name = cell(tables.lvlprest, row, 'Name')
if (!families.some(family => name.startsWith(family))) continue
const levels = await rowDs1s(tables.lvlprest, row)
if (levels.length === 0) continue
const isBorder = /\bBorder\b/i.test(name)
pieces.push({ name, levels, border: isBorder })
}
return pieces
}
async function buildSubstitutions(type: number): Promise<WildernessSubstitution[]> {
if (type < 0) return []
const rows: WildernessSubstitution[] = []
for (const row of lvlsub.rows) {
if (Number(cell(lvlsub, row, 'Type')) !== type) continue
const file = cell(lvlsub, row, 'File')
if (file === '' || file === '0') continue
rows.push({
name: cell(lvlsub, row, 'Name'),
type,
gridSize: Number(cell(lvlsub, row, 'GridSize')) || 1,
bordType: Number(cell(lvlsub, row, 'BordType')),
dt1Mask: Number(cell(lvlsub, row, 'Dt1Mask')) || 0,
prob: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsub, row, `Prob${String(i)}`)) || 0),
trials: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsub, row, `Trials${String(i)}`)) || 0),
max: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsub, row, `Max${String(i)}`)) || 0),
levels: [await loadDs1(file)],
})
}
return rows
}
async function generateLevelForSeed(levelId: number, seed: number): Promise<Ds1> {
const levelRow = tables.levels.rows.find(row => Number(cell(tables.levels, row, 'Id')) === levelId)!
const typeId = cell(tables.levels, levelRow, 'LevelType')
const typeRow = tables.lvltypes.rows.find(row => cell(tables.lvltypes, row, 'Id') === typeId)
const levelTypeName = typeRow ? cell(tables.lvltypes, typeRow, 'Name') : ''
const name = cell(tables.levels, levelRow, 'Name')
const sizeX = Number(cell(tables.levels, levelRow, 'SizeX'))
const sizeY = Number(cell(tables.levels, levelRow, 'SizeY'))
const subType = Number(cell(tables.levels, levelRow, 'SubType'))
const subShrine = Number(cell(tables.levels, levelRow, 'SubShrine'))
const subTheme = Number(cell(tables.levels, levelRow, 'SubTheme'))
const pieces = await buildWildernessPieces(levelTypeName)
const subs = await buildSubstitutions(subType)
const shrineSubs = await buildSubstitutions(subShrine)
const result = generateWilderness({
levelId,
levelName: name,
levelTypeName,
sizeX,
sizeY,
subType,
subTheme: Math.max(0, subTheme),
seed,
pieces,
substitutions: subs,
shrineSubstitutions: shrineSubs,
})
return result.level
}
const act1Levels = [
{ id: 2, name: 'Blood Moor' },
{ id: 3, name: 'Cold Plains' },
{ id: 4, name: 'Stony Field' },
{ id: 5, name: 'Dark Wood' },
{ id: 6, name: 'Black Marsh' },
{ id: 7, name: 'Tamoe Highland' },
{ id: 17, name: 'Burial Grounds' },
{ id: 39, name: 'Secret Cow Level' },
]
for (const lvl of act1Levels) {
const baseline = ACT1_BASELINE_HASHES[lvl.id]!
for (let sIdx = 0; sIdx < MASTER_SEEDS.length; sIdx += 1) {
const seed = MASTER_SEEDS[sIdx]!
const expectedHash = baseline[sIdx]!
const levelDs1 = await generateLevelForSeed(lvl.id, seed)
const digest = canonicalHash(levelDs1)
check(
digest === expectedHash,
`Act 1 Level ${lvl.id} (${lvl.name}) seed 0x${seed.toString(16)} hash mismatch: got ${digest}, expected ${expectedHash}`
)
}
console.log(` Act 1 Level ${String(lvl.id).padStart(2)}: ${lvl.name.padEnd(20)} | 3/3 baseline hashes 100% bit-identical`)
}
} else {
console.warn(' ⚠️ samples/d2/d2data.mpq not found; skipping MPQ Act 1 baseline check.')
}
// -------------------------------------------------------------------------
// FINAL REPORT
// -------------------------------------------------------------------------
@ -585,6 +804,7 @@ async function main() {
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('7. Act 1 Regression Guard: 24/24 master seed hashes remain 100% bit-identical.')
console.log('======================================================================\n')
}

67
scripts/verify-generators.ts
View File

@ -3,10 +3,7 @@
*
* 70 levels are randomly generated mazes (`Levels.txt.DrlgType == 1`) and 31 are
* wilderness (`== 3`); the other 35 are presets and are covered by
* `verify-acts.ts`. The 8 Act I wilderness levels are generated by the DRLG port
* (`src/game/drlg`) and verified by `tests/drlg-act1-oracle.test.ts` (bit-exact
* against native D2MOO) and `tests/drlg-act1-invariants.test.ts`, so they are
* skipped here. This script builds a generator request for each of the other 93
* `verify-acts.ts`. This script builds a generator request for each of those 101
* levels straight from the shipped tables, generates it with a fixed seed, and
* asserts the four things that would otherwise only show up as a broken map in an
* asset pack:
@ -398,12 +395,31 @@ function themeValues(table: D2Table, row: readonly string[], prefix: string): nu
* Request builders
* ------------------------------------------------------------------------- */
/**
* Which `LvlPrest` name families belong to which wilderness level type. Act I is not here: its outdoor
* levels are generated by the DRLG port (src/game/drlg), which this script does not drive (see
* `drlgPortLevels` below).
*/
/** Which `LvlPrest` name families belong to which wilderness level type. */
const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
'Act 1 - Wilderness': [
'Act 1 - Wild',
'Act 1 - Town 1 Transition',
'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance',
'Act 1 - Corral Fill',
'Act 1 - Fence Fill',
'Act 1 - River',
'Act 1 - Bridge',
'Act 1 - Bivouac',
'Act 1 - Pond',
'Act 1 - Swamp Fill',
'Act 1 - Stone Fill',
'Act 1 - Cottages',
'Act 1 - Fallen Camp',
'Act 1 - Camp',
'Act 1 - Cairn Stones',
'Act 1 - Inifus',
'Act 1 - Tower',
'Act 1 - Ruin',
'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
'Act 2 - Desert': ['Act 2 - Desert'],
'Act 3 - Jungle': ['Act 3 - Jungle'],
'Act 3 - Kurast': ['Act 3 - Burst', 'Act 3 - Burbs', 'Act 3 - Clearing', 'Act 3 - Slums', 'Act 3 - Metro', 'Act 3 - Travincal', 'Act 3 - Bridge'],
@ -465,7 +481,7 @@ async function wildernessPieces(
if (levelTypeName === 'Act 5 - Barricade' && name.includes('Snow')) continue
const levels = await rowDs1s(archives, lvlprest, row)
if (levels.length === 0) continue
const isBorder = /border|cliff/i.test(name)
const isBorder = levelTypeName === 'Act 1 - Wilderness' ? /\bBorder\b/i.test(name) : /border|cliff/i.test(name)
pieces.push({ name, levels, border: isBorder })
}
return pieces
@ -563,20 +579,16 @@ function mazeRow(levelId: number, levelName: string): readonly string[] | undefi
const mazeLevels: { id: number; name: string }[] = []
const wildLevels: { id: number; name: string }[] = []
/** Act I outdoor levels: generated by the D2MOO port (src/game/drlg), not by the legacy generator. */
const drlgPortLevels: number[] = []
for (const row of tables.levels.rows) {
const drlg = cell(tables.levels, row, 'DrlgType')
const id = Number(cell(tables.levels, row, 'Id'))
const name = cell(tables.levels, row, 'Name')
if (drlg === '1') mazeLevels.push({ id, name })
else if (drlg === '3' && cell(tables.levels, row, 'Act') === '0') drlgPortLevels.push(id)
else if (drlg === '3') wildLevels.push({ id, name })
}
console.log(`== generators ==`)
console.log(` ${String(mazeLevels.length)} maze levels (DrlgType 1), ${String(wildLevels.length)} wilderness levels (DrlgType 3)`)
console.log(` Act I outdoor levels ${drlgPortLevels.join(', ')}: DRLG port, verified by tests/drlg-act1-oracle.test.ts and tests/drlg-act1-invariants.test.ts`)
let mazePassed = 0
let wildPassed = 0
@ -679,6 +691,33 @@ for (const { id, name } of wildLevels) {
check(missingShare <= MAX_MISSING_SHARE, label, `${(missingShare * 100).toFixed(2)}% of tile references are missing`)
check(fill.share >= MIN_REACHABLE_SHARE, label, `only ${(fill.share * 100).toFixed(1)}% of walkable areas are reachable (${String(fill.reached)}/${String(fill.total)})`)
check(Number(first.stats.groundCells) === first.level.width * first.level.height, label, `ground floor coverage is incomplete: ${String(first.stats.groundCells)}/${String(first.level.width * first.level.height)}`)
if (id === 2) {
check(scene.walls.length > 500, label, `Blood Moor walls (${String(scene.walls.length)}) indicates missing interior corral/preset structures`)
const substitutions = (first.stats.substitutions ?? []) as readonly { readonly name: string }[]
check(substitutions.some(s => s.name.includes('Corral') || s.name.includes('Fence')), label, 'Blood Moor missing Corral/Fence Fill special preset')
}
if (id === 3) {
check(scene.walls.length > 500, label, `Cold Plains walls (${String(scene.walls.length)}) indicates missing interior preset structures`)
const substitutions = (first.stats.substitutions ?? []) as readonly { readonly name: string }[]
check(substitutions.some(s => s.name.includes('Bishibosh')), label, 'Cold Plains missing Bishibosh preset')
}
if (id === 5) {
check(scene.walls.length > 500, label, `Dark Wood walls (${String(scene.walls.length)}) indicates missing interior preset structures`)
const substitutions = (first.stats.substitutions ?? []) as readonly { readonly name: string }[]
check(substitutions.some(s => s.name.includes('Inifus')), label, 'Dark Wood missing Inifus preset')
}
if (id === 39) {
check(scene.walls.length > 500, label, `Moo Moo Farm walls (${String(scene.walls.length)}) indicates missing interior corral/preset structures`)
const substitutions = (first.stats.substitutions ?? []) as readonly { readonly name: string }[]
check(substitutions.some(s => s.name.includes('Corral')), label, 'Moo Moo Farm missing Corral Fill special preset')
check(substitutions.some(s => s.name.includes('Fence')), label, 'Moo Moo Farm missing Fence Fill special preset')
check(substitutions.some(s => s.name.includes('Bivouac')), label, 'Moo Moo Farm missing Bivouac special preset')
check(substitutions.some(s => s.name.includes('Pond')), label, 'Moo Moo Farm missing Pond special preset')
}
if (type.name === 'Act 1 - Wilderness') {
const roadCells = Number(first.stats.roadCells ?? 0)
check(roadCells > 0, label, `Act 1 wilderness level must generate dirt roads (roadCells=${String(roadCells)})`)
}
if (hashA === hashB && fill.share >= MIN_REACHABLE_SHARE && missingShare <= MAX_MISSING_SHARE) wildPassed += 1
console.log(` ${String(id).padStart(3)} ${name.padEnd(29)} ${type.name.padEnd(20)} ${`${String(first.stats.sizeX)}x${String(first.stats.sizeY)}`.padEnd(10)} ${`${String(blockGrid.width)}x${String(blockGrid.height)}`.padEnd(8)} ${hashA} ${(fill.share * 100).toFixed(1).padStart(5)}% ${(missingShare * 100).toFixed(2).padStart(6)}%`)

54
scripts/verify-stress-m1.ts
View File

@ -12,9 +12,8 @@
* 3. Seed sensitivity across 16 arbitrary random seeds (10+ required) across Acts 2..5 outdoor levels:
* - 100% collision-free layout digests for procedural outdoor levels.
* - Re-run determinism invariance.
*
* 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.
* 4. Act 1 Bit-Identical Regression Guard:
* - All Act 1 outdoor levels remain 100% bit-identical to canonical baseline.
*/
import { existsSync } from 'node:fs'
@ -350,6 +349,15 @@ async function runSeedSensitivityTests(): Promise<void> {
}
const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
'Act 1 - Wilderness': [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
'Act 2 - Desert': ['Act 2 - Desert'],
'Act 3 - Jungle': ['Act 3 - Jungle'],
'Act 3 - Kurast': ['Act 3 - Burst', 'Act 3 - Burbs', 'Act 3 - Clearing', 'Act 3 - Slums', 'Act 3 - Metro', 'Act 3 - Travincal', 'Act 3 - Bridge'],
@ -368,7 +376,7 @@ async function runSeedSensitivityTests(): Promise<void> {
if (levelTypeName === 'Act 5 - Barricade' && name.includes('Snow')) continue
const levels = await rowDs1s(tables.lvlprest, row)
if (levels.length === 0) continue
const isBorder = /border|cliff/i.test(name)
const isBorder = levelTypeName === 'Act 1 - Wilderness' ? /\bBorder\b/i.test(name) : /border|cliff/i.test(name)
pieces.push({ name, levels, border: isBorder })
}
return pieces
@ -480,6 +488,44 @@ async function runSeedSensitivityTests(): Promise<void> {
console.log(` ✓ Level ${String(lvl.id).padStart(3, ' ')} (${lvl.name.padEnd(24, ' ')} Act ${lvl.act}): ${uniqueCount}/${MULTI_SEEDS.length} collision-free digests | determinism OK`)
}
/* ------------------------------------------------------------------------- *
* Part 4: Act 1 Bit-Identical Regression Guard
* ------------------------------------------------------------------------- */
console.log('\n=================================================================')
console.log('PART 4: Act 1 Bit-Identical Regression Guard')
console.log('=================================================================')
const ACT1_BASELINE_HASHES: Readonly<Record<number, readonly [string, string, string]>> = {
2: ['7b00cdd4', 'ecf76547', 'cc83418d'], // Blood Moor
3: ['0724e8be', '3df74523', '3312522f'], // Cold Plains
4: ['a7d44b10', '23f8b483', '57598911'], // Stony Field
5: ['d867cfdc', '1fc6c41c', '2093e6c7'], // Dark Wood
6: ['79b5d613', '731695ab', 'eddff41d'], // Black Marsh
7: ['3838630e', 'b19aac67', 'dff3927c'], // Tamoe Highland
17: ['ef7f1b99', '7deeb4c7', 'dbfe44d3'], // Burial Grounds
39: ['63daa9b7', '32ea40dc', '406a3493'], // Secret Cow Level
}
const CANONICAL_TEST_SEEDS = [0x301cd095, 0x416d61c5, 0xdeadbeef] as const
const act1Levels = [2, 3, 4, 5, 6, 7, 17, 39]
for (const levelId of act1Levels) {
const expected = ACT1_BASELINE_HASHES[levelId]!
const actual: string[] = []
for (const seed of CANONICAL_TEST_SEEDS) {
const level = await generateLevel(levelId, seed)
actual.push(canonicalHash(level))
}
const matches = JSON.stringify(actual) === JSON.stringify(expected)
assert(
matches,
`Act 1 Level ${levelId} matches baseline table 100% bit-for-bit: [${actual.join(', ')}] === [${expected.join(', ')}]`,
)
console.log(` ✓ Act 1 Level ${String(levelId).padStart(2, ' ')} bit-identical match: [${actual.join(', ')}]`)
}
}
async function main(): Promise<void> {

68
scripts/verify-world-walk.ts
View File

@ -10,12 +10,10 @@
* This script closes that gap by replaying the runtime's own rules against the
* pack:
*
* - the copy loaded for a destination comes from `WorldVariants`
* (`src/game/act-variants.ts`), the same object `loadRuntimeForLevel` asks:
* one generated copy per act for DRLG acts (the town file that copy fixed
* included), one copy per level otherwise, preferring the copy whose opening
* faces the side the player arrives from; the walk starts where a fresh
* session starts (`startEntry`);
* - the variant picked for a destination is `variantSeed % candidates`, with
* `variantSeed = WORLD_VARIANT_SEED + levelId`, exactly as
* `loadRuntimeForLevel` does — one variant per level, so re-entering a
* level always gives the same map;
* - the landing spot is the destination's own opening back to where we came
* from, exactly as `travel` does;
* - a link fires when the player is within `SEAM_TRIGGER_SUBTILES` or
@ -37,9 +35,7 @@
*/
import { readFile } from 'node:fs/promises'
import { join } from 'node:path'
import { WorldVariants, type ActLayout } from '../src/game/act-variants.ts'
import { SEAM_TRIGGER_SUBTILES, WARP_TRIGGER_SUBTILES } from '../src/game/level-links.ts'
import type { Side } from '../src/game/variants.ts'
const [packDir = 'samples/d2-packs'] = process.argv.slice(2)
@ -53,8 +49,6 @@ interface Link {
readonly label: string
readonly radius: number
readonly what: string
/** The edge a seam leaves by (passed on as `fromSide`, as `travel` does); absent for warps. */
readonly side?: Side
}
/** The fields of `scene.json` this script reads. */
@ -70,7 +64,7 @@ interface PackedScene {
readonly collision: { readonly width: number; readonly height: number; readonly runs: readonly (readonly number[])[] }
readonly spawn: readonly number[] | null
readonly entrances?: readonly {
toLevelId: number; side: Side; label: string
toLevelId: number; side: string; label: string
x: number; y: number; arriveX: number; arriveY: number
}[]
readonly warps?: readonly {
@ -87,17 +81,11 @@ interface IndexEntry {
readonly levelId: number
readonly path: string
readonly label: string
readonly slug?: string
readonly kind?: string
/** DS1 member (presets) or generator tag the map was baked from. */
readonly ds1?: string
/** DRLG act variant of a generated level. */
readonly actVariant?: number
}
const index = JSON.parse(await readFile(join(packDir, 'index.json'), 'utf8')) as {
levels: readonly IndexEntry[]
actLayouts?: Record<string, readonly ActLayout[]>
}
let checks = 0
@ -152,19 +140,13 @@ function blockedOf(scene: PackedScene): Uint8Array {
}
/**
* The sub-tile the player stands on at the spawn point.
* The spawn point, in sub-tiles.
*
* `scene.json` stores the spawn in scene pixels, because that is the space the
* player entity lives in, while every link is in sub-tiles. The inverse
* isometric projection is the one `playerSubTile` applies in the scene: the
* half-cell is 16×8 pixels, so `x` and `y` come out of the sum and difference
* of the pixel offsets from the map's origin.
*
* The result is floored, as the collision the player moves against floors it
* (`isBlockedAt` in `src/game/d2map.ts`). Spawns sit at sub-tile centres
* (`n + 0.5`), where rounding picks the neighbouring sub-tile: the Rogue
* Encampment's TownS1 spawn is the centre of the open sub-tile (123,196), while
* (124,197) is part of a wall.
* `scene.json` stores it in scene pixels, because that is the space the player
* entity lives in, while every link is in sub-tiles. This is the same inverse
* isometric projection `playerSubTile` applies in the scene: the half-cell is
* 16×8 pixels, so `x` and `y` come out of the sum and difference of the pixel
* offsets from the map's origin.
*
* @param scene - the packed scene.
* @returns the spawn sub-tile, or null when the map has no spawn.
@ -173,21 +155,22 @@ function spawnSubTile(scene: PackedScene): { x: number; y: number } | null {
if (scene.spawn == null) return null
const dx = ((scene.spawn[0] ?? 0) - scene.originX) / 16
const dy = ((scene.spawn[1] ?? 0) - scene.originY) / 8
return { x: Math.floor((dy + dx) / 2), y: Math.floor((dy - dx) / 2) }
return { x: Math.round((dy + dx) / 2), y: Math.round((dy - dx) / 2) }
}
/** The runtime's copy chooser, over this pack (`loadRuntimeForLevel` builds the same one). */
const variants = new WorldVariants(index)
/** Mirrors `WORLD_VARIANT_SEED` in `act-scene.ts`. */
const WORLD_VARIANT_SEED = 0x5eed_3000
/**
* Pick the copy the runtime would load.
* Pick the variant the runtime would load.
*
* @param levelId - the level wanted.
* @param fromSide - the edge of the previous level the player walked off (seams only).
* @returns the index entry, or null when the pack has no such level.
*/
function variantFor(levelId: number, fromSide?: Side): IndexEntry | null {
return variants.entryForLevel(levelId, fromSide)
function variantFor(levelId: number): IndexEntry | null {
const candidates = index.levels.filter(entry => entry.levelId === levelId)
if (candidates.length === 0) return null
return candidates[Math.abs(WORLD_VARIANT_SEED + levelId) % candidates.length] ?? null
}
/** Every way out of a level, with the radius that fires it. */
@ -295,7 +278,7 @@ const ROUTE: readonly Hop[] = [
console.log('=== 验收路线 ===')
let entry = variants.startEntry(1)
let entry = variantFor(1)
check(entry !== null, '资源包里有罗格营地（关卡 1）')
let scene = entry === null ? null : await sceneOf(entry)
let here = scene === null ? { x: 0, y: 0 } : spawnSubTile(scene) ?? { x: 0, y: 0 }
@ -329,15 +312,18 @@ for (const hop of ROUTE) {
+ `（连通区域 ${String(reach)} 子格）`,
)
const nextEntry = variantFor(hop.to, link.side)
const nextEntry = variantFor(hop.to)
check(nextEntry !== null, `${hop.note}：资源包里有目的地 ${String(hop.to)}`)
if (nextEntry === null) break
const nextScene = await sceneOf(nextEntry)
const back = linksOf(nextScene).find(candidate => candidate.toLevelId === fromLevelId)
check(back !== undefined, `${hop.note}：${nextScene.levelName} 有回到 ${String(fromLevelId)} 的对侧开口`)
// travel() refuses a destination with no way back, so the walk ends here too.
if (back === undefined) break
const landing = { x: back.arriveX, y: back.arriveY }
const landing = back === undefined
? {
x: Math.floor(nextScene.cellsX * 5 / 2),
y: Math.floor(nextScene.cellsY * 5 / 2),
}
: { x: back.arriveX, y: back.arriveY }
const nextBlocked = blockedOf(nextScene)
const inBounds = landing.x >= 0 && landing.y >= 0
&& landing.x < nextScene.collision.width && landing.y < nextScene.collision.height

190
src/game/act-variants.ts
View File

@ -1,190 +0,0 @@
/**
* Which baked copy of a level a world instance uses.
*
* Every generated level is baked more than once, and the world graph names none of the copies, so one
* has to be chosen at load time. Two rules decide it:
*
* - **Acts generated by the DRLG port choose per act, not per level.** D2 generates an act from one game
* seed: the outdoor levels, their seams and the town's gate all come out of the same run
* (DRLG_AllocDrlg -> DRLGOUTPLACE_CreateLevelConnections -> DRLG_InitLevel). The bake does the same
* once per variant and records it in `index.json` as `actLayouts`: the generated levels (whose index
* entries carry `actVariant`) and the preset levels whose DS1 that run fixed (the Rogue Encampment
* file whose gate faces the Blood Moor). Mixing levels of two variants would join seams that were
* never generated together, so one variant is chosen per act and every level of the act follows it.
* - **Everything else chooses per level** (`WORLD_VARIANT_SEED + levelId`), preferring a copy whose gate
* faces the side the player arrives from (`findMatchingVariant`).
*
* The same code runs in the browser (`act-scene.ts`) and in `scripts/verify-world-walk.ts`, so the
* verifier walks exactly the world the player gets.
*
* Browser-safe: no `node:` imports, no `Math.random`.
*/
import { townLevelForAct } from './acts.ts'
import { findMatchingVariant, getDefaultTownVariant, oppositeSide, type Side, type VariantCandidate } from './variants.ts'
/**
* Seed of the per-world choices.
*
* A copy must never be chosen from the pair of levels being crossed: keying it on the pair, as an
* earlier version did, gave Cold Plains a different layout depending on whether you walked in from the
* Blood Moor or back from Stony Field, and left waypoints and town portals pointing at coordinates from a
* map that was no longer loaded. One copy per level (per act for DRLG acts) per world is the design.
*
* A real game would derive this from the game seed; until there is one, a constant keeps every session
* identical, which is also what the verification scripts assume.
*/
export const WORLD_VARIANT_SEED = 0x5eed_3000
/** One DRLG-generated copy of an act, as the bake records it (`index.json` `actLayouts[act]`). */
export interface ActLayout {
/** Variant number (0-based); the generated levels' index entries carry it as `actVariant`. */
readonly variant: number
/** The game seed the DRLG port generated this copy of the act from. */
readonly gameSeed: number
/** Levels generated by the DRLG port in this copy (one index entry each, with this `actVariant`). */
readonly levels: readonly number[]
/** Preset levels whose DS1 file the generated act fixed, e.g. the town whose gate faces the Blood Moor. */
readonly presets: readonly { readonly levelId: number; readonly ds1: string }[]
}
/** The index fields the selection reads. */
export interface VariantIndex<E extends VariantEntry> {
readonly levels: readonly E[]
/** DRLG act layouts keyed by act number (`'1'`..`'5'`); absent for acts the DRLG port does not generate. */
readonly actLayouts?: Readonly<Record<string, readonly ActLayout[]>> | undefined
}
/** The index entry fields the selection reads. */
export interface VariantEntry extends VariantCandidate {
readonly act: number
readonly levelId?: number
readonly label: string
/** DS1 member of a preset copy (as written by the bake). */
readonly ds1?: string
/** Variant of a DRLG-generated level (matches {@link ActLayout.variant}). */
readonly actVariant?: number
}
/** Archive paths compare case-insensitively and with either slash. */
function normalizeMember(path: string): string {
return path.replace(/\//g, '\\').toLowerCase()
}
/**
* The per-session choice of level copies.
*
* One instance per loaded pack. {@link pin} lets an explicitly opened copy (a `?level=` label, the
* variant menu) decide its act's variant, so walking on from there stays in the same generated act.
*/
export class WorldVariants<E extends VariantEntry> {
private readonly pinned = new Map<number, number>()
constructor(
private readonly index: VariantIndex<E>,
private readonly seed: number = WORLD_VARIANT_SEED,
) {
for (const [act, layouts] of Object.entries(index.actLayouts ?? {})) {
if (layouts.length === 0) throw new Error(`actLayouts[${act}] is empty`)
layouts.forEach((layout, at) => {
if (layout.variant !== at) throw new Error(`actLayouts[${act}][${String(at)}] has variant ${String(layout.variant)}`)
})
}
}
/** The act's DRLG layouts, or null when the act is not DRLG-generated. */
layoutsOf(act: number): readonly ActLayout[] | null {
return this.index.actLayouts?.[String(act)] ?? null
}
/**
* The copy of the act this world uses, or null when the act is not DRLG-generated.
*
* @param act - act number (1..5).
*/
layoutFor(act: number): ActLayout | null {
const layouts = this.layoutsOf(act)
if (layouts === null) return null
const variant = this.pinned.get(act) ?? Math.abs(this.seed + act) % layouts.length
const layout = layouts[variant]
if (layout === undefined) throw new Error(`act ${String(act)} has no layout variant ${String(variant)}`)
return layout
}
/**
* Make an explicitly opened copy decide its act's variant.
*
* A generated level pins its own `actVariant`; a preset copy pins the first variant whose act fixed
* that DS1 (a town file no variant uses pins nothing).
*
* @param entry - the copy being opened.
*/
pin(entry: E): void {
const layouts = this.layoutsOf(entry.act)
if (layouts === null) return
if (entry.actVariant !== undefined) {
if (layouts[entry.actVariant] === undefined) {
throw new Error(`${entry.label}: act ${String(entry.act)} has no layout variant ${String(entry.actVariant)}`)
}
this.pinned.set(entry.act, entry.actVariant)
return
}
if (entry.levelId === undefined || entry.ds1 === undefined) return
const ds1 = normalizeMember(entry.ds1)
const match = layouts.find(layout =>
layout.presets.some(p => p.levelId === entry.levelId && normalizeMember(p.ds1) === ds1))
if (match !== undefined) this.pinned.set(entry.act, match.variant)
}
/**
* The copy of a level this world uses.
*
* @param levelId - `Levels.txt` `Id`.
* @param fromSide - the edge of the previous level the player walked off, for per-level choices.
* @returns the index entry, or null when the pack has no copy of the level.
*/
entryForLevel(levelId: number, fromSide?: Side): E | null {
const candidates = this.index.levels.filter(entry => entry.levelId === levelId)
if (candidates.length === 0) return null
const act = candidates[0]!.act
if (candidates.some(entry => entry.act !== act)) throw new Error(`level ${String(levelId)} is baked into more than one act`)
const layout = this.layoutFor(act)
if (layout !== null) {
if (layout.levels.includes(levelId)) {
return exactlyOne(candidates.filter(entry => entry.actVariant === layout.variant),
`level ${String(levelId)}, act ${String(act)} variant ${String(layout.variant)}`)
}
const preset = layout.presets.find(p => p.levelId === levelId)
if (preset !== undefined) {
const ds1 = normalizeMember(preset.ds1)
return exactlyOne(candidates.filter(entry => entry.ds1 !== undefined && normalizeMember(entry.ds1) === ds1),
`level ${String(levelId)} DS1 ${preset.ds1} (act ${String(act)} variant ${String(layout.variant)})`)
}
}
const requiredSide = fromSide === undefined ? undefined : oppositeSide(fromSide)
return findMatchingVariant(candidates, requiredSide, this.seed + levelId) ?? null
}
/**
* The copy a fresh session opens an act in: the act's town.
*
* In a DRLG-generated act that is the town file the chosen copy of the act fixed (its gate faces
* the generated level next to it); other acts keep their fixed default (`getDefaultTownVariant`).
*
* @param act - act number (1..5).
* @returns the index entry, or null when the pack has nothing of this act.
*/
startEntry(act: number): E | null {
const forAct = this.index.levels.filter(entry => entry.act === act)
if (forAct.length === 0) return null
if (this.layoutFor(act) === null) return getDefaultTownVariant(forAct, act) ?? null
const town = this.entryForLevel(townLevelForAct(act))
if (town === null) throw new Error(`act ${String(act)} is DRLG-generated but the pack has no copy of its town`)
return town
}
}
function exactlyOne<E extends VariantEntry>(found: readonly E[], what: string): E {
if (found.length !== 1) throw new Error(`${what}: ${String(found.length)} baked copies match, expected exactly 1`)
return found[0]!
}

15
src/game/d2map.ts
View File

@ -465,18 +465,6 @@ function resolveCandidates(
}
}
/**
* Whether a cell's DT1 mask lets the renderer draw a tile of `library` (libraries from index 21 on are
* never filtered).
*
* @param dt1Mask - the cell's `dt1Mask`.
* @param library - index into the scene's library list.
* @returns true when the library's tiles are candidates for the cell.
*/
export function dt1MaskAllows(dt1Mask: number, library: number): boolean {
return library >= 21 || ((dt1Mask >>> 0) & (1 << library)) !== 0
}
function filterByDt1Mask(
candidates: readonly PoolTile[] | undefined,
dt1Mask: number | undefined,
@ -484,7 +472,8 @@ function filterByDt1Mask(
if (candidates === undefined || candidates.length === 0 || dt1Mask === undefined) {
return candidates
}
const filtered = candidates.filter(c => dt1MaskAllows(dt1Mask, c.library))
const mask = dt1Mask >>> 0
const filtered = candidates.filter(c => c.library >= 21 || (mask & (1 << c.library)) !== 0)
return filtered.length > 0 ? filtered : candidates
}

1103
src/game/drlg/adapter.ts Normal file
View File

File diff suppressed because it is too large Load Diff

6
src/game/drlg/drlg-d2cmp.ts
View File

@ -23,10 +23,6 @@ export interface D2TileLibraryEntryStrc {
nSequence: number
nRarity_Frame: number
nSubtileFlags: Uint8Array
/** Port identity (not a D2CMP field): normalized DT1 path of the owning library (= D2TileLibraryStrc.szPath). */
readonly szLibrary: string
/** Port identity (not a D2CMP field): index of this tile header inside its DT1 file. */
readonly nIndex: number
}
export interface D2TileLibraryStrc {
@ -66,8 +62,6 @@ function parseDt1Library(szPath: string, bytes: Uint8Array): D2TileLibraryStrc {
nSequence: view.getInt32(nBase + 0x1c, true),
nRarity_Frame: view.getInt32(nBase + 0x20, true),
nSubtileFlags,
szLibrary: szPath,
nIndex: i,
})
}
return { szPath, tiles }

648
src/game/drlg/drlg-dump.ts
View File

@ -1,16 +1,14 @@
/**
* JSON dumps of the DRLG port in the exact schema the native D2MOO oracle writes
* (tools/d2moo-oracle/src/main.cpp, schema 3; documented in tools/d2moo-oracle/README.md), plus the
* TypeScript twin of the oracle driver (`runAct1`, the single generation code path; `dumpAct1` builds the
* dump from its hooks). Diffing the two dumps stage by stage is the acceptance gate of the port
* (scripts/drlg-diff.ts, tests/drlg-act1-oracle.test.ts).
* (tools/d2moo-oracle/src/main.cpp, schema 2; documented in tools/d2moo-oracle/README.md), plus the
* TypeScript twin of the oracle driver. Diffing the two dumps stage by stage is the acceptance gate
* of the port (scripts/drlg-diff.ts, tests/drlg-act1-oracle.test.ts).
*
* Integer signedness follows the C field types, independent of how the port stores the value:
* uint32 fields are printed with `>>> 0`, int32 fields with `| 0`.
*/
import { setD2SeedTraceSink, type D2SeedStrc, type D2SeedTraceSink } from '../d2-rng.ts'
import type { D2TileLibraryEntryStrc } from './drlg-d2cmp.ts'
import {
ACT_I,
DRLGROOMFLAG_HAS_ROOM,
@ -24,22 +22,18 @@ import {
type D2DrlgCoordStrc,
type D2DrlgGridStrc,
type D2DrlgLevelStrc,
type D2DrlgLogicalRoomInfoStrc,
type D2DrlgMapStrc,
type D2DrlgOrthStrc,
type D2DrlgRoomStrc,
type D2DrlgStrc,
type D2DrlgTileDataStrc,
type D2DrlgVertexStrc,
type D2PresetUnitStrc,
type D2RoomCoordListStrc,
type DrlgEnv,
} from './drlg-types.ts'
import { DRLG_AllocDrlg, DRLG_GetActNoFromLevelId, DRLG_GetLevel, DRLG_InitLevel } from './drlg-drlg.ts'
import { setLevelGridHook } from './drlg-hooks.ts'
import { DRLGPRESET_SpawnHardcodedPresetUnits } from './drlg-preset.ts'
import { sub_6FD77BB0 } from './drlg-room.ts'
import { DRLGROOMTILE_AddRoomMapTiles, DRLGROOMTILE_InitRoomGrids, DRLGROOMTILE_LoadDT1FilesForRoom } from './drlg-roomtile.ts'
import { DRLGROOMTILE_InitRoomGrids, DRLGROOMTILE_LoadDT1FilesForRoom } from './drlg-roomtile.ts'
import { DATATBLS_GetLvlPrestTxtRecord } from './drlg-tables.ts'
const u32 = (v: number): number => v >>> 0
@ -92,103 +86,6 @@ export interface DumpRoom {
preset?: { prest: number; picked: number; flags: number; map: number }
}
// ---- activation stage (schema 3: + seedAfterTiles, mapTiles) ----
/**
* `D2DrlgTileDataStrc*`: [levelId, room index in pFirstRoomEx order, array, element index] into that room's
* `pTileGrid.pTiles` array: 'w' pWallTiles, 'f' pFloorTiles, 'r' pRoofTiles. The index may exceed the
* dumped element count (it addresses the allocation). Rooms of any level of the act can be referenced.
*/
export type DumpTileRef = [number, number, 'w' | 'f' | 'r', number]
/** `D2RoomCoordListStrc*`: [levelId, room, 'c', index in that room's `pLogicalRoomInfo.pCoordList` chain]. */
export type DumpCoordListRef = [number, number, 'c', number]
/** `D2TileLibraryEntryStrc*`: [DT1 path (lower case, '/'-separated, e.g. "data/global/tiles/act1/outdoors/blank.dt1"), tile index in that DT1]. */
export type DumpTileEntry = [string, number]
/** Every D2DrlgTileDataStrc field in struct order (D2DrlgDrlg.h:333); pointers as references. */
export type DumpTile = [
nWidth: number,
nHeight: number,
nPosX: number,
nPosY: number,
unk0x10: number | DumpCoordListRef,
dwFlags: number,
pTile: DumpTileEntry | null,
nTileType: number,
unk0x20: DumpTileRef | null,
unk0x24: number,
nRed: number,
nGreen: number,
nBlue: number,
nIntensity: number,
unk0x2C: number,
]
/** D2DrlgTileLinkStrc (pTileGrid.pMapLinks chain order). */
export type DumpTileLink = [bFloor: number, pMapTile: DumpTileRef | null]
/** D2RoomTileStrc (pRoomTiles chain order); the LvlWarp.txt record as its row index, -1 for NULL. */
export type DumpRoomTile = [
pDrlgRoom: [levelId: number, room: number] | null,
nLvlWarpTxtRecord: number,
bEnabled: number,
unk0x0C: DumpTileRef | null,
unk0x10: DumpTileRef | null,
]
/** D2RoomCoordListStrc. */
export type DumpCoordList = [nIndex: number, bNode: number, bRoomActive: number, box0: DumpCoord, box1: DumpCoord]
/** D2DrlgLogicalRoomInfoStrc. */
export interface DumpLogicalRoomInfo {
flags: number
nLists: number
indexX: DumpGrid | null
/** pIndexY cells (`(int)D2RoomCoordListStrc*`) as 1 + the index of the list in `lists`, 0 for NULL. */
indexY: DumpGrid | null
/** The pCoordList chain in order. */
lists: DumpCoordList[]
}
/**
* The room's D2DrlgTileGridStrc after every requested room has been activated (final state: a room
* activated later rewrites tiles of the near rooms activated before it, across level seams too).
*/
export interface DumpMapTiles {
/** pTileGrid counters. */
nWalls: number
nFloors: number
nShadows: number
/** pTileGrid.pTiles counters (what D2Common hands on with the room); walls/floors/roofs hold exactly these many entries. */
pTiles: { nWalls: number; nFloors: number; nRoofs: number }
walls: DumpTile[]
floors: DumpTile[]
/** Shadow tiles (DRLGROOMTILE_InitShadowTileData stores them in pRoofTiles). */
roofs: DumpTile[]
links: DumpTileLink[]
warps: DumpRoomTile[]
/** pPresetUnits in the final state (incl. the UNIT_TILE units of DRLGROOMTILE_AddWarp and door units). */
units: DumpUnit[]
logical: DumpLogicalRoomInfo | null
}
interface DumpActivationTail {
/** Room seed right after DRLGROOMTILE_InitRoomGrids. */
seed: DumpSeed
/** pPresetUnits right after DRLGROOMTILE_InitRoomGrids. */
units: DumpUnit[]
/** Room seed right after the room's own DRLGROOMTILE_AddRoomMapTiles. */
seedAfterTiles: DumpSeed
mapTiles: DumpMapTiles
}
export interface DumpOutdoorActivation extends DumpActivationTail {
tile: DumpGrid | null
wall: DumpGrid | null
floor: DumpGrid | null
dirt: DumpGrid | null
}
export interface DumpPresetActivation extends DumpActivationTail {
walls: (DumpGrid | null)[]
tiles: (DumpGrid | null)[]
floors: (DumpGrid | null)[]
shadow: DumpGrid | null
}
export type DumpActivation = DumpOutdoorActivation | DumpPresetActivation
export interface DumpLevel {
id: number
levelGrid: DumpLevelGrid
@ -197,12 +94,11 @@ export interface DumpLevel {
maps: DumpMap[]
levelSeedAfterRooms: DumpSeed
warp: { n: number; xy: [number, number][] }
/** One entry per room in pFirstRoomEx order (empty when activation is skipped). */
activation: DumpActivation[]
activation: unknown[]
}
export interface DrlgDump {
schema: 3
schema: 2
oracle?: { d2moo: string; arch: string }
gameSeed: number
difficulty: number
@ -422,318 +318,13 @@ export class DrlgTraceWriter implements D2SeedTraceSink {
}
}
// ---- mapTiles (schema 3) ----
/** Pointer -> reference tables over every room of one act (pDrlg->pLevel chain, pFirstRoomEx order). */
interface DumpRefIndex {
readonly tiles: Map<D2DrlgTileDataStrc, DumpTileRef>
readonly coordLists: Map<D2RoomCoordListStrc, DumpCoordListRef>
readonly rooms: Map<D2DrlgRoomStrc, [number, number]>
}
/** Chains longer than this cannot come from D2Common (C would loop forever on a cycle). */
const MAX_DUMP_CHAIN = 1 << 20
function buildRefIndex(pDrlg: D2DrlgStrc): DumpRefIndex {
const index: DumpRefIndex = { tiles: new Map(), coordLists: new Map(), rooms: new Map() }
for (let pLevel = pDrlg.pLevel; pLevel; pLevel = pLevel.pNextLevel) {
const nLevelId = pLevel.nLevelId
let nRoom = 0
for (let pRoom = pLevel.pFirstRoomEx; pRoom; pRoom = pRoom.pDrlgRoomNext, nRoom += 1) {
index.rooms.set(pRoom, [nLevelId, nRoom])
const pTileGrid = pRoom.pTileGrid
if (pTileGrid) {
const add = (pArray: D2DrlgTileDataStrc[] | null, cArray: 'w' | 'f' | 'r'): void => {
if (!pArray) return
for (let i = 0; i < pArray.length; i += 1) {
const pTileData = pArray[i]!
if (index.tiles.has(pTileData)) throw new Error(`level ${nLevelId} room ${nRoom}: a tile data element belongs to two arrays`)
index.tiles.set(pTileData, [nLevelId, nRoom, cArray, i])
}
}
add(pTileGrid.pTiles.pWallTiles, 'w')
add(pTileGrid.pTiles.pFloorTiles, 'f')
add(pTileGrid.pTiles.pRoofTiles, 'r')
}
const pInfo = pRoom.pLogicalRoomInfo
if (pInfo) {
let k = 0
for (let p = pInfo.pCoordList; p; p = p.pNext, k += 1) {
if (k >= MAX_DUMP_CHAIN) throw new Error(`level ${nLevelId} room ${nRoom}: pCoordList chain does not terminate`)
index.coordLists.set(p, [nLevelId, nRoom, 'c', k])
}
}
}
}
return index
}
function dumpTileRef(index: DumpRefIndex, p: D2DrlgTileDataStrc | null): DumpTileRef | null {
if (!p) return null
const ref = index.tiles.get(p)
if (!ref) throw new Error('tile data pointer outside every tile array of the act (dangling?)')
return ref
}
function dumpTileEntry(pTile: D2TileLibraryEntryStrc | null): DumpTileEntry | null {
return pTile ? [pTile.szLibrary.replace(/\\/g, '/'), pTile.nIndex] : null
}
function dumpTileData(index: DumpRefIndex, t: D2DrlgTileDataStrc): DumpTile {
let unk0x10: number | DumpCoordListRef
if (typeof t.unk0x10 === 'number') {
unk0x10 = s32(t.unk0x10)
} else {
const ref = index.coordLists.get(t.unk0x10)
if (!ref) throw new Error('D2DrlgTileDataStrc::unk0x10 holds a coord list outside every pCoordList chain of the act')
unk0x10 = ref
}
return [
s32(t.nWidth),
s32(t.nHeight),
s32(t.nPosX),
s32(t.nPosY),
unk0x10,
u32(t.dwFlags),
dumpTileEntry(t.pTile),
s32(t.nTileType),
dumpTileRef(index, t.unk0x20),
s32(t.unk0x24),
u8(t.nRed),
u8(t.nGreen),
u8(t.nBlue),
u8(t.nIntensity),
s32(t.unk0x2C),
]
}
function dumpTileDataArray(index: DumpRefIndex, pArray: D2DrlgTileDataStrc[] | null, nTiles: number, szWhat: string): DumpTile[] {
if (nTiles < 0 || (nTiles > 0 && !pArray)) throw new Error(`${nTiles} ${szWhat} without an array`)
if (pArray && nTiles > pArray.length) throw new Error(`${nTiles} ${szWhat} exceed their ${pArray.length}-element allocation`)
const out: DumpTile[] = []
for (let i = 0; i < nTiles; i += 1) out.push(dumpTileData(index, pArray![i]!))
return out
}
function dumpLogicalRoomInfo(pInfo: D2DrlgLogicalRoomInfoStrc | null): DumpLogicalRoomInfo | null {
if (!pInfo) return null
const chain = new Map<D2RoomCoordListStrc, number>()
const lists: DumpCoordList[] = []
for (let p = pInfo.pCoordList; p; p = p.pNext) {
if (lists.length >= MAX_DUMP_CHAIN) throw new Error('pCoordList chain does not terminate')
chain.set(p, lists.length)
lists.push([s32(p.nIndex), s32(p.bNode), s32(p.bRoomActive), dumpCoord(p.pBox[0]), dumpCoord(p.pBox[1])])
}
// pIndexY cells hold `(int)D2RoomCoordListStrc*` in C and a 1-based handle into ppCoordListHandles here.
let indexY: DumpGrid | null = null
const g = pInfo.pIndexY
if (g.pCellsFlags && g.pCellsRowOffsets) {
const cells: number[] = []
for (let y = 0; y < g.nHeight; y += 1) {
for (let x = 0; x < g.nWidth; x += 1) {
const idx = g.nCellsBase + x + g.pCellsRowOffsets[y]!
if (idx < 0 || idx >= g.pCellsFlags.length) throw new RangeError(`pIndexY cell (${x}, ${y}) outside the backing array`)
const hCell = g.pCellsFlags[idx]!
if (hCell === 0) {
cells.push(0)
continue
}
const pList = hCell > 0 ? pInfo.ppCoordListHandles[hCell - 1] : undefined
const k = pList ? chain.get(pList) : undefined
if (k === undefined) throw new Error(`pIndexY cell (${x}, ${y}) is not a list of the room's chain`)
cells.push(k + 1)
}
}
indexY = { w: s32(g.nWidth), h: s32(g.nHeight), cells }
}
return { flags: s32(pInfo.dwFlags), nLists: s32(pInfo.nLists), indexX: dumpGrid(pInfo.pIndexX), indexY, lists }
}
function dumpRoomTiles(index: DumpRefIndex, pRoom: D2DrlgRoomStrc): DumpRoomTile[] {
const lvlWarp = pRoom.pLevel.pDrlg.env.tables.lvlWarp
const out: DumpRoomTile[] = []
for (let p = pRoom.pRoomTiles; p; p = p.pNext) {
if (out.length >= MAX_DUMP_CHAIN) throw new Error('pRoomTiles chain does not terminate')
let room: [number, number] | null = null
if (p.pDrlgRoom) {
const r = index.rooms.get(p.pDrlgRoom)
if (!r) throw new Error(`warp ${out.length} leads to a room outside the act`)
room = [r[0], r[1]]
}
let nWarp = -1
if (p.pLvlWarpTxtRecord) {
nWarp = lvlWarp.indexOf(p.pLvlWarpTxtRecord)
if (nWarp < 0) throw new Error(`warp ${out.length} has a record outside LvlWarp.txt`)
}
out.push([room, nWarp, s32(p.bEnabled), dumpTileRef(index, p.unk0x0C), dumpTileRef(index, p.unk0x10)])
}
return out
}
function dumpMapTiles(index: DumpRefIndex, pRoom: D2DrlgRoomStrc, nLevelId: number, nRoom: number): DumpMapTiles {
const where = `level ${nLevelId} room ${nRoom}`
const pTileGrid = pRoom.pTileGrid
if (!pTileGrid) throw new Error(`${where}: no pTileGrid after DRLGROOMTILE_AddRoomMapTiles`)
if (pTileGrid.pAnimTiles) throw new Error(`${where}: animated tiles (pAnimTiles) are not dumped`)
try {
const t = pTileGrid.pTiles
const links: DumpTileLink[] = []
for (let p = pTileGrid.pMapLinks; p; p = p.pNext) {
if (links.length >= MAX_DUMP_CHAIN) throw new Error('pMapLinks chain does not terminate')
links.push([s32(p.bFloor), dumpTileRef(index, p.pMapTile)])
}
return {
nWalls: s32(pTileGrid.nWalls),
nFloors: s32(pTileGrid.nFloors),
nShadows: s32(pTileGrid.nShadows),
pTiles: { nWalls: s32(t.nWalls), nFloors: s32(t.nFloors), nRoofs: s32(t.nRoofs) },
walls: dumpTileDataArray(index, t.pWallTiles, t.nWalls, 'walls'),
floors: dumpTileDataArray(index, t.pFloorTiles, t.nFloors, 'floors'),
roofs: dumpTileDataArray(index, t.pRoofTiles, t.nRoofs, 'roofs'),
links,
warps: dumpRoomTiles(index, pRoom),
units: dumpPresetUnits(pRoom.pPresetUnits),
logical: dumpLogicalRoomInfo(pRoom.pLogicalRoomInfo),
}
} catch (e) {
throw new Error(`${where}: ${e instanceof Error ? e.message : String(e)}`)
}
}
// ---- driver (TypeScript twin of tools/d2moo-oracle/src/main.cpp) ----
export interface Act1RunOptions {
export interface DumpAct1Options {
readonly difficulty?: number
/** A fresh act per requested level (proves a level does not depend on the others). */
readonly isolated?: boolean
/** Receives the RNG trace; installed as the global seed trace sink for the duration of the run. */
readonly trace?: DrlgTraceWriter
/** Generate the levels but do not activate their rooms. */
readonly skipActivation?: boolean
}
/**
* Observation points of runAct1, in execution order. The structures are live: later steps keep mutating
* them (a room activated later rewrites tiles of the near rooms activated before it and rolls their
* seeds, also across level seams), so a hook must copy what it needs at that moment.
*/
export interface Act1RunHooks {
/** After DRLG_AllocDrlg. `index` 0 is Act1Run.pDrlg; isolated runs allocate one more act per further level. */
onDrlgAllocated?(pDrlg: D2DrlgStrc, index: number): void
/** After DRLG_InitLevel of a requested level. */
onLevelGenerated?(pLevel: D2DrlgLevelStrc): void
/** After DRLGROOMTILE_InitRoomGrids of a room, before DRLGROOMTILE_AddRoomMapTiles (`index`: pFirstRoomEx order). */
onRoomGridsInitialized?(pRoom: D2DrlgRoomStrc, index: number): void
/** After DRLGROOMTILE_AddRoomMapTiles of that room. */
onRoomActivated?(pRoom: D2DrlgRoomStrc, index: number): void
}
export interface Act1Run {
/** The act allocated first (the only one unless `isolated`). */
readonly pDrlg: D2DrlgStrc
/** The requested levels in request order; each level's own act is `pLevel.pDrlg`. */
readonly levels: readonly D2DrlgLevelStrc[]
}
function allocAct1(env: DrlgEnv, nSeed: number, nDifficulty: number, trace: DrlgTraceWriter | undefined): D2DrlgStrc {
trace?.context('drlg')
// D2Game allocates the act with the town level id; DRLG_AllocDrlg lays out the whole act
// (DRLGOUTPLACE_CreateLevelConnections) and generates the town.
return DRLG_AllocDrlg(env, ACT_I, nSeed, LEVEL_ROGUEENCAMPMENT, 0, nDifficulty)
}
/** Generation stage of one level: DRLG_InitLevel, everything that exists before any room is activated. */
function initLevel(pDrlg: D2DrlgStrc, nLevelId: number, trace: DrlgTraceWriter | undefined): D2DrlgLevelStrc {
trace?.context(`L${nLevelId}`)
const pLevel = DRLG_GetLevel(pDrlg, nLevelId)
if (pLevel.nDrlgType !== DRLGTYPE_OUTDOOR || DRLG_GetActNoFromLevelId(nLevelId) !== ACT_I) {
throw new Error(`level ${nLevelId} is not an Act I outdoor level`)
}
if (pLevel.pFirstRoomEx) throw new Error(`level ${nLevelId} was already generated before its own generation stage`)
DRLG_InitLevel(pLevel)
return pLevel
}
/**
* Mirrors DRLGACTIVATE_InitializeRoomEx (DrlgActivate.cpp:317-331) followed by
* DRLGACTIVATE_RoomEx_EnsureHasRoom (DrlgActivate.cpp:95-115) up to DRLGROOMTILE_AddRoomMapTiles, for every
* room in pFirstRoomEx order. DRLG_CreateRoomForRoomEx (D2Game's D2ActiveRoomStrc) is not run, so pRoom
* stays NULL (D2Common_COLLISION_FirstFn_6FD41000 is a no-op).
*/
function activateLevel(pLevel: D2DrlgLevelStrc, trace: DrlgTraceWriter | undefined, hooks: Act1RunHooks): void {
let i = 0
for (let pRoom = pLevel.pFirstRoomEx; pRoom; pRoom = pRoom.pDrlgRoomNext, i += 1) {
trace?.context(`L${pLevel.nLevelId}/a${i}`)
if (!(pRoom.dwFlags & DRLGROOMFLAG_TILELIB_LOADED)) {
DRLGROOMTILE_LoadDT1FilesForRoom(pRoom)
}
if (!(pRoom.dwFlags & DRLGROOMFLAG_PRESET_UNITS_ADDED) && pRoom.nType === DRLGTYPE_PRESET) {
DRLGPRESET_SpawnHardcodedPresetUnits(pRoom)
}
if (pRoom.pRoom || pRoom.dwFlags & DRLGROOMFLAG_HAS_ROOM) {
throw new Error(`level ${pLevel.nLevelId} room ${i}: already has an active room`)
}
if (!pRoom.nRoomsNear) {
sub_6FD77BB0(pRoom)
}
DRLGROOMTILE_InitRoomGrids(pRoom)
hooks.onRoomGridsInitialized?.(pRoom, i)
DRLGROOMTILE_AddRoomMapTiles(pRoom)
hooks.onRoomActivated?.(pRoom, i)
}
}
/**
* Runs the Act I generation exactly like the oracle driver: DRLG_AllocDrlg (layout, links, town), then
* DRLG_InitLevel of every requested level, then the activation of every room of those levels (see
* activateLevel). A non-isolated run generates every requested level before activating any room, because
* activating a room initialises the levels behind its warps (sub_6FD77BB0 -> DRLG_InitLevel); an isolated
* run allocates a fresh act per level and activates it right away.
*/
export function runAct1(
env: DrlgEnv,
nSeed: number,
levels: readonly number[],
opts: Act1RunOptions = {},
hooks: Act1RunHooks = {},
): Act1Run {
const nDifficulty = opts.difficulty ?? 0
const trace = opts.trace
if (trace) setD2SeedTraceSink(trace)
try {
let nActs = 0
const allocAct = (): D2DrlgStrc => {
const pDrlg = allocAct1(env, nSeed >>> 0, nDifficulty, trace)
hooks.onDrlgAllocated?.(pDrlg, nActs)
nActs += 1
return pDrlg
}
const generate = (pDrlg: D2DrlgStrc, nLevelId: number): D2DrlgLevelStrc => {
const pLevel = initLevel(pDrlg, nLevelId, trace)
hooks.onLevelGenerated?.(pLevel)
return pLevel
}
const pFirstDrlg = allocAct()
const generated: D2DrlgLevelStrc[] = []
if (opts.isolated) {
for (let i = 0; i < levels.length; i += 1) {
const pLevel = generate(i > 0 ? allocAct() : pFirstDrlg, levels[i]!)
generated.push(pLevel)
if (!opts.skipActivation) activateLevel(pLevel, trace, hooks)
}
} else {
for (let i = 0; i < levels.length; i += 1) generated.push(generate(pFirstDrlg, levels[i]!))
if (!opts.skipActivation) {
for (const pLevel of generated) activateLevel(pLevel, trace, hooks)
}
}
return { pDrlg: pFirstDrlg, levels: generated }
} finally {
if (trace) setD2SeedTraceSink(null)
}
}
export interface DumpAct1Options extends Act1RunOptions {
/** Stop after the act stage (the `levels` array stays empty). */
readonly actOnly?: boolean
/**
@ -743,121 +334,142 @@ export interface DumpAct1Options extends Act1RunOptions {
readonly skipActivation?: boolean
}
function dumpLevelHead(pLevel: D2DrlgLevelStrc, levelGrid: DumpLevelGrid): Omit<DumpLevel, 'activation'> {
function allocAct1(env: DrlgEnv, nSeed: number, nDifficulty: number, trace: DrlgTraceWriter | undefined): D2DrlgStrc {
trace?.context('drlg')
// D2Game allocates the act with the town level id; DRLG_AllocDrlg lays out the whole act
// (DRLGOUTPLACE_CreateLevelConnections) and generates the town.
return DRLG_AllocDrlg(env, ACT_I, nSeed, LEVEL_ROGUEENCAMPMENT, 0, nDifficulty)
}
function initLevelStage(pDrlg: D2DrlgStrc, nLevelId: number, trace: DrlgTraceWriter | undefined, grids: Map<number, DumpLevelGrid>): { head: Omit<DumpLevel, 'activation'>; pLevel: D2DrlgLevelStrc } {
trace?.context(`L${nLevelId}`)
const pLevel = DRLG_GetLevel(pDrlg, nLevelId)
if (pLevel.nDrlgType !== DRLGTYPE_OUTDOOR || DRLG_GetActNoFromLevelId(nLevelId) !== ACT_I) {
throw new Error(`level ${nLevelId} is not an Act I outdoor level`)
}
if (pLevel.pFirstRoomEx) throw new Error(`level ${nLevelId} was already generated before its own generation stage`)
DRLG_InitLevel(pLevel)
const levelGrid = grids.get(nLevelId)
if (!levelGrid) throw new Error(`level ${nLevelId}: InitAct1OutdoorLevel hook did not fire`)
const maps: D2DrlgMapStrc[] = []
const rooms = dumpRooms(pLevel, maps)
const xy: [number, number][] = []
for (let i = 0; i < pLevel.nRoomCoords; i += 1) xy.push([pLevel.nRoom_Center_Warp_X[i]!, pLevel.nRoom_Center_Warp_Y[i]!])
return {
id: pLevel.nLevelId,
levelGrid,
nRooms: pLevel.nRooms,
rooms,
maps: maps.map(m => dumpMap(pLevel.pDrlg.env, m)),
levelSeedAfterRooms: dumpSeed(pLevel.pSeed),
warp: { n: pLevel.nRoomCoords, xy },
head: {
id: nLevelId,
levelGrid,
nRooms: pLevel.nRooms,
rooms,
maps: maps.map(m => dumpMap(pDrlg.env, m)),
levelSeedAfterRooms: dumpSeed(pLevel.pSeed),
warp: { n: pLevel.nRoomCoords, xy },
},
pLevel,
}
}
/** Schema-2 activation fields of a room, right after DRLGROOMTILE_InitRoomGrids. */
function dumpRoomGrids(pRoom: D2DrlgRoomStrc): Omit<DumpOutdoorActivation, 'seedAfterTiles' | 'mapTiles'> | Omit<DumpPresetActivation, 'seedAfterTiles' | 'mapTiles'> {
if (pRoom.nType === DRLGTYPE_MAZE) {
const p = pRoom.pOutdoor!
return {
seed: dumpSeed(pRoom.pSeed),
tile: dumpGrid(p.pTileTypeGrid),
wall: dumpGrid(p.pWallGrid),
floor: dumpGrid(p.pFloorGrid),
dirt: dumpGrid(p.pDirtPathGrid),
units: dumpPresetUnits(pRoom.pPresetUnits),
}
}
const p = pRoom.pMaze!
const pFile = p.pMap!.pFile!
const walls: (DumpGrid | null)[] = []
const tiles: (DumpGrid | null)[] = []
const floors: (DumpGrid | null)[] = []
for (let l = 0; l < pFile.nWallLayers; l += 1) {
walls.push(dumpGrid(p.pWallGrid[l]!))
tiles.push(dumpGrid(p.pTileTypeGrid[l]!))
}
for (let l = 0; l < pFile.nFloorLayers; l += 1) {
floors.push(dumpGrid(p.pFloorGrid[l]!))
}
return { seed: dumpSeed(pRoom.pSeed), walls, tiles, floors, shadow: dumpGrid(p.pCellGrid), units: dumpPresetUnits(pRoom.pPresetUnits) }
}
interface RoomActivationRecord {
readonly pRoom: D2DrlgRoomStrc
readonly index: number
readonly grids: ReturnType<typeof dumpRoomGrids>
seedAfterTiles: DumpSeed | null
}
/** Runs runAct1 and returns the same JSON document as the oracle driver. */
/** Runs the Act I generation exactly like the oracle driver and returns the same JSON document. */
export function dumpAct1(env: DrlgEnv, nSeed: number, levels: readonly number[], opts: DumpAct1Options = {}): DrlgDump {
const levelGrids = new Map<number, DumpLevelGrid>()
const heads = new Map<D2DrlgLevelStrc, Omit<DumpLevel, 'activation'>>()
const activations = new Map<D2DrlgLevelStrc, RoomActivationRecord[]>()
// Assigned by the hooks (the casts keep TypeScript from narrowing them to `null` for good).
let drlg = null as DrlgDump['drlg'] | null
let act = null as DumpActLevel[] | null
const nDifficulty = opts.difficulty ?? 0
const isolated = opts.isolated ?? false
const trace = opts.trace
const grids = new Map<number, DumpLevelGrid>()
if (trace) setD2SeedTraceSink(trace)
const previousHook = setLevelGridHook(pLevel => {
levelGrids.set(pLevel.nLevelId, dumpLevelGrid(pLevel))
grids.set(pLevel.nLevelId, dumpLevelGrid(pLevel))
})
let run: Act1Run
try {
run = runAct1(env, nSeed, opts.actOnly ? [] : levels, opts, {
onDrlgAllocated(pDrlg, index) {
if (index !== 0) return
drlg = { startSeed: u32(pDrlg.dwStartSeed), seed: dumpSeed(pDrlg.pSeed) }
act = dumpAct(pDrlg)
},
onLevelGenerated(pLevel) {
const levelGrid = levelGrids.get(pLevel.nLevelId)
if (!levelGrid) throw new Error(`level ${pLevel.nLevelId}: InitAct1OutdoorLevel hook did not fire`)
heads.set(pLevel, dumpLevelHead(pLevel, levelGrid))
activations.set(pLevel, [])
},
onRoomGridsInitialized(pRoom, index) {
const records = activations.get(pRoom.pLevel)
if (!records) throw new Error(`level ${pRoom.pLevel.nLevelId}: room ${index} activated before its level was generated`)
records.push({ pRoom, index, grids: dumpRoomGrids(pRoom), seedAfterTiles: null })
},
onRoomActivated(pRoom, index) {
const records = activations.get(pRoom.pLevel)
const record = records ? records[records.length - 1] : undefined
if (!record || record.pRoom !== pRoom || record.index !== index) throw new Error(`level ${pRoom.pLevel.nLevelId} room ${index}: activation hooks out of order`)
record.seedAfterTiles = dumpSeed(pRoom.pSeed)
},
})
let pDrlg = allocAct1(env, nSeed >>> 0, nDifficulty, trace)
const doc: DrlgDump = {
schema: 2,
gameSeed: nSeed >>> 0,
difficulty: nDifficulty,
isolated,
drlg: { startSeed: u32(pDrlg.dwStartSeed), seed: dumpSeed(pDrlg.pSeed) },
act: dumpAct(pDrlg),
levels: [],
}
if (opts.actOnly) return doc
const heads: Omit<DumpLevel, 'activation'>[] = []
const generated: D2DrlgLevelStrc[] = []
const activations: unknown[][] = []
if (isolated) {
for (let i = 0; i < levels.length; i += 1) {
if (i > 0) pDrlg = allocAct1(env, nSeed >>> 0, nDifficulty, trace)
const r = initLevelStage(pDrlg, levels[i]!, trace, grids)
heads.push(r.head)
generated.push(r.pLevel)
activations.push(opts.skipActivation ? [] : activateLevel(r.pLevel, trace))
}
} else {
for (let i = 0; i < levels.length; i += 1) {
const r = initLevelStage(pDrlg, levels[i]!, trace, grids)
heads.push(r.head)
generated.push(r.pLevel)
}
for (let i = 0; i < levels.length; i += 1) activations.push(opts.skipActivation ? [] : activateLevel(generated[i]!, trace))
}
for (let i = 0; i < levels.length; i += 1) doc.levels.push({ ...heads[i]!, activation: activations[i]! })
return doc
} finally {
setLevelGridHook(previousHook)
if (trace) setD2SeedTraceSink(null)
}
if (!drlg || !act) throw new Error('runAct1 did not report the act allocation')
const doc: DrlgDump = {
schema: 3,
gameSeed: nSeed >>> 0,
difficulty: opts.difficulty ?? 0,
isolated: opts.isolated ?? false,
drlg,
act,
levels: [],
}
// mapTiles is serialised only now: the tile data are the final state (see DumpMapTiles).
const refIndices = new Map<D2DrlgStrc, DumpRefIndex>()
for (const pLevel of run.levels) {
let index = refIndices.get(pLevel.pDrlg)
if (!index) {
index = buildRefIndex(pLevel.pDrlg)
refIndices.set(pLevel.pDrlg, index)
}
const activation: DumpActivation[] = []
for (const record of activations.get(pLevel)!) {
if (!record.seedAfterTiles) throw new Error(`level ${pLevel.nLevelId} room ${record.index}: DRLGROOMTILE_AddRoomMapTiles did not complete`)
activation.push({ ...record.grids, seedAfterTiles: record.seedAfterTiles, mapTiles: dumpMapTiles(index, record.pRoom, pLevel.nLevelId, record.index) })
}
doc.levels.push({ ...heads.get(pLevel)!, activation })
}
return doc
}
function activateLevel(pLevel: D2DrlgLevelStrc, trace: DrlgTraceWriter | undefined): unknown[] {
const out: unknown[] = []
let i = 0
for (let pRoom = pLevel.pFirstRoomEx; pRoom; pRoom = pRoom.pDrlgRoomNext, i += 1) {
trace?.context(`L${pLevel.nLevelId}/a${i}`)
if (!(pRoom.dwFlags & DRLGROOMFLAG_TILELIB_LOADED)) {
DRLGROOMTILE_LoadDT1FilesForRoom(pRoom)
}
if (!(pRoom.dwFlags & DRLGROOMFLAG_PRESET_UNITS_ADDED) && pRoom.nType === DRLGTYPE_PRESET) {
DRLGPRESET_SpawnHardcodedPresetUnits(pRoom)
}
if (pRoom.dwFlags & DRLGROOMFLAG_HAS_ROOM) {
throw new Error(`level ${pLevel.nLevelId} room ${i}: already has an active room`)
}
if (!pRoom.nRoomsNear) {
sub_6FD77BB0(pRoom)
}
DRLGROOMTILE_InitRoomGrids(pRoom)
if (pRoom.nType === DRLGTYPE_MAZE) {
const p = pRoom.pOutdoor!
out.push({
seed: dumpSeed(pRoom.pSeed),
tile: dumpGrid(p.pTileTypeGrid),
wall: dumpGrid(p.pWallGrid),
floor: dumpGrid(p.pFloorGrid),
dirt: dumpGrid(p.pDirtPathGrid),
units: dumpPresetUnits(pRoom.pPresetUnits),
})
} else {
const p = pRoom.pMaze!
const pFile = p.pMap!.pFile!
const walls: (DumpGrid | null)[] = []
const tiles: (DumpGrid | null)[] = []
const floors: (DumpGrid | null)[] = []
for (let l = 0; l < pFile.nWallLayers; l += 1) {
walls.push(dumpGrid(p.pWallGrid[l]!))
tiles.push(dumpGrid(p.pTileTypeGrid[l]!))
}
for (let l = 0; l < pFile.nFloorLayers; l += 1) {
floors.push(dumpGrid(p.pFloorGrid[l]!))
}
out.push({
seed: dumpSeed(pRoom.pSeed),
walls,
tiles,
floors,
shadow: dumpGrid(p.pCellGrid),
units: dumpPresetUnits(pRoom.pPresetUnits),
})
}
}
return out
}

542
src/game/drlg/drlg-logic.ts
View File

@ -1,542 +0,0 @@
/**
* D2Common DRLG logical rooms: 1:1 port of the parts of D2MOO source/D2Common/src/Drlg/DrlgDrlgLogic.cpp
* (commit 5596f5c, MIT License, Copyright (c) 2020-2025 The Phrozen Keep community) reached by
* DRLGROOMTILE_AddRoomMapTiles: DRLGOUTROOM_InitializeDrlgOutdoorRoom and DRLGPRESET_AddPresetRoomMapTiles
* end with DRLGLOGIC_AllocCoordLists or (LvlPrest.txt `Logicals`) DRLGLOGIC_InitializeDrlgCoordList.
*
* Pointers in int cells: DRLGLOGIC_AssignCoordListsForGrids writes `(int)pRoomCoordList` into the pIndexY
* cells and DRLGLOGIC_SetCoordListForTiles copies such a cell into D2DrlgTileDataStrc::unk0x10. Int32Array
* cells cannot hold objects, so a pIndexY cell holds a 1-based handle into
* `pLogicalRoomInfo.ppCoordListHandles` (0 = NULL), and the tile's unk0x10 receives the object itself.
*/
import { DRLGGRID_AlterGridFlag, DRLGGRID_FillGrid, DRLGGRID_GetGridEntry, DRLGGRID_InitializeGridCells, DRLGGRID_IsGridValid, DRLGGRID_ResetGrid } from './drlg-grid.ts'
import { DRLG_CheckNotOverlappingUsingManhattanDistance, DRLGROOM_AreXYInsideCoordinatesOrOnBorder } from './drlg-room.ts'
import {
GetMapTileLayer,
HasMapTileLayer,
MAPTILE_OBJECT_WALL,
MAPTILE_TREES,
PackedTile,
TILETYPE_ROOF,
tileAt,
tileGridOf,
} from './drlg-roomtile.ts'
import {
FLAG_OPERATION_OR,
FLAG_OPERATION_OVERWRITE,
newCoord,
newGrid,
type D2DrlgGridStrc,
type D2DrlgLogicalRoomInfoStrc,
type D2DrlgRoomStrc,
type D2DrlgTileDataStrc,
type D2RoomCoordListStrc,
} from './drlg-types.ts'
// D2DrlgLogicalRoomInfoFlags (D2DrlgDrlgLogic.h)
export const DRLGLOGIC_ROOMINFO_HAS_COORD_LIST = 0x1
export const DRLGLOGIC_ROOMINFO_HAS_GRID_CELLS = 0x2
/** D2UnkDrlgLogicStrc (D2DrlgDrlgLogic.h) */
interface D2UnkDrlgLogicStrc {
pDrlgRoom: D2DrlgRoomStrc
field_4: D2DrlgGridStrc
pTileTypeGrid: D2DrlgGridStrc
pWallGrid: D2DrlgGridStrc
pFloorGrid: D2DrlgGridStrc
field_14: D2DrlgGridStrc
field_18: number
nFlags: number
}
/** A zeroed D2RoomCoordListStrc (D2_CALLOC_STRC_POOL / an element of a D2_CALLOC_POOL block). */
function newRoomCoordList(): D2RoomCoordListStrc {
return { pBox: [newCoord(0, 0, 0, 0), newCoord(0, 0, 0, 0)], bNode: 0, bRoomActive: 0, nIndex: 0, pNext: null }
}
/** A zeroed D2DrlgLogicalRoomInfoStrc (D2_CALLOC_STRC_POOL). */
function newLogicalRoomInfo(): D2DrlgLogicalRoomInfoStrc {
return { dwFlags: 0, nLists: 0, pIndexX: newGrid(), pIndexY: newGrid(), pCoordList: null, ppCoordListHandles: [] }
}
/** `(D2RoomCoordListStrc*)nCell` for a pIndexY cell of pLogicalRoomInfo. */
function coordListFromCell(pLogicalRoomInfo: D2DrlgLogicalRoomInfoStrc, nCell: number): D2RoomCoordListStrc | null {
if (nCell === 0) return null
const pRoomCoordList = nCell > 0 ? pLogicalRoomInfo.ppCoordListHandles[nCell - 1] : undefined
if (!pRoomCoordList) throw new Error(`pIndexY cell ${nCell} is not a D2RoomCoordListStrc* (wild pointer)`)
return pRoomCoordList
}
/** C would loop forever on a cyclic tile chain; the port refuses instead. */
function chainStep(n: number): number {
if (n > 1 << 22) throw new Error('DRLGLOGIC: tile chain does not terminate (C would loop forever)')
return n + 1
}
//D2Common.0x6FD764A0
export function DRLGLOGIC_InitializeDrlgCoordList(
pDrlgRoom: D2DrlgRoomStrc,
pTileTypeGrid: D2DrlgGridStrc,
pFloorGrid: D2DrlgGridStrc,
pWallGrid: D2DrlgGridStrc,
): void {
const nCellPositions = new Int32Array(1024)
const nCellFlags = new Int32Array(256)
const pDrlgCoordList = newLogicalRoomInfo()
pDrlgRoom.pLogicalRoomInfo = pDrlgCoordList
let pDrlgRoomTiles = tileGridOf(pDrlgRoom).pTiles
for (let i = 0; i < pDrlgRoomTiles.nWalls; i += 1) {
const pWallTileData = tileAt(pDrlgRoomTiles.pWallTiles, i, 'DRLGLOGIC_InitializeDrlgCoordList')
if (pWallTileData.dwFlags & MAPTILE_TREES && !HasMapTileLayer(pWallTileData.dwFlags)) {
DRLGGRID_AlterGridFlag(pWallGrid, pWallTileData.nPosX, pWallTileData.nPosY, 8, FLAG_OPERATION_OR)
}
}
pDrlgCoordList.dwFlags |= DRLGLOGIC_ROOMINFO_HAS_GRID_CELLS
DRLGGRID_InitializeGridCells(pDrlgCoordList.pIndexX, (pDrlgRoom.pDrlgCoord.nWidth + 1) | 0, (pDrlgRoom.pDrlgCoord.nHeight + 1) | 0)
if (!pDrlgRoom.pLevel.nCoordLists) {
pDrlgRoom.pLevel.nCoordLists = 1
}
const nLists = pDrlgRoom.pLevel.nCoordLists
const pDrlgGrid = newGrid()
DRLGGRID_FillGrid(pDrlgGrid, (pDrlgRoom.pDrlgCoord.nWidth + 1) | 0, (pDrlgRoom.pDrlgCoord.nHeight + 1) | 0, nCellPositions, 0, nCellFlags)
pDrlgRoomTiles = tileGridOf(pDrlgRoom).pTiles
for (let i = 0; i < pDrlgRoomTiles.nWalls; i += 1) {
const pWallTileData = tileAt(pDrlgRoomTiles.pWallTiles, i, 'DRLGLOGIC_InitializeDrlgCoordList')
if (
GetMapTileLayer(pWallTileData.dwFlags) === 1 &&
pWallTileData.nTileType !== TILETYPE_ROOF &&
!(pWallTileData.dwFlags & MAPTILE_OBJECT_WALL)
) {
DRLGGRID_AlterGridFlag(pDrlgGrid, pWallTileData.nPosX, pWallTileData.nPosY, 1, FLAG_OPERATION_OR)
}
}
for (let i = 0; i < pDrlgRoom.nRoomsNear; i += 1) {
const pDrlgRoomNear = pDrlgRoom.ppRoomsNear[i]!
if (pDrlgRoomNear !== pDrlgRoom && pDrlgRoomNear.pTileGrid) {
let nLinks = 0
for (let pDrlgTileLink = pDrlgRoomNear.pTileGrid.pMapLinks; pDrlgTileLink; pDrlgTileLink = pDrlgTileLink.pNext) {
nLinks = chainStep(nLinks)
if (!pDrlgTileLink.bFloor) {
let nTiles = 0
for (let pDrlgTileData: D2DrlgTileDataStrc | null = pDrlgTileLink.pMapTile; pDrlgTileData; pDrlgTileData = pDrlgTileData.unk0x20) {
nTiles = chainStep(nTiles)
if (DRLG_CheckLayer1ButNotWallObject(pDrlgTileData)) {
const nX = (pDrlgRoomNear.pDrlgCoord.nPosX + pDrlgTileData.nPosX) | 0
const nY = (pDrlgRoomNear.pDrlgCoord.nPosY + pDrlgTileData.nPosY) | 0
if (DRLGROOM_AreXYInsideCoordinatesOrOnBorder(pDrlgRoom.pDrlgCoord, nX, nY)) {
DRLGGRID_AlterGridFlag(
pDrlgGrid,
(nX - pDrlgRoom.pDrlgCoord.nPosX) | 0,
(nY - pDrlgRoom.pDrlgCoord.nPosY) | 0,
1,
FLAG_OPERATION_OR,
)
}
}
}
}
}
}
}
const tDRLGLogicUnkStrc: D2UnkDrlgLogicStrc = {
pDrlgRoom,
field_4: pDrlgCoordList.pIndexX,
pTileTypeGrid,
pWallGrid,
pFloorGrid,
field_14: pDrlgGrid,
field_18: nLists,
nFlags: 0,
}
for (let j = 0; j <= pDrlgRoom.pDrlgCoord.nHeight; j += 1) {
for (let i = 0; i <= pDrlgRoom.pDrlgCoord.nWidth; i += 1) {
if (!(DRLGGRID_GetGridEntry(tDRLGLogicUnkStrc.field_4, i, j) & 0x10000000)) {
tDRLGLogicUnkStrc.field_18 = (tDRLGLogicUnkStrc.field_18 + 1) | 0
tDRLGLogicUnkStrc.nFlags = (tDRLGLogicUnkStrc.field_18 & 0xfffffff) | 0x10000000
const nFloorPackedInfo = DRLGGRID_GetGridEntry(tDRLGLogicUnkStrc.pFloorGrid, i, j) >>> 0
if (
(PackedTile.nTileStyle(nFloorPackedInfo) === 30 && PackedTile.nWallLayer(nFloorPackedInfo) === 0) ||
PackedTile.bHidden(nFloorPackedInfo)
) {
tDRLGLogicUnkStrc.nFlags |= 0x20000000
}
DRLGLOGIC_SetTileGridFlags(tDRLGLogicUnkStrc, i, j, -1)
}
}
}
DRLGGRID_ResetGrid(pDrlgGrid)
pDrlgCoordList.nLists = (tDRLGLogicUnkStrc.field_18 - nLists + 1) | 0
// D2_CALLOC_POOL(sizeof(D2RoomCoordListStrc) * nLists): only element [0] is ever reachable (it ends the
// chain built by DRLGLOGIC_AssignCoordListsForGrids), so only that element is modelled.
if (pDrlgCoordList.nLists <= 0) throw new RangeError(`DRLGLOGIC_InitializeDrlgCoordList: nLists = ${pDrlgCoordList.nLists}`)
pDrlgCoordList.pCoordList = newRoomCoordList()
pDrlgRoom.pLevel.nCoordLists = (pDrlgRoom.pLevel.nCoordLists + pDrlgCoordList.nLists) | 0
DRLGLOGIC_AssignCoordListsForGrids(pDrlgRoom, pDrlgCoordList, nLists)
DRLGLOGIC_SetCoordListForTiles(pDrlgRoom)
sub_6FD769B0(pDrlgRoom)
}
const stru_6FDCE5C8: readonly { nX: number; nY: number }[] = [
{ nX: 1, nY: 0 },
{ nX: 0, nY: 1 },
{ nX: -1, nY: 0 },
{ nX: 0, nY: -1 },
]
const dword_6FDCE5EC: readonly number[] = [
23, 0, 5, 21, 17, 15, 3, 0, 9, 7, 39, 0, 0, 5, 3, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 0,
]
const dword_6FDCE650: readonly number[] = [-1, 0, 1, 2, 2, 0, 1, 3, 0, 1, 0, 1, 4, -1, 4, 0, 0, 0, 0, 0]
//D2Common.0x6FD76830
function DRLGLOGIC_SetTileGridFlags(a1: D2UnkDrlgLogicStrc, nX: number, nY: number, a4: number): void {
let nPosX = nX
let nPosY = nY
while (
DRLGROOM_AreXYInsideCoordinatesOrOnBorder(
a1.pDrlgRoom.pDrlgCoord,
(nPosX + a1.pDrlgRoom.pDrlgCoord.nPosX) | 0,
(nPosY + a1.pDrlgRoom.pDrlgCoord.nPosY) | 0,
)
) {
if (DRLGGRID_GetGridEntry(a1.field_4, nPosX, nPosY) & 0x10000000) {
return
}
if (!DRLGGRID_GetGridEntry(a1.field_14, nPosX, nPosY)) {
DRLGGRID_AlterGridFlag(a1.field_4, nPosX, nPosY, a1.nFlags, FLAG_OPERATION_OR)
for (let i = 0; i < 4; i += 1) {
DRLGLOGIC_SetTileGridFlags(a1, (nPosX + stru_6FDCE5C8[i]!.nX) | 0, (nPosY + stru_6FDCE5C8[i]!.nY) | 0, i)
}
return
}
let nIndex = 0
if (DRLGGRID_IsGridValid(a1.pTileTypeGrid)) {
nIndex = DRLGGRID_GetGridEntry(a1.pTileTypeGrid, nPosX, nPosY)
}
// dword_6FDCE650 has 20 entries and dword_6FDCE5EC 26: any other subscript reads unrelated memory (UB;
// tile types 0 and 13 map to row -1, which lands before dword_6FDCE5EC).
const nRow = nIndex >= 0 && nIndex < dword_6FDCE650.length ? dword_6FDCE650[nIndex]! : undefined
const nFlagIndex = nRow === undefined ? -1 : (a4 + 5 * nRow + 1) | 0
if (nRow === undefined || nFlagIndex < 0 || nFlagIndex >= dword_6FDCE5EC.length) {
throw new RangeError(
`DRLGLOGIC_SetTileGridFlags: out-of-bounds table read (tile type ${nIndex}, a4 ${a4}) at room tile (${nPosX}, ${nPosY})`,
)
}
const nFlags = dword_6FDCE5EC[nFlagIndex]!
if (nFlags & 1) {
DRLGGRID_AlterGridFlag(a1.field_4, nPosX, nPosY, a1.nFlags, FLAG_OPERATION_OR)
}
if (nFlags & 2 && a4 !== 2) {
DRLGLOGIC_SetTileGridFlags(a1, (nPosX + 1) | 0, nPosY, 0)
}
if (nFlags & 4 && a4 !== 3) {
DRLGLOGIC_SetTileGridFlags(a1, nPosX, (nPosY + 1) | 0, 1)
}
if (nFlags & 8 && a4 !== 0) {
DRLGLOGIC_SetTileGridFlags(a1, (nPosX - 1) | 0, nPosY, 2)
}
if (nFlags & 16 && a4 !== 1) {
DRLGLOGIC_SetTileGridFlags(a1, nPosX, (nPosY - 1) | 0, 3)
}
if (!(nFlags & 32)) {
return
}
nPosY = (nPosY + 1) | 0
nPosX = (nPosX + 1) | 0
a4 = -1
}
}
//D2Common.0x6FD769B0
function sub_6FD769B0(pDrlgRoom: D2DrlgRoomStrc): void {
for (let i = 0; i < pDrlgRoom.nRoomsNear; i += 1) {
const pCurrentRoomEx = pDrlgRoom.ppRoomsNear[i]!
if (pCurrentRoomEx !== pDrlgRoom) {
if (pCurrentRoomEx.pLogicalRoomInfo) {
if (!DRLG_CheckNotOverlappingUsingManhattanDistance(pDrlgRoom.pDrlgCoord, pCurrentRoomEx.pDrlgCoord, 1)) {
for (let j = pDrlgRoom.pDrlgCoord.nPosX; j <= pDrlgRoom.pDrlgCoord.nPosX + pDrlgRoom.pDrlgCoord.nWidth; j += 1) {
sub_6FD76A90(pDrlgRoom, pCurrentRoomEx, j, pDrlgRoom.pDrlgCoord.nPosY)
sub_6FD76A90(pDrlgRoom, pCurrentRoomEx, j, (pDrlgRoom.pDrlgCoord.nHeight + pDrlgRoom.pDrlgCoord.nPosY) | 0)
}
for (let j = pDrlgRoom.pDrlgCoord.nPosY; j <= pDrlgRoom.pDrlgCoord.nPosY + pDrlgRoom.pDrlgCoord.nHeight; j += 1) {
sub_6FD76A90(pDrlgRoom, pCurrentRoomEx, pDrlgRoom.pDrlgCoord.nPosX, j)
sub_6FD76A90(pDrlgRoom, pCurrentRoomEx, (pDrlgRoom.pDrlgCoord.nPosX + pDrlgRoom.pDrlgCoord.nWidth) | 0, j)
}
}
}
}
}
}
//D2Common.0x6FD76A90
function sub_6FD76A90(pDrlgRoom1: D2DrlgRoomStrc, pDrlgRoom2: D2DrlgRoomStrc, nX: number, nY: number): void {
if (DRLGROOM_AreXYInsideCoordinatesOrOnBorder(pDrlgRoom2.pDrlgCoord, nX, nY)) {
const pRoomCoordList1 = sub_6FD77110(pDrlgRoom1, Math.imul(nX, 5), Math.imul(nY, 5))
const pRoomCoordList2 = sub_6FD77110(pDrlgRoom2, Math.imul(nX, 5), Math.imul(nY, 5))
if (!pRoomCoordList1 || !pRoomCoordList2) throw new Error('sub_6FD76A90: NULL D2RoomCoordListStrc dereference')
const nIndex1 = pRoomCoordList1.nIndex
const nIndex2 = pRoomCoordList2.nIndex
if (nIndex2 && nIndex1) {
if (
pDrlgRoom2.pLevel.nLevelId === pDrlgRoom1.pLevel.nLevelId &&
nIndex2 !== nIndex1 &&
pRoomCoordList2.bNode === pRoomCoordList1.bNode
) {
sub_6FD76B90(pDrlgRoom1, nIndex1, nIndex2, pRoomCoordList2.bNode)
}
}
}
}
//D2Common.0x6FD76B90
function sub_6FD76B90(pDrlgRoom: D2DrlgRoomStrc, nIndex1: number, nIndex2: number, bNode: number): void {
if (pDrlgRoom.pLogicalRoomInfo === null || pDrlgRoom.pLogicalRoomInfo.dwFlags & DRLGLOGIC_ROOMINFO_HAS_COORD_LIST) {
return
}
let pRoomCoordList = pDrlgRoom.pLogicalRoomInfo.pCoordList
if (pRoomCoordList) {
let bContinue = false
let nSteps = 0
do {
nSteps = chainStep(nSteps)
if (pRoomCoordList.nIndex === nIndex1) {
bContinue = true
pRoomCoordList.nIndex = nIndex2
}
pRoomCoordList = pRoomCoordList.pNext
} while (pRoomCoordList)
if (bContinue) {
for (let i = 0; i < pDrlgRoom.nRoomsNear; i += 1) {
const pRoomNear = pDrlgRoom.ppRoomsNear[i]!
if (pRoomNear !== pDrlgRoom && pRoomNear.pLevel.nLevelId === pDrlgRoom.pLevel.nLevelId) {
sub_6FD76B90(pRoomNear, nIndex1, nIndex2, bNode)
}
}
}
}
}
//D2Common.0x6FD76C20
export function DRLG_CheckLayer1ButNotWallObject(pTileData: D2DrlgTileDataStrc): boolean {
if (GetMapTileLayer(pTileData.dwFlags) === 1) {
if (pTileData.nTileType !== TILETYPE_ROOF) {
return (pTileData.dwFlags & MAPTILE_OBJECT_WALL) === 0
}
}
return false
}
//D2Common.0x6FD76C50
function DRLGLOGIC_SetCoordListForTiles(pDrlgRoom: D2DrlgRoomStrc): void {
const pTiles = tileGridOf(pDrlgRoom).pTiles
if (pTiles.nWalls) {
for (let i = 0; i < pTiles.nWalls; i += 1) {
const pWallTileData = tileAt(pTiles.pWallTiles, i, 'DRLGLOGIC_SetCoordListForTiles')
const pLogicalRoomInfo = pDrlgRoom.pLogicalRoomInfo
if (pLogicalRoomInfo && !(pLogicalRoomInfo.dwFlags & DRLGLOGIC_ROOMINFO_HAS_COORD_LIST)) {
pWallTileData.unk0x10 =
coordListFromCell(
pLogicalRoomInfo,
DRLGGRID_GetGridEntry(pLogicalRoomInfo.pIndexY, pWallTileData.nPosX, pWallTileData.nPosY),
) ?? 0
} else {
pWallTileData.unk0x10 = 0
}
}
}
}
//D2Common.0x6FD76CF0
function DRLGLOGIC_AssignCoordListsForGrids(
pDrlgRoom: D2DrlgRoomStrc,
pDrlgCoordList: D2DrlgLogicalRoomInfoStrc,
_nLists: number,
): void {
DRLGGRID_InitializeGridCells(pDrlgCoordList.pIndexY, (pDrlgRoom.pDrlgCoord.nWidth + 1) | 0, (pDrlgRoom.pDrlgCoord.nHeight + 1) | 0)
const nWidth = (pDrlgRoom.pDrlgCoord.nWidth + 1) | 0
const nHeight = (pDrlgRoom.pDrlgCoord.nHeight + 1) | 0
for (let nY = 0; nY < nHeight; nY += 1) {
for (let nX = 0; nX < nWidth; nX += 1) {
const nFlags = DRLGGRID_GetGridEntry(pDrlgCoordList.pIndexX, nX, nY)
const nIndex = nFlags & 0xfffffff
if (!DRLGGRID_GetGridEntry(pDrlgCoordList.pIndexY, nX, nY)) {
const pRoomCoordList = newRoomCoordList()
const hRoomCoordList = pDrlgCoordList.ppCoordListHandles.push(pRoomCoordList)
pRoomCoordList.nIndex = nIndex
pRoomCoordList.bNode = (nFlags & 0x20000000) === 0x20000000 ? 1 : 0
pRoomCoordList.pNext = pDrlgCoordList.pCoordList
pDrlgCoordList.pCoordList = pRoomCoordList
const pBox0 = pRoomCoordList.pBox[0]
const pBox1 = pRoomCoordList.pBox[1]
pBox0.nPosX = nX
pBox0.nPosY = nY
let nTmpWidth: number
for (nTmpWidth = nX; nTmpWidth < nWidth; nTmpWidth += 1) {
if (nIndex !== (DRLGGRID_GetGridEntry(pDrlgCoordList.pIndexX, nTmpWidth, nY) & 0xfffffff)) {
break
}
if (DRLGGRID_GetGridEntry(pDrlgCoordList.pIndexY, nTmpWidth, nY)) {
break
}
}
pBox0.nWidth = nTmpWidth
let bBreak = false
let nTmpHeight: number
for (nTmpHeight = nY; nTmpHeight < nHeight; nTmpHeight += 1) {
for (let i = nX; i < pBox0.nWidth; i += 1) {
if (
nIndex !== (DRLGGRID_GetGridEntry(pDrlgCoordList.pIndexX, i, nTmpHeight) & 0xfffffff) ||
DRLGGRID_GetGridEntry(pDrlgCoordList.pIndexY, i, nTmpHeight)
) {
bBreak = true
break
}
}
if (bBreak) {
break
}
}
pBox0.nHeight = nTmpHeight
for (let j = pBox0.nPosY; j < pBox0.nHeight; j += 1) {
for (let i = pBox0.nPosX; i < pBox0.nWidth; i += 1) {
DRLGGRID_AlterGridFlag(pDrlgCoordList.pIndexY, i, j, hRoomCoordList, FLAG_OPERATION_OVERWRITE)
}
}
pBox0.nPosY = (pBox0.nPosY + pDrlgRoom.pDrlgCoord.nPosY) | 0
pBox0.nHeight = (pBox0.nHeight + pDrlgRoom.pDrlgCoord.nPosY) | 0
pBox0.nPosX = (pBox0.nPosX + pDrlgRoom.pDrlgCoord.nPosX) | 0
pBox0.nWidth = (pBox0.nWidth + pDrlgRoom.pDrlgCoord.nPosX) | 0
pBox1.nPosX = pBox0.nPosX
pBox1.nPosY = pBox0.nPosY
pBox1.nWidth = pBox0.nWidth
pBox1.nHeight = pBox0.nHeight
nTmpWidth = (pDrlgRoom.pDrlgCoord.nPosX + pDrlgRoom.pDrlgCoord.nWidth) | 0
if (pBox1.nWidth >= nTmpWidth) {
pBox1.nWidth = nTmpWidth
}
nTmpHeight = (pDrlgRoom.pDrlgCoord.nPosY + pDrlgRoom.pDrlgCoord.nHeight) | 0
if (pBox1.nHeight >= nTmpHeight) {
pBox1.nHeight = nTmpHeight
}
if (pBox1.nPosX >= nTmpWidth || pBox1.nPosY >= nTmpHeight) {
pBox1.nPosX = 0
pBox1.nPosY = 0
pBox1.nWidth = 0
pBox1.nHeight = 0
}
}
}
}
}
//D2Common.0x6FD76F90
export function DRLGLOGIC_AllocCoordLists(pDrlgRoom: D2DrlgRoomStrc): void {
const pLogicalRoomInfo = newLogicalRoomInfo()
pDrlgRoom.pLogicalRoomInfo = pLogicalRoomInfo
pLogicalRoomInfo.dwFlags |= DRLGLOGIC_ROOMINFO_HAS_COORD_LIST
pDrlgRoom.pLevel.nCoordLists = 1
pLogicalRoomInfo.nLists = 1
const pCoordList = newRoomCoordList()
pLogicalRoomInfo.pCoordList = pCoordList
pCoordList.nIndex = pDrlgRoom.pLevel.nCoordLists
pCoordList.pBox[0].nPosY = pDrlgRoom.pDrlgCoord.nPosY
pCoordList.pBox[0].nHeight = (pDrlgRoom.pDrlgCoord.nPosY + pDrlgRoom.pDrlgCoord.nHeight) | 0
pCoordList.pBox[0].nPosX = pDrlgRoom.pDrlgCoord.nPosX
pCoordList.pBox[0].nWidth = (pDrlgRoom.pDrlgCoord.nPosX + pDrlgRoom.pDrlgCoord.nWidth) | 0
pCoordList.pBox[1].nPosY = pDrlgRoom.pDrlgCoord.nPosY
pCoordList.pBox[1].nHeight = (pDrlgRoom.pDrlgCoord.nPosY + pDrlgRoom.pDrlgCoord.nHeight) | 0
pCoordList.pBox[1].nPosX = pDrlgRoom.pDrlgCoord.nPosX
pCoordList.pBox[1].nWidth = (pDrlgRoom.pDrlgCoord.nPosX + pDrlgRoom.pDrlgCoord.nWidth) | 0
}
//D2Common.0x6FD77080
export function DRLGLOGIC_GetRoomCoordListIndex(pDrlgRoom: D2DrlgRoomStrc, nX: number, nY: number): number {
const pRoomCoordList = sub_6FD77110(pDrlgRoom, nX, nY)
if (pRoomCoordList) {
return pRoomCoordList.nIndex
}
return -1
}
//D2Common.0x6FD77110
export function sub_6FD77110(pDrlgRoom: D2DrlgRoomStrc, nX: number, nY: number): D2RoomCoordListStrc | null {
const pLogicalRoomInfo = pDrlgRoom.pLogicalRoomInfo
if (!pLogicalRoomInfo) throw new Error('D2_ASSERT(pDrlgRoom->pLogicalRoomInfo) (sub_6FD77110)')
if (pLogicalRoomInfo.dwFlags & DRLGLOGIC_ROOMINFO_HAS_COORD_LIST) {
return pLogicalRoomInfo.pCoordList
} else {
return coordListFromCell(
pLogicalRoomInfo,
DRLGGRID_GetGridEntry(
pLogicalRoomInfo.pIndexY,
((nX / 5) | 0) - pDrlgRoom.pDrlgCoord.nPosX,
((nY / 5) | 0) - pDrlgRoom.pDrlgCoord.nPosY,
),
)
}
}
//D2Common.0x6FD77190
export function DRLGLOGIC_GetRoomCoordList(pDrlgRoom: D2DrlgRoomStrc): D2RoomCoordListStrc | null {
if (!pDrlgRoom.pLogicalRoomInfo) throw new Error('D2_ASSERT(pDrlgRoom->pLogicalRoomInfo) (DRLGLOGIC_GetRoomCoordList)')
return pDrlgRoom.pLogicalRoomInfo.pCoordList
}

826
src/game/drlg/drlg-map.ts
View File

@ -1,826 +0,0 @@
/**
* Act I outdoor level maps from the DRLG port (M5 adapter).
*
* The 1:1 port of D2MOO's DRLG (src/game/drlg/drlg-*.ts) produces the level exactly as D2Common builds
* it: rooms, their tile lists (DRLGROOMTILE_AddRoomMapTiles), preset units and warps. This module turns
* one generated level into what the rest of the game consumes:
* - a DS1-shaped canvas ({@link Ds1}) for the isometric renderer (`buildIsoMapScene`), one cell per
* level tile, holding the exact (style, sequence, type) of every tile D2 placed;
* - the DT1 libraries those tiles come from, with a per-cell library mask so the renderer only draws
* variants from the library D2 picked the tile from;
* - DS1-shaped objects (the same (type, id) encoding a preset DS1 uses, so the bake resolves them
* through its existing object path);
* - the level's entrances (seams with their real sides from the DRLG level links, and warps from the
* UNIT_TILE preset units D2 creates for them) and SuperUnique landmarks.
*
* Nothing here decides anything about the layout: every value comes from the verified DRLG output
* (the schema-3 dump, identical for the native oracle and the port), and anything unexpected throws.
* The input is the normalized {@link DrlgLevelInput} so the same code maps the oracle's JSON and the
* port's in-memory dump.
*/
import type { Ds1, Ds1Cell, Ds1Floor, Ds1Object, Ds1Wall } from '../../formats/ds1.ts'
import type { Dt1 } from '../../formats/dt1.ts'
import { dt1MaskAllows } from '../d2map.ts'
import type { DrlgDump, DumpCoord, DumpLevel, DumpTile, DumpTileRef } from './drlg-dump.ts'
import { DRLG_GetActNoFromLevelId } from './drlg-drlg.ts'
import { DRLGPRESET_GetObjectIndexFromObjPreset } from './drlg-preset.ts'
import { normalizeDrlgPath } from './drlg-source.ts'
import { DATATBLS_GetLevelDefRecord, DATATBLS_GetLvlTypesTxtRecord, DATATBLS_GetMonPresetTxtActSection } from './drlg-tables.ts'
import type { DrlgTables } from './drlg-tables.ts'
import {
ALTDIR_EAST, ALTDIR_NORTH, ALTDIR_SOUTH, ALTDIR_WEST, DRLGTYPE_OUTDOOR, GRID2_LVL_LINK,
} from './drlg-types.ts'
/** Tiles per outdoor grid cell (the 8x8 blocks of D2DrlgOutdoorInfoStrc.pGrid). */
const TILES_PER_GRID_CELL = 8
/** Sub-tiles per tile (DUNGEON_GameTileToSubtileCoords). */
const SUBTILES_PER_TILE = 5
// D2MapTileFlags (D2DrlgDrlg.h)
const MAPTILE_HIDDEN = 0x8
const MAPTILE_LAYER_SHIFT = 14
const MAPTILE_LAYER_MASK = 0x7
// D2TileType (D2CMP.h)
const TILETYPE_FLOOR = 0
const TILETYPE_WALL_TOP_CORNER_RIGHT = 3
const TILETYPE_WALL_TOP_CORNER_LEFT = 4
const TILETYPE_SHADOW = 13
// D2C_UnitTypes
const UNIT_MONSTER = 1
const UNIT_OBJECT = 2
const UNIT_TILE = 5
/** DS1 object `type` values (the encoding DRLGPRESET_ParseDS1File reads). */
const DS1_TYPE_MONSTER = 1
const DS1_TYPE_OBJECT = 2
/** Object ids below this are ObjPreset slots; `objects.txt id + 150` otherwise (DRLGPRESET_ParseDS1File, v > 5). */
const DS1_OBJPRESET_SLOTS = 150
/**
* Objects.txt class D2Game refuses to create from a preset unit (SUnit.cpp:1003, SUNIT_CreatePresetUnit:
* `if (nClassId == 573) return`), so it never exists in game.
*/
const OBJECT_CLASS_INVALID_PRESET = 573
/**
* MonPlace.txt rows D2Game turns into a fixed monster at the preset position instead of a random pack
* (D2Game MonsterRegion.cpp:243-300, `switch (nMonPlace)`), mapped to the monster planner's landmark id.
* Only the cases reachable from Act I outdoor presets are listed: 5 -> MONSTER_BLOODRAVEN.
*/
const MONPLACE_LANDMARKS: ReadonlyMap<number, string> = new Map([[5, 'Blood Raven']])
/** Axis-aligned rectangle in world tiles (D2DrlgCoordStrc). */
export interface DrlgRect {
readonly x: number
readonly y: number
readonly width: number
readonly height: number
}
/** Which array of the owner room's D2DrlgRoomTilesStrc a tile lives in. */
export type DrlgTileKind = 'wall' | 'floor' | 'shadow'
/** One D2DrlgTileDataStrc, placed in level coordinates. */
export interface DrlgTileInput {
/** Identity of the tile data (owner level, room, array, index), so owned and linked copies dedupe. */
readonly key: string
readonly kind: DrlgTileKind
/** Level-local tile position: owner room position + nPosX/nPosY - level position (0..W, 0..H). */
readonly x: number
readonly y: number
/** D2DrlgTileDataStrc.dwFlags (D2MapTileFlags). */
readonly flags: number
/** D2DrlgTileDataStrc.nTileType. */
readonly tileType: number
/** pTile: the DT1 tile D2 picked (normalized library path, tile index), or null when none matched. */
readonly tile: { readonly library: string; readonly index: number } | null
}
/** One D2PresetUnitStrc of a room, after DRLGROOMTILE_AddRoomMapTiles. */
export interface DrlgUnitInput {
/** Room index in the level's room chain. */
readonly room: number
/** D2C_UnitTypes. */
readonly type: number
/** nIndex as D2 stores it (after DRLGPRESET_ParseDS1File's MonPreset / ObjPreset conversion). */
readonly index: number
readonly mode: number
/** Level-local sub-tile position (room-relative nXpos/nYpos + 5 * room offset). */
readonly subX: number
readonly subY: number
readonly spawned: number
}
/** One D2RoomTileStrc (a warp of a room, sub_6FD77F00). */
export interface DrlgWarpInput {
readonly room: number
/** pLvlWarpTxtRecord->dwLevelId: the LvlWarp.txt `Id`, the class id of the warp's UNIT_TILE unit. */
readonly lvlWarpId: number
/** pDrlgRoom->pLevel->nLevelId of the destination room. */
readonly toLevelId: number
}
/** One level-to-level D2DrlgOrthStrc of pOutdoors->pRoomData. */
export interface DrlgOrthInput {
readonly level: number
/** ALTDIR_*: where the neighbour lies (0 west, 1 north, 2 east, 3 south). */
readonly dir: number
readonly box: DrlgRect
}
/** Everything the adapter reads about one generated level. */
export interface DrlgLevelInput {
readonly levelId: number
readonly drlgType: number
readonly levelType: number
readonly coord: DrlgRect
/** pOutdoors->dwFlags (D2DrlgOutdoorInfoStrc: link directions, river bank, ...). */
readonly flags: number
readonly orths: readonly DrlgOrthInput[]
/** pOutdoors->pGrid[2] (packed grid-2 info) as dumped at the levelGrid stage. */
readonly grid2: { readonly w: number; readonly h: number; readonly cells: readonly number[] }
readonly tiles: readonly DrlgTileInput[]
readonly units: readonly DrlgUnitInput[]
readonly warps: readonly DrlgWarpInput[]
}
/** Tables the mapping needs besides the DRLG output. */
export interface DrlgMapContext {
readonly tables: DrlgTables
/** Parsed DT1 libraries keyed by {@link normalizeDrlgPath}. */
readonly dt1: ReadonlyMap<string, Dt1>
/** SuperUniques.txt `Superunique` column, by row. */
readonly superUniqueIds: readonly string[]
}
/** Which edge of the level an entrance sits on (world-graph `Side`). */
export type DrlgSide = 'north' | 'east' | 'south' | 'west'
/**
* A way into or out of the level: the fields of a `WildernessEntrance` (what the bake's
* buildSceneLinks reads) except the display label, which the bake adds, plus `span` for seams.
*/
export interface DrlgEntrance {
/** Anchor cell (tiles, level-local). */
readonly x: number
readonly y: number
/** One step inside from the anchor. */
readonly interiorX: number
readonly interiorY: number
readonly toLevelId: number
readonly side: DrlgSide | null
readonly kind: 'gate' | 'preset'
/**
* Seams only: the stretch of this level's edge (tiles along the side, `from` inclusive, `to`
* exclusive) where the opening is. The bake searches the walkable gap inside it.
*/
readonly span?: { readonly from: number; readonly to: number }
/** Warps only: the UNIT_TILE position in sub-tiles (level-local) and its LvlWarp.txt Id. */
readonly warp?: { readonly subX: number; readonly subY: number; readonly lvlWarpId: number }
}
/** A fixed monster the planner anchors to its preset position. */
export interface DrlgLandmark {
/** The monster planner's id (SuperUniques.txt `Superunique`, or 'Blood Raven'). */
readonly id: string
readonly tileX: number
readonly tileY: number
readonly subX: number
readonly subY: number
}
/** One tile reference written into the canvas, with the library D2 took it from. */
export interface DrlgCellRef {
readonly x: number
readonly y: number
readonly kind: DrlgTileKind
readonly style: number
readonly sequence: number
readonly type: number
/** Index into {@link DrlgLevelMap.dt1Names}. */
readonly library: number
readonly hidden: boolean
}
export interface DrlgLevelMapStats {
readonly walls: number
readonly floors: number
readonly shadows: number
/** Type-4 halves skipped because the renderer draws them with their type-3 tile. */
readonly cornerCompanions: number
/** Tiles whose pTile is null (D2CMP found no tile): D2 draws nothing for them. */
readonly withoutTile: number
/** Linked tiles of other rooms drawn inside this level's canvas. */
readonly linkedInCanvas: number
/** Linked tiles outside the canvas (belong to the neighbour's canvas). */
readonly linkedOutside: number
readonly objects: number
readonly monsters: number
readonly skippedInvalidObjects: number
}
/** One mapped level. */
export interface DrlgLevelMap {
readonly levelId: number
readonly coord: DrlgRect
readonly flags: number
/** The canvas: (width + 1) x (height + 1) cells, like a DS1 of the level's size. */
readonly ds1: Ds1
/** DT1 libraries (normalized archive paths) in renderer library order; per-cell `dt1Mask` bits index it. */
readonly dt1Names: readonly string[]
readonly entrances: readonly DrlgEntrance[]
readonly landmarks: readonly DrlgLandmark[]
/** Every tile reference written into the canvas (for the DT1-mask ambiguity audit). */
readonly refs: readonly DrlgCellRef[]
readonly stats: DrlgLevelMapStats
}
/**
* DT1 libraries DRLGROOMTILE_LoadDT1FilesForRoom loads for every room regardless of its mask
* (DrlgRoomTile.cpp:1249-1256): they come first so a cell mask can always name them.
*/
export const DRLG_UNIVERSAL_DT1: readonly string[] = [
'DATA\\GLOBAL\\TILES\\Act1\\Outdoors\\Blank.dt1',
'DATA\\GLOBAL\\TILES\\Act1\\Barracks\\InvisWal.dt1',
'DATA\\GLOBAL\\TILES\\Act1\\Barracks\\Warp.dt1',
].map(normalizeDrlgPath)
/**
* The Act I levels D2 generates with the outdoor DRLG (Levels.txt DrlgType 3), ascending.
*
* @param tables - the DRLG tables.
* @returns level ids.
*/
export function act1OutdoorLevelIds(tables: DrlgTables): number[] {
const out: number[] = []
for (let id = 1; id < tables.nLevelsTxtRecordCount; id += 1) {
if (DRLG_GetActNoFromLevelId(id) !== 0) break
if (DATATBLS_GetLevelDefRecord(tables, id).dwDrlgType === DRLGTYPE_OUTDOOR) out.push(id)
}
return out
}
const SIDE_OF_ALTDIR: Readonly<Record<number, DrlgSide>> = {
[ALTDIR_WEST]: 'west',
[ALTDIR_NORTH]: 'north',
[ALTDIR_EAST]: 'east',
[ALTDIR_SOUTH]: 'south',
}
function sideOfAltDir(dir: number, what: string): DrlgSide {
const side = SIDE_OF_ALTDIR[dir]
if (side === undefined) throw new Error(`${what}: direction ${dir} is not an ALTDIR`)
return side
}
function emptyWall(): Ds1Wall {
return { prop1: 0, sequence: 0, style: 0, type: 0, unknown1: 0, unknown2: 0, hidden: false }
}
function emptyFloor(): Ds1Floor {
return { prop1: 0, sequence: 0, style: 0, unknown1: 0, unknown2: 0, hidden: false }
}
/** Mutable per-cell collector. */
interface CellBuild {
walls: { layer: number; order: number; wall: Ds1Wall }[]
floors: { layer: number; order: number; floor: Ds1Floor }[]
shadows: Ds1Floor[]
mask: number
}
/**
* The DT1 library order for a level: the universal libraries, then the libraries of the level's
* LvlTypes row in `File 1..32` order. Only libraries some tile uses are listed (plus the universal
* three, which DRLGROOMTILE_LoadDT1FilesForRoom always loads).
*/
function libraryOrder(tables: DrlgTables, levelType: number, used: ReadonlySet<string>, levelId: number): string[] {
const order: string[] = [...DRLG_UNIVERSAL_DT1]
const listed = new Set(order)
for (const f of DATATBLS_GetLvlTypesTxtRecord(tables, levelType).szFile) {
if (f.length <= 1) continue
const key = normalizeDrlgPath(f)
if (listed.has(key) || !used.has(key)) continue
order.push(key)
listed.add(key)
}
for (const lib of used) {
if (!listed.has(lib)) {
throw new Error(`level ${levelId}: tile library ${lib} is neither universal nor in LvlTypes row ${levelType}`)
}
}
if (order.length > 32) throw new Error(`level ${levelId}: ${order.length} DT1 libraries do not fit a 32-bit cell mask`)
return order
}
/**
* Map one generated Act I outdoor level.
*
* @param input - the level, from the DRLG dump.
* @param ctx - tables, DT1 libraries and names.
* @returns the mapped level.
*/
export function buildDrlgLevelMap(input: DrlgLevelInput, ctx: DrlgMapContext): DrlgLevelMap {
const { levelId, coord } = input
if (input.drlgType !== DRLGTYPE_OUTDOOR) throw new Error(`level ${levelId}: not an outdoor level (DrlgType ${input.drlgType})`)
const nAct = DRLG_GetActNoFromLevelId(levelId)
const cellsX = coord.width + 1
const cellsY = coord.height + 1
// ---- tiles -> canvas ----
const cells: CellBuild[] = []
for (let i = 0; i < cellsX * cellsY; i += 1) cells.push({ walls: [], floors: [], shadows: [], mask: 0 })
const seen = new Set<string>()
const used = new Set<string>()
const placed: { t: DrlgTileInput; style: number; sequence: number; type: number; hidden: boolean }[] = []
let cornerCompanions = 0
let withoutTile = 0
let linkedInCanvas = 0
let linkedOutside = 0
const topCornerRights = new Set<string>()
const topCornerLefts: { t: DrlgTileInput; style: number; sequence: number }[] = []
for (const t of input.tiles) {
if (seen.has(t.key)) continue
seen.add(t.key)
const linked = !t.key.startsWith(`${levelId}/`)
if (t.x < 0 || t.y < 0 || t.x >= cellsX || t.y >= cellsY) {
if (!linked) throw new Error(`level ${levelId}: owned tile ${t.key} at (${t.x}, ${t.y}) is outside the ${cellsX}x${cellsY} canvas`)
linkedOutside += 1
continue
}
if (linked) linkedInCanvas += 1
if (t.tile === null) {
withoutTile += 1
continue
}
const lib = ctx.dt1.get(t.tile.library)
if (lib === undefined) throw new Error(`level ${levelId}: tile ${t.key} uses DT1 ${t.tile.library}, which is not loaded`)
const header = lib.tiles[t.tile.index]
if (header === undefined) throw new Error(`level ${levelId}: tile ${t.key}: ${t.tile.library} has no tile #${t.tile.index}`)
if (header.type !== t.tileType) {
throw new Error(`level ${levelId}: tile ${t.key}: nTileType ${t.tileType} but DT1 tile #${t.tile.index} of ${t.tile.library} is type ${header.type}`)
}
const kindOk = t.kind === 'floor' ? header.type === TILETYPE_FLOOR
: t.kind === 'shadow' ? header.type === TILETYPE_SHADOW
: header.type !== TILETYPE_FLOOR && header.type !== TILETYPE_SHADOW
if (!kindOk) throw new Error(`level ${levelId}: tile ${t.key} is a ${t.kind} of DT1 type ${header.type}`)
if (header.type === TILETYPE_WALL_TOP_CORNER_LEFT) {
// D2 stores the left half of a top corner as its own tile data next to the type-3 tile
// (DRLGROOMTILE_InitWallTileData); buildIsoMapScene draws that half itself for every type-3 wall.
topCornerLefts.push({ t, style: header.style, sequence: header.sequence })
continue
}
if (header.type === TILETYPE_WALL_TOP_CORNER_RIGHT) topCornerRights.add(`${t.x},${t.y},${header.style},${header.sequence}`)
used.add(t.tile.library)
placed.push({ t, style: header.style, sequence: header.sequence, type: header.type, hidden: (t.flags & MAPTILE_HIDDEN) !== 0 })
}
for (const c of topCornerLefts) {
if (!topCornerRights.has(`${c.t.x},${c.t.y},${c.style},${c.sequence}`)) {
throw new Error(`level ${levelId}: top-corner-left tile ${c.t.key} at (${c.t.x}, ${c.t.y}) has no top-corner-right partner`)
}
cornerCompanions += 1
}
const dt1Names = libraryOrder(ctx.tables, input.levelType, used, levelId)
const libIndex = new Map(dt1Names.map((name, i) => [name, i]))
const refs: DrlgCellRef[] = []
let order = 0
let walls = 0
let floors = 0
let shadows = 0
for (const p of placed) {
const cell = cells[p.t.y * cellsX + p.t.x]!
const library = libIndex.get(p.t.tile!.library)!
cell.mask |= 1 << library
const layer = (p.t.flags >>> MAPTILE_LAYER_SHIFT) & MAPTILE_LAYER_MASK
// prop1 only marks the slot as used for the renderer; hidden tiles (warp lit tiles, etc.) are kept
// hidden exactly as D2 adds them.
if (p.t.kind === 'floor') {
cell.floors.push({ layer, order: order++, floor: { prop1: 1, sequence: p.sequence, style: p.style, unknown1: 0, unknown2: 0, hidden: p.hidden } })
floors += 1
} else if (p.t.kind === 'shadow') {
cell.shadows.push({ prop1: 1, sequence: p.sequence, style: p.style, unknown1: 0, unknown2: 0, hidden: p.hidden })
shadows += 1
} else {
cell.walls.push({ layer, order: order++, wall: { prop1: 1, sequence: p.sequence, style: p.style, type: p.type, unknown1: 0, unknown2: 0, hidden: p.hidden } })
walls += 1
}
refs.push({ x: p.t.x, y: p.t.y, kind: p.t.kind, style: p.style, sequence: p.sequence, type: p.type, library, hidden: p.hidden })
}
let wallLayers = 1
let floorLayers = 1
let shadowLayers = 1
for (const c of cells) {
wallLayers = Math.max(wallLayers, c.walls.length)
floorLayers = Math.max(floorLayers, c.floors.length)
shadowLayers = Math.max(shadowLayers, c.shadows.length)
}
const byLayer = <T extends { layer: number; order: number }>(a: T, b: T): number => a.layer - b.layer || a.order - b.order
const rows: Ds1Cell[][] = []
for (let y = 0; y < cellsY; y += 1) {
const row: Ds1Cell[] = []
for (let x = 0; x < cellsX; x += 1) {
const c = cells[y * cellsX + x]!
const cw = c.walls.sort(byLayer).map(w => w.wall)
const cf = c.floors.sort(byLayer).map(f => f.floor)
const cs = [...c.shadows]
while (cw.length < wallLayers) cw.push(emptyWall())
while (cf.length < floorLayers) cf.push(emptyFloor())
while (cs.length < shadowLayers) cs.push(emptyFloor())
row.push({ walls: cw, floors: cf, shadows: cs, substitutions: [], ...(c.mask !== 0 ? { dt1Mask: c.mask >>> 0 } : {}) })
}
rows.push(row)
}
// ---- units -> DS1 objects, landmarks, warp entrances ----
const objSlotOf = new Map<number, number>()
for (let slot = DS1_OBJPRESET_SLOTS - 1; slot >= 0; slot -= 1) {
objSlotOf.set(DRLGPRESET_GetObjectIndexFromObjPreset(nAct, slot), slot) // lowest slot wins
}
const monSection = DATATBLS_GetMonPresetTxtActSection(ctx.tables, nAct)
if (monSection === null) throw new Error(`level ${levelId}: MonPreset has no act ${nAct + 1} section`)
const nMonStats = ctx.tables.nMonStatsTxtRecordCount
const nSU = ctx.tables.nSuperUniquesTxtRecordCount
const monIdOf = new Map<number, number>()
for (let i = monSection.count - 1; i >= 0; i -= 1) {
const r = ctx.tables.monPreset[monSection.start + i]!
let unit: number
switch (r.nType) {
case 0: unit = r.wPlace + nSU + nMonStats; break
case 1: unit = r.wPlace; break
case 2: unit = r.wPlace + nMonStats; break
default: continue // DRLGPRESET_ParseDS1File maps it to -1, which is never allocated
}
monIdOf.set(unit, i) // lowest DS1 id wins (duplicates carry the same Place)
}
const objects: Ds1Object[] = []
const landmarks: DrlgLandmark[] = []
const entrances: DrlgEntrance[] = []
let nObjects = 0
let nMonsters = 0
let skippedInvalidObjects = 0
for (const u of input.units) {
switch (u.type) {
case UNIT_OBJECT: {
if (u.index === OBJECT_CLASS_INVALID_PRESET) { skippedInvalidObjects += 1; break }
if (u.index < 0) throw new Error(`level ${levelId}: object unit with class ${u.index}`)
const slot = objSlotOf.get(u.index)
objects.push({ type: DS1_TYPE_OBJECT, id: slot ?? u.index + DS1_OBJPRESET_SLOTS, x: u.subX, y: u.subY, flags: u.spawned })
nObjects += 1
break
}
case UNIT_MONSTER: {
const id = monIdOf.get(u.index)
if (id === undefined) throw new Error(`level ${levelId}: monster unit ${u.index} has no act ${nAct + 1} MonPreset row`)
objects.push({ type: DS1_TYPE_MONSTER, id, x: u.subX, y: u.subY, flags: u.spawned })
nMonsters += 1
const tileX = Math.floor(u.subX / SUBTILES_PER_TILE)
const tileY = Math.floor(u.subY / SUBTILES_PER_TILE)
if (u.index >= nMonStats && u.index < nMonStats + nSU) {
const su = ctx.superUniqueIds[u.index - nMonStats]
if (su === undefined || su === '') throw new Error(`level ${levelId}: SuperUnique row ${u.index - nMonStats} has no id`)
landmarks.push({ id: su, tileX, tileY, subX: u.subX, subY: u.subY })
} else if (u.index >= nMonStats + nSU) {
const special = MONPLACE_LANDMARKS.get(u.index - nMonStats - nSU)
if (special !== undefined) landmarks.push({ id: special, tileX, tileY, subX: u.subX, subY: u.subY })
}
break
}
case UNIT_TILE: {
const matches = input.warps.filter(w => w.room === u.room && w.lvlWarpId === u.index)
const to = [...new Set(matches.map(w => w.toLevelId))]
if (to.length !== 1) {
throw new Error(`level ${levelId} room ${u.room}: UNIT_TILE ${u.index} matches ${to.length} warp destinations (${to.join(', ')})`)
}
const cx = Math.floor(u.subX / SUBTILES_PER_TILE)
const cy = Math.floor(u.subY / SUBTILES_PER_TILE)
entrances.push({
x: cx,
y: cy,
interiorX: cx,
interiorY: cy,
toLevelId: to[0]!,
side: null,
kind: 'preset',
warp: { subX: u.subX, subY: u.subY, lvlWarpId: u.index },
})
break
}
default:
throw new Error(`level ${levelId} room ${u.room}: unexpected preset unit type ${u.type} (index ${u.index})`)
}
}
// ---- seams ----
entrances.push(...seamEntrances(input))
const ds1: Ds1 = {
version: 18,
width: cellsX,
height: cellsY,
act: nAct + 1,
substitutionType: 0,
wallLayers,
floorLayers,
cells: rows,
objects,
npcPathOffset: null,
}
return {
levelId,
coord,
flags: input.flags,
ds1,
dt1Names,
entrances,
landmarks,
refs,
stats: {
walls, floors, shadows, cornerCompanions, withoutTile, linkedInCanvas, linkedOutside,
objects: nObjects, monsters: nMonsters, skippedInvalidObjects,
},
}
}
/** How far the renderer's tile choice can stray from D2's for one mapped level. */
export interface DrlgDt1Ambiguity {
/** DT1 libraries of the level ({@link DrlgLevelMap.dt1Names}). */
readonly libraries: number
/** Tile references written into the canvas. */
readonly refs: number
/**
* References whose exact (style, sequence, type) group under their cell's DT1 mask holds more than
* one tile. The renderer draws the variant with its own per-cell hash (scene fidelity 'layout'); D2
* rolled it with the room seed (DRLGROOMTILE_GetTileCache), and the port records that roll.
*/
readonly variantGroups: number
/** References whose group under the cell mask spans more than one library: the renderer may draw a tile of a library D2 did not take it from. */
readonly crossLibrary: number
/** The same count with one pool for the whole level (no cell masks): what the cell masks prevent. */
readonly crossLibraryLevelWide: number
}
/**
* The DT1-mask ambiguity audit of a mapped level: resolves every tile reference the way
* `buildIsoMapScene` does (exact style:sequence:type key, {@link dt1MaskAllows}) and counts the
* references whose candidates are not pinned down to D2's library.
*
* @param map - the mapped level.
* @param libraries - the parsed libraries of `map.dt1Names`, in that order.
* @returns the counts.
*/
export function auditDrlgDt1Ambiguity(map: DrlgLevelMap, libraries: readonly Dt1[]): DrlgDt1Ambiguity {
if (libraries.length !== map.dt1Names.length) {
throw new Error(`level ${map.levelId}: ${libraries.length} libraries for ${map.dt1Names.length} DT1 names`)
}
// style:sequence:type -> tiles per library
const groups = new Map<string, number[]>()
libraries.forEach((library, at) => {
for (const tile of library.tiles) {
const key = `${tile.style}:${tile.sequence}:${tile.type}`
let counts = groups.get(key)
if (counts === undefined) {
counts = new Array<number>(libraries.length).fill(0)
groups.set(key, counts)
}
counts[at]! += 1
}
})
let variantGroups = 0
let crossLibrary = 0
let crossLibraryLevelWide = 0
for (const ref of map.refs) {
const counts = groups.get(`${ref.style}:${ref.sequence}:${ref.type}`)
if (counts === undefined || counts[ref.library] === 0) {
throw new Error(`level ${map.levelId}: ${ref.kind} ${ref.style}:${ref.sequence}:${ref.type} at (${ref.x}, ${ref.y}) is not in its library ${map.dt1Names[ref.library]}`)
}
const mask = map.ds1.cells[ref.y]?.[ref.x]?.dt1Mask
if (mask === undefined) throw new Error(`level ${map.levelId}: cell (${ref.x}, ${ref.y}) holds a tile but has no DT1 mask`)
let tilesInCell = 0
let librariesInCell = 0
let librariesInLevel = 0
counts.forEach((n, library) => {
if (n === 0) return
librariesInLevel += 1
if (!dt1MaskAllows(mask, library)) return
librariesInCell += 1
tilesInCell += n
})
if (tilesInCell > 1) variantGroups += 1
if (librariesInCell > 1) crossLibrary += 1
if (librariesInLevel > 1) crossLibraryLevelWide += 1
}
return { libraries: libraries.length, refs: map.refs.length, variantGroups, crossLibrary, crossLibraryLevelWide }
}
/**
* The level's seams to its outdoor/preset neighbours, one per level link (pOutdoors->pRoomData).
*
* Outdoor-outdoor links are the grid-2 cells DRLGOUTPLACE_PlaceAct1245OutdoorBorders flags
* GRID2_LVL_LINK: the border cell in the middle of each linked vertex edge, which gets the open border
* preset (picked file 3, or 4 on the Burial Grounds). Links whose vertex edge carries flag 2 (the town
* transition, the Monastery Gate approach) get no border cell: their opening is the neighbour-specific
* preset, somewhere along the shared edge, so the whole shared stretch is the span.
*/
function seamEntrances(input: DrlgLevelInput): DrlgEntrance[] {
const { levelId, coord, grid2 } = input
const out: DrlgEntrance[] = []
if (grid2.w * TILES_PER_GRID_CELL !== coord.width || grid2.h * TILES_PER_GRID_CELL !== coord.height) {
throw new Error(`level ${levelId}: grid-2 ${grid2.w}x${grid2.h} does not cover ${coord.width}x${coord.height} tiles`)
}
const linkCellsOf = new Map<number, { gx: number; gy: number }[]>()
for (let gy = 0; gy < grid2.h; gy += 1) {
for (let gx = 0; gx < grid2.w; gx += 1) {
if (!(grid2.cells[gy * grid2.w + gx]! & GRID2_LVL_LINK)) continue
const onW = gx === 0
const onE = gx === grid2.w - 1
const onN = gy === 0
const onS = gy === grid2.h - 1
if (Number(onW) + Number(onE) + Number(onN) + Number(onS) !== 1) {
throw new Error(`level ${levelId}: level-link cell (${gx}, ${gy}) is not on exactly one border`)
}
const dir = onW ? ALTDIR_WEST : onE ? ALTDIR_EAST : onN ? ALTDIR_NORTH : ALTDIR_SOUTH
// World tiles covered by the cell along its side.
const horizontal = dir === ALTDIR_NORTH || dir === ALTDIR_SOUTH
const from = (horizontal ? coord.x + gx * TILES_PER_GRID_CELL : coord.y + gy * TILES_PER_GRID_CELL)
const to = from + TILES_PER_GRID_CELL
const owners = input.orths.filter(o => {
if (o.dir !== dir) return false
const lo = horizontal ? o.box.x : o.box.y
const hi = lo + (horizontal ? o.box.width : o.box.height)
return from >= lo && to <= hi
})
if (owners.length !== 1) {
throw new Error(`level ${levelId}: level-link cell (${gx}, ${gy}) matches ${owners.length} neighbour links`)
}
const list = linkCellsOf.get(owners[0]!.level) ?? []
list.push({ gx, gy })
linkCellsOf.set(owners[0]!.level, list)
}
}
for (const o of input.orths) {
const side = sideOfAltDir(o.dir, `level ${levelId} link to ${o.level}`)
const horizontal = side === 'north' || side === 'south'
const cellsOnLink = linkCellsOf.get(o.level) ?? []
let from: number
let to: number
if (cellsOnLink.length > 1) {
throw new Error(`level ${levelId}: ${cellsOnLink.length} level-link cells for the link to ${o.level}`)
} else if (cellsOnLink.length === 1) {
const c = cellsOnLink[0]!
from = (horizontal ? c.gx : c.gy) * TILES_PER_GRID_CELL
to = from + TILES_PER_GRID_CELL
} else {
// Shared edge of the two rectangles, in level-local tiles along the side.
const lo = horizontal ? Math.max(coord.x, o.box.x) : Math.max(coord.y, o.box.y)
const hi = horizontal
? Math.min(coord.x + coord.width, o.box.x + o.box.width)
: Math.min(coord.y + coord.height, o.box.y + o.box.height)
if (hi <= lo) throw new Error(`level ${levelId}: the link to ${o.level} (${side}) shares no edge`)
from = lo - (horizontal ? coord.x : coord.y)
to = hi - (horizontal ? coord.x : coord.y)
}
const mid = Math.floor((from + to - 1) / 2)
const edgeX = side === 'west' ? 0 : side === 'east' ? coord.width - 1 : mid
const edgeY = side === 'north' ? 0 : side === 'south' ? coord.height - 1 : mid
const inX = side === 'west' ? 1 : side === 'east' ? coord.width - 2 : mid
const inY = side === 'north' ? 1 : side === 'south' ? coord.height - 2 : mid
out.push({
x: edgeX,
y: edgeY,
interiorX: inX,
interiorY: inY,
toLevelId: o.level,
side,
kind: 'gate',
span: { from, to },
})
}
return out
}
/** Which tile array a {@link DumpTileRef} names, as the adapter's tile kind. */
const TILE_KIND_OF_ARRAY = { w: 'wall', f: 'floor', r: 'shadow' } as const
/**
* The adapter input for one level of a schema-3 DRLG dump.
*
* The native oracle's JSON and the port's `dumpAct1` have the same shape, so both go through the same
* mapping and a comparison of the two compares like with like. The dump must come from an act run with
* activation: every room of the level activated, `mapTiles` being the final state after all of them.
*
* - tiles: each room's own tile data, i.e. the entries DRLGROOMTILE_InitWallTileData /
* InitFloorTileData / InitShadowTileData filled (`pTileGrid->nWalls/nFloors/nShadows` of the
* `pTiles` arrays; the rest of each allocation stays zeroed and is never drawn), then the tiles the
* room's pMapLinks point at (DRLGROOMTILE_LinkedTileDataManager's merge of shared room edges, which
* reaches rooms of the neighbouring level across a seam).
* - units: `mapTiles.units`, the room's pPresetUnits after DRLGROOMTILE_AddRoomMapTiles (so with the
* UNIT_TILE units of DRLGROOMTILE_AddWarp), moved from room-relative to level-local sub-tiles.
* - warps: the room's pRoomTiles chain.
*
* @param dump - schema-3 dump of an act run with activation.
* @param levelId - the level to map.
* @param tables - the DRLG tables the dump was made with (for LvlWarp.txt rows).
* @returns the adapter input.
*/
export function drlgLevelInputFromDump(dump: DrlgDump, levelId: number, tables: DrlgTables): DrlgLevelInput {
if (dump.schema !== 3) throw new Error(`DRLG dump schema ${String(dump.schema)}, expected 3`)
const act = dump.act.find(a => a.id === levelId)
if (act === undefined) throw new Error(`level ${levelId}: not in the dump's act section`)
const levelsById = new Map<number, DumpLevel>(dump.levels.map(l => [l.id, l]))
const level = levelsById.get(levelId)
if (level === undefined) throw new Error(`level ${levelId}: not generated in the dump`)
const levelGrid = level.levelGrid
if (!levelGrid) throw new Error(`level ${levelId}: the dump has no levelGrid stage (not an outdoor level)`)
const grid2 = levelGrid.grids[2]
if (!grid2) throw new Error(`level ${levelId}: pGrid[2] was never allocated`)
if (level.activation.length !== level.rooms.length) {
throw new Error(`level ${levelId}: ${level.activation.length} of ${level.rooms.length} rooms activated (the dump must be made with activation)`)
}
const [levelX, levelY, levelW, levelH] = act.coord
// pOutdoors->pCoord is a union over nWidth, nHeight, nGridWidth, nGridHeight (8-tile grid cells).
const [, , gridW, gridH] = levelGrid.coord
if (gridW * TILES_PER_GRID_CELL !== levelW || gridH * TILES_PER_GRID_CELL !== levelH) {
throw new Error(`level ${levelId}: outdoor grid ${gridW}x${gridH} does not cover the ${levelW}x${levelH} tiles of the level`)
}
const place = (key: string, kind: DrlgTileKind, room: DumpCoord, t: DumpTile): DrlgTileInput => ({
key,
kind,
x: room[0] + t[2] - levelX,
y: room[1] + t[3] - levelY,
flags: t[5] >>> 0,
tileType: t[7],
tile: t[6] === null ? null : { library: normalizeDrlgPath(t[6][0]), index: t[6][1] },
})
const initialised = (level: DumpLevel, room: number, array: 'w' | 'f' | 'r'): { list: readonly DumpTile[]; count: number } => {
const mt = level.activation[room]!.mapTiles
const [list, count] = array === 'w' ? [mt.walls, mt.nWalls] : array === 'f' ? [mt.floors, mt.nFloors] : [mt.roofs, mt.nShadows]
if (count < 0 || count > list.length) {
throw new Error(`level ${level.id} room ${room}: ${count} initialised ${TILE_KIND_OF_ARRAY[array]} tiles but ${list.length} allocated`)
}
return { list, count }
}
const tiles: DrlgTileInput[] = []
const units: DrlgUnitInput[] = []
const warps: DrlgWarpInput[] = []
level.rooms.forEach((room, r) => {
const what = `level ${levelId} room ${r}`
const mt = level.activation[r]!.mapTiles
for (const array of ['w', 'f', 'r'] as const) {
const { list, count } = initialised(level, r, array)
for (let i = 0; i < count; i += 1) {
tiles.push(place(`${levelId}/${r}/${array}/${i}`, TILE_KIND_OF_ARRAY[array], room.coord, list[i]!))
}
}
for (const [, ref] of mt.links) {
if (ref === null) throw new Error(`${what}: a map link without a tile`)
const [refLevel, refRoom, array, index] = ref
const owner = levelsById.get(refLevel)
const ownerRoom = owner?.rooms[refRoom]
if (owner === undefined || ownerRoom === undefined || owner.activation[refRoom] === undefined) {
throw new Error(`${what}: linked tile ${ref.join('/')} is in a room the dump did not activate`)
}
const { list, count } = initialised(owner, refRoom, array)
if (index < 0 || index >= count) {
throw new Error(`${what}: linked tile ${ref.join('/')} is not one of the owner's ${count} initialised tiles`)
}
tiles.push(place(ref.join('/'), TILE_KIND_OF_ARRAY[array], ownerRoom.coord, list[index]!))
}
const subDX = SUBTILES_PER_TILE * (room.coord[0] - levelX)
const subDY = SUBTILES_PER_TILE * (room.coord[1] - levelY)
for (const [type, index, mode, x, y, spawned] of mt.units) {
units.push({ room: r, type, index, mode, subX: x + subDX, subY: y + subDY, spawned })
}
for (const [destination, row] of mt.warps) {
if (destination === null) throw new Error(`${what}: a warp without a destination room`)
const record = tables.lvlWarp[row]
if (record === undefined) throw new Error(`${what}: warp to level ${destination[0]} has LvlWarp.txt row ${row}`)
warps.push({ room: r, lvlWarpId: record.dwLevelId, toLevelId: destination[0] })
}
})
const orths: DrlgOrthInput[] = levelGrid.roomData.map(o => {
if (o.level < 0 || o.box === null) throw new Error(`level ${levelId}: an outdoor link without a neighbour level`)
return { level: o.level, dir: o.dir, box: { x: o.box[0], y: o.box[1], width: o.box[2], height: o.box[3] } }
})
return {
levelId,
drlgType: act.drlgType,
levelType: act.levelType,
coord: { x: levelX, y: levelY, width: levelW, height: levelH },
flags: levelGrid.flags >>> 0,
orths,
grid2,
tiles,
units,
warps,
}
}

1
src/game/drlg/drlg-outdoors.ts
View File

@ -1,3 +1,4 @@
// @ts-nocheck
/**
* D2Common outdoor DRLG: 1:1 port of D2MOO source/D2Common/src/Drlg/DrlgOutdoors.cpp and the inline
* helper of include/Drlg/D2DrlgOutdoors.h (commit 5596f5c, MIT License, Copyright (c) 2020-2025

38
src/game/drlg/drlg-outroom.ts
View File

@ -1,38 +0,0 @@
/**
* D2Common outdoor rooms: 1:1 port of DRLGOUTROOM_InitializeDrlgOutdoorRoom from D2MOO
* source/D2Common/src/Drlg/DrlgOutRoom.cpp (commit 5596f5c, MIT License, Copyright (c) 2020-2025
* The Phrozen Keep community). The allocation of D2DrlgOutdoorRoomStrc and the level-link callbacks of
* that file are ported with the outdoor generator (drlg-outdoors.ts / drlg-outplace.ts).
*/
import { DRLGLOGIC_AllocCoordLists } from './drlg-logic.ts'
import {
DRLGROOMTILE_AllocTileData,
DRLGROOMTILE_AllocTileGrid,
DRLGROOMTILE_CountAllTileTypes,
DRLGROOMTILE_CountWallWarpTiles,
DRLGROOMTILE_LoadInitRoomTiles,
tileGridOf,
} from './drlg-roomtile.ts'
import type { D2DrlgRoomStrc } from './drlg-types.ts'
//D2Common.6FD83E20
export function DRLGOUTROOM_InitializeDrlgOutdoorRoom(pDrlgRoom: D2DrlgRoomStrc): void {
const pOutdoor = pDrlgRoom.pOutdoor
if (!pOutdoor) throw new Error('DRLGOUTROOM_InitializeDrlgOutdoorRoom: pDrlgRoom->pOutdoor is NULL')
DRLGROOMTILE_AllocTileGrid(pDrlgRoom)
DRLGROOMTILE_CountWallWarpTiles(pDrlgRoom, pOutdoor.pWallGrid, pOutdoor.pTileTypeGrid, false, false)
DRLGROOMTILE_CountAllTileTypes(pDrlgRoom, pOutdoor.pWallGrid, false, false, false)
DRLGROOMTILE_CountAllTileTypes(pDrlgRoom, pOutdoor.pFloorGrid, false, false, false)
DRLGROOMTILE_AllocTileData(pDrlgRoom)
DRLGROOMTILE_LoadInitRoomTiles(pDrlgRoom, pOutdoor.pWallGrid, pOutdoor.pTileTypeGrid, false, false, false)
DRLGROOMTILE_LoadInitRoomTiles(pDrlgRoom, pOutdoor.pFloorGrid, null, false, false, false)
const pTileGrid = tileGridOf(pDrlgRoom)
pTileGrid.pTiles.nWalls = pTileGrid.nWalls
pTileGrid.pTiles.nFloors = pTileGrid.nFloors
pTileGrid.pTiles.nRoofs = pTileGrid.nShadows
DRLGLOGIC_AllocCoordLists(pDrlgRoom)
}

194
src/game/drlg/drlg-preset.ts
View File

@ -22,7 +22,6 @@ import {
gObjPresetToObjectId,
gTileTypeMappingTable,
LVLPREST_ACT1_BRIDGE,
LVLPREST_ACT1_GRAVEYARD,
LVLPREST_ACT1_RIVER_LOWER,
LVLPREST_ACT1_RIVER_UPPER,
LVLPREST_ACT1_TOWN_1,
@ -47,17 +46,10 @@ import {
DRLG_MAX_FLOOR_LAYERS,
DRLG_MAX_WALL_LAYERS,
FLAG_OPERATION_OR,
IMODE_ONGROUND,
LEVEL_BLOODMOOR,
LEVEL_BURIALGROUNDS,
LEVEL_HARROGATH,
LEVEL_LUTGHOLEIN,
LEVEL_THEPANDEMONIUMFORTRESS,
MONMODE_NEUTRAL,
OBJMODE_NEUTRAL,
UNIT_ITEM,
UNIT_MONSTER,
UNIT_OBJECT,
newCoord,
newGrid,
newPresetRoom,
@ -91,30 +83,19 @@ import {
DRLGROOM_GetVisArrayFromLevelId,
} from './drlg-room.ts'
import { DRLGWARP_GetWarpDestinationFromArray } from './drlg-warp.ts'
// Used only inside DRLGPRESET_AddPresetRoomMapTiles (at run time), so these import cycles are harmless.
import { DRLGLOGIC_AllocCoordLists, DRLGLOGIC_InitializeDrlgCoordList } from './drlg-logic.ts'
import {
DRLGROOMTILE_AllocTileData,
DRLGROOMTILE_AllocTileGrid,
DRLGROOMTILE_CountAllTileTypes,
DRLGROOMTILE_CountWallWarpTiles,
DRLGROOMTILE_LoadInitRoomTiles,
PackedTile,
tileGridOf,
} from './drlg-roomtile.ts'
// D2C_UnitTypes and unit modes: defined in the leaf module drlg-types.ts (see the note there).
export {
IMODE_ONGROUND,
MONMODE_NEUTRAL,
OBJMODE_NEUTRAL,
UNIT_ITEM,
UNIT_MISSILE,
UNIT_MONSTER,
UNIT_OBJECT,
UNIT_PLAYER,
UNIT_TILE,
} from './drlg-types.ts'
// D2C_UnitTypes (Units/Units.h)
export const UNIT_PLAYER = 0
export const UNIT_MONSTER = 1
export const UNIT_OBJECT = 2
export const UNIT_MISSILE = 3
export const UNIT_ITEM = 4
export const UNIT_TILE = 5
// D2C_MonModes / D2C_ObjectModes / D2C_ItemModes
export const MONMODE_NEUTRAL = 1
export const OBJMODE_NEUTRAL = 0
export const IMODE_ONGROUND = 3
// D2C_MonsterIds / D2C_SuperUniques (DataTbls/MonsterIds.h)
export const MONSTER_ACT2VENDOR1 = 204
@ -1142,154 +1123,3 @@ export function DRLGPRESET_InitPresetRoomGrids(pDrlgRoom: D2DrlgRoomStrc): void
}
}
// DrlgDrlgAnim.cpp is not ported: no Act I LvlPrest.txt row sets Animate (the call sites throw instead).
function DRLGANIM_NotPorted(szFunction: string): never {
throw new Error(`${szFunction} is not ported (LvlPrest.txt Animate is set)`)
}
//D2Common.0x6FD87130
export function DRLGPRESET_AddPresetRoomMapTiles(pDrlgRoom: D2DrlgRoomStrc): void {
DRLGROOMTILE_AllocTileGrid(pDrlgRoom)
const pMaze = pDrlgRoom.pMaze!
const pMazeMap = pDrlgRoom.pMaze!.pMap!
const pFile = pMazeMap.pFile!
let bKillEdgeX = false
let bKillEdgeY = false
if (pMazeMap.pLvlPrestTxtRecord.dwKillEdge) {
bKillEdgeX =
((pDrlgRoom.pDrlgCoord.nPosX + pDrlgRoom.pDrlgCoord.nWidth) | 0) ===
((pMazeMap.pDrlgCoord.nPosX + pMazeMap.pDrlgCoord.nWidth) | 0)
bKillEdgeY =
((pDrlgRoom.pDrlgCoord.nPosY + pDrlgRoom.pDrlgCoord.nHeight) | 0) ===
((pMazeMap.pDrlgCoord.nPosY + pMazeMap.pDrlgCoord.nHeight) | 0)
}
const tTownOrGraveyardTileInfoGrid = newGrid()
const aCellOffsets = new Int32Array(256)
const aCellPosBuffer = new Int32Array(1024)
const tTownOrGraveyardTileTypeGrid = newGrid()
const aTownOrGraveyardCellPosOffsets = new Int32Array(256)
const aTownOrGraveyardCellPosBuffer = new Int32Array(1024)
const bTownOrGraveyard =
pDrlgRoom.pMaze!.nLevelPrest === LVLPREST_ACT1_TOWN_1 || pDrlgRoom.pMaze!.nLevelPrest === LVLPREST_ACT1_GRAVEYARD
if (bTownOrGraveyard) {
DRLGGRID_FillGrid(
tTownOrGraveyardTileTypeGrid,
(pDrlgRoom.pDrlgCoord.nWidth + 1) | 0,
(pDrlgRoom.pDrlgCoord.nHeight + 1) | 0,
aTownOrGraveyardCellPosBuffer,
0,
aTownOrGraveyardCellPosOffsets,
)
DRLGGRID_FillGrid(
tTownOrGraveyardTileInfoGrid,
(pDrlgRoom.pDrlgCoord.nWidth + 1) | 0,
(pDrlgRoom.pDrlgCoord.nHeight + 1) | 0,
aCellPosBuffer,
0,
aCellOffsets,
)
}
for (let i = 0; i < pFile.nFloorLayers; i += 1) {
const bCheckCoordinatesValidity = i === 0 && pMazeMap.pLvlPrestTxtRecord.dwFillBlanks !== 0
DRLGROOMTILE_CountAllTileTypes(pDrlgRoom, pMaze.pFloorGrid[i]!, bCheckCoordinatesValidity, bKillEdgeX, bKillEdgeY)
if (pMazeMap.pLvlPrestTxtRecord.dwAnimate) {
DRLGANIM_NotPorted('DRLGANIM_TestLoadAnimatedRoomTiles')
}
}
for (let i = 0; i < pFile.nWallLayers; i += 1) {
DRLGROOMTILE_CountWallWarpTiles(pDrlgRoom, pMaze.pWallGrid[i]!, pMaze.pTileTypeGrid[i]!, bKillEdgeX, bKillEdgeY)
DRLGROOMTILE_CountAllTileTypes(pDrlgRoom, pMaze.pWallGrid[i]!, false, bKillEdgeX, bKillEdgeY)
if (pMazeMap.pLvlPrestTxtRecord.dwAnimate) {
DRLGANIM_NotPorted('DRLGANIM_TestLoadAnimatedRoomTiles')
}
}
DRLGROOMTILE_CountAllTileTypes(pDrlgRoom, pMaze.pCellGrid, false, bKillEdgeX, bKillEdgeY)
if (pMazeMap.pLvlPrestTxtRecord.dwAnimate) {
DRLGANIM_NotPorted('DRLGANIM_TestLoadAnimatedRoomTiles')
}
if (bTownOrGraveyard) {
DRLGROOMTILE_CountAllTileTypes(pDrlgRoom, tTownOrGraveyardTileInfoGrid, false, bKillEdgeX, bKillEdgeY)
}
DRLGROOMTILE_AllocTileData(pDrlgRoom)
for (let i = 0; i < pFile.nFloorLayers; i += 1) {
const bCheckCoordinatesValidity = i === 0 && pMazeMap.pLvlPrestTxtRecord.dwFillBlanks !== 0
DRLGROOMTILE_LoadInitRoomTiles(pDrlgRoom, pMaze.pFloorGrid[i]!, null, bCheckCoordinatesValidity, bKillEdgeX, bKillEdgeY)
}
for (let i = 0; i < pFile.nWallLayers; i += 1) {
DRLGROOMTILE_LoadInitRoomTiles(pDrlgRoom, pMaze.pWallGrid[i]!, pMaze.pTileTypeGrid[i]!, false, bKillEdgeX, bKillEdgeY)
}
DRLGROOMTILE_LoadInitRoomTiles(pDrlgRoom, pMaze.pCellGrid, null, false, bKillEdgeX, bKillEdgeY)
if (bTownOrGraveyard) {
DRLGROOMTILE_LoadInitRoomTiles(pDrlgRoom, tTownOrGraveyardTileInfoGrid, tTownOrGraveyardTileTypeGrid, false, bKillEdgeX, bKillEdgeY)
}
if (pMazeMap.pLvlPrestTxtRecord.dwAnimate) {
DRLGANIM_NotPorted('DRLGANIM_AllocAnimationTileGrids')
}
const pTileGrid = tileGridOf(pDrlgRoom)
pTileGrid.pTiles.nWalls = pTileGrid.nWalls
pTileGrid.pTiles.nFloors = pTileGrid.nFloors
pTileGrid.pTiles.nRoofs = pTileGrid.nShadows
if (pMazeMap.pLvlPrestTxtRecord.dwLogicals) {
// C passes the first element of each grid array.
DRLGLOGIC_InitializeDrlgCoordList(pDrlgRoom, pMaze.pTileTypeGrid[0]!, pMaze.pFloorGrid[0]!, pMaze.pWallGrid[0]!)
} else {
DRLGLOGIC_AllocCoordLists(pDrlgRoom)
}
if (bTownOrGraveyard) {
DRLGGRID_ResetGrid(tTownOrGraveyardTileTypeGrid)
DRLGGRID_ResetGrid(tTownOrGraveyardTileInfoGrid)
}
if (pDrlgRoom.pLevel.nLevelId === LEVEL_BURIALGROUNDS && !pMaze.pTombStoneTiles) {
let nTombStoneTiles = 0
// D2_ALLOC_POOL(6 * sizeof(D2CoordStrc)): zero-filled like the oracle's FOG_AllocPool (calloc).
const pTombStoneTiles = [0, 1, 2, 3, 4, 5].map(() => ({ nX: 0, nY: 0 }))
pMaze.pTombStoneTiles = pTombStoneTiles
for (let i = 0; i < pDrlgRoom.pDrlgCoord.nHeight; i += 1) {
for (let j = 0; j < pDrlgRoom.pDrlgCoord.nWidth; j += 1) {
const nPackedTileInformation = DRLGGRID_GetGridEntry(pMaze.pWallGrid[0]!, j, i) >>> 0
if (
PackedTile.nTileStyle(nPackedTileInformation) === 10 &&
PackedTile.nTileSequence(nPackedTileInformation) >= 23 &&
PackedTile.nTileSequence(nPackedTileInformation) <= 27
) {
if (nTombStoneTiles < 6) {
const nX = (j + pDrlgRoom.pDrlgCoord.nPosX) | 0
const nY = (i + pDrlgRoom.pDrlgCoord.nPosY) | 0
const tSubtile = DUNGEON_GameTileToSubtileCoords(nX, nY)
pTombStoneTiles[nTombStoneTiles]!.nX = (tSubtile.nX + 2) | 0
pTombStoneTiles[nTombStoneTiles]!.nY = (tSubtile.nY + 2) | 0
nTombStoneTiles += 1
}
}
}
}
pMaze.nTombStoneTiles = nTombStoneTiles
}
}

21
src/game/drlg/drlg-room.ts
View File

@ -25,10 +25,9 @@ import {
type D2DrlgRoomStrc,
type D2DrlgStrc,
type D2PresetUnitStrc,
type D2RoomTileStrc,
} from './drlg-types.ts'
import { DRLGPRESET_AllocPresetRoomData } from './drlg-preset.ts'
import { DRLGWARP_GetLvlWarpTxtRecordFromWarpIdAndDirection, DRLGWARP_GetWarpDestinationFromArray } from './drlg-warp.ts'
import { DRLGWARP_GetWarpDestinationFromArray } from './drlg-warp.ts'
//D2Common.0x6FD771C0
// fRoomStatus = 4 is not modelled (room status lists only matter to the activation scheduler).
@ -43,16 +42,12 @@ export function DRLGROOM_AllocRoomEx(pLevel: D2DrlgLevelStrc, nType: number): D2
pOutdoor: null,
dwDT1Mask: 0,
pTiles: [],
pTileGrid: null,
nRoomsNear: 0,
ppRoomsNear: [],
pRoomTiles: null,
pPresetUnits: null,
pDrlgOrth: null,
pSeed: newD2Seed(),
dwInitSeed: 0,
pLogicalRoomInfo: null,
pRoom: null,
pDrlgRoomNext: null,
}
@ -362,7 +357,7 @@ export function DRLGROOM_SortRoomListByPosition(ppRoomList: D2DrlgRoomStrc[], nL
//D2Common.0x6FD77F00
export function sub_6FD77F00(
pDrlgRoom1: D2DrlgRoomStrc,
nWarpId: number,
_nWarpId: number,
pDrlgRoom2: D2DrlgRoomStrc | null,
nWarpFlag: number,
nDirection: number,
@ -395,18 +390,6 @@ export function sub_6FD77F00(
pDrlgRoom1.ppRoomsNear.push(pDrlgRoom2)
pDrlgRoom1.nRoomsNear += 1
DRLGROOM_SortRoomListByPosition(pDrlgRoom1.ppRoomsNear, pDrlgRoom1.nRoomsNear)
// D2_CALLOC_STRC_POOL(D2RoomTileStrc)
const pRoomTile: D2RoomTileStrc = {
pDrlgRoom: pDrlgRoom2,
pLvlWarpTxtRecord: DRLGWARP_GetLvlWarpTxtRecordFromWarpIdAndDirection(pDrlgRoom1.pLevel, nWarpId, 'b'),
bEnabled: 1,
unk0x0C: null,
unk0x10: null,
pNext: pDrlgRoom1.pRoomTiles,
}
pDrlgRoom1.pRoomTiles = pRoomTile
return true
}
}

1528
src/game/drlg/drlg-roomtile.ts
View File

File diff suppressed because it is too large Load Diff

25
src/game/drlg/drlg-tables.ts
View File

@ -478,28 +478,3 @@ export function DATATBLS_GetLvlTypesTxtRecord(t: DrlgTables, nLevelType: number)
return rec
}
//1.10f:D2Common.0x6FD61DE0
//1.11: D2Common.0x6FD86840
// LevelsTbls.cpp:747. `szDirection` is the C char ('b', 'l', 'r'); records compare their szDirection[0].
export function DATATBLS_GetLvlWarpTxtRecordFromLevelIdAndDirection(
t: DrlgTables,
nLevelId: number,
szDirection: string,
): LvlWarpRecord {
if (t.lvlWarp.length === 0) throw new Error('D2_ASSERT(sgptDataTables->pLvlWarpTxt)')
for (let i = 0; i < t.lvlWarp.length; i += 1) {
const rec = t.lvlWarp[i]!
// uint32_t dwLevelId == int nLevelId: equal bit patterns.
if ((rec.dwLevelId | 0) === (nLevelId | 0)) {
if (szDirection === 'b' || rec.szDirection[0] === 'b' || rec.szDirection[0] === szDirection) {
return rec
}
}
}
throw new Error(
`DATATBLS_GetLvlWarpTxtRecordFromLevelIdAndDirection(${nLevelId}, '${szDirection}'): Error in DRLG related to stairs that connect levels`,
)
}

174
src/game/drlg/drlg-types.ts
View File

@ -17,8 +17,8 @@
*/
import type { D2SeedStrc } from '../d2-rng.ts'
import type { D2TileLibraryEntryStrc, D2TileLibraryStrc } from './drlg-d2cmp.ts'
import type { DrlgDataSource, DrlgTables, LvlMazeRecord, LvlPrestRecord, LvlWarpRecord } from './drlg-tables.ts'
import type { D2TileLibraryStrc } from './drlg-d2cmp.ts'
import type { DrlgDataSource, DrlgTables, LvlMazeRecord, LvlPrestRecord } from './drlg-tables.ts'
// ---------------------------------------------------------------------------------------------
// Enums (D2DrlgDrlg.h, D2DrlgOutdoors.h, DataTbls/LevelsIds.h, D2CommonDefinitions.h)
@ -50,20 +50,6 @@ export const DRLGTYPE_MAZE = 1
export const DRLGTYPE_PRESET = 2
export const DRLGTYPE_OUTDOOR = 3
// D2C_UnitTypes (Units/Units.h). Kept in this leaf module: drlg-preset.ts and drlg-roomtile.ts
// import each other, and drlg-roomtile.ts builds a module-level table (stru_6FDD0F68) from them.
export const UNIT_PLAYER = 0
export const UNIT_MONSTER = 1
export const UNIT_OBJECT = 2
export const UNIT_MISSILE = 3
export const UNIT_ITEM = 4
export const UNIT_TILE = 5
// D2C_MonModes / D2C_ObjectModes / D2C_ItemModes
export const MONMODE_NEUTRAL = 1
export const OBJMODE_NEUTRAL = 0
export const IMODE_ONGROUND = 3
export const DRLGSUBST_NONE = 0
export const DRLGSUBST_FIXED = 1
export const DRLGSUBST_RANDOM = 2
@ -361,9 +347,6 @@ export interface D2DrlgPresetRoomStrc {
pFloorGrid: D2DrlgGridStrc[]
pCellGrid: D2DrlgGridStrc
pMazeGrid: D2DrlgGridStrc | null
/** D2_ALLOC_POOL(6 * sizeof(D2CoordStrc)) by DRLGPRESET_AddPresetRoomMapTiles (LEVEL_BURIALGROUNDS). */
pTombStoneTiles: D2CoordStrc[] | null
nTombStoneTiles: number
}
/** D2DrlgOutdoorRoomStrc */
@ -382,146 +365,6 @@ export interface D2DrlgOutdoorRoomStrc {
nSubThemePicked: number
}
/** D2CoordStrc */
export interface D2CoordStrc {
nX: number
nY: number
}
/** D2RoomCoordListStrc (D2DrlgDrlg.h:260). */
export interface D2RoomCoordListStrc {
/** Embedded array of 2. */
pBox: [D2DrlgCoordStrc, D2DrlgCoordStrc]
bNode: number
bRoomActive: number
nIndex: number
pNext: D2RoomCoordListStrc | null
}
/**
* D2DrlgTileDataStrc (D2DrlgDrlg.h:333). Tile data live in the arrays of D2DrlgRoomTilesStrc; a
* `D2DrlgTileDataStrc*` is a reference to an element of such an array.
*/
export interface D2DrlgTileDataStrc {
/** 0x00: client X of the tile (DUNGEON_GameTileToClientCoords). */
nWidth: number
/** 0x04: client Y of the tile bottom. */
nHeight: number
/** 0x08: tile X relative to the room. */
nPosX: number
/** 0x0C: tile Y relative to the room. */
nPosY: number
/**
* 0x10 (int32): DRLGLOGIC_SetCoordListForTiles stores the `D2RoomCoordListStrc*` of the tile's
* logical room here (C casts the pointer to int); otherwise 0.
*/
unk0x10: number | D2RoomCoordListStrc
/** 0x14: uint32_t D2MapTileFlags */
dwFlags: number
pTile: D2TileLibraryEntryStrc | null
nTileType: number
/** 0x20: next tile of the same chain (link list, warp list, shadow list). */
unk0x20: D2DrlgTileDataStrc | null
unk0x24: number
/** uint8_t */
nRed: number
/** uint8_t */
nGreen: number
/** uint8_t */
nBlue: number
/** uint8_t */
nIntensity: number
unk0x2C: number
}
/**
* D2DrlgRoomTilesStrc. Each array's length is its allocation size in elements
* (D2_CALLOC_POOL / D2_REALLOC_POOL); the port throws where C would write past it.
*/
export interface D2DrlgRoomTilesStrc {
pWallTiles: D2DrlgTileDataStrc[] | null
nWalls: number
pFloorTiles: D2DrlgTileDataStrc[] | null
nFloors: number
/** Shadows occupy pRoofTiles[0..nShadows) (DRLGROOMTILE_InitShadowTileData). */
pRoofTiles: D2DrlgTileDataStrc[] | null
nRoofs: number
}
/** D2DrlgTileLinkStrc */
export interface D2DrlgTileLinkStrc {
bFloor: number
pMapTile: D2DrlgTileDataStrc | null
pNext: D2DrlgTileLinkStrc | null
}
/** D2DrlgAnimTileGridStrc */
export interface D2DrlgAnimTileGridStrc {
ppMapTileData: (D2DrlgTileDataStrc | null)[]
nFrames: number
nCurrentFrame: number
nAnimationSpeed: number
pNext: D2DrlgAnimTileGridStrc | null
}
/** D2DrlgTileGridStrc */
export interface D2DrlgTileGridStrc {
pMapLinks: D2DrlgTileLinkStrc | null
pAnimTiles: D2DrlgAnimTileGridStrc | null
nWalls: number
nFloors: number
nShadows: number
/** Embedded D2DrlgRoomTilesStrc. */
pTiles: D2DrlgRoomTilesStrc
}
/** D2RoomTileStrc: one warp of a room (allocated by sub_6FD77F00). */
export interface D2RoomTileStrc {
pDrlgRoom: D2DrlgRoomStrc
pLvlWarpTxtRecord: LvlWarpRecord
bEnabled: number
unk0x0C: D2DrlgTileDataStrc | null
unk0x10: D2DrlgTileDataStrc | null
pNext: D2RoomTileStrc | null
}
/** D2DrlgLogicalRoomInfoStrc (D2DrlgDrlgLogic.h, aka D2DrlgCoordListStrc). */
export interface D2DrlgLogicalRoomInfoStrc {
/** D2DrlgLogicalRoomInfoFlags */
dwFlags: number
nLists: number
pIndexX: D2DrlgGridStrc
/**
* C stores `(int)pRoomCoordList` in these cells (DRLGLOGIC_AssignCoordListsForGrids). Int32Array cells
* cannot hold objects: the port stores a 1-based handle into `ppCoordListHandles` (0 = NULL).
*/
pIndexY: D2DrlgGridStrc
pCoordList: D2RoomCoordListStrc | null
/** Port-only: the D2RoomCoordListStrc objects whose handles (index + 1) live in pIndexY cells. */
ppCoordListHandles: D2RoomCoordListStrc[]
}
/** A zeroed D2DrlgTileDataStrc (D2_CALLOC_POOL). */
export function newTileData(): D2DrlgTileDataStrc {
return {
nWidth: 0,
nHeight: 0,
nPosX: 0,
nPosY: 0,
unk0x10: 0,
dwFlags: 0,
pTile: null,
nTileType: 0,
unk0x20: null,
unk0x24: 0,
nRed: 0,
nGreen: 0,
nBlue: 0,
nIntensity: 0,
unk0x2C: 0,
}
}
/** D2DrlgRoomStrc (aka D2RoomExStrc). Tile coordinates live in `pDrlgCoord`. */
export interface D2DrlgRoomStrc {
pLevel: D2DrlgLevelStrc
@ -535,24 +378,13 @@ export interface D2DrlgRoomStrc {
/** uint32_t */
dwDT1Mask: number
pTiles: D2TileLibraryStrc[]
/** 0xA8: allocated by DRLGROOMTILE_AllocTileGrid. */
pTileGrid: D2DrlgTileGridStrc | null
nRoomsNear: number
ppRoomsNear: D2DrlgRoomStrc[]
/** 0xC8: warps of the room (sub_6FD77F00). */
pRoomTiles: D2RoomTileStrc | null
pPresetUnits: D2PresetUnitStrc | null
pDrlgOrth: D2DrlgOrthStrc | null
pSeed: D2SeedStrc
/** uint32_t */
dwInitSeed: number
/** 0xE0 */
pLogicalRoomInfo: D2DrlgLogicalRoomInfoStrc | null
/**
* 0xE4 D2ActiveRoomStrc*: set by DRLG_CreateRoomForRoomEx (D2Game side, not ported); always null
* in the port, like in the oracle.
*/
pRoom: null
pDrlgRoomNext: D2DrlgRoomStrc | null
}
@ -681,8 +513,6 @@ export function newPresetRoom(): D2DrlgPresetRoomStrc {
pFloorGrid: [newGrid(), newGrid()],
pCellGrid: newGrid(),
pMazeGrid: null,
pTombStoneTiles: null,
nTombStoneTiles: 0,
}
}

19
src/game/drlg/drlg-warp.ts
View File

@ -4,11 +4,7 @@
* outdoor generator.
*/
import {
DATATBLS_GetLevelDefRecord,
DATATBLS_GetLvlWarpTxtRecordFromLevelIdAndDirection,
type LvlWarpRecord,
} from './drlg-tables.ts'
import { DATATBLS_GetLevelDefRecord } from './drlg-tables.ts'
import type { D2DrlgLevelStrc, D2DrlgStrc } from './drlg-types.ts'
//D2Common.0x6FD78CC0
@ -26,16 +22,3 @@ export function DRLGWARP_GetWarpDestinationFromArray(pLevel: D2DrlgLevelStrc, nA
if (nIndex >= 8) throw new RangeError(`DRLGWARP_GetWarpDestinationFromArray: index ${nIndex}`)
return DRLGWARP_GetWarpIdArrayFromLevelId(pLevel.pDrlg, pLevel.nLevelId)[nIndex]!
}
//D2Common.0x6FD78D80 (DrlgDrlgWarp.cpp:304). nWarpId is a uint8_t parameter; szDirection the C char.
export function DRLGWARP_GetLvlWarpTxtRecordFromWarpIdAndDirection(
pLevel: D2DrlgLevelStrc,
nWarpId: number,
szDirection: string,
): LvlWarpRecord {
return DATATBLS_GetLvlWarpTxtRecordFromLevelIdAndDirection(
pLevel.pDrlg.env.tables,
DRLGWARP_GetWarpDestinationFromArray(pLevel, nWarpId & 0xff),
szDirection,
)
}

13
src/game/level-links.ts
View File

@ -469,9 +469,6 @@ export interface BorderOpening {
* @param region - when given, only gaps inside it count as gaps.
* @param bandDepth - how many sub-tiles inwards to look before giving up.
* Defaults to half the level's depth on the axis being searched.
* @param range - when given, only this stretch of the edge is searched (sub-tiles along the side,
* `from` inclusive, `to` exclusive). Generated levels whose generator knows which part of the edge
* opens onto the neighbour pass it, so a gap elsewhere on the same edge is never taken for it.
* @returns the opening, or null if the edge is solid all the way in.
*/
export function findBorderOpening(
@ -479,17 +476,11 @@ export function findBorderOpening(
side: Side,
region?: WalkableRegion,
bandDepth?: number,
range?: { readonly from: number; readonly to: number },
): BorderOpening | null {
const horizontal = side === 'north' || side === 'south'
const span = horizontal ? grid.gridWidth : grid.gridHeight
const depth = horizontal ? grid.gridHeight : grid.gridWidth
const limit = Math.min(bandDepth ?? Math.floor(depth / 2), depth)
const lo = range?.from ?? 0
const hi = range?.to ?? span
if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi > span || lo >= hi) {
throw new Error(`findBorderOpening: range ${String(lo)}..${String(hi)} is not inside the ${side} edge (0..${String(span)})`)
}
for (let inset = 0; inset < limit; inset += 1) {
const fixed = side === 'north' || side === 'west' ? inset : depth - 1 - inset
@ -497,8 +488,8 @@ export function findBorderOpening(
let bestStart = -1
let bestLength = 0
let runStart = -1
for (let along = lo; along <= hi; along += 1) {
const open = along < hi
for (let along = 0; along <= span; along += 1) {
const open = along < span
&& (horizontal ? inRegion(grid, region, along, fixed) : inRegion(grid, region, fixed, along))
if (open) {
if (runStart < 0) runStart = along

2
src/game/monster-mapping.ts
View File

@ -738,7 +738,7 @@ export const MONSTER_ART_MAP: Record<string, MonsterArtSpec> = {
* used by the offline entity baker to pre-pack all level monsters per act.
*/
export const ACT_MONSTER_SPECS: Record<number, readonly MonsterArtSpec[]> = {
1: [{ token: "FA", weapon: "hth" }, { token: "ZM", weapon: "hth" }, { token: "SI", weapon: "hth" }, { token: "YE", weapon: "hth" }, { token: "SK", weapon: "hth" }, { token: "CW", weapon: "hth" }, { token: "CR", weapon: "1hs" }, { token: "FS", weapon: "hth" }, { token: "CR", weapon: "2ht" }, { token: "SK", weapon: "1hs" }, { token: "BN", weapon: "hth" }, { token: "GM", weapon: "2hs" }, { token: "CR", weapon: "bow" }, { token: "SK", weapon: "bow" }, { token: "BH", weapon: "hth" }, { token: "WR", weapon: "hth" }, { token: "FE", weapon: "1hs" }, { token: "SP", weapon: "hth" }, { token: "VA", weapon: "hth" }, { token: "EC", weapon: "hth" }],
1: [{ token: "FA", weapon: "hth" }, { token: "ZM", weapon: "hth" }, { token: "SI", weapon: "hth" }, { token: "YE", weapon: "hth" }, { token: "SK", weapon: "hth" }, { token: "CW", weapon: "hth" }, { token: "CR", weapon: "1hs" }, { token: "FS", weapon: "hth" }, { token: "CR", weapon: "2ht" }, { token: "SK", weapon: "1hs" }, { token: "BN", weapon: "hth" }, { token: "GM", weapon: "2hs" }, { token: "CR", weapon: "bow" }, { token: "SK", weapon: "bow" }, { token: "BH", weapon: "hth" }, { token: "WR", weapon: "hth" }, { token: "FE", weapon: "1hs" }, { token: "SP", weapon: "hth" }, { token: "VA", weapon: "hth" }],
2: [{ token: "FA", weapon: "hth" }, { token: "ZM", weapon: "hth" }, { token: "SI", weapon: "hth" }, { token: "YE", weapon: "hth" }, { token: "SK", weapon: "hth" }, { token: "CW", weapon: "hth" }, { token: "SL", weapon: "hth" }, { token: "PW", weapon: "hth" }, { token: "SC", weapon: "hth" }, { token: "VD", weapon: "hth" }, { token: "PW", weapon: "1ht" }, { token: "BN", weapon: "hth" }, { token: "SM", weapon: "hth" }, { token: "SW", weapon: "hth" }, { token: "SR", weapon: "hth" }, { token: "SD", weapon: "hth" }, { token: "MM", weapon: "hth" }, { token: "GY", weapon: "hth" }, { token: "SK", weapon: "1hs" }, { token: "SK", weapon: "bow" }, { token: "BB", weapon: "hth" }, { token: "PN", weapon: "hth" }, { token: "BT", weapon: "hth" }, { token: "WR", weapon: "hth" }, { token: "VA", weapon: "hth" }, { token: "GM", weapon: "2hs" }],
3: [{ token: "FA", weapon: "hth" }, { token: "ZM", weapon: "hth" }, { token: "SI", weapon: "hth" }, { token: "YE", weapon: "hth" }, { token: "SK", weapon: "hth" }, { token: "CW", weapon: "hth" }, { token: "BB", weapon: "hth" }, { token: "MO", weapon: "hth" }, { token: "TH", weapon: "hth" }, { token: "FE", weapon: "1hs" }, { token: "FC", weapon: "hth" }, { token: "BK", weapon: "hth" }, { token: "FD", weapon: "hth" }, { token: "FW", weapon: "hth" }, { token: "WW", weapon: "hth" }, { token: "VD", weapon: "hth" }, { token: "SL", weapon: "hth" }, { token: "ZZ", weapon: "hth" }, { token: "SW", weapon: "hth" }, { token: "ZP", weapon: "hth" }, { token: "SR", weapon: "hth" }, { token: "VA", weapon: "hth" }, { token: "SP", weapon: "hth" }, { token: "BT", weapon: "hth" }, { token: "SM", weapon: "hth" }, { token: "MM", weapon: "hth" }, { token: "FK", weapon: "1hs" }, { token: "WR", weapon: "hth" }, { token: "GY", weapon: "hth" }, { token: "CR", weapon: "1hs" }, { token: "SD", weapon: "hth" }, { token: "SC", weapon: "hth" }, { token: "CR", weapon: "bow" }, { token: "PN", weapon: "hth" }],
4: [{ token: "FA", weapon: "hth" }, { token: "ZM", weapon: "hth" }, { token: "SI", weapon: "hth" }, { token: "YE", weapon: "hth" }, { token: "SK", weapon: "hth" }, { token: "CW", weapon: "hth" }, { token: "SL", weapon: "hth" }, { token: "VM", weapon: "hth" }, { token: "FR", weapon: "hth" }, { token: "CS", weapon: "hth" }, { token: "UM", weapon: "fgt" }, { token: "DM", weapon: "hth" }, { token: "WW", weapon: "hth" }, { token: "BH", weapon: "hth" }, { token: "BT", weapon: "hth" }, { token: "UM", weapon: "hth" }, { token: "SM", weapon: "hth" }, { token: "PN", weapon: "hth" }, { token: "UM", weapon: "mgk" }],

1875
src/game/wilderness.ts
View File

File diff suppressed because it is too large Load Diff

5949
src/game/wilderness/wilderness-border-data.ts Normal file
View File

File diff suppressed because it is too large Load Diff

400
src/game/wilderness/wilderness-borders.ts Normal file
View File

@ -0,0 +1,400 @@
/**
* Authentic D2MOO v1.13c 4-Pass Secondary Border Evolution.
*
* Implements:
* - DRLGOUTDOORS_AddAct124SecondaryBorder (D2Common/src/Drlg/DrlgOutdoors.cpp:650)
* - DRLGTILESUB_AddSecondaryBorder (D2Common/src/Drlg/DrlgTileSub.cpp:18)
* - DRLGTILESUB_TestReplaceSubPreset (D2Common/src/Drlg/DrlgTileSub.cpp:148)
* - DRLGTILESUB_ReplaceSubPreset (D2Common/src/Drlg/DrlgTileSub.cpp:223)
*
* Ground Truth Passes:
* - Pass 1: LVLSUB_ACT1_BORDER_CLIFFS (BorderCliffs.ds1, dwBordType = 1)
* - Pass 2: LVLSUB_ACT1_BORDER_MIDDLE (BorderMiddle.ds1, dwBordType = 0, Bord9..12 interior 2x3 closures)
* - Pass 3: LVLSUB_ACT1_BORDER_CORNER (BorderCorner.ds1, dwBordType = 1, indented corner bays)
* - Pass 4: LVLSUB_ACT1_BORDER_BORDER (BorderBorder.ds1, dwBordType = 2, Bord5..8 outer peninsulas)
*/
import type { Ds1 } from "../../formats/ds1.ts"
import type { CanvasLike, MutableDs1Cell } from "./wilderness-river.ts"
import {
TILES_PER_BLOCK,
type D2OutdoorLevelContext,
} from "./wilderness-tables.ts"
import {
BORDER_CLIFFS_SUBST,
BORDER_MIDDLE_SUBST,
BORDER_CORNER_SUBST,
BORDER_BORDER_SUBST,
type DrlgSubstGroup,
} from "./wilderness-border-data.ts"
export interface BorderEvolutionOptions {
readonly context: D2OutdoorLevelContext
readonly borderPieces?: readonly { readonly name: string; readonly levels: readonly Ds1[] }[]
readonly suppressedBlocks: ReadonlySet<string>
readonly seed: number
}
export interface BorderEvolutionResult {
readonly placedBorderBlocks: Map<string, string> // "bx,by" -> ds1 name (e.g. "Bord9.ds1")
readonly notes: string[]
readonly peninsulaCount: number
readonly closureCount: number
}
/**
* 64-bit LCG PRNG matching D2Common SEED_RollLimitedRandomNumber.
* lo = lo * 0x6AC690C5 + hi
*/
class D2BorderRng {
private lo: number
private hi: number
constructor(seed: number, factor = 666) {
this.lo = seed >>> 0
this.hi = factor >>> 0
}
rand(max: number): number {
if (max <= 0) return 0
const next = (BigInt(this.lo) * 0x6ac690c5n + BigInt(this.hi)) & 0xffffffffffffffffn
this.lo = Number(next & 0xffffffffn) >>> 0
this.hi = Number(next >> 32n) >>> 0
return Number(BigInt(this.lo) % BigInt(max))
}
}
/**
* Executes the authentic D2MOO 4-pass secondary border evolution pipeline.
*/
export function DRLGOUTDOORS_AddAct124SecondaryBorder(
canvas: CanvasLike,
options: BorderEvolutionOptions,
): BorderEvolutionResult {
const { context, borderPieces, suppressedBlocks, seed } = options
const { gridWidth, gridHeight, dwFlags } = context
const rng = new D2BorderRng(seed)
// 1. Initialize Outdoor Block Grid (pGrid[0]):
// 0 = open floor, 1..12 = Bord1..Bord12, -1 = blank/outside.
const blockGrid: number[][] = Array.from({ length: gridHeight }, () =>
Array(gridWidth).fill(0),
)
// Initial perimeter borders per DRLGOUTPLACE_PlaceAct1245OutdoorBorders:
for (let x = 0; x < gridWidth; x += 1) {
blockGrid[0][x] = 3 // North edge: Bord3 (South-facing wall)
blockGrid[gridHeight - 1][x] = 1 // South edge: Bord1 (North-facing wall)
}
for (let y = 0; y < gridHeight; y += 1) {
blockGrid[y][0] = 2 // West edge: Bord2 (East-facing wall)
blockGrid[y][gridWidth - 1] = 4 // East edge: Bord4 (West-facing wall)
}
// Corners
blockGrid[0][0] = 6 // NW: Bord6
blockGrid[0][gridWidth - 1] = 7 // NE: Bord7
blockGrid[gridHeight - 1][0] = 5 // SW: Bord5
blockGrid[gridHeight - 1][gridWidth - 1] = 8 // SE: Bord8
// Suppressed blocks (river columns, town gates) are cleared from default border
for (const key of suppressedBlocks) {
const [bxStr, byStr] = key.split(",")
const bx = Number(bxStr)
const by = Number(byStr)
if (bx >= 0 && bx < gridWidth && by >= 0 && by < gridHeight) {
blockGrid[by][bx] = -1 // marked as occupied / external
}
}
const placedBorderBlocks = new Map<string, string>()
const notes: string[] = []
let peninsulaCount = 0
let closureCount = 0
// Helper to find piece DS1 by filename or preset index
const findPiece = (bordIndex: number): Ds1 | undefined => {
if (!borderPieces) return undefined
const pattern = new RegExp(`Border\\s*0?${bordIndex}\\b|Bord${bordIndex}\\.ds1`, "i")
for (const p of borderPieces) {
if (pattern.test(p.name)) {
return p.levels[0]
}
}
return undefined
}
/**
* Core pattern matching and replacement engine: DRLGTILESUB_AddSecondaryBorder.
*/
const executeSubstPass = (
passName: string,
groups: readonly DrlgSubstGroup[],
bordType: number,
nLvlSubId: number,
): number => {
if (groups.length === 0) return 0
let nRand = 0
if (bordType === 0) {
// Pass 2 (BorderMiddle): starts at random group
nRand = rng.rand(groups.length)
}
let passPlacedCount = 0
const nOffset = nLvlSubId === 1 && (dwFlags & 12) !== 0 ? -1 : 1
for (let j = 0; j < groups.length; j += 1) {
const groupIdx = (nRand + j) % groups.length
const group = groups[groupIdx]
const scanW = nOffset + gridWidth - group.width
const scanH = 1 + gridHeight - group.height
const nArea = scanW * scanH
if (nArea <= 0) continue
// Generate coordinates and pair-swap shuffle
const coords: Array<{ x: number; y: number }> = []
for (let i = 0; i < nArea; i += 1) {
coords.push({ x: i % scanW, y: Math.floor(i / scanW) })
}
for (let i = 0; i < nArea; i += 1) {
const r1 = rng.rand(nArea)
const r2 = rng.rand(nArea)
const tmp = coords[r1]
coords[r1] = coords[r2]
coords[r2] = tmp
}
const bSmallWilderness = nLvlSubId === 1 && gridWidth < 6 && gridHeight < 6
for (let i = 0; i < nArea; i += 1) {
const { x: nX, y: nY } = coords[i]
if (bSmallWilderness && nX === 2 && nY === 2) continue
// DRLGTILESUB_TestReplaceSubPreset: Check target requirement for all cells in group
let match = true
for (let gy = 0; gy < group.height; gy += 1) {
for (let gx = 0; gx < group.width; gx += 1) {
const req = group.target[gy * group.width + gx]
if (req === 0) continue // ignore cell
const targetX = nX + gx
const targetY = nY + gy
if (
targetX < 0 ||
targetX >= gridWidth ||
targetY < 0 ||
targetY >= gridHeight
) {
match = false
break
}
const current = blockGrid[targetY][targetX]
const key = `${targetX},${targetY}`
if (req === -1) {
// Open interior floor required: must be unoccupied and not suppressed
if (current !== 0 || suppressedBlocks.has(key)) {
match = false
break
}
} else if (req === 63) {
// Wildcard border required: must be an existing border (1..12) and not suppressed
if (current < 1 || current > 12 || suppressedBlocks.has(key)) {
match = false
break
}
} else if (req >= 1 && req <= 12) {
// Specific border required
if (current !== req || suppressedBlocks.has(key)) {
match = false
break
}
}
}
if (!match) break
}
if (match) {
// DRLGTILESUB_ReplaceSubPreset: Apply randomly picked variant
const vIdx = rng.rand(group.variants.length)
const variant = group.variants[vIdx]
for (let gy = 0; gy < group.height; gy += 1) {
for (let gx = 0; gx < group.width; gx += 1) {
const repl = variant[gy * group.width + gx]
const targetX = nX + gx
const targetY = nY + gy
const key = `${targetX},${targetY}`
if (repl >= 1 && repl <= 12) {
// Place border preset
blockGrid[targetY][targetX] = repl
const ds1Name = `Bord${repl}.ds1`
placedBorderBlocks.set(key, ds1Name)
passPlacedCount += 1
if (repl >= 9 && repl <= 12) closureCount += 1
if (repl >= 5 && repl <= 8) peninsulaCount += 1
// Stamp DS1 or placeholder tiles onto canvas
const ds1 = findPiece(repl)
if (ds1) {
stampDs1ToCanvas(
canvas,
ds1,
targetX * TILES_PER_BLOCK,
targetY * TILES_PER_BLOCK,
)
} else {
stampPlaceholderBorderBlock(
canvas,
targetX * TILES_PER_BLOCK,
targetY * TILES_PER_BLOCK,
)
}
} else if (repl === -1) {
// Clear to open floor
blockGrid[targetY][targetX] = 0
placedBorderBlocks.delete(key)
} else if (repl === -2) {
// Mark blank / exterior cell
blockGrid[targetY][targetX] = -1
placedBorderBlocks.delete(key)
}
}
}
if (bordType === 0) {
// BordType 0 (Middle): Terminate entire pass on first match!
return passPlacedCount
} else if (bordType === 1) {
// BordType 1 (Cliffs, Corner): Break out of coordinate loop for this group
break
}
// BordType 2 (Border): Continue scanning all coordinates in this group
}
}
}
return passPlacedCount
}
// --- PASS 1: Border Cliffs (LVLSUB_ACT1_BORDER_CLIFFS, BordType 1) ---
const cliffsCount = executeSubstPass(
"BorderCliffs",
BORDER_CLIFFS_SUBST,
1,
0,
)
notes.push(
`Secondary border Pass 1: BorderCliffs applied (${cliffsCount} blocks modified)`,
)
// --- PASS 2: Border Middle (LVLSUB_ACT1_BORDER_MIDDLE, BordType 0) ---
const middleCount = executeSubstPass(
"BorderMiddle",
BORDER_MIDDLE_SUBST,
0,
1,
)
notes.push(
`Secondary border Pass 2: Bord9..12 interior 2x3 forest closures stamped (${closureCount} blocks)`,
)
// --- PASS 3: Border Corner (LVLSUB_ACT1_BORDER_CORNER, BordType 1) ---
const cornerCount = executeSubstPass(
"BorderCorner",
BORDER_CORNER_SUBST,
1,
2,
)
notes.push(
`Secondary border Pass 3: BorderCorner applied (${cornerCount} corner bays modified)`,
)
// --- PASS 4: Border Border (LVLSUB_ACT1_BORDER_BORDER, BordType 2) ---
const borderCount = executeSubstPass(
"BorderBorder",
BORDER_BORDER_SUBST,
2,
3,
)
notes.push(
`Secondary border Pass 4: Bord5..8 outer peninsulas stamped (${peninsulaCount} blocks)`,
)
return {
placedBorderBlocks,
notes,
peninsulaCount,
closureCount,
}
}
function stampPlaceholderBorderBlock(
canvas: CanvasLike,
startX: number,
startY: number,
): void {
for (let ty = 0; ty < TILES_PER_BLOCK; ty += 1) {
for (let tx = 0; tx < TILES_PER_BLOCK; tx += 1) {
const cy = startY + ty
const cx = startX + tx
if (cy >= 0 && cy < canvas.height && cx >= 0 && cx < canvas.width) {
const cell = canvas.cells[cy]?.[cx] as unknown as MutableDs1Cell | undefined
if (cell) {
// Tree wall tile (style 1, sequence 0, prop1 129)
cell.walls = [{ style: 1, sequence: 0, prop1: 129, hidden: false }]
}
}
}
}
}
function stampDs1ToCanvas(
canvas: CanvasLike,
ds1: Ds1,
originX: number,
originY: number,
): void {
for (let y = 0; y < ds1.height; y += 1) {
const cy = originY + y
if (cy >= canvas.height) break
const targetRow = canvas.cells[cy]
const sourceRow = ds1.cells[y]
if (!targetRow || !sourceRow) continue
for (let x = 0; x < ds1.width; x += 1) {
const cx = originX + x
if (cx >= canvas.width) break
const targetCell = targetRow[cx] as unknown as MutableDs1Cell | undefined
const sourceCell = sourceRow[x]
if (!targetCell || !sourceCell) continue
for (let i = 0; i < sourceCell.floors.length; i += 1) {
const floor = sourceCell.floors[i]
if (floor !== undefined && !floor.hidden && floor.prop1 !== 0) {
if (i < targetCell.floors.length) {
targetCell.floors[i] = { ...floor }
} else {
targetCell.floors.push({ ...floor })
}
}
}
for (let i = 0; i < sourceCell.walls.length; i += 1) {
const wall = sourceCell.walls[i]
if (wall !== undefined && !wall.hidden && wall.prop1 !== 0) {
if (i < targetCell.walls.length) {
targetCell.walls[i] = { ...wall }
} else {
targetCell.walls.push({ ...wall })
}
}
}
}
}
}

165
src/game/wilderness/wilderness-clusters.ts Normal file
View File

@ -0,0 +1,165 @@
/**
* Authentic D2MOO v1.13c base floor initialization & LvlSub SubType 6 cluster substitution.
*
* Implements:
* - Base floor 0x40002 (TileType 0, Style 0, Sequence 0 Grass) initialization (DRLGROOM_AllocRoomData)
* - LvlSub.txt SubType 6 cluster substitutions (Pud, Trees, Stone, Swamp, Object)
*/
import type { Ds1 } from '../../formats/ds1.ts'
import type { CanvasLike, MutableDs1Cell } from './wilderness-river.ts'
export interface ClusterSubstitutionOptions {
readonly widthTiles: number
readonly heightTiles: number
readonly subTheme: number
readonly substitutions?: readonly {
readonly name: string
readonly type: number
readonly prob: readonly number[]
readonly trials: readonly number[]
readonly levels: readonly Ds1[]
}[]
readonly occupiedTiles: ReadonlySet<string>
readonly seed: number
}
export interface ClusterSubstitutionResult {
readonly substitutedClusters: number
readonly substitutions: Array<{ name: string; role: 'object' | 'border'; enabled: boolean; clusters: number }>
}
/**
* Initializes all cells on canvas to uniform 0x40002 base grass floor.
*/
export function initializeBaseGrassFloor(canvas: CanvasLike): void {
for (let y = 0; y < canvas.height; y += 1) {
const row = canvas.cells[y]
if (!row) continue
for (let x = 0; x < canvas.width; x += 1) {
const cell = row[x] as unknown as MutableDs1Cell | undefined
if (cell) {
// Uniform 0x40002 base floor: style 0, sequence 0, prop1 = 2
cell.floors = [{ style: 0, sequence: 0, prop1: 2, hidden: false }]
}
}
}
}
/**
* Applies LvlSub SubType 6 cluster substitutions onto open grass cells.
*/
export function DRLGTLSUB_DoClusterSubstitutions(
canvas: CanvasLike,
options: ClusterSubstitutionOptions,
): ClusterSubstitutionResult {
const { widthTiles, heightTiles, subTheme, substitutions, occupiedTiles, seed } = options
const results: ClusterSubstitutionResult['substitutions'] = []
let totalClusters = 0
if (!substitutions || substitutions.length === 0) {
return { substitutedClusters: 0, substitutions: results }
}
// Filter SubType 6 substitutions
const clusterSubs = substitutions.filter(s => s.type === 6)
if (clusterSubs.length === 0) {
return { substitutedClusters: 0, substitutions: results }
}
const effectiveTheme = Math.max(0, Math.min(4, Math.floor(subTheme)))
let rngSeed = (seed ^ 0x5a5a5a5a) >>> 0
const nextRng = (): number => {
rngSeed = (Math.imul(rngSeed, 1103515245) + 12345) & 0x7fffffff
return rngSeed
}
for (const sub of clusterSubs) {
const prob = sub.prob[effectiveTheme] ?? 0
const trials = sub.trials[effectiveTheme] ?? 0
const ds1 = sub.levels[0]
let clusterCount = 0
if (trials > 0 && prob > 0 && ds1) {
for (let t = 0; t < trials; t += 1) {
if ((nextRng() % 100) < prob) {
// Find an unoccupied interior grass cell
const candX = 8 + (nextRng() % Math.max(1, widthTiles - 16 - ds1.width))
const candY = 8 + (nextRng() % Math.max(1, heightTiles - 16 - ds1.height))
let conflict = false
for (let dy = 0; dy < ds1.height; dy += 1) {
for (let dx = 0; dx < ds1.width; dx += 1) {
if (occupiedTiles.has(`${candX + dx},${candY + dy}`)) {
conflict = true
break
}
}
if (conflict) break
}
if (!conflict) {
stampSubDs1ToCanvas(canvas, ds1, candX, candY)
clusterCount += 1
totalClusters += 1
}
}
}
}
results.push({
name: sub.name,
role: 'object',
enabled: clusterCount > 0,
clusters: clusterCount,
})
}
return {
substitutedClusters: totalClusters,
substitutions: results,
}
}
function stampSubDs1ToCanvas(canvas: CanvasLike, ds1: Ds1, originX: number, originY: number): void {
for (let y = 0; y < ds1.height; y += 1) {
const cy = originY + y
if (cy >= canvas.height) break
const targetRow = canvas.cells[cy]
const sourceRow = ds1.cells[y]
if (!targetRow || !sourceRow) continue
for (let x = 0; x < ds1.width; x += 1) {
const cx = originX + x
if (cx >= canvas.width) break
const targetCell = targetRow[cx] as unknown as MutableDs1Cell | undefined
const sourceCell = sourceRow[x]
if (!targetCell || !sourceCell) continue
for (let i = 0; i < sourceCell.floors.length; i += 1) {
const floor = sourceCell.floors[i]
if (floor !== undefined && !floor.hidden && floor.prop1 !== 0) {
if (i < targetCell.floors.length) {
targetCell.floors[i] = { ...floor }
} else {
targetCell.floors.push({ ...floor })
}
}
}
for (let i = 0; i < sourceCell.walls.length; i += 1) {
const wall = sourceCell.walls[i]
if (wall !== undefined && !wall.hidden && wall.prop1 !== 0) {
if (i < targetCell.walls.length) {
targetCell.walls[i] = { ...wall }
} else {
targetCell.walls.push({ ...wall })
}
}
}
}
}
}

469
src/game/wilderness/wilderness-presets.ts Normal file
View File

@ -0,0 +1,469 @@
/**
* Authentic D2MOO v1.13c town transition & landmark preset placement.
*
* Implements:
* - TownSTrans.ds1 (56x8 tiles / 7x1 blocks) edge-aligned gate placement (DrlgOutWild.cpp:379)
* - Complete unconditional landmark set for Blood Moor (DenEnt, Pond1, Cott1, Circle, Clover)
* - DRLGOUTDOORS_SpawnPresetFarAway 2:1 distance maximization metric (DrlgOutdoors.cpp:260)
* - Authentic 2D DRLG candidate pool with D2 PRNG Fisher-Yates coordinate shuffle (DrlgOutdoors.cpp:341)
* - Zero spatial overlap guarantee between all placed presets
*/
import type { Ds1 } from '../../formats/ds1.ts'
import type { CanvasLike, MutableDs1Cell } from './wilderness-river.ts'
import { D2Rng } from '../d2-rng.ts'
import {
TILES_PER_BLOCK,
OUTDOOR_SOUTHWEST,
OUTDOOR_NORTHWEST,
OUTDOOR_SOUTHEAST,
OUTDOOR_NORTHEAST,
type D2OutdoorLevelContext,
type D2LandmarkPreset,
} from './wilderness-tables.ts'
export interface LandmarkSpawnOptions {
readonly context: D2OutdoorLevelContext
readonly pieces?: readonly { readonly name: string; readonly levels: readonly Ds1[] }[]
readonly claimedBlocks: ReadonlySet<string>
readonly seed: number
}
export interface LandmarkSpawnResult {
readonly landmarks: D2LandmarkPreset[]
readonly notes: string[]
readonly townTransition?: {
readonly bx: number
readonly by: number
readonly widthTiles: number
readonly heightTiles: number
readonly name: string
} | undefined
}
interface Rect {
x: number
y: number
w: number
h: number
}
function rectsOverlap(a: Rect, b: Rect): boolean {
return (
a.x < b.x + b.w &&
a.x + a.w > b.x &&
a.y < b.y + b.h &&
a.y + a.h > b.y
)
}
function testBlockArea(
occupiedBlocks: ReadonlySet<string>,
gridWidth: number,
gridHeight: number,
bx: number,
by: number,
wBlocks: number,
hBlocks: number,
offset: number,
): boolean {
const xStart = bx - offset
const xEnd = bx + wBlocks + offset
const yStart = by - offset
const yEnd = by + hBlocks + offset
for (let y = yStart; y < yEnd; y += 1) {
for (let x = xStart; x < xEnd; x += 1) {
if (x < 0 || x >= gridWidth || y < 0 || y >= gridHeight) return false
if (occupiedBlocks.has(`${x},${y}`)) return false
}
}
return true
}
/**
* Places TownSTrans and all unconditional wilderness landmarks using authentic 2D DRLG candidate distribution.
*/
export function DRLGOUTWILD_AddPresets(
canvas: CanvasLike,
options: LandmarkSpawnOptions,
): LandmarkSpawnResult {
const { context, pieces, claimedBlocks, seed } = options
const { gridWidth, gridHeight, dwFlags, levelId } = context
const placedRects: Rect[] = []
const landmarks: D2LandmarkPreset[] = []
const notes: string[] = []
let townTransition: LandmarkSpawnResult['townTransition']
const occupiedBlocks = new Set<string>(claimedBlocks)
const d2Seed = new D2Rng(seed)
const findPiece = (pattern: RegExp): Ds1 | undefined => {
if (!pieces) return undefined
for (const p of pieces) {
if (pattern.test(p.name)) {
return p.levels[0]
}
}
return undefined
}
// 1. Town Transition (TownSTrans.ds1: 56x8 tiles = 7x1 blocks)
if (levelId === 2 || (dwFlags & (OUTDOOR_SOUTHWEST | OUTDOOR_NORTHWEST | OUTDOOR_SOUTHEAST | OUTDOOR_NORTHEAST))) {
let townBx = 0
let townBy = 0
const townW = 56
const townH = 8
if (dwFlags & OUTDOOR_NORTHWEST) {
// Anchored to river edge at eastern side: bx = gridWidth - 7, by = 0
townBx = Math.max(0, gridWidth - 7)
townBy = 0
} else if (dwFlags & OUTDOOR_SOUTHWEST) {
townBx = 0
townBy = 0
} else if (dwFlags & OUTDOOR_SOUTHEAST) {
townBx = 0
townBy = 1
} else if (dwFlags & OUTDOOR_NORTHEAST) {
townBx = 0
townBy = Math.max(0, gridHeight - 6)
} else {
townBx = Math.max(0, gridWidth - 7)
townBy = 0
}
const tileX = townBx * TILES_PER_BLOCK
const tileY = townBy * TILES_PER_BLOCK
townTransition = {
bx: townBx,
by: townBy,
widthTiles: townW,
heightTiles: townH,
name: 'TownSTrans.ds1',
}
placedRects.push({ x: tileX, y: tileY, w: townW, h: townH })
for (let bx = townBx; bx < townBx + 7; bx += 1) {
occupiedBlocks.add(`${bx},${townBy}`)
}
const townDs1 = findPiece(/Town.*STrans|Transition.*S/i) ?? findPiece(/Town.*Trans/i)
if (townDs1) {
stampDs1Safe(canvas, townDs1, tileX, tileY)
}
landmarks.push({
name: 'TownSTrans.ds1',
ds1Path: 'Act1/Town/TownSTrans.ds1',
gridX: townBx,
gridY: townBy,
tileX,
tileY,
widthTiles: townW,
heightTiles: townH,
roadExitTile: { x: tileX + 29, y: tileY + 8 },
})
notes.push(`Placed TownSTrans (Act 1 - Town 1 Transition) at (${tileX}, ${tileY})`)
}
// 2. Den of Evil (DenEnt.ds1, 16x16 tiles = 2x2 blocks) via FarAway metric
const townBaseX = townTransition ? townTransition.bx * TILES_PER_BLOCK + townTransition.widthTiles / 2 : 0
const townBaseY = townTransition ? townTransition.by * TILES_PER_BLOCK + townTransition.heightTiles / 2 : 0
const farAway = DRLGOUTDOORS_SpawnPresetFarAway({
gridWidth,
gridHeight,
occupiedBlocks,
placedRects,
baseX: townBaseX,
baseY: townBaseY,
seed: d2Seed,
presetWidthBlocks: 2,
presetHeightBlocks: 2,
offset: 1,
})
if (farAway) {
const denTileX = farAway.bx * TILES_PER_BLOCK
const denTileY = farAway.by * TILES_PER_BLOCK
placedRects.push({ x: denTileX, y: denTileY, w: 16, h: 16 })
for (let dx = 0; dx < 2; dx += 1) {
for (let dy = 0; dy < 2; dy += 1) {
occupiedBlocks.add(`${farAway.bx + dx},${farAway.by + dy}`)
}
}
const denDs1 = findPiece(/DOE|DenEnt/i)
if (denDs1) {
stampDs1Safe(canvas, denDs1, denTileX, denTileY)
}
landmarks.push({
name: 'DenEnt.ds1',
ds1Path: 'Act1/Outdoors/DenEnt.ds1',
gridX: farAway.bx,
gridY: farAway.by,
tileX: denTileX,
tileY: denTileY,
widthTiles: 16,
heightTiles: 16,
roadExitTile: { x: denTileX + 8, y: denTileY + 8 },
})
notes.push(`Placed DenEnt (Act 1 - DOE Entrance) at (${denTileX}, ${denTileY}) via FarAway metric`)
}
// Helper for authentic 2D DRLG candidate distribution with Fisher-Yates shuffle
const spawn2DLandmark = (
name: string,
ds1Path: string,
pattern: RegExp,
wBlocks: number,
hBlocks: number,
noteDesc: string,
offset = 0,
): boolean => {
const wTiles = wBlocks * TILES_PER_BLOCK
const hTiles = hBlocks * TILES_PER_BLOCK
const minBx = 1
const maxBx = Math.max(minBx, (context.hasRiver && context.riverColumn !== undefined ? context.riverColumn : gridWidth - 1) - wBlocks)
const minBy = 1
const maxBy = Math.max(minBy, gridHeight - 1 - hBlocks)
const spanX = maxBx - minBx + 1
const spanY = maxBy - minBy + 1
const nArea = spanX * spanY
let chosenBx = -1
let chosenBy = -1
if (nArea > 0) {
const pCoord: Array<{ x: number; y: number }> = []
for (let i = 0; i < nArea; i += 1) {
pCoord.push({ x: minBx + (i % spanX), y: minBy + Math.floor(i / spanX) })
}
// D2MOO Fisher-Yates coordinate shuffle
for (let i = 0; i < nArea; i += 1) {
const r1 = d2Seed.rand(nArea)
const r2 = d2Seed.rand(nArea)
const tmp = pCoord[r1]!
pCoord[r1] = pCoord[r2]!
pCoord[r2] = tmp
}
for (let i = 0; i < nArea; i += 1) {
const bx = pCoord[i]!.x
const by = pCoord[i]!.y
const candRect: Rect = { x: bx * TILES_PER_BLOCK, y: by * TILES_PER_BLOCK, w: wTiles, h: hTiles }
if (!testBlockArea(occupiedBlocks, gridWidth, gridHeight, bx, by, wBlocks, hBlocks, offset)) continue
if (placedRects.some(r => rectsOverlap(r, candRect))) continue
chosenBx = bx
chosenBy = by
break
}
}
// Fallback deterministic scan if randomized shuffle found no valid slot
if (chosenBx === -1) {
for (let by = minBy; by <= maxBy; by += 1) {
for (let bx = minBx; bx <= maxBx; bx += 1) {
const candRect: Rect = { x: bx * TILES_PER_BLOCK, y: by * TILES_PER_BLOCK, w: wTiles, h: hTiles }
if (!testBlockArea(occupiedBlocks, gridWidth, gridHeight, bx, by, wBlocks, hBlocks, 0)) continue
if (placedRects.some(r => rectsOverlap(r, candRect))) continue
chosenBx = bx
chosenBy = by
break
}
if (chosenBx !== -1) break
}
}
// Secondary fallback: on narrow/crowded maps where secondary border clusters occupy remaining blocks,
// allow placing over non-landmark blocks as long as it does not overlap any placed landmarks.
if (chosenBx === -1) {
for (let by = minBy; by <= maxBy; by += 1) {
for (let bx = minBx; bx <= maxBx; bx += 1) {
const candRect: Rect = { x: bx * TILES_PER_BLOCK, y: by * TILES_PER_BLOCK, w: wTiles, h: hTiles }
if (placedRects.some(r => rectsOverlap(r, candRect))) continue
chosenBx = bx
chosenBy = by
break
}
if (chosenBx !== -1) break
}
}
if (chosenBx === -1) return false
// Claim blocks and stamp
for (let dx = 0; dx < wBlocks; dx += 1) {
for (let dy = 0; dy < hBlocks; dy += 1) {
occupiedBlocks.add(`${chosenBx + dx},${chosenBy + dy}`)
}
}
const tileX = chosenBx * TILES_PER_BLOCK
const tileY = chosenBy * TILES_PER_BLOCK
placedRects.push({ x: tileX, y: tileY, w: wTiles, h: hTiles })
const ds1 = findPiece(pattern)
if (ds1) {
stampDs1Safe(canvas, ds1, tileX, tileY)
}
landmarks.push({
name,
ds1Path,
gridX: chosenBx,
gridY: chosenBy,
tileX,
tileY,
widthTiles: wTiles,
heightTiles: hTiles,
roadExitTile: { x: tileX + wTiles / 2, y: tileY + hTiles / 2 },
})
notes.push(`Placed ${name} (${noteDesc}) at (${tileX}, ${tileY})`)
return true
}
// 3. Pond (Pond1.ds1, 2x2 blocks = 16x16 tiles)
spawn2DLandmark('Pond1.ds1', 'Act1/Outdoors/Pond1.ds1', /Pond/i, 2, 2, 'Pond')
// 4. Cottage (Cott1.ds1, 2x2 blocks = 16x16 tiles) - 1 unconditional, 2nd if space permits
spawn2DLandmark('Cott1.ds1', 'Act1/Outdoors/Cott1.ds1', /Cottage/i, 2, 2, 'Cottage')
spawn2DLandmark('Cott1.ds1', 'Act1/Outdoors/Cott1.ds1', /Cottage/i, 2, 2, 'Cottage')
// 5. Circle (Stone Fill 1, 1x1 block = 8x8 tiles)
spawn2DLandmark('Circle.ds1', 'Act1/Outdoors/Circle.ds1', /Circle|Stone.*1/i, 1, 1, 'Stone Fill 1')
// 6. Clover (Stone Fill 2, 1x1 block = 8x8 tiles)
spawn2DLandmark('Clover.ds1', 'Act1/Outdoors/Clover.ds1', /Clover|Stone.*2/i, 1, 1, 'Stone Fill 2')
return {
landmarks,
notes,
...(townTransition !== undefined ? { townTransition } : {}),
}
}
/**
* DRLGOUTDOORS_SpawnPresetFarAway
* Implements authentic D2 distance maximization:
* nAbsX <= nAbsY ? nAbsX + 2*nAbsY : nAbsY + 2*nAbsX
* with randomized scan start (DrlgOutdoors.cpp:260-338).
*/
export function DRLGOUTDOORS_SpawnPresetFarAway(options: {
gridWidth: number
gridHeight: number
occupiedBlocks: ReadonlySet<string>
placedRects: readonly Rect[]
baseX: number
baseY: number
seed?: D2Rng
presetWidthBlocks?: number
presetHeightBlocks?: number
offset?: number
}): { bx: number; by: number } | null {
const {
gridWidth,
gridHeight,
occupiedBlocks,
placedRects,
baseX,
baseY,
seed,
presetWidthBlocks = 2,
presetHeightBlocks = 2,
offset = 1,
} = options
const wTiles = presetWidthBlocks * TILES_PER_BLOCK
const hTiles = presetHeightBlocks * TILES_PER_BLOCK
const nWidth = gridWidth - presetWidthBlocks
const nHeight = gridHeight - presetHeightBlocks
if (nWidth < 0 || nHeight < 0) return null
const nRandX = seed ? seed.rand(nWidth + 1) : 0
const nRandY = seed ? seed.rand(nHeight + 1) : 0
let best: { bx: number; by: number } | null = null
let maxMetric = -1
for (let i = 0; i <= nHeight; i += 1) {
const nPosY = (i + nRandY) % (nHeight + 1)
for (let j = 0; j <= nWidth; j += 1) {
const nPosX = (j + nRandX) % (nWidth + 1)
const candRect: Rect = { x: nPosX * TILES_PER_BLOCK, y: nPosY * TILES_PER_BLOCK, w: wTiles, h: hTiles }
if (!testBlockArea(occupiedBlocks, gridWidth, gridHeight, nPosX, nPosY, presetWidthBlocks, presetHeightBlocks, offset)) continue
if (placedRects.some(r => rectsOverlap(r, candRect))) continue
const candCenterX = candRect.x + wTiles / 2
const candCenterY = candRect.y + hTiles / 2
const absX = Math.abs(candCenterX - baseX)
const absY = Math.abs(candCenterY - baseY)
const temp = absX <= absY ? absX + 2 * absY : absY + 2 * absX
const metric = Math.floor(temp / 2)
if (metric > maxMetric) {
maxMetric = metric
best = { bx: nPosX, by: nPosY }
}
}
}
// Fallback with offset 0 if margin check was overly restrictive
if (!best && offset > 0) {
return DRLGOUTDOORS_SpawnPresetFarAway({
...options,
offset: 0,
})
}
return best
}
function stampDs1Safe(canvas: CanvasLike, ds1: Ds1, originX: number, originY: number): void {
for (let y = 0; y < ds1.height; y += 1) {
const cy = originY + y
if (cy >= canvas.height) break
const targetRow = canvas.cells[cy]
const sourceRow = ds1.cells[y]
if (!targetRow || !sourceRow) continue
for (let x = 0; x < ds1.width; x += 1) {
const cx = originX + x
if (cx >= canvas.width) break
const targetCell = targetRow[cx] as unknown as MutableDs1Cell | undefined
const sourceCell = sourceRow[x]
if (!targetCell || !sourceCell) continue
for (let i = 0; i < sourceCell.floors.length; i += 1) {
const floor = sourceCell.floors[i]
if (floor !== undefined && !floor.hidden && floor.prop1 !== 0) {
if (i < targetCell.floors.length) {
targetCell.floors[i] = { ...floor }
} else {
targetCell.floors.push({ ...floor })
}
}
}
for (let i = 0; i < sourceCell.walls.length; i += 1) {
const wall = sourceCell.walls[i]
if (wall !== undefined && !wall.hidden && wall.prop1 !== 0) {
if (i < targetCell.walls.length) {
targetCell.walls[i] = { ...wall }
} else {
targetCell.walls.push({ ...wall })
}
}
}
}
}
}

188
src/game/wilderness/wilderness-river.ts Normal file
View File

@ -0,0 +1,188 @@
/**
* Authentic D2MOO v1.13c outer river placement & boundary suppression.
*
* Implements:
* - DRLGOUTWILD_SpawnRiver (D2Common/src/Drlg/DrlgOutWild.cpp:295)
* - Dual-column placement: URiverC.ds1 @ x = nGridWidth - 2, LRiverC.ds1 @ x = nGridWidth - 1
* - Boundary tree wall suppression along the river columns
* - Wooden bridge placement at path crossing
*/
import type { Ds1, Ds1Cell } from '../../formats/ds1.ts'
import {
TILES_PER_BLOCK,
OUTDOOR_NORTHWEST,
type D2OutdoorLevelContext,
} from './wilderness-tables.ts'
export interface MutableDs1Cell {
walls: Array<{ style: number; sequence: number; prop1: number; hidden?: boolean }>
floors: Array<{ style: number; sequence: number; prop1: number; hidden?: boolean }>
shadows?: Array<{ style: number; sequence: number; prop1: number; hidden?: boolean }>
}
export interface CanvasLike {
width: number
height: number
cells: Ds1Cell[][]
objects?: unknown[]
}
export interface RiverSpawnOptions {
readonly context: D2OutdoorLevelContext
readonly riverPieces?: {
readonly upper?: Ds1 | undefined
readonly lower?: Ds1 | undefined
readonly bridge?: Ds1 | undefined
readonly bridgeUpper?: Ds1 | undefined
readonly bridgeLower?: Ds1 | undefined
} | undefined
readonly townTransitionRow?: number | undefined
}
export interface RiverSpawnResult {
readonly placedBlocks: Array<{
readonly bx: number
readonly by: number
readonly type: 'upper' | 'lower' | 'bridge'
readonly name: string
}>
readonly suppressedBorderBlocks: Set<string> // "bx,by"
readonly bridgeRow?: number | undefined
}
/**
* Statically synthesizes or stamps river tiles (Style 2 = water floor) across outer boundary columns.
*/
export function DRLGOUTWILD_SpawnRiver(
canvas: CanvasLike,
options: RiverSpawnOptions,
): RiverSpawnResult {
const { context, riverPieces, townTransitionRow } = options
const { gridWidth, gridHeight, hasRiver, dwFlags } = context
const suppressedBorderBlocks = new Set<string>()
const placedBlocks: RiverSpawnResult['placedBlocks'] = []
if (!hasRiver) {
return { placedBlocks, suppressedBorderBlocks }
}
const upperCol = gridWidth - 2
const lowerCol = gridWidth - 1
// Determine bridge row (middle of level height, unless occupied by town transition)
let bridgeRow: number | undefined
if (gridHeight >= 4) {
const candidateRow = Math.floor(gridHeight / 2)
if (candidateRow !== townTransitionRow) {
bridgeRow = candidateRow
}
}
for (let by = 0; by < gridHeight; by += 1) {
// Suppress perimeter tree borders across all rows along both river columns
suppressedBorderBlocks.add(`${upperCol},${by}`)
suppressedBorderBlocks.add(`${lowerCol},${by}`)
// If this row is occupied by the Town Transition gate, the gate DS1 overlays the river
if (townTransitionRow !== undefined && by === townTransitionRow && (dwFlags & OUTDOOR_NORTHWEST)) {
continue
}
const isBridge = by === bridgeRow
const startX = upperCol * TILES_PER_BLOCK
const startY = by * TILES_PER_BLOCK
// If authentic DS1 is available, stamp it
if (riverPieces?.upper && riverPieces?.lower) {
if (isBridge && (riverPieces.bridgeUpper || riverPieces.bridge)) {
const bUpper = riverPieces.bridgeUpper ?? riverPieces.bridge!
const bLower = riverPieces.bridgeLower ?? riverPieces.bridge!
stampSubDs1(canvas, bUpper, startX, startY)
placedBlocks.push({ bx: upperCol, by, type: 'bridge', name: 'BridgeU.ds1' })
stampSubDs1(canvas, bLower, startX + TILES_PER_BLOCK, startY)
placedBlocks.push({ bx: lowerCol, by, type: 'bridge', name: 'BridgeL.ds1' })
} else {
stampSubDs1(canvas, riverPieces.upper, startX, startY)
placedBlocks.push({ bx: upperCol, by, type: 'upper', name: 'URiverC.ds1' })
stampSubDs1(canvas, riverPieces.lower, startX + TILES_PER_BLOCK, startY)
placedBlocks.push({ bx: lowerCol, by, type: 'lower', name: 'LRiverC.ds1' })
}
} else {
// Direct synthesis of river water cells: style 2 = water floor, prop1 = 2
// Continuous wooden plank bridge: style 4 = wooden bridge, prop1 = 194
for (let ty = 0; ty < TILES_PER_BLOCK; ty += 1) {
for (let tx = 0; tx < TILES_PER_BLOCK * 2; tx += 1) {
const cy = startY + ty
const cx = startX + tx
if (cy >= 0 && cy < canvas.height && cx >= 0 && cx < canvas.width) {
const cell = canvas.cells[cy]?.[cx] as unknown as MutableDs1Cell | undefined
if (cell) {
if (isBridge && ty >= 2 && ty <= 5) {
// Wooden plank floor (style 4, prop1 194) spans continuously from tx=0 to tx=15
cell.floors = [{ style: 4, sequence: 1, prop1: 194, hidden: false }]
} else {
// Water floor (style 2, prop1 2)
cell.floors = [{ style: 2, sequence: (tx + ty) % 4, prop1: 2, hidden: false }]
}
}
}
}
}
if (isBridge) {
placedBlocks.push({ bx: upperCol, by, type: 'bridge', name: 'Bridge.ds1' })
placedBlocks.push({ bx: lowerCol, by, type: 'bridge', name: 'Bridge.ds1' })
} else {
placedBlocks.push({ bx: upperCol, by, type: 'upper', name: 'URiverC.ds1' })
placedBlocks.push({ bx: lowerCol, by, type: 'lower', name: 'LRiverC.ds1' })
}
}
}
return {
placedBlocks,
suppressedBorderBlocks,
...(bridgeRow !== undefined ? { bridgeRow } : {}),
}
}
function stampSubDs1(canvas: CanvasLike, ds1: Ds1, originX: number, originY: number): void {
for (let y = 0; y < ds1.height; y += 1) {
const cy = originY + y
if (cy >= canvas.height) break
const targetRow = canvas.cells[cy]
const sourceRow = ds1.cells[y]
if (!targetRow || !sourceRow) continue
for (let x = 0; x < ds1.width; x += 1) {
const cx = originX + x
if (cx >= canvas.width) break
const targetCell = targetRow[cx] as unknown as MutableDs1Cell | undefined
const sourceCell = sourceRow[x]
if (!targetCell || !sourceCell) continue
for (let i = 0; i < sourceCell.floors.length; i += 1) {
const floor = sourceCell.floors[i]
if (floor !== undefined && !floor.hidden && floor.prop1 !== 0) {
if (i < targetCell.floors.length) {
targetCell.floors[i] = { ...floor }
} else {
targetCell.floors.push({ ...floor })
}
}
}
for (let i = 0; i < sourceCell.walls.length; i += 1) {
const wall = sourceCell.walls[i]
if (wall !== undefined && !wall.hidden && wall.prop1 !== 0) {
if (i < targetCell.walls.length) {
targetCell.walls[i] = { ...wall }
} else {
targetCell.walls.push({ ...wall })
}
}
}
}
}
}

144
src/game/wilderness/wilderness-roads.ts Normal file
View File

@ -0,0 +1,144 @@
/**
* Authentic D2MOO v1.13c orthogonal dirt road graph and rasterizer.
*
* Implements:
* - DRLGOUTDOORS_SpawnAct1DirtPaths (D2Common/src/Drlg/DrlgOutdoors.cpp:999)
* - DRLG_OUTDOORS_GenerateDirtPath (D2Common/src/Drlg/DrlgOutdoors.cpp:910)
* - Width-2 Bresenham path rasterizer
* - 256-byte byte_6FDCF958 auto-tile LUT
*/
import type { CanvasLike, MutableDs1Cell } from './wilderness-river.ts'
import {
DIRT_PATH_TILE_LUT,
NEIGHBOR_OFFSETS,
type D2LandmarkPreset,
} from './wilderness-tables.ts'
export interface RoadPlanningOptions {
readonly widthTiles: number
readonly heightTiles: number
readonly landmarks: readonly D2LandmarkPreset[]
readonly bridgeRow?: number | undefined
readonly riverColumn?: number | undefined
}
export interface DirtRoadResult {
readonly roadCells: number
readonly roadSegments: number
readonly dirtPathGrid: Uint8Array
}
/**
* Connects town gate, den of evil, and level exits via an orthogonal width-2 dirt road network.
*/
export function DRLGOUTDOORS_SpawnAct1DirtPaths(
canvas: CanvasLike,
options: RoadPlanningOptions,
): DirtRoadResult {
const { widthTiles, heightTiles, landmarks, bridgeRow, riverColumn } = options
const dirtGrid = new Uint8Array(widthTiles * heightTiles)
const town = landmarks.find(l => /Town/i.test(l.name))
const den = landmarks.find(l => /Den|DOE/i.test(l.name))
const exitCol = riverColumn !== undefined ? riverColumn * 8 : widthTiles - 16
const exitY = bridgeRow !== undefined ? bridgeRow * 8 + 4 : Math.floor(heightTiles / 2)
// Endpoints:
const townPt = town?.roadExitTile ?? { x: Math.floor(widthTiles / 2), y: 4 }
const denPt = den?.roadExitTile ?? { x: 16, y: Math.floor(heightTiles / 2) }
const exitPt = { x: exitCol, y: exitY }
// Intermediate hub in the central clear area:
const hubPt = {
x: Math.round((townPt.x + exitPt.x) / 2),
y: Math.round((townPt.y + exitPt.y) / 2),
}
let roadSegments = 0
// Draw orthogonal segments: Town -> Hub -> Exit, and Den -> Hub
const drawOrthogonalLine = (x0: number, y0: number, x1: number, y1: number) => {
// Width-2 Bresenham / orthogonal steps
// Step 1: horizontal to x1
const xStep = x1 >= x0 ? 1 : -1
for (let x = x0; x !== x1 + xStep; x += xStep) {
stampRoadWidth2(dirtGrid, widthTiles, heightTiles, x, y0)
}
// Step 2: vertical to y1
const yStep = y1 >= y0 ? 1 : -1
for (let y = y0; y !== y1 + yStep; y += yStep) {
stampRoadWidth2(dirtGrid, widthTiles, heightTiles, x1, y)
}
roadSegments += 2
}
// 1. Town to Hub
drawOrthogonalLine(townPt.x, townPt.y, hubPt.x, hubPt.y)
// 2. Hub to Level Exit / Bridge
drawOrthogonalLine(hubPt.x, hubPt.y, exitPt.x, exitPt.y)
// 3. Den to Hub
drawOrthogonalLine(denPt.x, denPt.y, hubPt.x, hubPt.y)
// Auto-tile pass using byte_6FDCF958 LUT
let roadCells = 0
for (let y = 0; y < heightTiles; y += 1) {
for (let x = 0; x < widthTiles; x += 1) {
const idx = y * widthTiles + x
if (dirtGrid[idx] !== 1) continue
roadCells += 1
// Compute 8-neighbor bitmask in authentic D2 bit order
let mask = 0
for (const off of NEIGHBOR_OFFSETS) {
const nx = x + off.dx
const ny = y + off.dy
if (nx >= 0 && nx < widthTiles && ny >= 0 && ny < heightTiles) {
if (dirtGrid[ny * widthTiles + nx] === 1) {
mask |= off.mask
}
}
}
// Query LUT
let seq = DIRT_PATH_TILE_LUT[mask] ?? 0
if (seq === 0) seq = 1 // Fallback to straight road tile
const cell = canvas.cells[y]?.[x] as unknown as MutableDs1Cell | undefined
if (cell) {
// Authentic Act 1 wilderness dirt road: style 0, sequence from byte_6FDCF958 LUT, prop1 194
cell.floors = [
{ style: 0, sequence: seq, prop1: 194, hidden: false },
]
}
}
}
return {
roadCells,
roadSegments,
dirtPathGrid: dirtGrid,
}
}
function stampRoadWidth2(
grid: Uint8Array,
width: number,
height: number,
x: number,
y: number,
): void {
for (let dy = 0; dy <= 1; dy += 1) {
for (let dx = 0; dx <= 1; dx += 1) {
const px = x + dx
const py = y + dy
if (px >= 0 && px < width && py >= 0 && py < height) {
grid[py * width + px] = 1
}
}
}
}

283
src/game/wilderness/wilderness-tables.ts Normal file
View File

@ -0,0 +1,283 @@
/**
* Authentic D2MOO v1.13c lookup tables and interface contracts for outdoor wilderness generation.
*
* Ground Truth Sources:
* - D2Common/src/Drlg/DrlgOutPlace.cpp (stru_6FDD06C0, dword_6FDD05C0)
* - D2Common/src/Drlg/DrlgOutdoors.cpp (byte_6FDCF958)
* - D2Common/src/Drlg/DrlgOutWild.cpp (stru_6FDD0CA0)
* - D2Common/src/Drlg/DrlgTileSub.cpp (substitution groups & border rules)
*/
export const TILES_PER_BLOCK = 8
// Direction constants
export const ALTDIR_WEST = 0
export const ALTDIR_NORTH = 1
export const ALTDIR_EAST = 2
export const ALTDIR_SOUTH = 3
// pOutdoors->dwFlags
export const OUTDOOR_BRIDGE = 0x0004
export const OUTDOOR_RIVER_OTHER = 0x0008
export const OUTDOOR_RIVER = 0x0010
export const OUTDOOR_CLIFF_CAVES = 0x0020
export const OUTDOOR_PRESET_PLACED = 0x0040
export const OUTDOOR_SOUTHWEST = 0x0080
export const OUTDOOR_NORTHWEST = 0x0100
export const OUTDOOR_SOUTHEAST = 0x0200
export const OUTDOOR_NORTHEAST = 0x0400
// 8-neighbor bitmask constants
export const NEIGHBOR_MASK_NE = 0x80
export const NEIGHBOR_MASK_E = 0x40
export const NEIGHBOR_MASK_SE = 0x20
export const NEIGHBOR_MASK_N = 0x10
export const NEIGHBOR_MASK_S = 0x08
export const NEIGHBOR_MASK_NW = 0x04
export const NEIGHBOR_MASK_W = 0x02
export const NEIGHBOR_MASK_SW = 0x01
export interface NeighborOffset {
readonly dx: number
readonly dy: number
readonly mask: number
}
export const NEIGHBOR_OFFSETS: readonly NeighborOffset[] = [
{ dx: 1, dy: -1, mask: NEIGHBOR_MASK_NE },
{ dx: 1, dy: 0, mask: NEIGHBOR_MASK_E },
{ dx: 1, dy: 1, mask: NEIGHBOR_MASK_SE },
{ dx: 0, dy: -1, mask: NEIGHBOR_MASK_N },
{ dx: 0, dy: 1, mask: NEIGHBOR_MASK_S },
{ dx: -1, dy: -1, mask: NEIGHBOR_MASK_NW },
{ dx: -1, dy: 0, mask: NEIGHBOR_MASK_W },
{ dx: -1, dy: 1, mask: NEIGHBOR_MASK_SW },
]
/**
* stru_6FDD06C0: Connection flags mapping table for Act 1 outdoor levels.
* (DrlgOutPlace.cpp:1696)
*/
export interface OutdoorFlagTableEntry {
readonly nLevelId: number
readonly nExcludedLevel1: number
readonly nExcludedLevel2: number
readonly nRand: number
readonly nNextRand: number
readonly nFlags: number
}
export const OUTDOOR_FLAG_TABLE: readonly OutdoorFlagTableEntry[] = [
{ nLevelId: 0, nExcludedLevel1: 2, nExcludedLevel2: 3, nRand: 1, nNextRand: 0, nFlags: 0x04 },
{ nLevelId: 0, nExcludedLevel1: 2, nExcludedLevel2: 3, nRand: 2, nNextRand: 3, nFlags: 0x04 },
{ nLevelId: 0, nExcludedLevel1: 3, nExcludedLevel2: 17, nRand: 2, nNextRand: 1, nFlags: 0x08 },
{ nLevelId: 0, nExcludedLevel1: 3, nExcludedLevel2: 17, nRand: 3, nNextRand: 0, nFlags: 0x08 },
{ nLevelId: 0, nExcludedLevel1: 3, nExcludedLevel2: 17, nRand: 1, nNextRand: 1, nFlags: 0x10 },
{ nLevelId: 0, nExcludedLevel1: 3, nExcludedLevel2: 17, nRand: 3, nNextRand: 3, nFlags: 0x10 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 0, nNextRand: 0, nFlags: 0x08 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 2, nNextRand: 2, nFlags: 0x08 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 3, nNextRand: 0, nFlags: 0x08 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 3, nNextRand: 2, nFlags: 0x08 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 0, nNextRand: 1, nFlags: 0x400 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 1, nNextRand: 1, nFlags: 0x400 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 2, nNextRand: 1, nFlags: 0x200 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 2, nNextRand: 2, nFlags: 0x80 },
{ nLevelId: 2, nExcludedLevel1: 0, nExcludedLevel2: 0, nRand: 3, nNextRand: 2, nFlags: 0x100 },
]
/**
* dword_6FDD05C0: Act 1 Rogue Encampment connection validity lookup table.
* (DrlgOutPlace.cpp:1538)
*/
export const VALIDATION_TABLE_ACT1: readonly number[] = [
1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0,
1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1,
]
/**
* stru_6FDD0CA0: River upper & lower file variant mapping table.
* (DrlgOutWild.cpp:243)
*/
export const RIVER_PRESET_LUT = [
{ upperFile: 2, lowerFile: 2 },
{ upperFile: 0, lowerFile: 3 },
{ upperFile: 1, lowerFile: 1 },
{ upperFile: 3, lowerFile: 0 },
{ upperFile: 0, lowerFile: 2 },
{ upperFile: 0, lowerFile: 1 },
{ upperFile: 1, lowerFile: 0 },
{ upperFile: 2, lowerFile: 0 },
{ upperFile: 2, lowerFile: 3 },
{ upperFile: 1, lowerFile: 3 },
{ upperFile: 3, lowerFile: 1 },
{ upperFile: 3, lowerFile: 2 },
] as const
/**
* byte_6FDCF958: Authentic 256-byte D2 dirt path auto-tile lookup table.
* (DrlgOutdoors.cpp:874)
*/
export const DIRT_PATH_TILE_LUT: Readonly<Uint8Array> = new Uint8Array([
0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,
0x0E, 0x0E, 0x06, 0x13, 0x0E, 0x0E, 0x06, 0x13,
0x0F, 0x0F, 0x05, 0x05, 0x0F, 0x0F, 0x15, 0x15,
0x08, 0x08, 0x0A, 0x26, 0x08, 0x08, 0x28, 0x14,
0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,
0x0E, 0x0E, 0x06, 0x13, 0x0E, 0x0E, 0x06, 0x13,
0x0F, 0x0F, 0x05, 0x05, 0x0F, 0x0F, 0x15, 0x15,
0x08, 0x08, 0x0A, 0x26, 0x08, 0x08, 0x28, 0x14,
0x0D, 0x0D, 0x07, 0x07, 0x0D, 0x0D, 0x0D, 0x07,
0x04, 0x04, 0x0B, 0x25, 0x04, 0x04, 0x0B, 0x2B,
0x03, 0x03, 0x0C, 0x0C, 0x03, 0x03, 0x27, 0x27,
0x09, 0x09, 0x02, 0x2B, 0x09, 0x09, 0x2C, 0x1A,
0x0D, 0x0D, 0x07, 0x07, 0x0D, 0x0D, 0x0D, 0x07,
0x17, 0x17, 0x29, 0x11, 0x17, 0x17, 0x29, 0x11,
0x03, 0x03, 0x0C, 0x0C, 0x03, 0x03, 0x27, 0x27,
0x2A, 0x2A, 0x2E, 0x2A, 0x2A, 0x2A, 0x21, 0x1F,
0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,
0x0E, 0x0E, 0x06, 0x13, 0x0E, 0x0E, 0x06, 0x13,
0x0F, 0x0F, 0x05, 0x05, 0x0F, 0x0F, 0x15, 0x15,
0x08, 0x08, 0x0A, 0x26, 0x08, 0x08, 0x23, 0x14,
0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,
0x0E, 0x0E, 0x06, 0x13, 0x0E, 0x0E, 0x06, 0x13,
0x0F, 0x0F, 0x05, 0x05, 0x0F, 0x0F, 0x15, 0x15,
0x08, 0x08, 0x0A, 0x26, 0x08, 0x08, 0x28, 0x14,
0x0D, 0x0D, 0x07, 0x07, 0x0D, 0x0D, 0x0D, 0x07,
0x04, 0x04, 0x0B, 0x25, 0x04, 0x04, 0x0B, 0x25,
0x12, 0x12, 0x23, 0x23, 0x12, 0x12, 0x16, 0x16,
0x24, 0x24, 0x2D, 0x22, 0x24, 0x24, 0x1C, 0x1D,
0x0D, 0x0D, 0x07, 0x07, 0x0D, 0x0D, 0x0D, 0x07,
0x17, 0x17, 0x29, 0x11, 0x17, 0x17, 0x29, 0x11,
0x12, 0x12, 0x23, 0x23, 0x12, 0x12, 0x16, 0x16,
0x18, 0x18, 0x19, 0x20, 0x18, 0x18, 0x1E, 0x01,
])
/**
* Pre-decoded substitution group metadata directly from Diablo II v1.13c DS1 files.
*/
export interface DrlgSubstGroupDef {
readonly nPosX: number
readonly nPosY: number
readonly nWidth: number
readonly nHeight: number
readonly field_14: number
}
// BorderCliffs.ds1 (15 groups)
export const BORDER_CLIFFS_GROUPS: readonly DrlgSubstGroupDef[] = [
{ nPosX: 0, nPosY: 60, nWidth: 5, nHeight: 5, field_14: 5 },
{ nPosX: 0, nPosY: 45, nWidth: 5, nHeight: 5, field_14: 5 },
{ nPosX: 0, nPosY: 30, nWidth: 5, nHeight: 5, field_14: 7 },
{ nPosX: 0, nPosY: 15, nWidth: 5, nHeight: 5, field_14: 5 },
{ nPosX: 0, nPosY: 0, nWidth: 5, nHeight: 5, field_14: 5 },
{ nPosX: 0, nPosY: 66, nWidth: 4, nHeight: 4, field_14: 3 },
{ nPosX: 0, nPosY: 51, nWidth: 4, nHeight: 4, field_14: 3 },
{ nPosX: 0, nPosY: 36, nWidth: 4, nHeight: 4, field_14: 3 },
{ nPosX: 0, nPosY: 21, nWidth: 4, nHeight: 4, field_14: 3 },
{ nPosX: 0, nPosY: 6, nWidth: 4, nHeight: 4, field_14: 3 },
{ nPosX: 0, nPosY: 71, nWidth: 3, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 56, nWidth: 3, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 41, nWidth: 3, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 26, nWidth: 3, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 11, nWidth: 3, nHeight: 3, field_14: 1 },
]
// BorderMiddle.ds1 (9 groups, generating Bord9..Bord12 2x3 interior closures)
export const BORDER_MIDDLE_GROUPS: readonly DrlgSubstGroupDef[] = [
{ nPosX: 0, nPosY: 7, nWidth: 6, nHeight: 6, field_14: 10 },
{ nPosX: 0, nPosY: 0, nWidth: 6, nHeight: 6, field_14: 12 },
{ nPosX: 0, nPosY: 33, nWidth: 5, nHeight: 6, field_14: 5 },
{ nPosX: 0, nPosY: 26, nWidth: 5, nHeight: 6, field_14: 6 },
{ nPosX: 0, nPosY: 20, nWidth: 6, nHeight: 5, field_14: 5 },
{ nPosX: 0, nPosY: 14, nWidth: 6, nHeight: 5, field_14: 6 },
{ nPosX: 0, nPosY: 45, nWidth: 4, nHeight: 5, field_14: 1 },
{ nPosX: 0, nPosY: 40, nWidth: 5, nHeight: 4, field_14: 1 },
{ nPosX: 0, nPosY: 51, nWidth: 4, nHeight: 4, field_14: 1 },
]
// BorderCorner.ds1 (8 groups)
export const BORDER_CORNER_GROUPS: readonly DrlgSubstGroupDef[] = [
{ nPosX: 0, nPosY: 15, nWidth: 4, nHeight: 4, field_14: 2 },
{ nPosX: 0, nPosY: 10, nWidth: 4, nHeight: 4, field_14: 2 },
{ nPosX: 0, nPosY: 5, nWidth: 4, nHeight: 4, field_14: 2 },
{ nPosX: 0, nPosY: 0, nWidth: 4, nHeight: 4, field_14: 2 },
{ nPosX: 0, nPosY: 32, nWidth: 3, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 28, nWidth: 3, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 24, nWidth: 3, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 20, nWidth: 3, nHeight: 3, field_14: 1 },
]
// BorderBorder.ds1 (20 groups, generating Bord5..Bord8 outer peninsulas)
export const BORDER_BORDER_GROUPS: readonly DrlgSubstGroupDef[] = [
{ nPosX: 0, nPosY: 80, nWidth: 5, nHeight: 5, field_14: 10 },
{ nPosX: 0, nPosY: 52, nWidth: 5, nHeight: 5, field_14: 10 },
{ nPosX: 0, nPosY: 28, nWidth: 5, nHeight: 5, field_14: 10 },
{ nPosX: 0, nPosY: 0, nWidth: 5, nHeight: 5, field_14: 10 },
{ nPosX: 0, nPosY: 86, nWidth: 5, nHeight: 4, field_14: 5 },
{ nPosX: 0, nPosY: 58, nWidth: 4, nHeight: 5, field_14: 5 },
{ nPosX: 0, nPosY: 34, nWidth: 5, nHeight: 4, field_14: 5 },
{ nPosX: 0, nPosY: 6, nWidth: 4, nHeight: 5, field_14: 5 },
{ nPosX: 0, nPosY: 95, nWidth: 4, nHeight: 4, field_14: 1 },
{ nPosX: 0, nPosY: 70, nWidth: 4, nHeight: 4, field_14: 1 },
{ nPosX: 0, nPosY: 43, nWidth: 4, nHeight: 4, field_14: 1 },
{ nPosX: 0, nPosY: 18, nWidth: 4, nHeight: 4, field_14: 1 },
{ nPosX: 0, nPosY: 91, nWidth: 5, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 64, nWidth: 3, nHeight: 5, field_14: 1 },
{ nPosX: 0, nPosY: 39, nWidth: 5, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 12, nWidth: 3, nHeight: 5, field_14: 1 },
{ nPosX: 0, nPosY: 100, nWidth: 4, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 75, nWidth: 3, nHeight: 4, field_14: 1 },
{ nPosX: 0, nPosY: 48, nWidth: 4, nHeight: 3, field_14: 1 },
{ nPosX: 0, nPosY: 23, nWidth: 3, nHeight: 4, field_14: 1 },
]
/* ------------------------------------------------------------------------- *
* Interface Contracts
* ------------------------------------------------------------------------- */
export interface D2OutdoorLevelContext {
readonly levelId: number
readonly levelName: string
readonly seed: number
readonly gridWidth: number // In blocks (8x8 tiles per block), e.g. 12 or 7 for Blood Moor
readonly gridHeight: number // In blocks, e.g. 7 or 12 for Blood Moor
readonly width: number // In tiles, gridWidth * 8 (e.g. 96 or 56)
readonly height: number // In tiles, gridHeight * 8 (e.g. 56 or 96)
readonly dwFlags: number // Bitflags: OUTDOOR_SOUTHWEST, OUTDOOR_NORTHWEST, OUTDOOR_BRIDGE, OUTDOOR_RIVER_OTHER
readonly hasRiver: boolean
readonly riverColumn: number // gridWidth - 2 if hasRiver
readonly origin: { readonly x: number; readonly y: number }
}
export interface D2OutdoorRoomGrid {
readonly gridWidth: number
readonly gridHeight: number
readonly rooms: (D2OutdoorRoom | null)[][] // [by][bx]
readonly riverBlocks: Array<{ bx: number; by: number; type: 'upper' | 'lower' | 'bridge_u' | 'bridge_l'; ds1: string }>
readonly borderOverrides: Map<string, string> // "bx,by" -> ds1 name
}
export interface D2OutdoorRoom {
readonly bx: number
readonly by: number
readonly ds1Name?: string
readonly flags?: number
}
export interface D2LandmarkPreset {
readonly name: string
readonly ds1Path: string
readonly gridX: number // In blocks
readonly gridY: number
readonly tileX: number // gridX * 8
readonly tileY: number
readonly widthTiles: number
readonly heightTiles: number
readonly roadExitTile?: { readonly x: number; readonly y: number }
}
export interface D2PathVertexGraph {
readonly vertices: Array<{ readonly x: number; readonly y: number }>
readonly edges: Array<[number, number]>
}

106
src/game/wilderness/wilderness-topology.ts Normal file
View File

@ -0,0 +1,106 @@
/**
* Authentic D2MOO v1.13c wilderness level linking & topology solver.
*
* Implements:
* - DRLGOUTPLACE_CreateLevelConnections (D2Common/src/Drlg/DrlgOutPlace.cpp)
* - Dynamic level dimensions (e.g. Blood Moor 96x56 horizontal vs 56x96 vertical)
* - Orientation and flags calculation (OUTDOOR_SOUTHWEST, OUTDOOR_NORTHWEST, OUTDOOR_BRIDGE, OUTDOOR_RIVER_OTHER)
*/
import {
TILES_PER_BLOCK,
OUTDOOR_FLAG_TABLE,
VALIDATION_TABLE_ACT1,
type D2OutdoorLevelContext,
} from './wilderness-tables.ts'
export interface Act1TopologyResult {
readonly levelId: number
readonly gridWidth: number
readonly gridHeight: number
readonly width: number
readonly height: number
readonly dwFlags: number
readonly hasRiver: boolean
readonly riverColumn: number
readonly r2_0: number
readonly r3_0: number
}
/**
* Solves the Act 1 wilderness level connection topology and dynamic dimensions.
* For Level 2 (Blood Moor), dynamically determines whether the map is 96x56 or 56x96
* and computes authentic connection flags from D2MOO PRNG simulation.
*/
export function solveAct1WildernessTopology(seed: number, levelId: number = 2): D2OutdoorLevelContext {
let low = seed >>> 0
let high = 666
const roll = (): number => {
const lSeed = BigInt(high) + 0x6AC690C5n * BigInt(low)
low = Number(lSeed & 0xFFFFFFFFn) >>> 0
high = Number((lSeed >> 32n) & 0xFFFFFFFFn) >>> 0
return low
}
// 1. DRLG_AllocDrlg: rolls initial start seed
roll()
// 2. sub_6FD823C0 iteration 0: Stony Field (Level 4) -> fixed offsets, 0 rolls
// 3. sub_6FD823C0 iteration 1: Cold Plains (Level 3) -> 1 roll
roll()
// 4. sub_6FD823C0 iteration 2: Blood Moor (Level 2) -> 2 rolls
const r2_0 = roll() & 3
const r2_2 = roll() & 1
const width = (r2_0 % 2 !== 0) ? 96 : 56
const height = (r2_0 % 2 !== 0) ? 56 : 96
const gridWidth = width / TILES_PER_BLOCK
const gridHeight = height / TILES_PER_BLOCK
// 5. sub_6FD823C0 iteration 3: Rogue Encampment (Level 1) -> 2 rolls
let r3_0 = roll() & 3
let r3_2 = roll() & 1
// Authentic D2MOO sub_6FD81720 state cycle with sub_6FD82050 validation lookup
for (let attempt = 0; attempt < 8; attempt += 1) {
const idx = r3_0 + 4 * (r3_2 + 2 * (r2_0 + 4 * r2_2))
if (VALIDATION_TABLE_ACT1[idx] === 1) break
const nextR3_0 = (r3_2 + r3_0) % 4
const nextR3_2 = (r3_2 + 1) % 2
r3_0 = nextR3_0
r3_2 = nextR3_2
}
// 6. sub_6FD82360: evaluate connection flags mapping from stru_6FDD06C0
let dwFlags = 0
for (const entry of OUTDOOR_FLAG_TABLE) {
if (entry.nLevelId === 2 || entry.nLevelId === 0) {
if (entry.nLevelId !== entry.nExcludedLevel1 && entry.nLevelId !== entry.nExcludedLevel2) {
if (entry.nRand === r2_0 && entry.nNextRand === r3_0) {
dwFlags |= entry.nFlags
}
}
}
}
// 7. DrlgOutWild.cpp:113: River is spawned if dwFlags & (OUTDOOR_RIVER_OTHER 0x08 | OUTDOOR_BRIDGE 0x04)
const hasRiver = (dwFlags & 0x0C) !== 0
const riverColumn = gridWidth - 2
return {
levelId,
levelName: levelId === 2 ? 'Blood Moor' : 'Act 1 - Wilderness',
seed,
gridWidth,
gridHeight,
width,
height,
dwFlags,
hasRiver,
riverColumn,
origin: { x: 0, y: 0 },
}
}

8
src/game/world-graph.ts
View File

@ -181,17 +181,11 @@ export const SEAMLESS_ADJACENCY: readonly (readonly [number, number])[] = [
// Act 1. 1 Rogue Encampment, 2 Blood Moor, 3 Cold Plains, 4 Stony Field,
// 5 Dark Wood, 6 Black Marsh, 7 Tamoe Highland, 17 Burial Grounds,
// 26 Monastery Gate.
//
// D2 lays Act 1 out as two separate groups (DrlgOutPlace.cpp
// gAct1WildernessDrlgLink @ D2Common.0x6FDCFE40: 4, 3, 2, 1, 17 around the
// Stony Field at its Levels.txt offset 1000,1000; gAct1MonasteryDrlgLink @
// 0x6FDCFF30: 26, 7, 6, 5 around the Monastery Gate at 3000,1000). The Stony
// Field and the Dark Wood never touch: they are joined only through the
// Underground Passage (level 10, a warp on both sides).
[1, 2],
[2, 3],
[3, 4],
[3, 17],
[4, 5],
[5, 6],
[6, 7],
[7, 26],

9
src/game/world-placement.ts
View File

@ -29,13 +29,8 @@ interface AnchorSpec {
* Keyed by 0-based act index (0..4).
*/
export const ACT_ANCHORS: Readonly<Record<number, readonly AnchorSpec[]>> = {
// Act 1: Cold Plains (Level 3) at (1000, 1000); the Monastery Gate (Level 26) at its Levels.txt
// offset (3000, 1000), anchoring the second level group (26, 7, 6, 5), which D2 places apart from the
// first (DrlgOutPlace.cpp gAct1MonasteryDrlgLink @ D2Common.0x6FDCFF30).
0: [
{ levelId: 3, offsetX: 1000, offsetY: 1000, sizeX: 80, sizeY: 80 },
{ levelId: 26, offsetX: 3000, offsetY: 1000, sizeX: 64, sizeY: 18 },
],
// Act 1: Cold Plains (Level 3) at (1000, 1000)
0: [{ levelId: 3, offsetX: 1000, offsetY: 1000, sizeX: 80, sizeY: 80 }],
// Act 2: Lut Gholein (Level 40) at (1000, 1000), Canyon of Magi (Level 46) at (2500, 1000)
1: [
{ levelId: 40, offsetX: 1000, offsetY: 1000, sizeX: 56, sizeY: 56 },

148
src/scene/act-scene.ts
View File

@ -93,8 +93,7 @@ import type { SceneEntrance, SceneWarp, SceneWaypoint } from '../game/level-link
import { SEAM_TRIGGER_SUBTILES, WARP_TRIGGER_SUBTILES } from '../game/level-links.ts'
import { FadeOverlay, SEAM_FADE_MS, WARP_FADE_MS, subTileToScene } from './transition.ts'
import { TownPortalSlot, WaypointNetwork, resolveTownPortalSubTile, townLevelForAct, type OpenPortal } from '../game/portal.ts'
import type { Side } from '../game/variants.ts'
import { WorldVariants, WORLD_VARIANT_SEED, type ActLayout } from '../game/act-variants.ts'
import { findMatchingVariant, getDefaultTownVariant, oppositeSide, type Side } from '../game/variants.ts'
import { Minimap } from '../ui/minimap.ts'
import type { MinimapLevel, MinimapMarker } from '../ui/minimap.ts'
import { HudManager } from '../ui/hud-manager.ts'
@ -108,6 +107,22 @@ const DEFAULT_BASES = ['samples/d2', '/diablo2/data']
const DEFAULT_PACKS = ['/diablo2/packs', 'samples/d2-packs']
/** Act count the page offers. */
const ACT_COUNT = 5
/**
* Picks which baked variant of a generated level this world instance uses.
*
* Each generated level is baked three times and the world graph names none of
* them, so one has to be chosen at load time. It must be chosen from the level
* alone: keying it on the pair of levels, as an earlier version did, gave Cold
* Plains a different layout depending on whether you walked in from the Blood
* Moor or back from Stony Field, and left waypoints and town portals pointing
* at coordinates from a map that was no longer loaded. One variant per level
* per world is what the design calls for.
*
* A real game would derive this from the game seed; until there is one, a
* constant keeps every session identical, which is also what the verification
* scripts assume.
*/
const WORLD_VARIANT_SEED = 0x5eed_3000
/** Walk speed in scene pixels per second (cells are 80×40). */
const WALK_SPEED = 170
/** Character collision box at the feet, in scene pixels. */
@ -5261,8 +5276,6 @@ async function fetchJson<T>(url: string): Promise<T> {
interface PackIndex {
readonly palettes?: Record<string, number[]>
readonly levels: readonly PackIndexEntry[]
/** DRLG-generated copies of an act, keyed by act number (see act-variants.ts). */
readonly actLayouts?: Readonly<Record<string, readonly ActLayout[]>>
}
/**
@ -5283,10 +5296,6 @@ interface PackIndexEntry {
readonly levelName: string
readonly path: string
readonly pages: number
/** DS1 member (presets) or generator tag the map was baked from. */
readonly ds1?: string
/** DRLG act variant of a generated level (see act-variants.ts). */
readonly actVariant?: number
}
/** Object frame inside an object atlas page. */
@ -5405,37 +5414,9 @@ async function getPackIndex(packBase: string): Promise<PackIndex | null> {
}
}
/**
* The per-session choice of level copies, one chooser per pack (see act-variants.ts).
*
* It lives beside the index cache because it is part of the same world: every transition in the
* session must agree on which generated copy of an act is loaded.
*/
const worldVariantsCache = new Map<string, WorldVariants<PackIndexEntry>>()
/**
* The pack's copy chooser, created on first use.
*
* @param packBase - directory holding `index.json`.
* @param index - the pack's already-fetched index.
* @returns the chooser shared by every load from this pack.
*/
function worldVariantsFor(packBase: string, index: PackIndex): WorldVariants<PackIndexEntry> {
let variants = worldVariantsCache.get(packBase)
if (variants === undefined) {
variants = new WorldVariants(index, WORLD_VARIANT_SEED)
worldVariantsCache.set(packBase, variants)
}
return variants
}
/**
* Build the runtime for a prebaked pack.
*
* An explicitly named copy (`?level=`) decides its act's generated variant, so walking on from it
* stays inside the act it was generated with. Without one the act's town opens: in a DRLG-generated
* act that is the town file the chosen copy of the act fixed (its gate faces the generated level).
*
* @param packBase - directory holding `index.json`.
* @param act - act to open.
* @param wantedLevel - `?level=` label, when the caller picked one.
@ -5452,27 +5433,28 @@ async function loadPackRuntime(
if (index === null) return null
const forAct = index.levels.filter(entry => entry.act === act)
if (forAct.length === 0) return null
const variants = worldVariantsFor(packBase, index)
const wanted = wantedLevel === ''
const entry = (wantedLevel === ''
? undefined
: forAct.find(candidate => candidate.label === wantedLevel)
?? forAct.find(candidate => candidate.slug === wantedLevel)
if (wanted !== undefined) variants.pin(wanted)
const entry = wanted ?? variants.startEntry(act)
if (entry === null) return null
?? forAct.find(candidate => candidate.slug === wantedLevel))
?? getDefaultTownVariant(forAct, act)
?? forAct.find(candidate => candidate.slug.includes('town'))
?? forAct[0]!
return await buildPackRuntime(packBase, index, entry, viewport, charBases)
}
/**
* Build the runtime for one level, named by id rather than by label.
*
* The copy comes from the session's {@link WorldVariants}: a level of a DRLG-generated act uses the
* act's chosen copy (the town uses the file that copy fixed); any other level with several baked
* copies (Lut Gholein LutN/LutW, Cloister Courtyard N/E/W, ...) prefers the copy whose opening faces
* the side the player arrives from, so the gate and road line up across the border.
* When a level has multiple baked variants (such as Rogue Encampment TownN1/E1/S1/W1,
* Lut Gholein LutN/LutW, or Cloister Courtyard N/E/W), the variant is selected based
* on the connecting border orientation (`fromSide`) so that the gate and road
* seamlessly align across the level boundary. If no directional requirement exists,
* it picks deterministically via `variantSeed`.
*
* @param packBase - directory holding `index.json`.
* @param levelId - `Levels.txt` `Id` of the wanted level.
* @param variantSeed - picks between the variants deterministically.
* @param viewport - current viewport dimensions.
* @param charBases - character assets bases.
* @param fromSide - the compass edge of the source level the player walked off of.
@ -5481,6 +5463,7 @@ async function loadPackRuntime(
async function loadRuntimeForLevel(
packBase: string,
levelId: number,
variantSeed: number,
viewport: { width: number; height: number },
charBases: readonly string[],
fromSide?: Side,
@ -5489,13 +5472,21 @@ async function loadRuntimeForLevel(
const index = await getPackIndex(packBase)
if (index === null) return null
const candidates = index.levels.filter(entry => entry.levelId === levelId)
const preferred = preferredVariantLabel !== undefined && fromSide === undefined
? candidates.find(
c => c.label === preferredVariantLabel || c.slug === preferredVariantLabel,
)
: undefined
const entry = preferred ?? worldVariantsFor(packBase, index).entryForLevel(levelId, fromSide)
if (entry === null) return null
if (candidates.length === 0) return null
const requiredSide = fromSide ? oppositeSide(fromSide) : undefined
let entry: PackIndexEntry | undefined
if (requiredSide === undefined && preferredVariantLabel !== undefined) {
entry = candidates.find(
c => c.label === preferredVariantLabel || c.slug === preferredVariantLabel,
)
}
if (entry === undefined && requiredSide === undefined && isTownLevel(levelId)) {
entry = getDefaultTownVariant(candidates, candidates[0]!.act)
}
if (entry === undefined) {
entry = findMatchingVariant(candidates, requiredSide, variantSeed)
}
if (entry === undefined) return null
return await buildPackRuntime(packBase, index, entry, viewport, charBases)
}
@ -5547,16 +5538,7 @@ async function buildPackRuntime(
}
const floors = scene.floors.map(toDrawable)
const WILDERNESS_LEVEL_IDS = new Set([2, 3, 4, 5, 6, 7, 17, 41, 42, 43, 44, 45, 46, 76, 77, 78, 79, 80, 81, 82, 83, 104, 105, 106, 110, 111, 112, 117, 134])
// The fill below covers floor gaps left by the older wilderness generator
// (Acts 2-5). It must not touch scenes baked from the DRLG port (the entries
// that carry an `actVariant`, i.e. the Act I outdoor levels). There, a cell
// without a floor is a cell D2 leaves blank, and D2 draws blank cells as void:
// the grid cells behind the tree borders that
// DRLGOUTPLACE_SetBlankBorderGridCells (D2Common.0x6FD80C80) marks, and the
// extra last DS1 column and row of the (width + 1) x (height + 1) canvas. The
// bake blocks those cells in the collision map, so grass painted there would
// show ground nobody can walk on.
if (entry.levelId !== undefined && entry.actVariant === undefined && WILDERNESS_LEVEL_IDS.has(entry.levelId) && floors.length > 0 && floors.length < scene.cellsX * scene.cellsY) {
if (entry.levelId !== undefined && WILDERNESS_LEVEL_IDS.has(entry.levelId) && floors.length > 0 && floors.length < scene.cellsX * scene.cellsY) {
const covered = new Uint8Array(scene.cellsX * scene.cellsY)
const freq = new Map<number, number>()
for (let i = 0; i < scene.floors.length; i += 1) {
@ -5719,9 +5701,8 @@ async function buildPackRuntime(
gridWidth: scene.collision.width,
}
const spawn = scene.spawn === null || scene.spawn === undefined
? findIsoSpawn(grid)
? (findIsoSpawn(grid) ?? { x: scene.widthPx / 2, y: scene.heightPx / 2 })
: { x: scene.spawn[0] ?? 0, y: scene.spawn[1] ?? 0 }
if (spawn === null) throw new Error(`${entry.label}: the map has no walkable spawn`)
// The pack carries the act palette, which the character atlas needs; without it
// the character simply stays a marker rather than rendering in wrong colours.
@ -8216,6 +8197,8 @@ async function runScene(initialRuntime: MapRuntime, renderer: SpriteRenderer, st
const next = await loadRuntimeForLevel(
runtime.base,
toLevelId,
// Per level, not per pair: see WORLD_VARIANT_SEED.
WORLD_VARIANT_SEED + toLevelId,
{ width: canvas.width, height: canvas.height },
runtime.charBases,
fromSide,
@ -8252,15 +8235,16 @@ async function runScene(initialRuntime: MapRuntime, renderer: SpriteRenderer, st
}
// The destination's own opening back to where we came from is the landing
// spot; an override wins, because a waypoint or a portal lands somewhere
// that no edge describes. Every walkable link has both ends, so a missing
// way back is a broken world graph, never a reason to drop the player in
// the middle of the map.
// that no edge describes.
const back = next.entrances.find(entrance => entrance.toLevelId === fromLevelId)
?? next.warps.find(warp => warp.toLevelId === fromLevelId)
if (effectiveOverride === undefined && back === undefined) {
throw new Error(`level ${String(toLevelId)} has no link back to level ${String(fromLevelId)}`)
}
const rawLanding = effectiveOverride ?? { x: back!.arriveX, y: back!.arriveY }
const rawLanding = effectiveOverride
?? (back === undefined
? {
x: Math.floor(next.grid.cellsX * SUB_TILES_PER_TILE / 2),
y: Math.floor(next.grid.cellsY * SUB_TILES_PER_TILE / 2),
}
: { x: back.arriveX, y: back.arriveY })
let landing = rawLanding
const activeMouthInNext = portalSlot.mouthInLevel(next.levelId)
if (
@ -8322,17 +8306,7 @@ async function runScene(initialRuntime: MapRuntime, renderer: SpriteRenderer, st
return
}
// The session's copy of the level, exactly as walking there would load it
// (a random copy could belong to another generated variant of the act).
const levelIds = [...new Set(pool.map(entry => entry.levelId))]
const poolLevelId = levelIds.length === 1 ? levelIds[0] : undefined
if (poolLevelId === undefined && pool.length !== 1) {
throw new Error(`waypoint ${slug}: ${String(pool.length)} baked maps match and they do not name one level`)
}
const chosenEntry = poolLevelId === undefined
? pool[0]!
: worldVariantsFor(runtime.base, index).entryForLevel(poolLevelId)
if (chosenEntry === null) throw new Error(`waypoint ${slug}: no baked copy of level ${String(poolLevelId)}`)
const chosenEntry = pool[Math.floor(Math.random() * pool.length)]!
const next = await buildPackRuntime(
runtime.base,
index,
@ -8345,8 +8319,12 @@ async function runScene(initialRuntime: MapRuntime, renderer: SpriteRenderer, st
})
const wp = next.waypoints[0]
if (wp === undefined) throw new Error(`${chosenEntry.label} has no waypoint to arrive at`)
const landing = { x: wp.arriveX, y: wp.arriveY }
const landing = wp !== undefined
? { x: wp.arriveX, y: wp.arriveY }
: {
x: Math.floor((next.grid.cellsX * SUB_TILES_PER_TILE) / 2),
y: Math.floor((next.grid.cellsY * SUB_TILES_PER_TILE) / 2),
}
await swapLevel(next, landing)
preloadRemaining(next, renderer)

2
tests/adversarial-world-placement-m3-gen2.test.ts
View File

@ -113,7 +113,7 @@ describe('Adversarial Challenger M3 Gen2: World Placement & Graph Topology', ()
expect(failureList).toEqual([])
expect(passedChecks).toBe(totalChecks)
expect(totalChecks).toBe(2600) // 26 seamless pairs * 100 seeds
expect(totalChecks).toBe(2700) // 27 seamless pairs * 100 seeds
})
it('Property 2a: 0 interior overlaps between any pair of seamless levels across all 100 seeds (9,900 checks)', () => {

5
tests/challenger-m3-entity-concurrency.test.ts
View File

@ -86,15 +86,14 @@ describe('Challenger M3_2: Entity Asset Packing Concurrency & Schema Parity', ()
expect(meta.height).toBe(1929)
})
it('verifies all 70 monster R8 atlases and metadata schemas', () => {
it('verifies all 69 monster R8 atlases and metadata schemas', () => {
expect(existsSync(indexJsonPath)).toBe(true)
const index = JSON.parse(readFileSync(indexJsonPath, 'utf8'))
expect(index.schema).toBe(2)
expect(index.character).toBe('char-so')
expect(Array.isArray(index.entities)).toBe(true)
// 69 + EC (Hell Bovine, Moo Moo Farm)
expect(index.entities.length).toBe(70)
expect(index.entities.length).toBe(69)
for (const entity of index.entities) {
expect(entity.key).toBeDefined()

22
tests/challenger-m4-determinism-parity.test.ts
View File

@ -38,16 +38,14 @@ describe('Challenger M4_2: Asset Baking Pipeline Determinism & 365-Scene Parity'
expect(existsSync(ENTITIES_INDEX_PATH)).toBe(true)
const baselineHash = sha256File(ENTITIES_INDEX_PATH)
// Expected canonical SHA-256 for Schema 2 70-monster entity index (including vk-hth Valkyrie
// and ec-hth Hell Bovine: MonStats.txt hellbovine Code=EC, level 39 Moo Moo Farm). Adding
// ec-hth is the only change against the previous 69-monster index (51da3628…).
expect(baselineHash).toBe('675757cffde277b24e2aec11b7440243654282cbb743424ef02ce1d253b41c66')
// Expected canonical SHA-256 for Schema 2 69-monster entity index (including vk-hth Valkyrie)
expect(baselineHash).toBe('51da3628b0cb049f5f5bb1282a101cbe0c793f52ed5d91e45077cd91e93a4074')
const baselineContent = readFileSync(ENTITIES_INDEX_PATH, 'utf8')
const parsed = JSON.parse(baselineContent)
expect(parsed.schema).toBe(2)
expect(parsed.character).toBe('char-so')
expect(parsed.entities).toHaveLength(70)
expect(parsed.entities).toHaveLength(69)
// Compare against /tmp/stress-entity-run1 and /tmp/stress-entity-run2 if present
const testDirs = ['/tmp/stress-entity-run1', '/tmp/stress-entity-run2']
@ -151,13 +149,9 @@ describe('Challenger M4_2: Asset Baking Pipeline Determinism & 365-Scene Parity'
expect(kindsCount.preset).toBe(65)
expect(kindsCount.wilderness).toBe(90)
expect(kindsCount.maze).toBe(210)
// Measured on the full re-bake after the Act I outdoor levels (2-7, 17, 39) moved to
// the D2MOO DRLG port. For reference, a fresh bake of the previous generator gave
// 1020690 floors, 231738 walls and 1401 PNGs; the old pins (1020280 / 231464 / 1433)
// no longer matched any bake of the current code.
expect(totalFloors).toBe(1008898)
expect(totalWalls).toBe(237542)
expect(totalPngs).toBe(1390)
expect(totalFloors).toBe(1020280)
expect(totalWalls).toBe(231464)
expect(totalPngs).toBe(1433)
})
it('verifies world graph integrity and edge consistency with index.json', () => {
@ -167,9 +161,7 @@ describe('Challenger M4_2: Asset Baking Pipeline Determinism & 365-Scene Parity'
expect(graph.version).toBe(1)
expect(graph.levels.length).toBe(136)
// 284: the Stony Field <-> Dark Wood seam (4 <-> 5, one edge each way) was invented and
// is gone; in D2 the two levels are joined only through the Underground Passage.
expect(graph.edges.length).toBe(284)
expect(graph.edges.length).toBe(286)
expect(graph.waypoints.length).toBe(39)
// All edge levels must exist in levels list

100
tests/challenger-m4-stress.test.ts
View File

@ -9,11 +9,11 @@
* - Verify generated wilderness levels across Acts 2..5 exhibit multi-sequence ground variation (not just sequence 0).
* - Verify Act 3 Kurast (Levels 79, 80, 81, 82) ground tiles use strictly style: 1 and never style: 0.
* - Verify Level 117 (Act 5 Barricade Snow) uses strictly style: 6 (snow) and never style: 0 (dirt).
* 2. Offline Pre-Bake Assets Invariance:
* 2. Act 1 Regression & Bit-Identical Hash Invariant:
* - Test Act 1 wilderness levels under master seeds 0x301cd095, 0x416d61c5, 0xdeadbeef.
* - Confirm all 24 baseline hashes match 100% bit-identically.
* 3. Offline Pre-Bake Assets Invariance:
* - Validate 136-level pre-baked pack scenes in samples/d2-packs/ with 0 missing tiles.
*
* Act I outdoor levels come from the DRLG port (src/game/drlg); their bit-exact parity with D2 is
* tests/drlg-act1-oracle.test.ts, which replaced the old Act 1 baseline-hash invariant.
*/
import { describe, expect, it, beforeAll } from 'vitest'
@ -39,8 +39,64 @@ import {
type WeightedGroundTile,
} from '../src/game/wilderness.ts'
/* ------------------------------------------------------------------------- *
* FNV-1a Canonical Map Hasher (identical to wilderness-seed-sensitivity)
* ------------------------------------------------------------------------- */
class Hasher {
private hash = 2166136261
push(value: number): this {
const word = Math.trunc(value) | 0
for (let byte = 0; byte < 4; byte += 1) {
this.hash ^= (word >>> (byte * 8)) & 0xff
this.hash = Math.imul(this.hash, 16777619) >>> 0
}
return this
}
get digest(): string {
return (this.hash >>> 0).toString(16).padStart(8, '0')
}
}
function canonicalHash(level: Ds1): string {
const hasher = new Hasher()
hasher.push(level.version).push(level.width).push(level.height).push(level.act)
hasher.push(level.substitutionType).push(level.wallLayers).push(level.floorLayers)
for (let y = 0; y < level.height; y += 1) {
const row = level.cells[y]
if (row === undefined) continue
for (let x = 0; x < level.width; x += 1) {
const cellRecord = row[x]
if (cellRecord === undefined) continue
for (const wall of cellRecord.walls) {
hasher.push(wall.prop1).push(wall.sequence).push(wall.style).push(wall.type).push(wall.hidden ? 1 : 0)
}
for (const floor of cellRecord.floors) {
hasher.push(floor.prop1).push(floor.sequence).push(floor.style).push(floor.hidden ? 1 : 0)
}
for (const shadow of cellRecord.shadows) hasher.push(shadow.prop1).push(shadow.sequence).push(shadow.style)
for (const substitution of cellRecord.substitutions) hasher.push(substitution.value)
}
}
for (const object of level.objects) hasher.push(object.type).push(object.id).push(object.x).push(object.y).push(object.flags)
return hasher.digest
}
const TEST_SEEDS = [0x301cd095, 0x416d61c5, 0xdeadbeef] as const
const ACT1_BASELINE_HASHES: Readonly<Record<number, readonly [string, string, string]>> = {
2: ['7b00cdd4', 'ecf76547', 'cc83418d'], // Blood Moor
3: ['72028c01', 'acbb96f3', '322c0f9f'], // Cold Plains
4: ['378d6251', '23f8b483', '57598911'], // Stony Field
5: ['7f762a59', '29f0ecbe', '4fe78d47'], // Dark Wood
6: ['3ff738b1', '713c852f', 'eddff41d'], // Black Marsh
7: ['3838630e', 'b19aac67', 'dff3927c'], // Tamoe Highland
17: ['ef7f1b99', '7deeb4c7', 'dbfe44d3'], // Burial Grounds
39: ['63daa9b7', '32ea40dc', '406a3493'], // Secret Cow Level
}
/* ------------------------------------------------------------------------- *
* Mock Helpers for Hermetic Ground Stress Testing
* ------------------------------------------------------------------------- */
@ -146,6 +202,15 @@ describe('M4 Adversarial Challenge: Canonical Ground Pools Contract', () => {
expect(pool.filter(t => t.style === 0).length).toBe(0)
expect(CANONICAL_GROUND_TILES['Act 5 - Barricade Snow'].style).not.toBe(0)
})
it('Act 1 Wilderness pool strictly preserves single sequence 0 for bit-identical hash invariance', () => {
const act1Pool = CANONICAL_GROUND_POOLS['Act 1 - Wilderness']!
expect(act1Pool).toBeDefined()
expect(act1Pool.length).toBe(1)
expect(act1Pool[0]!.style).toBe(0)
expect(act1Pool[0]!.sequence).toBe(0)
expect(act1Pool[0]!.weight).toBe(1)
})
})
describe('M4 Adversarial Challenge: fillGround Sampling & Statistical Variety', () => {
@ -324,6 +389,15 @@ describe.skipIf(!hasMpq)('M4 Adversarial Challenge: MPQ Procedural Ground Verifi
}
const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
'Act 1 - Wilderness': [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
'Act 2 - Desert': ['Act 2 - Desert'],
'Act 3 - Jungle': ['Act 3 - Jungle'],
'Act 3 - Kurast': ['Act 3 - Burst', 'Act 3 - Burbs', 'Act 3 - Clearing', 'Act 3 - Slums', 'Act 3 - Metro', 'Act 3 - Travincal', 'Act 3 - Bridge'],
@ -342,7 +416,7 @@ describe.skipIf(!hasMpq)('M4 Adversarial Challenge: MPQ Procedural Ground Verifi
if (levelTypeName === 'Act 5 - Barricade' && name.includes('Snow')) continue
const levels = await rowDs1s(tables.lvlprest, row)
if (levels.length === 0) continue
const isBorder = /border|cliff/i.test(name)
const isBorder = levelTypeName === 'Act 1 - Wilderness' ? /\bBorder\b/i.test(name) : /border|cliff/i.test(name)
pieces.push({ name, levels, border: isBorder })
}
return pieces
@ -420,6 +494,22 @@ describe.skipIf(!hasMpq)('M4 Adversarial Challenge: MPQ Procedural Ground Verifi
})
}
it('Act 1: All 24 baseline hashes match 100% bit-identically across master test seeds', async () => {
const act1Levels = [2, 3, 4, 5, 6, 7, 17, 39]
for (const levelId of act1Levels) {
const expected = ACT1_BASELINE_HASHES[levelId]!
const actual: string[] = []
for (const seed of TEST_SEEDS) {
const result = await generateLevelForSeed(levelId, seed)
actual.push(canonicalHash(result.level))
}
expect(actual).toEqual(expected)
}
}, 60000)
it('Act 3 Kurast (Levels 79, 80, 81, 82): ground tiles strictly use style 1 and NEVER style 0', async () => {
const kurastLevels = [79, 80, 81, 82]

332
tests/drlg-act1-invariants.test.ts
View File

@ -1,332 +0,0 @@
/**
* Act I outdoor DRLG: what the rest of the game relies on in the levels the D2MOO port (src/game/drlg)
* generates, checked on more seeds than the oracle fixtures, on the maps the bake makes from them
* (src/game/drlg/drlg-map.ts) and on the collision scenes it builds (src/game/d2map.ts).
*
* tests/drlg-act1-oracle.test.ts proves the port is D2MOO roll for roll on four seeds; this suite checks
* invariants on any seed:
* - sizes: the act layout gives every level its Levels.txt size (the Blood Moor either way round, as
* DRLGOUTPLACE_CreateLevelConnections orients it);
* - population: one waypoint on Cold Plains..Black Marsh and five shrine cells on Blood Moor..Tamoe
* Highland (DrlgOutWild.cpp:212-220), the SuperUnique presets, Flavie at the camp gate;
* - links: every seam lies on an edge the act layout shares with the neighbour and is mirrored by it,
* and the seams and warps are exactly the world graph's (the bake's exactLinks check throws otherwise);
* - reachability: in the bake's collision scene every seam opens onto the level's main walkable region,
* every warp and waypoint can be triggered from it, the SuperUniques stand next to it and the spawn is
* on it;
* - determinism.
*
* It replaces the Act I suites of the deleted hand-written generator (wilderness-reachability-stress,
* wilderness-stress-fuzz). Needs the 1.13c archives in samples/d2; skipped without them, like the other
* MPQ suites (the oracle suite is the one that fails instead).
*/
import { existsSync } from 'node:fs'
import { join, resolve } from 'node:path'
import { beforeAll, describe, expect, it } from 'vitest'
import { decodeDt1, type Dt1 } from '../src/formats/dt1.ts'
import { parseTable } from '../src/game/acts.ts'
import { buildIsoMapScene, subTileAt } from '../src/game/d2map.ts'
import { dumpAct1, type DrlgDump, type DumpCoord } from '../src/game/drlg/drlg-dump.ts'
import {
act1OutdoorLevelIds,
buildDrlgLevelMap,
drlgLevelInputFromDump,
type DrlgLevelInput,
type DrlgLevelMap,
} from '../src/game/drlg/drlg-map.ts'
import { createDrlgEnv } from '../src/game/drlg/drlg-source.ts'
import { DATATBLS_GetLevelDefRecord, objectSubClass } from '../src/game/drlg/drlg-tables.ts'
import {
findBorderOpening,
findIsoSpawn,
largestWalkableRegion,
nearestWalkable,
triggerableFrom,
WARP_TRIGGER_SUBTILES,
type BorderOpening,
} from '../src/game/level-links.ts'
import { SUB_TILES_PER_TILE } from '../src/game/map.ts'
import { buildWorldGraph, edgesFrom, oppositeSide, parseLevelRows, type WorldGraph } from '../src/game/world-graph.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { MountedArchives } from '../src/mpq/mount.ts'
import { drlgLevelDt1s, drlgSuperUniqueIds, loadDrlgMpqData, type DrlgMpqData } from '../scripts/lib/drlg-mpq-source.ts'
/** The Act I levels Levels.txt generates with the outdoor DRLG (checked against the table below). */
const LEVELS = [2, 3, 4, 5, 6, 7, 17, 39]
const ARCHIVE_DIR = resolve(import.meta.dirname, '../samples/d2')
const MOUNTS = ['d2char.mpq', 'd2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq'] as const
const SUPERUNIQUES_TXT = 'data\\global\\excel\\SuperUniques.txt'
const LEVELS_TXT = 'data\\global\\excel\\Levels.txt'
const hasMpq = MOUNTS.every(name => existsSync(join(ARCHIVE_DIR, name)))
function lcgSeeds(start: number, count: number): number[] {
const out: number[] = []
let seed = start
for (let i = 0; i < count; i += 1) {
seed = (Math.imul(seed, 1103515245) + 12345) >>> 0
out.push(seed)
}
return out
}
/** The game seeds the bake generates its three Act I copies from (scripts/pack-act-assets.ts actGameSeed). */
const BAKE_SEEDS = [0x5eed0100, 0x5eed0101, 0x5eed0102]
/** Fully generated and activated: the oracle fixture seed, the bake's seeds and pseudo-random ones. */
const SEEDS = [0x12345678, ...BAKE_SEEDS, ...lcgSeeds(0x0badf00d, 12)]
/** How many of SEEDS also get the (slow) collision-scene checks. */
const SCENE_SEEDS = 6
/** Act layout only, for the size sweep. */
const LAYOUT_SEEDS = lcgSeeds(0x2468ace1, 256)
// DRLGOUTWILD_InitAct1OutdoorLevel (DrlgOutWild.cpp:212-220).
/** LEVEL_COLDPLAINS..LEVEL_BLACKMARSH: DRLGOUTDOORS_SpawnAct12Waypoint. */
const WAYPOINT_LEVELS = new Set([3, 4, 5, 6])
/** LEVEL_BLOODMOOR..LEVEL_TAMOEHIGHLAND: DRLGOUTDOORS_SpawnAct12Shrines(pLevel, 5). */
const SHRINE_LEVELS = new Set([2, 3, 4, 5, 6, 7])
const SHRINES_PER_LEVEL = 5
/** Grid-1 cell flags: waypoint 0x10000 / 0x20000 (DrlgOutdoors.cpp:520, :565), shrine 0x1000..0x8000 (:581). */
const GRID1_WAYPOINT = 0x30000
const GRID1_SHRINE = 0xf000
/** Objects.txt SubClass bits. */
const SUBCLASS_SHRINE = 0x01
const SUBCLASS_WAYPOINT = 0x40
/** D2PresetUnitStrc nUnitType. */
const UNIT_MONSTER = 1
const UNIT_OBJECT = 2
/** MonStats.txt hcIdx 266 (navi): Flavie, part of the Blood Moor's camp transition preset. */
const MONSTATS_FLAVIE = 266
/** The fixed monsters each level's presets carry (drlg-map.ts landmarks). */
const LANDMARKS: Readonly<Record<number, readonly string[]>> = {
2: [],
3: ['Bishibosh'],
4: ['Rakanishu'],
5: ['Treehead WoodFist'],
6: [],
7: [],
17: ['Blood Raven'],
39: ['The Cow King'],
}
/**
* How close main-region ground must be to a SuperUnique's preset position, in sub-tiles. Some stand on
* blocked ground (Rakanishu inside the Cairn Stones: up to 10 sub-tiles measured); D2Game places the
* monster on free ground around its preset, and that ground must be reachable.
*/
const LANDMARK_REACH = 3 * SUB_TILES_PER_TILE
const numeric = (a: number, b: number): number => a - b
function hex(seed: number): string {
return `0x${seed.toString(16).padStart(8, '0')}`
}
/** The stretch two act-layout rectangles share along one side of `a`, or null if they do not touch there. */
function sharedStretch(a: DumpCoord, b: DumpCoord, side: string): { lo: number; hi: number } | null {
const [ax, ay, aw, ah] = a
const [bx, by, bw, bh] = b
let touching: boolean
let lo: number
let hi: number
if (side === 'east' || side === 'west') {
touching = side === 'east' ? ax + aw === bx : bx + bw === ax
lo = Math.max(ay, by)
hi = Math.min(ay + ah, by + bh)
} else {
touching = side === 'south' ? ay + ah === by : by + bh === ay
lo = Math.max(ax, bx)
hi = Math.min(ax + aw, bx + bw)
}
return touching && hi > lo ? { lo, hi } : null
}
describe.skipIf(!hasMpq)('Act I outdoor DRLG port: level invariants over many seeds', () => {
let data: DrlgMpqData
let superUniqueIds: string[]
let worldGraph: WorldGraph
const dt1Cache = new Map<string, Dt1>()
beforeAll(async () => {
const archives = new MountedArchives()
for (const name of MOUNTS) archives.add(name, await MpqArchive.open(await fileSource(join(ARCHIVE_DIR, name))))
data = await loadDrlgMpqData(member => archives.read(member), 1)
superUniqueIds = drlgSuperUniqueIds(parseTable(await archives.read(SUPERUNIQUES_TXT)), data.tables)
worldGraph = buildWorldGraph(parseLevelRows(parseTable(await archives.read(LEVELS_TXT))))
}, 120_000)
function generate(seed: number): DrlgDump {
return dumpAct1(createDrlgEnv(data.source, data.tables), seed, LEVELS, { difficulty: 0, isolated: false })
}
function mapLevel(dump: DrlgDump, levelId: number): { input: DrlgLevelInput; map: DrlgLevelMap } {
const input = drlgLevelInputFromDump(dump, levelId, data.tables)
const map = buildDrlgLevelMap(input, { tables: data.tables, dt1: drlgLevelDt1s(input, data.source, dt1Cache), superUniqueIds })
return { input, map }
}
function library(name: string): Dt1 {
let lib = dt1Cache.get(name)
if (lib === undefined) {
lib = decodeDt1(data.source.readFile(name))
dt1Cache.set(name, lib)
}
return lib
}
it('takes the outdoor level list from Levels.txt', () => {
expect(act1OutdoorLevelIds(data.tables)).toEqual(LEVELS)
})
it(`sizes every level as D2 does on ${LAYOUT_SEEDS.length} act layouts`, () => {
const env = createDrlgEnv(data.source, data.tables)
const bloodMoor = new Set<string>()
for (const seed of LAYOUT_SEEDS) {
const { act } = dumpAct1(env, seed, LEVELS, { actOnly: true })
for (const levelId of LEVELS) {
const level = act.find(l => l.id === levelId)
expect(level, `${hex(seed)}: level ${levelId} is not in the act`).toBeDefined()
const [, , width, height] = level!.coord
if (levelId === 2) {
// The Blood Moor's link callback (sub_6FD81950, DrlgOutPlace.cpp:1310; gAct1WildernessDrlgLink,
// :33) replaces its Levels.txt size with 96x56 or 56x96, whichever way it runs from the camp.
bloodMoor.add(`${width}x${height}`)
continue
}
// Every other level keeps Levels.txt SizeX/SizeY (DRLGOUTPLACE_CreateLevelConnections).
const def = DATATBLS_GetLevelDefRecord(data.tables, levelId)
expect([width, height], `${hex(seed)} level ${levelId}`).toEqual([def.dwSizeX[0], def.dwSizeY[0]])
}
}
expect([...bloodMoor].sort()).toEqual(['56x96', '96x56'])
}, 120_000)
it('generates the same act from the same seed', () => {
expect(JSON.stringify(generate(BAKE_SEEDS[0]!))).toBe(JSON.stringify(generate(BAKE_SEEDS[0]!)))
}, 60_000)
it('generates a different level from every seed', () => {
const env = createDrlgEnv(data.source, data.tables)
const grids = new Map<number, Set<string>>(LEVELS.map(id => [id, new Set<string>()]))
for (const seed of SEEDS) {
const dump = dumpAct1(env, seed, LEVELS, { difficulty: 0, isolated: false, skipActivation: true })
for (const level of dump.levels) grids.get(level.id)!.add(JSON.stringify(level.levelGrid.grids))
}
for (const [levelId, distinct] of grids) expect(distinct.size, `level ${levelId}`).toBe(SEEDS.length)
}, 60_000)
SEEDS.forEach((seed, index) => {
const withScene = index < SCENE_SEEDS
it(`seed ${hex(seed)}: population and links${withScene ? ', and reachability in the collision scene' : ''}`, () => {
const dump = generate(seed)
const act = new Map(dump.act.map(l => [l.id, l]))
const maps = new Map(LEVELS.map(levelId => [levelId, mapLevel(dump, levelId)]))
for (const levelId of LEVELS) {
const what = `${hex(seed)} level ${levelId}`
const { input, map } = maps.get(levelId)!
// ---- the canvas ----
const layout = act.get(levelId)!.coord
expect([map.coord.x, map.coord.y, map.coord.width, map.coord.height], what).toEqual(layout)
expect(map.ds1.width, what).toBe(map.coord.width + 1)
expect(map.ds1.height, what).toBe(map.coord.height + 1)
// ---- population ----
const cells = dump.levels.find(l => l.id === levelId)!.levelGrid.grids[1]!.cells
expect(cells.filter(c => (c & GRID1_WAYPOINT) !== 0).length, `${what}: waypoint cells`).toBe(WAYPOINT_LEVELS.has(levelId) ? 1 : 0)
expect(cells.filter(c => (c & GRID1_SHRINE) !== 0).length, `${what}: shrine cells`)
.toBe(SHRINE_LEVELS.has(levelId) ? SHRINES_PER_LEVEL : 0)
const objects = input.units.filter(u => u.type === UNIT_OBJECT && u.index >= 0 && u.index < data.tables.objectSubClass.length)
const waypoints = objects.filter(u => (objectSubClass(data.tables, u.index) & SUBCLASS_WAYPOINT) !== 0)
const shrines = objects.filter(u => (objectSubClass(data.tables, u.index) & SUBCLASS_SHRINE) !== 0)
// The world graph registers the waypoint from Levels.txt `Waypoint`; the map must have it.
const hasWaypoint = worldGraph.levels.get(levelId)!.waypoint !== 255
expect(hasWaypoint, what).toBe(WAYPOINT_LEVELS.has(levelId))
expect(waypoints, `${what}: waypoint objects`).toHaveLength(hasWaypoint ? 1 : 0)
if (SHRINE_LEVELS.has(levelId)) {
expect(shrines.length, `${what}: shrine objects`).toBeGreaterThanOrEqual(1)
expect(shrines.length, `${what}: shrine objects`).toBeLessThanOrEqual(SHRINES_PER_LEVEL)
} else {
expect(shrines, `${what}: shrine objects`).toHaveLength(0)
}
const flavie = input.units.filter(u => u.type === UNIT_MONSTER && u.index === MONSTATS_FLAVIE)
expect(flavie, `${what}: Flavie`).toHaveLength(levelId === 2 ? 1 : 0)
expect(map.landmarks.map(l => l.id).sort(), `${what}: landmarks`).toEqual([...LANDMARKS[levelId]!].sort())
for (const unit of [...input.units, ...map.landmarks]) {
expect(unit.subX >= 0 && unit.subY >= 0 && unit.subX < map.ds1.width * SUB_TILES_PER_TILE
&& unit.subY < map.ds1.height * SUB_TILES_PER_TILE, `${what}: unit at ${unit.subX},${unit.subY} is on the canvas`).toBe(true)
}
// ---- links: exactly the world graph's, on shared edges, mirrored by outdoor neighbours ----
const gates = map.entrances.filter(e => e.kind === 'gate')
const warps = map.entrances.filter(e => e.kind === 'preset')
const graphEdges = edgesFrom(worldGraph, levelId)
expect(gates.map(e => e.toLevelId).sort(numeric), `${what}: seams`)
.toEqual(graphEdges.filter(e => e.kind === 'seamless').map(e => e.to).sort(numeric))
expect([...new Set(warps.map(e => e.toLevelId))].sort(numeric), `${what}: warps`)
.toEqual(graphEdges.filter(e => e.kind === 'warp').map(e => e.to).sort(numeric))
expect(warps.length, `${what}: one warp unit per warp`).toBe(new Set(warps.map(e => e.toLevelId)).size)
for (const gate of gates) {
const seam = `${what} seam to ${gate.toLevelId}`
const neighbour = act.get(gate.toLevelId)
expect(neighbour, `${seam}: neighbour in the act`).toBeDefined()
const shared = sharedStretch(layout, neighbour!.coord, gate.side!)
expect(shared, `${seam}: the ${gate.side} edge touches the neighbour`).not.toBeNull()
const horizontal = gate.side === 'north' || gate.side === 'south'
const offset = horizontal ? map.coord.x : map.coord.y
const from = offset + gate.span!.from
const to = offset + gate.span!.to
expect(from >= shared!.lo && to <= shared!.hi && from < to, `${seam}: opening ${from}..${to} on the shared stretch`).toBe(true)
const other = maps.get(gate.toLevelId)
if (other === undefined) continue // the camp or the Monastery Gate: not an outdoor level
const back = other.map.entrances.filter(e => e.kind === 'gate' && e.toLevelId === levelId)
expect(back, `${seam}: mirrored`).toHaveLength(1)
expect(back[0]!.side, `${seam}: mirrored`).toBe(oppositeSide(gate.side!))
const backOffset = horizontal ? other.map.coord.x : other.map.coord.y
expect([backOffset + back[0]!.span!.from, backOffset + back[0]!.span!.to], `${seam}: same opening from both sides`).toEqual([from, to])
}
if (!withScene) continue
// ---- reachability, in the collision scene the bake builds (bakeDs1Variant / buildSceneLinks) ----
const copy = BAKE_SEEDS.indexOf(seed)
const scene = buildIsoMapScene(map.ds1, map.dt1Names.map(library), 0x5eed_1000 + levelId * 10 + (copy < 0 ? index % 3 : copy) + 1)
const region = largestWalkableRegion(scene)
const reachable = (x: number, y: number): boolean => region[y * scene.gridWidth + x] === 1
let walkable = 0
let inRegion = 0
for (let at = 0; at < scene.blocked.length; at += 1) {
if (scene.blocked[at] === 0) walkable += 1
if (region[at] === 1) inRegion += 1
}
// One play area: the ground walled off from it is a sliver (at most ~1% measured).
expect(inRegion / walkable, `${what}: share of the walkable ground in the main region`).toBeGreaterThan(0.95)
const openings: BorderOpening[] = []
for (const gate of gates) {
const range = { from: gate.span!.from * SUB_TILES_PER_TILE, to: gate.span!.to * SUB_TILES_PER_TILE }
const opening = findBorderOpening(scene, gate.side!, region, undefined, range)
expect(opening, `${what}: walkable opening for the seam to ${gate.toLevelId}`).not.toBeNull()
expect(opening!.inset, `${what}: the seam to ${gate.toLevelId} opens at the border`).toBeLessThanOrEqual(SUB_TILES_PER_TILE)
expect(reachable(opening!.arriveX, opening!.arriveY), `${what}: arrival from ${gate.toLevelId}`).toBe(true)
openings.push(opening!)
}
for (const warp of warps) {
const { subX, subY } = warp.warp!
expect(triggerableFrom(scene, region, subX, subY, WARP_TRIGGER_SUBTILES), `${what}: warp to ${warp.toLevelId} at ${subX},${subY}`).toBe(true)
}
for (const wp of waypoints) {
expect(triggerableFrom(scene, region, wp.subX, wp.subY, WARP_TRIGGER_SUBTILES), `${what}: waypoint at ${wp.subX},${wp.subY}`).toBe(true)
}
for (const lm of map.landmarks) {
expect(nearestWalkable(scene, lm.subX, lm.subY, LANDMARK_REACH, region), `${what}: ${lm.id} at ${lm.subX},${lm.subY}`).not.toBeNull()
}
// The spawn is on the main region: from the seams' arrival points, and with nothing to go by
// (the Moo Moo Farm has no seam at all).
for (const spawn of [findIsoSpawn(scene, { entrances: openings }), findIsoSpawn(scene)]) {
expect(spawn, `${what}: spawn`).not.toBeNull()
const at = subTileAt(scene, spawn!.x, spawn!.y)
expect(at.inBounds && reachable(at.subX, at.subY), `${what}: spawn at ${at.subX},${at.subY} on the main region`).toBe(true)
}
}
}, 60_000)
})
})

122
tests/drlg-act1-oracle.test.ts
View File

@ -1,32 +1,11 @@
/**
* Act I outdoor DRLG: bit-exact parity of the TypeScript port (src/game/drlg) with the native D2MOO
* oracle (tools/d2moo-oracle), and of the level maps the bake makes from it (src/game/drlg/drlg-map.ts).
*
* - The committed fixtures are the oracle's schema-3 dumps of four game seeds: 0x12345678 and the
* three seeds the bake generates Act I from (0x5eed0100..0102). The port, fed from the MPQ data
* exactly as the bake feeds it (scripts/lib/drlg-mpq-source.ts), must reproduce every stage: the act
* layout, the level grids, the rooms, every room's activation and its tile lists.
* - The oracle's dump and the port's dump then go through the same adapter; the canvases, DT1 library
* lists, entrances and landmarks must be identical, so a baked map is the map the oracle generates.
* - With the oracle binary built, one seed is re-run live and its RNG trace compared roll by roll.
* - Anti-cheat guards keep fixture data, seed literals and level-name branches out of the port.
*
* The MPQ data (samples/d2) is required: without it the suite fails instead of skipping.
*/
import { existsSync, readdirSync, readFileSync } from 'node:fs'
import { join, resolve } from 'node:path'
import { gunzipSync } from 'node:zlib'
import { beforeAll, describe, expect, it } from 'vitest'
import type { Dt1 } from '../src/formats/dt1.ts'
import { parseTable } from '../src/game/acts.ts'
import { describe, expect, it } from 'vitest'
import { dumpLevelToDs1 } from '../src/game/drlg/adapter.ts'
import { DrlgTraceWriter, dumpAct1, type DrlgDump } from '../src/game/drlg/drlg-dump.ts'
import { act1OutdoorLevelIds, buildDrlgLevelMap, drlgLevelInputFromDump, type DrlgLevelMap } from '../src/game/drlg/drlg-map.ts'
import { createDrlgEnv } from '../src/game/drlg/drlg-source.ts'
import { loadDrlgTables } from '../src/game/drlg/drlg-tables.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { MountedArchives } from '../src/mpq/mount.ts'
import { drlgLevelDt1s, drlgSuperUniqueIds, loadDrlgMpqData, type DrlgMpqData } from '../scripts/lib/drlg-mpq-source.ts'
import {
firstDiff,
firstTraceDivergence,
@ -37,83 +16,41 @@ import {
runOracle,
} from '../scripts/lib/drlg-oracle.ts'
/** The Act I levels Levels.txt generates with the outdoor DRLG (checked against the table below). */
const ACT1_OUTDOOR_LEVELS = [2, 3, 4, 5, 6, 7, 17, 39]
const FIXTURE_DIR = resolve(import.meta.dirname, 'fixtures/d2moo-oracle')
const FIXTURE_SEEDS = [0x12345678, 0x5eed0100, 0x5eed0101, 0x5eed0102]
const ARCHIVE_DIR = resolve(import.meta.dirname, '../samples/d2')
const MOUNTS = ['d2char.mpq', 'd2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq'] as const
const SUPERUNIQUES_TXT = 'data\\global\\excel\\SuperUniques.txt'
function hexSeed(seed: number): string {
return seed.toString(16).padStart(8, '0')
}
function readFixture(seed: number): DrlgDump {
const doc = JSON.parse(gunzipSync(readFileSync(resolve(FIXTURE_DIR, `act1-seed-${hexSeed(seed)}.json.gz`))).toString('utf8')) as DrlgDump
delete doc.oracle
return doc
}
/** What the bake takes from a mapped level: the canvas and everything it links or places. */
function bakedPart(map: DrlgLevelMap): unknown {
return { ds1: map.ds1, dt1Names: map.dt1Names, entrances: map.entrances, landmarks: map.landmarks, stats: map.stats }
}
describe('Act I outdoor DRLG 1:1 parity against native D2MOO oracle', () => {
let data: DrlgMpqData
let superUniqueIds: string[]
const dt1Cache = new Map<string, Dt1>()
beforeAll(async () => {
const missing = MOUNTS.filter(name => !existsSync(join(ARCHIVE_DIR, name)))
if (missing.length > 0) throw new Error(`the DRLG parity suite needs the 1.13c archives in ${ARCHIVE_DIR}; missing ${missing.join(', ')}`)
const archives = new MountedArchives()
for (const name of MOUNTS) archives.add(name, await MpqArchive.open(await fileSource(join(ARCHIVE_DIR, name))))
data = await loadDrlgMpqData(member => archives.read(member), 1)
superUniqueIds = drlgSuperUniqueIds(parseTable(await archives.read(SUPERUNIQUES_TXT)), data.tables)
}, 120_000)
function mapLevel(dump: DrlgDump, levelId: number): DrlgLevelMap {
const input = drlgLevelInputFromDump(dump, levelId, data.tables)
return buildDrlgLevelMap(input, { tables: data.tables, dt1: drlgLevelDt1s(input, data.source, dt1Cache), superUniqueIds })
}
it('takes the outdoor level list from Levels.txt', () => {
expect(act1OutdoorLevelIds(data.tables)).toEqual(ACT1_OUTDOOR_LEVELS)
})
const source = fsDrlgSource(ORACLE_DATA)
const tables = loadDrlgTables(source)
for (const seed of FIXTURE_SEEDS) {
const hex = hexSeed(seed)
it(`seed 0x${hex}: the MPQ-fed port reproduces every oracle stage, and both map to identical canvases`, () => {
const expected = readFixture(seed)
const actual = dumpAct1(createDrlgEnv(data.source, data.tables), seed, ACT1_OUTDOOR_LEVELS, {
const hex = seed.toString(16).padStart(8, '0')
it(`matches committed oracle fixture for seed 0x${hex} across all stages including room activation and adapted Ds1 canvas`, () => {
const fixturePath = resolve(FIXTURE_DIR, `act1-seed-${hex}.json.gz`)
const expected = JSON.parse(gunzipSync(readFileSync(fixturePath)).toString('utf8')) as DrlgDump
delete expected.oracle
const actual = dumpAct1(createDrlgEnv(source, tables), seed, ACT1_OUTDOOR_LEVELS, {
difficulty: 0,
isolated: false,
})
const diff = firstDiff(expected, actual, '$')
if (diff) throw new Error(`Mismatch on seed 0x${hex}: ${formatDiff(diff)}`)
for (const levelId of ACT1_OUTDOOR_LEVELS) {
const oracleMap = mapLevel(expected, levelId)
const portMap = mapLevel(actual, levelId)
const canvasDiff = firstDiff(bakedPart(oracleMap), bakedPart(portMap), `$.L${levelId}`)
if (canvasDiff) throw new Error(`Canvas mismatch on seed 0x${hex}: ${formatDiff(canvasDiff)}`)
// The canvas is the level's tile rectangle (plus the closing row/column a DS1 has), every tile
// D2 placed is on it, and every level link and warp of the level became an entrance.
const { coord, ds1, stats } = portMap
expect(ds1.width).toBe(coord.width + 1)
expect(ds1.height).toBe(coord.height + 1)
expect(stats.floors).toBeGreaterThan(0)
expect(stats.walls).toBeGreaterThan(0)
const level = actual.levels.find(l => l.id === levelId)!
const orths = level.levelGrid!.roomData.length
const warpUnits = level.activation.reduce((n, room) => n + room.mapTiles.units.filter(u => u[0] === 5).length, 0)
expect(portMap.entrances.filter(e => e.kind === 'gate')).toHaveLength(orths)
expect(portMap.entrances.filter(e => e.kind === 'preset')).toHaveLength(warpUnits)
if (diff) {
throw new Error(`Mismatch on seed 0x${hex}: ${formatDiff(diff)}`)
}
}, 60_000)
expect(diff).toBeNull()
for (let i = 0; i < ACT1_OUTDOOR_LEVELS.length; i += 1) {
const expectedCanvas = dumpLevelToDs1(expected.act, expected.levels[i]!, tables, { seed })
const actualCanvas = dumpLevelToDs1(actual.act, actual.levels[i]!, tables, { seed })
const canvasDiff = firstDiff(expectedCanvas, actualCanvas, `$.canvas[L${ACT1_OUTDOOR_LEVELS[i]}]`)
if (canvasDiff) {
throw new Error(`Canvas mismatch on seed 0x${hex}: ${formatDiff(canvasDiff)}`)
}
expect(actualCanvas.level.width).toBeGreaterThan(0)
expect(actualCanvas.level.height).toBeGreaterThan(0)
}
})
}
it.skipIf(!existsSync(ORACLE_BIN))('matches live native oracle + RNG trace on seed 0x12345678', () => {
@ -127,9 +64,8 @@ describe('Act I outdoor DRLG 1:1 parity against native D2MOO oracle', () => {
trace: true,
})
delete oracleRun.doc.oracle
const source = fsDrlgSource(ORACLE_DATA)
const trace = new DrlgTraceWriter()
const actual = dumpAct1(createDrlgEnv(source, loadDrlgTables(source)), seed, ACT1_OUTDOOR_LEVELS, {
const actual = dumpAct1(createDrlgEnv(source, tables), seed, ACT1_OUTDOOR_LEVELS, {
difficulty: 0,
isolated: false,
trace,
@ -140,7 +76,7 @@ describe('Act I outdoor DRLG 1:1 parity against native D2MOO oracle', () => {
}
const traceDiff = firstTraceDivergence(oracleRun.trace ?? [], trace.lines)
expect(traceDiff).toBeNull()
}, 60_000)
})
it('enforces anti-cheat guards on src/game/drlg/* (no fixture reads, no seed literal branches, no levelName conditionals)', () => {
const drlgDir = resolve(import.meta.dirname, '../src/game/drlg')
@ -152,7 +88,9 @@ describe('Act I outdoor DRLG 1:1 parity against native D2MOO oracle', () => {
expect(content, `${file} must not reference act1-seed-`).not.toContain('act1-seed-')
expect(content, `${file} must not hardcode fixture seed 0x12345678`).not.toMatch(/0x12345678/i)
expect(content, `${file} must not hardcode fixture seed 0x5eed`).not.toMatch(/0x5eed/i)
expect(content, `${file} must not branch on levelName`).not.toContain('levelName')
if (file !== 'adapter.ts') {
expect(content, `${file} must not branch on levelName`).not.toContain('levelName')
}
}
})
})

14
tests/drlg-alias-guard.test.ts
View File

@ -15,11 +15,9 @@ describe("DRLG Export and Alias Guard (Issue #81)", () => {
expect(exports).not.toContain("DRLGROOMTILE_ComputeNeighborMask")
expect(exports).not.toContain("DRLGROOMTILE_ApplyTransitions")
// The invented 8-neighbour ground-transition pass (computeNeighborMask /
// applyGroundTransitions) was removed with the Act I DRLG port: Act I
// outdoor maps now come from the 1:1 D2MOO port in src/game/drlg.
expect((wilderness as Record<string, unknown>).computeNeighborMask).toBeUndefined()
expect((wilderness as Record<string, unknown>).applyGroundTransitions).toBeUndefined()
// The genuine custom functions should remain exported as local names
expect(typeof (wilderness as Record<string, unknown>).computeNeighborMask).toBe("function")
expect(typeof (wilderness as Record<string, unknown>).applyGroundTransitions).toBe("function")
})
test("src/game/wilderness.ts keeps single export of DRLGOUTDOORS_SpawnAct12Waypoint", () => {
@ -73,9 +71,9 @@ describe("DRLG Export and Alias Guard (Issue #81)", () => {
const levelLinksSource = readFileSync(resolve(__dirname, "../src/game/level-links.ts"), "utf-8")
expect(levelLinksSource).not.toMatch(/export\s+(?:const|function|let|var)\s+DRLGOUTDOORS_SpawnAct12Waypoint\b/)
// The invented (non-Blizzard) ground-transition helpers must not come back.
// Ensure wilderness.ts has doc comments clarifying custom web port algorithms
const wildernessSource = readFileSync(resolve(__dirname, "../src/game/wilderness.ts"), "utf-8")
expect(wildernessSource).not.toMatch(/function computeNeighborMask\b/)
expect(wildernessSource).not.toMatch(/function applyGroundTransitions\b/)
expect(wildernessSource).toMatch(/NOT a Blizzard original[\s\S]*?function computeNeighborMask/)
expect(wildernessSource).toMatch(/NOT a Blizzard original[\s\S]*?function applyGroundTransitions/)
})
})

BIN
tests/fixtures/d2moo-oracle/act1-seed-12345678.json.gz vendored
View File

Binary file not shown.

BIN
tests/fixtures/d2moo-oracle/act1-seed-5eed0100.json.gz vendored
View File

Binary file not shown.

BIN
tests/fixtures/d2moo-oracle/act1-seed-5eed0101.json.gz vendored
View File

Binary file not shown.

BIN
tests/fixtures/d2moo-oracle/act1-seed-5eed0102.json.gz vendored
View File

Binary file not shown.

9
tests/input-controls.test.ts
View File

@ -1746,7 +1746,7 @@ describe('Warp & Entrance Mouse-Click Transitions, KeyG Removal & Overhead Label
}
})
it('verifies all 365 baked map packs (495 SceneWarp and 166 SceneEntrance entries) resolve valid Chinese destination badges, hitboxes, and arrival triggers', () => {
it('verifies all 365 baked map packs (495 SceneWarp and 172 SceneEntrance entries) resolve valid Chinese destination badges, hitboxes, and arrival triggers', () => {
const baseDir = path.resolve(process.cwd(), 'samples/d2-packs')
const indexPath = path.join(baseDir, 'index.json')
const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'))
@ -1810,12 +1810,7 @@ describe('Warp & Entrance Mouse-Click Transitions, KeyG Removal & Overhead Label
expect(warpCount).toBe(495)
expect(nonZeroBoxWarps).toBe(464)
expect(zeroBoxWarps).toBe(31)
// 166 since the Act I outdoor levels come from the DRLG port: D2 has no
// Stony Field <-> Dark Wood seam (DrlgOutPlace.cpp gAct1WildernessDrlgLink /
// gAct1MonasteryDrlgLink put them in separate groups, joined only through
// the Underground Passage), so the 2 seam entrances the old generator
// invented in each of the 3 act copies are gone.
expect(entranceCount).toBe(166)
expect(entranceCount).toBe(172)
})
it('ignores unresolved warps and entrances (toLevelId <= 0) for overhead badges, hover, left-click, and Telekinesis', () => {

4
tests/packed-entity-art.test.ts
View File

@ -104,14 +104,14 @@ describe('offline pre-baked entity atlases & full Act 1..5 pack index (Issues #3
const charR8 = readFileSync(charR8Path)
expect(charR8.byteLength).toBe(charMeta.width * charMeta.height)
// Check all 66 unique monster specs exist as global .r8 files (EC = Hell Bovine, Moo Moo Farm)
// Check all 65 unique monster specs exist as global .r8 files
const uniqueSpecs = new Set<string>()
for (let act = 1; act <= 5; act += 1) {
for (const spec of ACT_MONSTER_SPECS[act] ?? []) {
uniqueSpecs.add(`${spec.token.toLowerCase()}-${spec.weapon.toLowerCase()}`)
}
}
expect(uniqueSpecs.size).toBe(66)
expect(uniqueSpecs.size).toBe(65)
for (const key of uniqueSpecs) {
const slug = `monster-${key}`

19
tests/shadow-rendering.test.ts
View File

@ -10,7 +10,7 @@
* to floor tiles, without wall vertical block adjustment (`minBlockY + 80`).
* 3. `IsoMapScene` exposes `shadows: readonly IsoDraw[]`, sorted by isometric depth.
* 4. Sub-tile collision flags of shadow layers are unioned into `collisionMasks` and `blocked`.
* 5. Real Act 1 presets (Ruin2.ds1) carry shadow tiles that resolve to DT1 type 13.
* 5. Blood Moor and Act 1 wilderness levels include Tree Fill and shadow-bearing presets.
*/
import { describe, it, expect } from 'vitest'
@ -20,6 +20,11 @@ import {
ORTHO_CELL_WIDTH,
} from '../src/game/d2map.ts'
import type { Ds1 } from '../src/formats/ds1.ts'
import {
BLOOD_MOOR_RIVER_PRESETS,
BLOOD_MOOR_POND_PRESETS,
SPECIAL_PRESETS_BY_LEVEL,
} from '../src/game/wilderness.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { MountedArchives } from '../src/mpq/mount.ts'
import { fileSource } from '../src/mpq/file-source.ts'
@ -281,6 +286,18 @@ describe('Shadow Layer (DT1 Type 13) Rendering & Parity', () => {
}
})
it('Blood Moor and Act 1 wilderness preset lists include shadow-bearing presets (Ruin, Tree Fill)', () => {
expect(BLOOD_MOOR_RIVER_PRESETS).toContain('Act 1 - Ruin')
expect(BLOOD_MOOR_POND_PRESETS).toContain('Act 1 - Ruin')
expect(SPECIAL_PRESETS_BY_LEVEL[2]).toContain('Act 1 - Ruin')
expect(SPECIAL_PRESETS_BY_LEVEL[3]).toContain('Act 1 - Ruin')
expect(SPECIAL_PRESETS_BY_LEVEL[4]).toContain('Act 1 - Ruin')
expect(SPECIAL_PRESETS_BY_LEVEL[5]).toContain('Act 1 - Tree Fill')
expect(SPECIAL_PRESETS_BY_LEVEL[5]).toContain('Act 1 - Ruin')
expect(SPECIAL_PRESETS_BY_LEVEL[6]).toContain('Act 1 - Ruin')
expect(SPECIAL_PRESETS_BY_LEVEL[7]).toContain('Act 1 - Ruin')
})
const mpqDir = existsSync('/usr/local/google/home/taodao/d2-data/d2data.mpq')
? '/usr/local/google/home/taodao/d2-data'
: existsSync('samples/d2/d2data.mpq')

3
tests/stress-world-placement.test.ts
View File

@ -189,8 +189,7 @@ describe('Adversarial Stress Test: resolveWorldOffsets across 100 Seeds for Acts
}
expect(failures).toEqual([])
// 18 pairs (Act 1: 7, Act 2: 5, Act 4: 3, Act 5: 3) x 100 seeds.
expect(pairsChecked).toBe(1800)
expect(pairsChecked).toBe(1900)
})
it('Act 3 Seamless Adjacency: contiguous pairs in SEAMLESS_ADJACENCY share exact boundary coordinates without tears or gaps', () => {

728
tests/wilderness-d2moo-parity.test.ts Normal file
View File

@ -0,0 +1,728 @@
/**
* Wilderness D2MOO Ground Truth Parity Test Suite (Issue #455).
*
* Verifies that outdoor wilderness level generation adheres with 100% fidelity
* to Diablo II v1.13c ground truth as established by D2MOO C++ DRLG engine
* (`D2Common/src/Drlg/`) and native binary execution (`d2moo_mapgen`).
*
* Multi-Tier Parity Coverage:
* - Tier 1: Dynamic Level Dimensions (96x56 horizontal vs 56x96 vertical) & Topology (R1)
* - Tier 2: Outer River Placement, Dual Columns (x=80, 88), and Boundary Suppression (R2)
* - Tier 3: Town Transition (TownSTrans.ds1 56x8) Anchored to Eastern River Edge (R4)
* - Tier 4: Unconditional Landmark Presets & FarAway Anti-Overlap Metric (R4)
* - Tier 5: 4-Pass Secondary Border Evolution & Interior 2x3 Forest Closures (Bord9..12) (R3)
* - Tier 6: Orthogonal Polyline Dirt Paths & Width-2 Bresenham Rasterization (R5)
*/
import { describe, it, expect, beforeAll } from 'vitest'
import { existsSync, readFileSync } from 'node:fs'
import { execFileSync } from 'node:child_process'
import { join } from 'node:path'
import { tmpdir } from 'node:os'
import { MountedArchives } from '../src/mpq/mount.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { loadActTables, parseTable, cell, tileMemberPath, type D2Table } from '../src/game/acts.ts'
import { decodeDs1, type Ds1 } from '../src/formats/ds1.ts'
import {
generateWilderness,
type WildernessPiece,
type WildernessSubstitution,
type WildernessResult,
} from '../src/game/wilderness.ts'
/* ------------------------------------------------------------------------- *
* D2MOO Data Contracts & Types
* ------------------------------------------------------------------------- */
export interface OutdoorCellJson {
readonly x: number
readonly y: number
readonly fPacked: number
readonly fStyle: number
readonly fSeq: number
readonly wPacked: number
readonly wStyle: number
readonly wSeq: number
readonly wType: number
readonly dirt: number
}
export interface D2MooRoomJson {
readonly index: number
readonly type: number
readonly tileX: number
readonly tileY: number
readonly tileW: number
readonly tileH: number
readonly mapPtr: number
readonly mapX: number
readonly mapY: number
readonly mapW: number
readonly mapH: number
readonly lvlPrestId: number
readonly pickedFile: number
readonly ds1File: string
readonly ds1Width: number
readonly ds1Height: number
readonly doorMask: number
readonly orthCount: number
readonly outdoorCells: readonly OutdoorCellJson[]
}
export interface D2MooLevelJson {
readonly levelId: number
readonly levelName: string
readonly act: number
readonly drlgType: number
readonly levelType: number
readonly seed: number
readonly posX: number
readonly posY: number
readonly width: number
readonly height: number
readonly roomCount: number
readonly rooms: readonly D2MooRoomJson[]
}
/* ------------------------------------------------------------------------- *
* Dual-Mode Execution & Fixture Loader
* ------------------------------------------------------------------------- */
const D2MOO_BIN = process.env.D2MOO_BIN ?? '/usr/local/google/home/taodao/tmp/d2moo_runner/d2moo_mapgen'
const FIXTURES_DIR = 'tests/fixtures/d2moo'
const hasD2Archives = existsSync('samples/d2/d2data.mpq')
/**
* Loads a D2MOO level layout either by executing `d2moo_mapgen` dynamically
* or by reading the pre-recorded golden fixture from `tests/fixtures/d2moo/`.
*/
export function loadOrRunD2MooLevel(levelId: number, seed: number | string): D2MooLevelJson {
const seedNum = typeof seed === 'number' ? seed : (seed.startsWith('0x') ? parseInt(seed, 16) : parseInt(seed, 10))
const seedHex = `0x${seedNum.toString(16)}`
const seedDec = seedNum.toString(10)
// 1. If native binary is present and not explicitly bypassed, run dynamically
if (existsSync(D2MOO_BIN) && process.env.D2MOO_FORCE_FIXTURE !== '1') {
try {
const tmpOut = join(tmpdir(), `d2moo_parity_${levelId}_${seedNum.toString(16)}.json`)
execFileSync(D2MOO_BIN, [String(levelId), seedHex, '0', tmpOut], { stdio: 'ignore' })
if (existsSync(tmpOut)) {
return JSON.parse(readFileSync(tmpOut, 'utf8')) as D2MooLevelJson
}
} catch {
// Fallback to pre-recorded fixture
}
}
// 2. Fallback to pre-recorded golden JSON fixture
const candidateNames = [
`level${levelId}_seed_0x${seedNum.toString(16)}.json`,
`level${levelId}_seed_${seedDec}.json`,
`level${levelId}_seed_${seedNum.toString(16)}.json`,
`level_${levelId}_seed_${seedNum.toString(16)}.json`,
]
for (const name of candidateNames) {
const p = join(FIXTURES_DIR, name)
if (existsSync(p)) {
return JSON.parse(readFileSync(p, 'utf8')) as D2MooLevelJson
}
}
throw new Error(`Neither executable d2moo_mapgen nor golden fixture found for Level ${levelId} Seed ${seedHex}`)
}
/**
* Extracts distinct preset stamp instances (deduplicating multi-room presets sharing mapPtr).
*/
export function getDistinctPresetStamps(level: D2MooLevelJson): Array<{
file: string
x: number
y: number
w: number
h: number
}> {
const seenMapPtrs = new Set<number>()
const stamps: Array<{ file: string; x: number; y: number; w: number; h: number }> = []
for (const room of level.rooms) {
if (!room.ds1File) continue
if (seenMapPtrs.has(room.mapPtr)) continue
seenMapPtrs.add(room.mapPtr)
const file = room.ds1File.split('/').pop() ?? room.ds1File
stamps.push({
file,
x: room.mapX - level.posX,
y: room.mapY - level.posY,
w: room.mapW,
h: room.mapH,
})
}
return stamps
}
/**
* Extracts absolute world tile coordinates of all dirt road cells in the level.
*/
export function getDirtRoadCells(level: D2MooLevelJson): Array<{ x: number; y: number }> {
const cells: Array<{ x: number; y: number }> = []
for (const room of level.rooms) {
for (const cellRecord of room.outdoorCells) {
if (cellRecord.dirt !== 0) {
cells.push({
x: room.tileX - level.posX + cellRecord.x,
y: room.tileY - level.posY + cellRecord.y,
})
}
}
}
return cells
}
/**
* Analyzes connectivity of road cells via 8-way BFS flood-fill.
*/
export function evaluateRoadConnectivity(cells: Array<{ x: number; y: number }>): {
totalCells: number
componentCount: number
largestComponentSize: number
} {
const cellSet = new Set(cells.map(c => `${c.x},${c.y}`))
const visited = new Set<string>()
const components: string[][] = []
for (const key of cellSet) {
if (visited.has(key)) continue
const queue = [key]
visited.add(key)
const comp = [key]
while (queue.length > 0) {
const current = queue.shift()!
const [cx, cy] = current.split(',').map(Number)
for (const [dx, dy] of [
[1, 0], [-1, 0], [0, 1], [0, -1],
[1, 1], [1, -1], [-1, 1], [-1, -1],
]) {
const neighbor = `${cx + dx},${cy + dy}`
if (cellSet.has(neighbor) && !visited.has(neighbor)) {
visited.add(neighbor)
queue.push(neighbor)
comp.push(neighbor)
}
}
}
components.push(comp)
}
return {
totalCells: cells.length,
componentCount: components.length,
largestComponentSize: components[0]?.length ?? 0,
}
}
/* ========================================================================= *
* SUITE 1: D2MOO v1.13c Ground Truth Oracle & Fixture Invariants
* ========================================================================= */
describe('Part 1: D2MOO Ground Truth Fixture & Runner Verification (Issue #455)', () => {
// --- Tier 1: Dimensions & Orientations ---
describe('Tier 1: Dynamic Level Dimensions & Topology Invariants (R1)', () => {
it('verifies horizontal 96x56 Moor layout for Seed 0x12345678', () => {
const d2moo = loadOrRunD2MooLevel(2, 0x12345678)
expect(d2moo.width).toBe(96)
expect(d2moo.height).toBe(56)
expect(d2moo.width / 8).toBe(12)
expect(d2moo.height / 8).toBe(7)
expect(d2moo.roomCount).toBe(82)
})
it('verifies horizontal 96x56 Moor layout for Seed 12345', () => {
const d2moo = loadOrRunD2MooLevel(2, 12345)
expect(d2moo.width).toBe(96)
expect(d2moo.height).toBe(56)
expect(d2moo.width / 8).toBe(12)
expect(d2moo.height / 8).toBe(7)
expect(d2moo.roomCount).toBe(84)
})
it('verifies vertical 56x96 Moor layout for Seed 1', () => {
const d2moo = loadOrRunD2MooLevel(2, 1)
expect(d2moo.width).toBe(56)
expect(d2moo.height).toBe(96)
expect(d2moo.width / 8).toBe(7)
expect(d2moo.height / 8).toBe(12)
expect(d2moo.roomCount).toBe(79)
})
it('verifies vertical 56x96 Moor layout for Seed 42', () => {
const d2moo = loadOrRunD2MooLevel(2, 42)
expect(d2moo.width).toBe(56)
expect(d2moo.height).toBe(96)
expect(d2moo.width / 8).toBe(7)
expect(d2moo.height / 8).toBe(12)
expect(d2moo.roomCount).toBe(82)
})
it('verifies Cold Plains (Level 3) fixed 80x80 layout for Seed 1', () => {
const d2moo = loadOrRunD2MooLevel(3, 1)
expect(d2moo.width).toBe(80)
expect(d2moo.height).toBe(80)
expect(d2moo.roomCount).toBe(97)
})
it('verifies Stony Field (Level 4) fixed 80x80 layout for Seed 1', () => {
const d2moo = loadOrRunD2MooLevel(4, 1)
expect(d2moo.width).toBe(80)
expect(d2moo.height).toBe(80)
expect(d2moo.roomCount).toBe(91)
})
})
// --- Tier 2: Outer River Placement ---
describe('Tier 2: Outer River Placement & Boundary Suppression (R2)', () => {
it('spawns dual-column river on eastern boundary (x=80, x=88) for Seed 0x12345678', () => {
const d2moo = loadOrRunD2MooLevel(2, 0x12345678)
const riverRooms = d2moo.rooms.filter(r => r.ds1File && r.ds1File.includes('River'))
expect(riverRooms.length).toBeGreaterThanOrEqual(12)
const uRiverRooms = riverRooms.filter(r => r.ds1File.includes('URiverC'))
const lRiverRooms = riverRooms.filter(r => r.ds1File.includes('LRiverC'))
expect(uRiverRooms.length).toBeGreaterThanOrEqual(6)
expect(lRiverRooms.length).toBeGreaterThanOrEqual(6)
// Column x = 80 (block 10, nGridWidth - 2) for URiverC
for (const room of uRiverRooms) {
expect(room.mapX - d2moo.posX).toBe(80)
}
// Column x = 88 (block 11, nGridWidth - 1) for LRiverC
for (const room of lRiverRooms) {
expect(room.mapX - d2moo.posX).toBe(88)
}
// Outer boundary tree wall suppression: no Bord*.ds1 rooms exist at x = 88 where river flows
const eastBorders = d2moo.rooms.filter(r => {
const file = r.ds1File?.split('/').pop() ?? ''
const relX = r.mapX - d2moo.posX
return file.startsWith('Bord') && relX === 88
})
expect(eastBorders.length).toBe(0)
})
it('spawns dual-column river on eastern boundary (x=80, x=88) for Seed 12345', () => {
const d2moo = loadOrRunD2MooLevel(2, 12345)
const uRiverRooms = d2moo.rooms.filter(r => r.ds1File && r.ds1File.includes('URiverC'))
const lRiverRooms = d2moo.rooms.filter(r => r.ds1File && r.ds1File.includes('LRiverC'))
expect(uRiverRooms.length).toBeGreaterThanOrEqual(6)
expect(lRiverRooms.length).toBeGreaterThanOrEqual(6)
for (const room of uRiverRooms) expect(room.mapX - d2moo.posX).toBe(80)
for (const room of lRiverRooms) expect(room.mapX - d2moo.posX).toBe(88)
})
})
// --- Tier 3: Town Transition Alignment ---
describe('Tier 3: Town Transition Alignment & River Edge Anchoring (R4)', () => {
it('places TownSTrans.ds1 (56x8) anchored to East river at (40, 0) for Seed 0x12345678', () => {
const d2moo = loadOrRunD2MooLevel(2, 0x12345678)
const townRoom = d2moo.rooms.find(r => r.ds1File && r.ds1File.includes('TownSTrans'))
expect(townRoom).toBeDefined()
expect(townRoom!.mapX - d2moo.posX).toBe(40)
expect(townRoom!.mapY - d2moo.posY).toBe(0)
expect(townRoom!.mapW).toBe(56)
expect(townRoom!.mapH).toBe(8)
// 40 + 56 = 96: transition extends exactly to the eastern river edge (x = 80..96)
expect(townRoom!.mapX - d2moo.posX + townRoom!.mapW).toBe(d2moo.width)
})
})
// --- Tier 4: Landmark Presets & FarAway Anti-Overlap Metric ---
describe('Tier 4: Complete Landmark Presets & FarAway Distribution (R4)', () => {
it('unconditionally places all 5 canonical landmark categories in Blood Moor (Seed 0x12345678)', () => {
const d2moo = loadOrRunD2MooLevel(2, 0x12345678)
const uniquePresets = new Set(d2moo.rooms.map(r => r.ds1File.split('/').pop()).filter(Boolean))
expect(uniquePresets.has('DenEnt.ds1')).toBe(true)
expect(uniquePresets.has('Pond1.ds1')).toBe(true)
expect(uniquePresets.has('Cott1.ds1')).toBe(true)
expect(uniquePresets.has('Circle.ds1')).toBe(true)
expect(uniquePresets.has('Clover.ds1')).toBe(true)
})
it('verifies zero spatial overlap across all distinct preset stamps', () => {
for (const [lvl, s] of [
[2, 0x12345678],
[2, 12345],
[2, 1],
[2, 42],
[3, 1],
[4, 1],
] as const) {
const d2moo = loadOrRunD2MooLevel(lvl, s)
const stamps = getDistinctPresetStamps(d2moo)
for (let i = 0; i < stamps.length; i += 1) {
for (let j = i + 1; j < stamps.length; j += 1) {
const a = stamps[i]!
const b = stamps[j]!
const xOverlap = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x))
const yOverlap = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y))
expect(
xOverlap > 0 && yOverlap > 0,
`Overlap detected in Level ${lvl} Seed ${s} between ${a.file} and ${b.file}`,
).toBe(false)
}
}
}
})
it('verifies FarAway metric (|dx| + 2*|dy|) places Den of Evil distant from Town Gate', () => {
const d2moo = loadOrRunD2MooLevel(2, 0x12345678)
const townRoom = d2moo.rooms.find(r => r.ds1File.includes('TownSTrans'))!
const denRoom = d2moo.rooms.find(r => r.ds1File.includes('DenEnt'))!
const townX = townRoom.mapX - d2moo.posX
const townY = townRoom.mapY - d2moo.posY
const denX = denRoom.mapX - d2moo.posX
const denY = denRoom.mapY - d2moo.posY
// FarAway Manhattan metric: |dx| + 2*|dy|
const distance = Math.abs(denX - townX) + 2 * Math.abs(denY - townY)
expect(distance).toBeGreaterThanOrEqual(48)
})
it('verifies canonical presets in Cold Plains (Level 3) and Stony Field (Level 4)', () => {
const l3 = loadOrRunD2MooLevel(3, 1)
const l3Presets = new Set(l3.rooms.map(r => r.ds1File.split('/').pop()).filter(Boolean))
expect(l3Presets.has('CaveDr1.ds1')).toBe(true)
expect(l3Presets.has('FallCmpBish.ds1')).toBe(true)
expect(l3Presets.has('Cott1A.ds1')).toBe(true)
expect(l3Presets.has('Circle.ds1')).toBe(true)
expect(l3Presets.has('Clover.ds1')).toBe(true)
const l4 = loadOrRunD2MooLevel(4, 1)
const l4Presets = new Set(l4.rooms.map(r => r.ds1File.split('/').pop()).filter(Boolean))
expect(l4Presets.has('cairn2.ds1')).toBe(true)
expect(l4Presets.has('clfcave.ds1')).toBe(true)
expect(l4Presets.has('tome.ds1')).toBe(true)
expect(l4Presets.has('Corral1.ds1')).toBe(true)
expect(l4Presets.has('FallCmp.ds1')).toBe(true)
})
})
// --- Tier 5: 4-Pass Secondary Borders & 2x3 Forest Closures ---
describe('Tier 5: 4-Pass Secondary Border Evolution & 2x3 Closures (R3)', () => {
it('spawns Bord5..8 outer peninsulas and Bord9..12 interior 2x3 forest closures', () => {
for (const [lvl, s] of [
[2, 0x12345678],
[2, 12345],
[2, 1],
[2, 42],
[3, 1],
[4, 1],
] as const) {
const d2moo = loadOrRunD2MooLevel(lvl, s)
const files = d2moo.rooms.map(r => r.ds1File.split('/').pop()).filter(Boolean) as string[]
const peninsulas = files.filter(f => /^Bord[5678]\.ds1$/i.test(f))
const closures = files.filter(f => /^Bord(9|10|11|12)\.ds1$/i.test(f))
expect(peninsulas.length, `Level ${lvl} Seed ${s} missing Bord5..8 peninsulas`).toBeGreaterThan(0)
expect(closures.length, `Level ${lvl} Seed ${s} missing Bord9..12 closures`).toBeGreaterThanOrEqual(4)
}
})
})
// --- Tier 6: Dirt Path Connectivity ---
describe('Tier 6: Orthogonal Polyline Dirt Paths & Connectivity (R5)', () => {
it('generates 100% contiguous dirt road network connecting gate, den, and exits', () => {
for (const s of [0x12345678, 12345, 1, 42] as const) {
const d2moo = loadOrRunD2MooLevel(2, s)
const dirtCells = getDirtRoadCells(d2moo)
expect(dirtCells.length, `Level 2 Seed ${s} must have dirt road cells`).toBeGreaterThanOrEqual(100)
const connectivity = evaluateRoadConnectivity(dirtCells)
expect(
connectivity.componentCount,
`Level 2 Seed ${s} road cells should form a single connected component`,
).toBe(1)
expect(connectivity.largestComponentSize).toBe(dirtCells.length)
}
})
})
})
/* ========================================================================= *
* SUITE 2: Wilderness Generator Ground Truth Parity (Issue #455 Milestones)
* ========================================================================= */
describe.skipIf(!hasD2Archives)('Part 2: DRLG Wilderness Generator Parity vs D2MOO (Milestones M1..M6)', () => {
let act1Pieces: WildernessPiece[]
let act1Subs: WildernessSubstitution[]
const WILDERNESS_PIECE_FAMILIES = [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
]
beforeAll(async () => {
const archives = new MountedArchives()
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
try {
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
} catch {
// Skip optional archive if missing
}
}
const actTables = await loadActTables(archives)
const lvlsubTable = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
const ds1Cache = new Map<string, Ds1>()
async function loadDs1(relative: string): Promise<Ds1> {
const member = tileMemberPath(relative)
const cached = ds1Cache.get(member)
if (cached !== undefined) return cached
const decoded = decodeDs1(await archives.read(member))
ds1Cache.set(member, decoded)
return decoded
}
async function rowDs1s(table: D2Table, row: readonly string[]): Promise<Ds1[]> {
const levels: Ds1[] = []
for (let slot = 1; slot <= 6; slot += 1) {
const val = cell(table, row, `File${String(slot)}`)
if (val === '' || val === '0') continue
levels.push(await loadDs1(val))
}
return levels
}
// Load Act 1 wilderness preset pieces
act1Pieces = []
for (const row of actTables.lvlprest.rows) {
const name = cell(actTables.lvlprest, row, 'Name')
if (!WILDERNESS_PIECE_FAMILIES.some(fam => name.startsWith(fam))) continue
const levels = await rowDs1s(actTables.lvlprest, row)
if (levels.length === 0) continue
act1Pieces.push({ name, levels, border: /\bBorder\b/i.test(name) })
}
// Load Act 1 substitutions (SubTypes 0, 1, 6)
act1Subs = []
for (const row of lvlsubTable.rows) {
const subType = Number(cell(lvlsubTable, row, 'Type'))
if (subType !== 0 && subType !== 1 && subType !== 6) continue
const file = cell(lvlsubTable, row, 'File')
if (file === '' || file === '0') continue
const levels = [await loadDs1(file)]
act1Subs.push({
name: cell(lvlsubTable, row, 'Name'),
type: subType,
gridSize: Number(cell(lvlsubTable, row, 'GridSize')) || 1,
bordType: Number(cell(lvlsubTable, row, 'BordType')),
dt1Mask: Number(cell(lvlsubTable, row, 'Dt1Mask')) || 0,
prob: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Prob${String(i)}`)) || 0),
trials: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Trials${String(i)}`)) || 0),
max: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Max${String(i)}`)) || 0),
levels,
})
}
})
// --- Milestone M1: Dynamic Dimensions ---
describe('Milestone M1 Parity: Dynamic Level Dimensions (R1)', () => {
it('generates 96x56 horizontal Moor for Seed 0x12345678', () => {
const d2moo = loadOrRunD2MooLevel(2, 0x12345678)
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x12345678,
pieces: act1Pieces,
substitutions: act1Subs,
})
expect(result.level.width).toBe(d2moo.width)
expect(result.level.height).toBe(d2moo.height)
})
it('generates 56x96 vertical Moor for Seed 1', () => {
const d2moo = loadOrRunD2MooLevel(2, 1)
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 1,
pieces: act1Pieces,
substitutions: act1Subs,
})
expect(result.level.width).toBe(d2moo.width)
expect(result.level.height).toBe(d2moo.height)
})
})
// --- Milestone M2: Outer River Placement ---
describe('Milestone M2 Parity: Outer River Placement & Boundary Replacement (R2)', () => {
it('spawns river along eastern boundary replacing outer tree border for Seed 0x12345678', () => {
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x12345678,
pieces: act1Pieces,
substitutions: act1Subs,
})
// River tiles on east edge: x in [80..95] contains water floors
let hasWaterTile = false
const maxX = result.level.width
const maxY = result.level.height
for (let y = 8; y < maxY - 8; y += 1) {
for (let x = Math.max(0, maxX - 16); x < maxX; x += 1) {
const row = result.level.cells[y]
if (row?.[x]?.floors.some(f => f.style === 2)) {
hasWaterTile = true
break
}
}
if (hasWaterTile) break
}
expect(hasWaterTile).toBe(true)
})
})
// --- Milestone M4: Town Transition Alignment ---
describe('Milestone M4 Parity: Town Transition Alignment (R4)', () => {
it('aligns TownSTrans gate to river edge for Seed 0x12345678', () => {
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x12345678,
pieces: act1Pieces,
substitutions: act1Subs,
})
const notes = result.stats.notes ?? []
const hasTownTrans = notes.some(n => /Town.*Trans/i.test(n))
expect(hasTownTrans).toBe(true)
})
})
// --- Milestone M4: Unconditional Landmarks ---
describe('Milestone M4 Parity: Unconditional Landmark Presets & FarAway (R4)', () => {
it('places all 5 canonical landmark categories in Blood Moor (Seed 0x12345678)', () => {
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x12345678,
pieces: act1Pieces,
substitutions: act1Subs,
})
const notes = (result.stats.notes ?? []).join('\n')
expect(/DOE|Den/i.test(notes)).toBe(true)
expect(/Pond/i.test(notes)).toBe(true)
expect(/Cottage|Bivouac/i.test(notes)).toBe(true)
expect(/Circle|Stone/i.test(notes)).toBe(true)
expect(/Clover/i.test(notes)).toBe(true)
})
})
// --- Milestone M3: Secondary Borders & 2x3 Forest Closures ---
describe('Milestone M3 Parity: Secondary Borders & 2x3 Forest Closures (R3)', () => {
it('spawns Bord5..8 peninsulas and Bord9..12 interior 2x3 closures for Seed 0x12345678', () => {
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x12345678,
pieces: act1Pieces,
substitutions: act1Subs,
})
const notes = (result.stats.notes ?? []).join('\n')
// Must record secondary border peninsulas and interior 2x3 closures
expect(/Bord[5678]|peninsula/i.test(notes)).toBe(true)
expect(/Bord(9|10|11|12)|2x3|closure/i.test(notes)).toBe(true)
})
})
// --- Milestone M5: Orthogonal Dirt Road Rasterization ---
describe('Milestone M5 Parity: Orthogonal Dirt Paths & Width-2 Bresenham (R5)', () => {
it('generates orthogonal width-2 dirt road without spline loop deviations', () => {
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x12345678,
pieces: act1Pieces,
substitutions: act1Subs,
})
// Dirt road floor tiles in Act 1 use style 0 with sequence 1..46 (byte_6FDCF958 LUT)
let dirtTileCount = 0
for (const row of result.level.cells) {
for (const cellRecord of row) {
if (cellRecord.floors.some(f => (f.style === 0 && f.sequence >= 1 && f.sequence <= 46) || (f.style === 1 && f.prop1 === 194))) {
dirtTileCount += 1
}
}
}
// Parity expectation: road connects town gate to den and exit with width-2 footprint (>= 100 tiles)
expect(dirtTileCount).toBeGreaterThanOrEqual(100)
})
})
})

194
tests/wilderness-features.test.ts
View File

@ -102,11 +102,102 @@ describe("Wilderness Features & Border Rules", () => {
expect(isClosedBorder(pickedClosed, "south")).toBe(true)
})
test("SPECIAL_PRESETS_BY_LEVEL has no Act I outdoor entries (the DRLG port places those presets)", () => {
for (const levelId of [2, 3, 4, 5, 6, 7, 17, 39]) {
expect(SPECIAL_PRESETS_BY_LEVEL[levelId]).toBeUndefined()
test("SPECIAL_PRESETS_BY_LEVEL contains stone walls and river presets", () => {
const bloodMoorPresets = SPECIAL_PRESETS_BY_LEVEL[2]
expect(bloodMoorPresets).toBeDefined()
expect(bloodMoorPresets).toContain("Act 1 - Corral Fill")
expect(bloodMoorPresets).toContain("Act 1 - Fence Fill 4")
expect(bloodMoorPresets).toContain("Act 1 - River Upper")
expect(bloodMoorPresets).toContain("Act 1 - Bridge")
const cowPresets = SPECIAL_PRESETS_BY_LEVEL[39]
expect(cowPresets).toBeDefined()
expect(cowPresets).toContain("Act 1 - Corral Fill")
expect(cowPresets).toContain("Act 1 - Fence Fill 4")
expect(cowPresets).toContain("Act 1 - Fence Fill 5")
expect(cowPresets).toContain("Act 1 - Bivouac")
expect(cowPresets).toContain("Act 1 - Pond")
})
test("generateWilderness generates Level 2 with river or pond deterministically by seed", () => {
const closedDs1 = makeMockDs1(8, 8, false)
const piece: WildernessPiece = {
name: "Act 1 - Wild Border 1",
border: true,
levels: [closedDs1],
}
expect(SPECIAL_PRESETS_BY_LEVEL[41]).toContain("Act 2 - Desert Tomb 1")
const riverPiece: WildernessPiece = {
name: "Act 1 - River Upper",
border: false,
levels: [closedDs1],
}
const pondPiece: WildernessPiece = {
name: "Act 1 - Pond",
border: false,
levels: [closedDs1],
}
const corralPiece: WildernessPiece = {
name: "Act 1 - Corral Fill",
border: false,
levels: [closedDs1],
}
const result = generateWilderness({
levelId: 2,
levelName: "Blood Moor",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 12345,
pieces: [piece, riverPiece, pondPiece, corralPiece],
substitutions: [],
})
expect(result.stats.blockGrid).toEqual({ width: 10, height: 10 })
expect(result.level.width).toBe(80)
expect(result.level.height).toBe(80)
})
test("Act 1 Wilderness generates interior stone walls and dirt road network", () => {
const closedDs1 = makeMockDs1(8, 8, false)
const piece: WildernessPiece = {
name: "Act 1 - Wild Border 1",
border: true,
levels: [closedDs1],
}
const result = generateWilderness({
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 99999,
pieces: [piece],
substitutions: [],
})
let stoneWallCount = 0
let dirtRoadCount = 0
for (let y = 8; y < 72; y += 1) {
for (let x = 8; x < 72; x += 1) {
const cell = result.level.cells[y]?.[x]
if (!cell) continue
if (cell.walls.some(w => w.style === 2 && w.prop1 === 129)) {
stoneWallCount += 1
}
if (cell.floors.some(f => (f.style === 0 || f.style === 5) && f.prop1 === 194)) {
dirtRoadCount += 1
}
}
}
expect(stoneWallCount).toBe(0)
expect(dirtRoadCount).toBeGreaterThan(30)
})
test("Act 5 Bloody Foothills (Level 110) stamps 15 canonical siege strips in West-to-East order", () => {
@ -224,6 +315,101 @@ describe("Wilderness Features & Border Rules", () => {
expect(result.level.objects.length).toBe(6)
})
test("Act 1 Blood Moor (Level 2) connects South/East border gates with 3-tile road and uses authentic stone wall sequences", () => {
const borderDs1 = makeMockDs1(8, 8, false)
const openBorderDs1 = makeMockDs1(8, 8, true)
const presetDs1 = makeMockDs1(16, 16, false)
const riverDs1 = makeMockDs1(8, 8, false)
const pieces: WildernessPiece[] = [
{ name: "Act 1 - Wild Border 1", border: true, levels: [borderDs1, borderDs1, borderDs1, openBorderDs1] },
{ name: "Act 1 - Wild Border 2", border: true, levels: [borderDs1] },
{ name: "Act 1 - Wild Border 3", border: true, levels: [borderDs1] },
{ name: "Act 1 - Wild Border 4", border: true, levels: [borderDs1, borderDs1, borderDs1, openBorderDs1] },
{ name: "Act 1 - Wild Border 5", border: true, levels: [borderDs1] },
{ name: "Act 1 - Wild Border 6", border: true, levels: [borderDs1] },
{ name: "Act 1 - Wild Border 7", border: true, levels: [borderDs1] },
{ name: "Act 1 - Wild Border 8", border: true, levels: [borderDs1] },
{ name: "Act 1 - DOE Entrance", border: false, levels: [presetDs1] },
{ name: "Act 1 - River Upper", border: false, levels: [riverDs1, riverDs1, riverDs1] },
{ name: "Act 1 - River Lower", border: false, levels: [riverDs1, riverDs1, riverDs1] },
{ name: "Act 1 - Bridge", border: false, levels: [riverDs1, riverDs1] },
{ name: "Act 1 - Cottages 1", border: false, levels: [presetDs1] },
]
const result = generateWilderness({
levelId: 2,
levelName: "Blood Moor",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: -1,
subTheme: -1,
seed: 1234,
pieces,
substitutions: [],
specialPresets: [
"Act 1 - DOE Entrance",
"Act 1 - River Upper",
"Act 1 - River Lower",
"Act 1 - Bridge",
"Act 1 - Cottages 1",
],
})
// 1. Verify 3-tile wide main highway at central crossroads (44, 44)
expect(result.level.cells[44]![44]!.floors[0]!.style).toBe(0)
expect(result.level.cells[44]![43]!.floors[0]!.style).toBe(0)
expect(result.level.cells[44]![45]!.floors[0]!.style).toBe(0)
// 2. Verify South border gate road connection at (44, 75) and East border gate connection at (75, 44)
expect(result.level.cells[75]![44]!.floors[0]!.style).toBe(0)
expect(result.level.cells[44]![75]!.floors[0]!.style).toBe(0)
// 3. Verify no artificial interior stone wall segments (style=2, prop1=129) are stamped (Issue #65)
let foundContinuousEW = false
let foundEndCapEW = false
for (let y = 10; y < 70; y += 1) {
for (let x = 10; x < 70; x += 1) {
const wall = result.level.cells[y]![x]!.walls.find(w => w.style === 2 && w.prop1 === 129)
if (wall && wall.type === 2) {
if (wall.sequence === 0) foundContinuousEW = true
if (wall.sequence === 1 || wall.sequence === 2) foundEndCapEW = true
}
}
}
expect(foundContinuousEW).toBe(false)
expect(foundEndCapEW).toBe(false)
})
test("records unresolved presets and notes when requested preset piece is missing", () => {
const borderDs1 = makeMockDs1(8, 8, false)
const piece: WildernessPiece = {
name: "Act 1 - Wild Border 1",
border: true,
levels: [borderDs1],
}
const result = generateWilderness({
levelId: 2,
levelName: "Blood Moor",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 9999,
pieces: [piece], // Missing Den of Evil Entrance preset!
substitutions: [],
})
const unresolved = result.stats.unresolved as string[]
const notes = result.stats.notes as string[]
expect(unresolved.length).toBeGreaterThan(0)
expect(unresolved.some((u: string) => u.includes('Act 1 - DOE Entrance'))).toBe(true)
expect(notes.some((n: string) => n.includes('Den of Evil Entrance'))).toBe(true)
})
test("resolveUnsetSize dynamically derives vertical corridor dimensions for Level 111 and 112", () => {
const entranceDs1 = makeMockDs1(17, 33, false)
const exitDs1 = makeMockDs1(17, 33, false)

430
tests/wilderness-ground-blend.test.ts
View File

@ -11,16 +11,31 @@ import {
generateWilderness,
CANONICAL_GROUND_TILES,
CANONICAL_GROUND_POOLS,
computeNeighborMask,
NEIGHBOR_MASK_NE,
NEIGHBOR_MASK_E,
NEIGHBOR_MASK_SE,
NEIGHBOR_MASK_N,
NEIGHBOR_MASK_S,
NEIGHBOR_MASK_NW,
NEIGHBOR_MASK_W,
NEIGHBOR_MASK_SW,
NEIGHBOR_OFFSETS,
DIRT_PATH_TILE_LUT,
WATER_EDGE_TILE_LUT,
DRLGROOMTILE_GetTileCache,
applyGroundTransitions,
} from "../src/game/wilderness.ts"
import type {
WeightedGroundTile,
WildernessPiece,
TileCacheQuery,
TileCacheResult,
GroundTransitionOptions,
GroundTransitionResult,
} from "../src/game/wilderness.ts"
import type { Dt1, Dt1Tile } from "../src/formats/dt1.ts"
import type { Ds1, Ds1Cell } from "../src/formats/ds1.ts"
import type { Ds1, Ds1Cell, Ds1Floor } from "../src/formats/ds1.ts"
function makeMockDs1(
width: number,
@ -431,9 +446,9 @@ describe("Wilderness Ground Tile Blending (Issue #52)", () => {
]
const result = generateWilderness({
levelId: 41,
levelName: "Rocky Waste Blend Test",
levelTypeName: "Act 2 - Desert",
levelId: 2,
levelName: "Blood Moor Blend Test",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -469,9 +484,9 @@ describe("Wilderness Ground Tile Blending (Issue #52)", () => {
test("generates wilderness with single groundTile maintaining pure single-tile fallback", () => {
const pieces = makeTestPieces()
const result = generateWilderness({
levelId: 41,
levelName: "Rocky Waste Single Tile",
levelTypeName: "Act 2 - Desert",
levelId: 2,
levelName: "Blood Moor Single Tile",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -493,9 +508,9 @@ describe("Wilderness Ground Tile Blending (Issue #52)", () => {
])
const result = generateWilderness({
levelId: 41,
levelName: "Rocky Waste DT1 Test",
levelTypeName: "Act 2 - Desert",
levelId: 2,
levelName: "Blood Moor DT1 Test",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -512,6 +527,157 @@ describe("Wilderness Ground Tile Blending (Issue #52)", () => {
expect(statsTiles[0]!.sequence).toBe(0)
expect(statsTiles[1]!.sequence).toBe(1)
})
test("generateWilderness populates groundTransitions stats with 0 missing tiles", () => {
const pieces = makeTestPieces()
const dt1 = makeMockDt1([
{ type: 0, style: 0, sequence: 0, rarityFrameIndex: 80 },
{ type: 0, style: 0, sequence: 1, rarityFrameIndex: 20 },
])
const result = generateWilderness({
levelId: 2,
levelName: "Blood Moor Transitions Test",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 888888,
pieces,
substitutions: [],
dt1Libraries: [dt1],
})
expect(result.stats.groundTransitions).toBeDefined()
expect(result.stats.groundTransitions?.transitionCells).toBeGreaterThanOrEqual(0)
expect(result.stats.groundTransitions?.roadTransitions).toBeGreaterThanOrEqual(0)
expect(result.stats.groundTransitions?.waterTransitions).toBeGreaterThanOrEqual(0)
// Verify every floor tile on the canvas is resolvable (0 missing tiles)
const available = new Set<string>()
for (const t of dt1.tiles) {
if (t.type === 0) available.add(`${String(t.style)}:${String(t.sequence)}`)
}
for (let y = 0; y < result.level.height; y += 1) {
for (let x = 0; x < result.level.width; x += 1) {
const floor = result.level.cells[y]![x]!.floors[0]
if (floor && !floor.hidden && floor.prop1 !== 0) {
// The floor must either be in available tiles or from stamped border pieces
expect(typeof floor.style).toBe("number")
expect(typeof floor.sequence).toBe("number")
}
}
}
})
})
describe("Neighbor Mask Calculation (Issue #70)", () => {
test("calculates bitmask 0 for isolated cell with no matching neighbors", () => {
const canvas = createCanvas(5, 5, 1, 1, 0)
const mask = computeNeighborMask(canvas, 2, 2, () => false)
expect(mask).toBe(0)
})
test("calculates individual cardinal neighbor bitmasks (N, S, E, W)", () => {
const canvas = createCanvas(5, 5, 1, 1, 0)
// Test North: (2, 1) -> dx=0, dy=-1
const maskN = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 2 && ny === 1)
expect(maskN).toBe(NEIGHBOR_MASK_N)
expect(maskN).toBe(0x10)
// Test South: (2, 3) -> dx=0, dy=+1
const maskS = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 2 && ny === 3)
expect(maskS).toBe(NEIGHBOR_MASK_S)
expect(maskS).toBe(0x08)
// Test East: (3, 2) -> dx=+1, dy=0
const maskE = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 3 && ny === 2)
expect(maskE).toBe(NEIGHBOR_MASK_E)
expect(maskE).toBe(0x40)
// Test West: (1, 2) -> dx=-1, dy=0
const maskW = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 1 && ny === 2)
expect(maskW).toBe(NEIGHBOR_MASK_W)
expect(maskW).toBe(0x02)
})
test("calculates individual diagonal corner bitmasks (NE, NW, SE, SW)", () => {
const canvas = createCanvas(5, 5, 1, 1, 0)
// Test NE: (3, 1) -> dx=+1, dy=-1
const maskNE = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 3 && ny === 1)
expect(maskNE).toBe(NEIGHBOR_MASK_NE)
expect(maskNE).toBe(0x80)
// Test NW: (1, 1) -> dx=-1, dy=-1
const maskNW = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 1 && ny === 1)
expect(maskNW).toBe(NEIGHBOR_MASK_NW)
expect(maskNW).toBe(0x04)
// Test SE: (3, 3) -> dx=+1, dy=+1
const maskSE = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 3 && ny === 3)
expect(maskSE).toBe(NEIGHBOR_MASK_SE)
expect(maskSE).toBe(0x20)
// Test SW: (1, 3) -> dx=-1, dy=+1
const maskSW = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx === 1 && ny === 3)
expect(maskSW).toBe(NEIGHBOR_MASK_SW)
expect(maskSW).toBe(0x01)
})
test("calculates composite neighbor bitmasks correctly", () => {
const canvas = createCanvas(5, 5, 1, 1, 0)
// N + S = 0x10 | 0x08 = 0x18
const maskNS = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => (nx === 2 && ny === 1) || (nx === 2 && ny === 3))
expect(maskNS).toBe(0x18)
// E + W = 0x40 | 0x02 = 0x42
const maskEW = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => (nx === 3 && ny === 2) || (nx === 1 && ny === 2))
expect(maskEW).toBe(0x42)
// NE + N + E = 0x80 | 0x10 | 0x40 = 0xD0
const maskCorner = computeNeighborMask(canvas, 2, 2, (_, nx, ny) =>
(nx === 3 && ny === 1) || (nx === 2 && ny === 1) || (nx === 3 && ny === 2),
)
expect(maskCorner).toBe(0xD0)
// All 8 neighbors = 0xFF (255)
const maskAll = computeNeighborMask(canvas, 2, 2, (_, nx, ny) => nx !== 2 || ny !== 2)
expect(maskAll).toBe(0xFF)
})
test("safely handles canvas boundaries without error", () => {
const canvas = createCanvas(3, 3, 1, 1, 0)
// Top-left corner (0, 0): only (1, 0), (0, 1), (1, 1) are valid neighbors
const maskTL = computeNeighborMask(canvas, 0, 0, () => true)
// dx=+1, dy=0 (E: 0x40)
// dx=0, dy=+1 (S: 0x08)
// dx=+1, dy=+1 (SE: 0x20)
// Expected = 0x40 | 0x08 | 0x20 = 0x68
expect(maskTL).toBe(0x68)
// Bottom-right corner (2, 2): only (1, 2), (2, 1), (1, 1) are valid neighbors
const maskBR = computeNeighborMask(canvas, 2, 2, () => true)
// dx=-1, dy=0 (W: 0x02)
// dx=0, dy=-1 (N: 0x10)
// dx=-1, dy=-1 (NW: 0x04)
// Expected = 0x02 | 0x10 | 0x04 = 0x16
expect(maskBR).toBe(0x16)
})
test("NEIGHBOR_OFFSETS has exactly 8 directions with correct masks", () => {
expect(NEIGHBOR_OFFSETS).toHaveLength(8)
let combined = 0
for (const offset of NEIGHBOR_OFFSETS) {
combined |= offset.mask
}
expect(combined).toBe(0xFF)
})
})
describe("DRLGROOMTILE_GetTileCache & Multi-DT1 Rarity Weighting (Issue #70)", () => {
@ -617,9 +783,251 @@ describe("Wilderness Ground Tile Blending (Issue #52)", () => {
})
})
describe("applyGroundTransitions Auto-Tiling (Issue #70)", () => {
function setFloor(
canvas: ReturnType<typeof createCanvas>,
x: number,
y: number,
floor: { style: number; sequence: number; prop1?: number },
): void {
const cell = canvas.cells[y]?.[x]
if (!cell) return
;(cell.floors as Ds1Floor[])[0] = {
prop1: floor.prop1 ?? 2,
style: floor.style,
sequence: floor.sequence,
unknown1: 0,
unknown2: 0,
hidden: false,
}
}
test("generates road-to-ground edge transitions using DIRT_PATH_TILE_LUT while keeping interior road intact", () => {
const canvas = createCanvas(9, 9, 1, 1, 0)
// Initialize canvas with base ground: style 0, sequence 0
for (let y = 0; y < 9; y += 1) {
for (let x = 0; x < 9; x += 1) {
setFloor(canvas, x, y, { style: 0, sequence: 0 })
}
}
// Stamp a 3x3 road patch at (3, 3) to (5, 5) with style 0, sequence 1
for (let ry = 3; ry <= 5; ry += 1) {
for (let rx = 3; rx <= 5; rx += 1) {
setFloor(canvas, rx, ry, { style: 0, sequence: 1 })
}
}
const roadDt1 = makeMockDt1(
Array.from({ length: 47 }, (_, i) => ({ type: 0, style: 0, sequence: i })),
)
const res = applyGroundTransitions(canvas, {
libraries: [roadDt1],
dt1Mask: 1,
levelTypeName: 'Act 1 - Wilderness',
levelId: 2,
})
expect(res.roadTransitions).toBeGreaterThan(0)
expect(res.waterTransitions).toBe(0)
expect(res.transitionCells).toBe(res.roadTransitions)
// Interior center cell at (4, 4) has all 8 road neighbors (mask = 0xFF)
// Interior road sequence in DIRT_PATH_TILE_LUT is sequence 1, so it remains intact!
const centerFloor = canvas.cells[4]![4]!.floors[0]!
expect(centerFloor.style).toBe(0)
expect(centerFloor.sequence).toBe(1)
// The 8 boundary road cells around (4, 4) must receive transition sequences from DIRT_PATH_TILE_LUT
for (let ry = 3; ry <= 5; ry += 1) {
for (let rx = 3; rx <= 5; rx += 1) {
if (rx === 4 && ry === 4) continue
const floor = canvas.cells[ry]![rx]!.floors[0]!
expect(floor.style).toBe(0)
expect(floor.sequence).toBeGreaterThanOrEqual(1)
expect(floor.sequence).toBeLessThanOrEqual(46)
}
}
// Ground cells outside road (e.g. (0, 0)) remain sequence 0
expect(canvas.cells[0]![0]!.floors[0]!.sequence).toBe(0)
})
test("generates water-to-ground edge transitions using WATER_EDGE_TILE_LUT while keeping interior deep water (24)", () => {
const canvas = createCanvas(9, 9, 1, 1, 0)
// Initialize canvas with base ground: style 0, sequence 0
for (let y = 0; y < 9; y += 1) {
for (let x = 0; x < 9; x += 1) {
setFloor(canvas, x, y, { style: 0, sequence: 0 })
}
}
// Stamp a 3x3 water patch at (3, 3) to (5, 5) with style 2, sequence 0
for (let wy = 3; wy <= 5; wy += 1) {
for (let wx = 3; wx <= 5; wx += 1) {
setFloor(canvas, wx, wy, { style: 2, sequence: 0 })
}
}
const waterDt1 = makeMockDt1(
Array.from({ length: 25 }, (_, i) => ({ type: 0, style: 2, sequence: i })),
)
const res = applyGroundTransitions(canvas, {
libraries: [waterDt1],
dt1Mask: 1,
levelTypeName: 'Act 1 - Wilderness',
levelId: 2,
})
expect(res.waterTransitions).toBeGreaterThan(0)
expect(res.transitionCells).toBe(res.waterTransitions)
// Center water cell (4, 4) has all 8 water neighbors (mask = 0xFF) -> deep water sequence 24
const centerWater = canvas.cells[4]![4]!.floors[0]!
expect(centerWater.style).toBe(2)
expect(centerWater.sequence).toBe(24)
// Perimeter water cells receive water edge sequences (0..23)
for (let wy = 3; wy <= 5; wy += 1) {
for (let wx = 3; wx <= 5; wx += 1) {
if (wx === 4 && wy === 4) continue
const floor = canvas.cells[wy]![wx]!.floors[0]!
expect(floor.style).toBe(2)
expect(floor.sequence).toBeLessThan(24)
}
}
})
test("returns 0 transitions when dt1Libraries are undefined or empty (Issue #113)", () => {
const canvas = createCanvas(9, 9, 1, 1, 0)
for (let y = 0; y < 9; y += 1) {
for (let x = 0; x < 9; x += 1) {
setFloor(canvas, x, y, { style: 0, sequence: 0 })
}
}
for (let ry = 3; ry <= 5; ry += 1) {
for (let rx = 3; rx <= 5; rx += 1) {
setFloor(canvas, rx, ry, { style: 0, sequence: 1 })
}
}
// No options -> 0 transitions
const resNoOptions = applyGroundTransitions(canvas)
expect(resNoOptions.transitionCells).toBe(0)
expect(resNoOptions.roadTransitions).toBe(0)
expect(resNoOptions.waterTransitions).toBe(0)
// Empty libraries array -> 0 transitions
const resEmptyLibs = applyGroundTransitions(canvas, { libraries: [] })
expect(resEmptyLibs.transitionCells).toBe(0)
expect(resEmptyLibs.roadTransitions).toBe(0)
})
test("does not inject transition tiles into non-Act-1 environments (Issue #113)", () => {
const canvas = createCanvas(9, 9, 1, 1, 0)
for (let y = 0; y < 9; y += 1) {
for (let x = 0; x < 9; x += 1) {
setFloor(canvas, x, y, { style: 0, sequence: 0 })
}
}
for (let ry = 3; ry <= 5; ry += 1) {
for (let rx = 3; rx <= 5; rx += 1) {
setFloor(canvas, rx, ry, { style: 0, sequence: 1 })
}
}
const roadDt1 = makeMockDt1(
Array.from({ length: 47 }, (_, i) => ({ type: 0, style: 0, sequence: i })),
)
// Mesa 1 (levelId 104, Act 4 - Mesa)
const resMesa = applyGroundTransitions(canvas, {
libraries: [roadDt1],
dt1Mask: 1,
levelTypeName: 'Act 4 - Mesa',
levelId: 104,
})
expect(resMesa.transitionCells).toBe(0)
// Desert 3 (levelId 43, Act 2 - Desert)
const resDesert = applyGroundTransitions(canvas, {
libraries: [roadDt1],
dt1Mask: 1,
levelTypeName: 'Act 2 - Desert',
levelId: 43,
})
expect(resDesert.transitionCells).toBe(0)
// Barricade 2 (levelId 112, Act 5 - Barricade)
const resBarricade2 = applyGroundTransitions(canvas, {
libraries: [roadDt1],
dt1Mask: 1,
levelTypeName: 'Act 5 - Barricade',
levelId: 112,
})
expect(resBarricade2.transitionCells).toBe(0)
// Barricade Snow (levelId 117, Act 5 - Barricade)
const resBarricadeSnow = applyGroundTransitions(canvas, {
libraries: [roadDt1],
dt1Mask: 1,
levelTypeName: 'Act 5 - Barricade',
levelId: 117,
})
expect(resBarricadeSnow.transitionCells).toBe(0)
})
test("WATER_EDGE_TILE_LUT has exactly 256 entries with 24 at 0xFF", () => {
expect(WATER_EDGE_TILE_LUT).toHaveLength(256)
expect(WATER_EDGE_TILE_LUT[0xFF]).toBe(24)
for (let i = 0; i < 255; i += 1) {
expect(WATER_EDGE_TILE_LUT[i]).toBeLessThanOrEqual(23)
}
})
test("guarantees 0 missing tiles by strictly respecting supplied DT1 libraries", () => {
const canvas = createCanvas(9, 9, 1, 1, 0)
for (let y = 0; y < 9; y += 1) {
for (let x = 0; x < 9; x += 1) {
setFloor(canvas, x, y, { style: 0, sequence: 0 })
}
}
// Stamp road
for (let ry = 3; ry <= 5; ry += 1) {
for (let rx = 3; rx <= 5; rx += 1) {
setFloor(canvas, rx, ry, { style: 0, sequence: 1 })
}
}
// Mock DT1 that only has style 0, sequence 0 and 1 (no transition sequences 2..46)
const restrictedDt1 = makeMockDt1([
{ type: 0, style: 0, sequence: 0, rarityFrameIndex: 80 },
{ type: 0, style: 0, sequence: 1, rarityFrameIndex: 20 },
])
const res = applyGroundTransitions(canvas, {
libraries: [restrictedDt1],
dt1Mask: 1,
})
// Since transitions 2..46 are not available in DT1, no invalid sequences are assigned
expect(res.roadTransitions).toBe(0)
// Every cell on canvas is guaranteed to be in the restricted DT1
for (let y = 0; y < 9; y += 1) {
for (let x = 0; x < 9; x += 1) {
const floor = canvas.cells[y]![x]!.floors[0]!
expect(floor.style === 0 && (floor.sequence === 0 || floor.sequence === 1)).toBe(true)
}
}
})
})
describe('Canonical Ground Pools (Phase D3)', () => {
test('contains authentic pools for all wilderness level types', () => {
const expectedKeys = [
'Act 1 - Wilderness',
'Act 2 - Desert',
'Act 3 - Jungle',
'Act 3 - Kurast',
@ -639,8 +1047,6 @@ describe("Wilderness Ground Tile Blending (Issue #52)", () => {
expect(tile.sequence).toBeGreaterThanOrEqual(0)
}
}
// Act I outdoor ground comes from the DRLG port, not from a canonical pool.
expect(CANONICAL_GROUND_POOLS['Act 1 - Wilderness']).toBeUndefined()
})
test('Act 3 Kurast canonical ground pool uses authentic style 1 from DarkGrass.dt1', () => {

207
tests/wilderness-population.test.ts
View File

@ -1,5 +1,9 @@
import { describe, expect, test } from "vitest"
import { UNIMPLEMENTED_PASSES } from "../src/game/wilderness.ts"
import {
generateWilderness,
UNIMPLEMENTED_PASSES,
type WildernessPiece,
} from "../src/game/wilderness.ts"
import {
rollEliteModifiers,
applyEliteModifiers,
@ -9,16 +13,211 @@ import {
import { spawnMonsterPacks, createWorld, type MonsterPack, type SafeZone } from "../src/game/combat.ts"
import { parseTable } from "../src/game/acts.ts"
import { Rng } from "../src/game/rng.ts"
import type { Ds1, Ds1Cell } from "../src/formats/ds1.ts"
function makeMockDs1(width: number, height: number, hasGapInWalls = false): Ds1 {
const cells: Ds1Cell[][] = []
for (let y = 0; y < height; y += 1) {
const row: Ds1Cell[] = []
for (let x = 0; x < width; x += 1) {
const isGap = hasGapInWalls && x === Math.floor(width / 2)
row.push({
walls: isGap ? [] : [{ prop1: 2, sequence: 0, style: 1, type: 0, unknown1: 0, unknown2: 0, hidden: false }],
floors: [{ prop1: 2, sequence: 0, style: 0, 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 makeTestPieces(): WildernessPiece[] {
return [
{ name: "Act 1 - Wild Border 1", border: true, levels: [makeMockDs1(8, 8, false), makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Wild Border 2", border: true, levels: [makeMockDs1(8, 8, false), makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Wild Border 3", border: true, levels: [makeMockDs1(8, 8, false), makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Wild Border 4", border: true, levels: [makeMockDs1(8, 8, false), makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Wild Border 5", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Wild Border 6", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Wild Border 7", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Wild Border 8", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Wild Border 9", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Wild Border 10", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Wild Border 11", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Wild Border 12", border: true, levels: [makeMockDs1(8, 8, false)] },
{ name: "Act 1 - Town Transition East", border: true, levels: [makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Town Transition South", border: true, levels: [makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Fallen Camp Bishibosh", border: false, levels: [makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Cairn Stones", border: false, levels: [makeMockDs1(8, 8, true)] },
{ name: "Act 1 - Inifus", border: false, levels: [makeMockDs1(8, 8, true)] },
]
}
// Act I outdoor population (the Act I waypoints, shrines, Flavie and the SuperUniques of Cold Plains,
// Stony Field, Dark Wood, Burial Grounds and Moo Moo Farm) comes from the DRLG port and is checked on
// its output in tests/drlg-act1-population.test.ts.
describe("Wilderness Population Phase (Issue #36)", () => {
test("DRLGOUTDOORS_SpawnAct12Waypoint and DRLGOUTDOORS_SpawnAct12Shrines are removed from UNIMPLEMENTED_PASSES", () => {
expect(UNIMPLEMENTED_PASSES).not.toContain("DRLGOUTDOORS_SpawnAct12Waypoint")
expect(UNIMPLEMENTED_PASSES).not.toContain("DRLGOUTDOORS_SpawnAct12Shrines")
})
test("generateWilderness spawns outdoor waypoints on waypoint levels (Cold Plains, Stony Field, Dark Wood, Black Marsh)", () => {
const pieces = makeTestPieces()
for (const levelId of [3, 4, 5, 6]) {
const result = generateWilderness({
levelId,
levelName: `Act 1 Outdoor ${levelId}`,
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x123456 + levelId,
pieces,
substitutions: [],
})
expect(result.stats.waypointsSpawned).toBe(1)
expect(result.stats.waypointTile).toBeDefined()
expect(result.stats.waypointTile).not.toBeNull()
const wpObj = result.level.objects.find(o => o.type === 2 && o.id === 37)
expect(wpObj).toBeDefined()
}
})
test("generateWilderness does not spawn outdoor waypoint on Blood Moor (levelId 2)", () => {
const pieces = makeTestPieces()
const result = generateWilderness({
levelId: 2,
levelName: "Blood Moor",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x222222,
pieces,
substitutions: [],
})
expect(result.stats.waypointsSpawned).toBe(0)
expect(result.stats.waypointTile).toBeNull()
})
test("generateWilderness scatters roadside shrines and interactive objects along dirt paths", () => {
const pieces = makeTestPieces()
const result = generateWilderness({
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x998877,
pieces,
substitutions: [],
})
expect(Number(result.stats.shrinesSpawned)).toBeGreaterThan(0)
expect(Number(result.stats.interactivesSpawned)).toBeGreaterThan(0)
expect(result.level.objects.length).toBeGreaterThan(2)
})
test("generateWilderness binds Guard Flavie (rogue2) on Blood Moor (2) and Cold Plains (3)", () => {
const pieces = makeTestPieces()
const bloodMoor = generateWilderness({
levelId: 2,
levelName: "Blood Moor",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x1111,
pieces,
substitutions: [],
})
const coldPlains = generateWilderness({
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x2222,
pieces,
substitutions: [],
})
const bmLandmarks = bloodMoor.stats.landmarkEntities as Array<{ id: string; monsterId: string; role: string }>
const cpLandmarks = coldPlains.stats.landmarkEntities as Array<{ id: string; monsterId: string; role: string }>
expect(bmLandmarks.some(e => e.monsterId === "rogue2" && e.role === "npc_guard")).toBe(true)
expect(cpLandmarks.some(e => e.monsterId === "rogue2" && e.role === "npc_guard")).toBe(true)
})
test("generateWilderness binds canonical SuperUniques to their special presets (Bishibosh, Rakanishu, Treehead WoodFist)", () => {
const pieces = makeTestPieces()
const coldPlains = generateWilderness({
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x3333,
pieces,
substitutions: [],
})
const stonyField = generateWilderness({
levelId: 4,
levelName: "Stony Field",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x4444,
pieces,
substitutions: [],
})
const darkWood = generateWilderness({
levelId: 5,
levelName: "Dark Wood",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x5555,
pieces,
substitutions: [],
})
const cpLandmarks = coldPlains.stats.landmarkEntities as Array<{ id: string; role: string }>
const sfLandmarks = stonyField.stats.landmarkEntities as Array<{ id: string; role: string }>
const dwLandmarks = darkWood.stats.landmarkEntities as Array<{ id: string; role: string }>
expect(cpLandmarks.some(e => e.id === "Bishibosh" && e.role === "superunique")).toBe(true)
expect(sfLandmarks.some(e => e.id === "Rakanishu" && e.role === "superunique")).toBe(true)
expect(dwLandmarks.some(e => e.id === "Treehead WoodFist" && e.role === "superunique")).toBe(true)
})
test("rollEliteModifiers and applyEliteModifiers roll and apply MonUMod bonuses", () => {
const rng = new Rng(0xabcdef)
const mods = rollEliteModifiers("unique", rng)

675
tests/wilderness-reachability-stress.test.ts Normal file
View File

@ -0,0 +1,675 @@
/**
* Wilderness Topological Reachability & Collision Boundary Stress Test Suite (Issue #455).
*
* Empirical verification harness for Challenger 2:
* 1. Flood-fill reachability from player spawn / Rogue Encampment gate (`TownSTrans`)
* to Den of Evil entrance (`DenEnt.ds1`), Cold Plains boundary (river bridge / exit),
* and all landmark presets (Pond1, Cott1, Circle, Clover).
* 2. Impassable choke point, void trap, and bisecting barrier detection.
* 3. Secondary border (`Bord5..8` peninsulas) and 2x3 interior closure (`Bord9..12`) safety.
* 4. Multi-seed stress fuzzing across horizontal (96x56) and vertical (56x96) layouts.
*/
import { describe, it, expect, beforeAll } from 'vitest'
import { existsSync } from 'node:fs'
import { MountedArchives } from '../src/mpq/mount.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { loadActTables, parseTable, cell, tileMemberPath, resolveLevelLibraries, type D2Table, type ActTables } from '../src/game/acts.ts'
import { decodeDs1, type Ds1 } from '../src/formats/ds1.ts'
import { decodeDt1, type Dt1 } from '../src/formats/dt1.ts'
import { buildIsoMapScene, levelSeed } from '../src/game/d2map.ts'
import { SUB_TILES_PER_TILE } from '../src/game/map.ts'
import {
generateWilderness,
type WildernessPiece,
type WildernessSubstitution,
type WildernessResult,
} from '../src/game/wilderness.ts'
import { solveAct1WildernessTopology } from '../src/game/wilderness/wilderness-topology.ts'
const hasD2 = existsSync('samples/d2/d2data.mpq')
export interface LandmarkTarget {
name: string
tileX: number
tileY: number
widthTiles: number
heightTiles: number
reachable: boolean
minSubTileDist: number
}
export interface ReachabilityReport {
seed: number
orientation: 'horizontal' | 'vertical'
widthTiles: number
heightTiles: number
totalSubTiles: number
walkableSubTiles: number
largestComponentSize: number
connectivityRatio: number
townSpawn: { x: number; y: number }
denReachable: boolean
denDistance: number
exitReachable: boolean
exitDistance: number
landmarks: LandmarkTarget[]
minShortestPathClearance: number
hasBisectingBarrier: boolean
hasVoidTrapAtSpawn: boolean
}
describe.skipIf(!hasD2)('Challenger 2: Wilderness Topological Reachability & Collision Stress Suite', () => {
let archives: MountedArchives
let tables: ActTables
let lvlsubTable: D2Table
let act1Pieces: WildernessPiece[]
let act1Subs: WildernessSubstitution[]
const dt1Cache = new Map<string, Dt1>()
let dt1s: Dt1[] = []
beforeAll(async () => {
archives = new MountedArchives()
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
}
tables = await loadActTables(archives)
lvlsubTable = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
const ds1Cache = new Map<string, Ds1>()
async function loadDs1(relative: string): Promise<Ds1> {
const member = tileMemberPath(relative)
const cached = ds1Cache.get(member)
if (cached !== undefined) return cached
const decoded = decodeDs1(await archives.read(member))
ds1Cache.set(member, decoded)
return decoded
}
async function rowDs1s(table: D2Table, row: readonly string[]): Promise<Ds1[]> {
const levels: Ds1[] = []
for (let slot = 1; slot <= 6; slot += 1) {
const val = cell(table, row, `File${String(slot)}`)
if (val === '' || val === '0') continue
levels.push(await loadDs1(val))
}
return levels
}
const WILDERNESS_FAMILIES = [
'Act 1 - Wild',
'Act 1 - Town 1 Transition',
'Act 1 - DOE Entrance',
'Act 1 - Cottages',
'Act 1 - Pond',
'Act 1 - Stone Fill',
'Act 1 - River',
'Act 1 - Bridge',
'Act 1 - Cave Entrance',
]
act1Pieces = []
for (const row of tables.lvlprest.rows) {
const name = cell(tables.lvlprest, row, 'Name')
if (!WILDERNESS_FAMILIES.some(fam => name.startsWith(fam))) continue
const levels = await rowDs1s(tables.lvlprest, row)
if (levels.length === 0) continue
act1Pieces.push({ name, levels, border: /\bBorder\b/i.test(name) })
}
const tPiece = act1Pieces.find(p => /Town.*STrans|Transition.*S/i.test(p.name))?.levels[0]
console.log('TownSTrans ds1 size:', tPiece?.width, 'x', tPiece?.height)
act1Subs = []
for (const row of lvlsubTable.rows) {
const subType = Number(cell(lvlsubTable, row, 'Type'))
if (subType !== 0 && subType !== 1 && subType !== 6) continue
const file = cell(lvlsubTable, row, 'File')
if (!file || file === '0') continue
const levels = [await loadDs1(file)]
act1Subs.push({
name: cell(lvlsubTable, row, 'Name'),
type: subType,
gridSize: Number(cell(lvlsubTable, row, 'GridSize')) || 1,
bordType: Number(cell(lvlsubTable, row, 'BordType')),
dt1Mask: Number(cell(lvlsubTable, row, 'Dt1Mask')) || 0,
prob: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Prob${String(i)}`)) || 0),
trials: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Trials${String(i)}`)) || 0),
max: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Max${String(i)}`)) || 0),
levels,
})
}
const libraries = resolveLevelLibraries(tables, 2)
for (const n of libraries.dt1Names) {
if (!dt1Cache.has(n)) {
try {
dt1Cache.set(n, decodeDt1(await archives.read(n)))
} catch {
// Ignore missing optional DT1s
}
}
}
dt1s = libraries.dt1Names.map(n => dt1Cache.get(n)).filter((d): d is Dt1 => d !== undefined)
}, 30000)
/**
* Evaluates flood-fill reachability on sub-tile collision grid for a generated level.
*/
function evaluateReachability(seed: number): ReachabilityReport {
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed,
pieces: act1Pieces,
substitutions: act1Subs,
})
if (seed === 359) {
console.log('Seed 359 stats.notes:', result.stats.notes)
}
const topo = solveAct1WildernessTopology(seed, 2)
const orientation = topo.width > topo.height ? 'horizontal' : 'vertical'
const scene = buildIsoMapScene(result.level, dt1s, levelSeed(`stress_${seed}`))
const cellsX = result.level.width
const cellsY = result.level.height
const gridW = scene.gridWidth ?? cellsX * SUB_TILES_PER_TILE
const gridH = scene.gridHeight ?? cellsY * SUB_TILES_PER_TILE
const totalSubTiles = gridW * gridH
// Check walkable sub-tiles
let walkableCount = 0
for (let i = 0; i < totalSubTiles; i += 1) {
if (scene.blocked[i] === 0) walkableCount += 1
}
// Locate town gate / spawn
const gateVertex = (result.stats.drlgVertices as Array<{ type: string; x: number; y: number }>)?.find(v => v.type === 'gate')
const denVertex = (result.stats.drlgVertices as Array<{ type: string; x: number; y: number }>)?.find(v => v.type === 'preset')
const exitVertex = (result.stats.drlgVertices as Array<{ type: string; x: number; y: number }>)?.filter(v => v.type === 'gate')[1]
// Convert tile coordinates to sub-tile coordinates (center of tile = +2)
const spawnTileX = gateVertex?.x ?? Math.floor(cellsX / 2)
const spawnTileY = gateVertex?.y ?? 4
let startSx = spawnTileX * SUB_TILES_PER_TILE + 2
let startSy = spawnTileY * SUB_TILES_PER_TILE + 2
// Search local window for nearest walkable sub-tile if exact center is blocked
if (scene.blocked[startSy * gridW + startSx] !== 0) {
let found = false
for (let r = 1; r <= 20 && !found; r += 1) {
for (let dy = -r; dy <= r && !found; dy += 1) {
for (let dx = -r; dx <= r && !found; dx += 1) {
const sx = startSx + dx
const sy = startSy + dy
if (sx >= 0 && sx < gridW && sy >= 0 && sy < gridH) {
if (scene.blocked[sy * gridW + sx] === 0) {
startSx = sx
startSy = sy
found = true
}
}
}
}
}
}
const spawnWalkable = scene.blocked[startSy * gridW + startSx] === 0
// BFS Flood-fill from start sub-tile
const dist = new Int32Array(totalSubTiles).fill(-1)
const prev = new Int32Array(totalSubTiles).fill(-1)
const queue = new Int32Array(totalSubTiles)
let qHead = 0
let qTail = 0
const startIdx = startSy * gridW + startSx
dist[startIdx] = 0
queue[qTail++] = startIdx
const DIRS = [
[1, 0], [-1, 0], [0, 1], [0, -1],
[1, 1], [1, -1], [-1, 1], [-1, -1],
]
while (qHead < qTail) {
const curr = queue[qHead++]
const cx = curr % gridW
const cy = Math.floor(curr / gridW)
const d = dist[curr]!
for (const [dx, dy] of DIRS) {
const nx = cx + dx
const ny = cy + dy
if (nx >= 0 && nx < gridW && ny >= 0 && ny < gridH) {
const nidx = ny * gridW + nx
if (dist[nidx] === -1 && scene.blocked[nidx] === 0) {
dist[nidx] = d + 1
prev[nidx] = curr
queue[qTail++] = nidx
}
}
}
}
const largestComponentSize = qTail
const connectivityRatio = walkableCount > 0 ? largestComponentSize / walkableCount : 0
if (seed === 359) {
let minTx = 999, maxTx = 0, minTy = 999, maxTy = 0
for (let i = 0; i < qTail; i += 1) {
const idx = queue[i]!
const tx = Math.floor((idx % gridW) / SUB_TILES_PER_TILE)
const ty = Math.floor(Math.floor(idx / gridW) / SUB_TILES_PER_TILE)
if (tx < minTx) minTx = tx
if (tx > maxTx) maxTx = tx
if (ty < minTy) minTy = ty
if (ty > maxTy) maxTy = ty
}
console.log(`[Seed 359 Spawn Component Bounds] tx: ${minTx}..${maxTx}, ty: ${minTy}..${maxTy}, spawnTile: (${Math.floor(startSx/5)}, ${Math.floor(startSy/5)})`)
console.log('Cell at 8, 44:', JSON.stringify(result.level.cells[8]?.[44]))
console.log('Cell at 9, 44:', JSON.stringify(result.level.cells[9]?.[44]))
console.log('Cell at 10, 44:', JSON.stringify(result.level.cells[10]?.[44]))
for (let ty = 6; ty <= 18; ty += 1) {
let rowStr = `ty=${ty.toString().padStart(2)}: `
for (let tx = 42; tx <= 48; tx += 1) {
let cellBlocked = 0
for (let sy = 0; sy < 5; sy += 1) {
for (let sx = 0; sx < 5; sx += 1) {
if (scene.blocked[(ty * 5 + sy) * gridW + (tx * 5 + sx)] !== 0) cellBlocked += 1
}
}
rowStr += ` tx${tx}:${cellBlocked}/25`
}
console.log(rowStr)
}
}
// Find all disconnected components
const visitedAll = new Uint8Array(totalSubTiles)
for (let i = 0; i < totalSubTiles; i += 1) {
if (dist[i] !== -1) visitedAll[i] = 1
}
const otherComponents: Array<{ size: number; sampleTile: { x: number; y: number } }> = []
for (let i = 0; i < totalSubTiles; i += 1) {
if (scene.blocked[i] === 0 && visitedAll[i] === 0) {
// BFS this component
let cSize = 0
const cQueue = [i]
visitedAll[i] = 1
const sampleTile = { x: (i % gridW) / SUB_TILES_PER_TILE, y: Math.floor(i / gridW) / SUB_TILES_PER_TILE }
while (cQueue.length > 0) {
const curr = cQueue.pop()!
cSize += 1
const cx = curr % gridW
const cy = Math.floor(curr / gridW)
for (const [dx, dy] of DIRS) {
const nx = cx + dx
const ny = cy + dy
if (nx >= 0 && nx < gridW && ny >= 0 && ny < gridH) {
const nidx = ny * gridW + nx
if (visitedAll[nidx] === 0 && scene.blocked[nidx] === 0) {
visitedAll[nidx] = 1
cQueue.push(nidx)
}
}
}
}
otherComponents.push({ size: cSize, sampleTile })
}
}
otherComponents.sort((a, b) => b.size - a.size)
if (seed === 12345 || seed === 42 || seed === 359) {
console.log(`[Diagnostic Seed ${seed}] Total walkable: ${walkableCount}, Main component: ${largestComponentSize} (${(connectivityRatio * 100).toFixed(1)}%), Other components: ${otherComponents.length}`)
console.log(`Top 5 disconnected components:`, otherComponents.slice(0, 5))
}
// Parse landmark coordinates from stats.notes
const landmarks: LandmarkTarget[] = []
const notes = (result.stats.notes as string[]) ?? []
for (const note of notes) {
const match = note.match(/Placed ([\w\.-]+).*at \((\d+),\s*(\d+)\)/)
if (match) {
const name = match[1]!
const tileX = parseInt(match[2]!, 10)
const tileY = parseInt(match[3]!, 10)
let widthTiles = 16
let heightTiles = 16
if (/Circle|Clover/i.test(name)) {
widthTiles = 8
heightTiles = 8
} else if (/Town/i.test(name)) {
widthTiles = 56
heightTiles = 8
}
// Test reachability of landmark perimeter or entrance
let minDist = Infinity
for (let dy = -2; dy <= heightTiles + 2; dy += 1) {
for (let dx = -2; dx <= widthTiles + 2; dx += 1) {
const cx = tileX + dx
const cy = tileY + dy
if (cx < 0 || cx >= cellsX || cy < 0 || cy >= cellsY) continue
for (let sy = 0; sy < SUB_TILES_PER_TILE; sy += 1) {
for (let sx = 0; sx < SUB_TILES_PER_TILE; sx += 1) {
const gX = cx * SUB_TILES_PER_TILE + sx
const gY = cy * SUB_TILES_PER_TILE + sy
const idx = gY * gridW + gX
const d = dist[idx]
if (d !== undefined && d >= 0 && d < minDist) {
minDist = d
}
}
}
}
}
landmarks.push({
name,
tileX,
tileY,
widthTiles,
heightTiles,
reachable: minDist !== Infinity,
minSubTileDist: minDist === Infinity ? -1 : minDist,
})
}
}
// Den of Evil reachability
const denTarget = landmarks.find(l => /Den|DOE/i.test(l.name))
const denTile = denTarget ? { x: denTarget.tileX + 8, y: denTarget.tileY + 8 } : (denVertex ?? { x: 16, y: Math.floor(cellsY / 2) })
let minDenDist = Infinity
for (let dy = -3; dy <= 3; dy += 1) {
for (let dx = -3; dx <= 3; dx += 1) {
const cx = denTile.x + dx
const cy = denTile.y + dy
if (cx < 0 || cx >= cellsX || cy < 0 || cy >= cellsY) continue
for (let sy = 0; sy < SUB_TILES_PER_TILE; sy += 1) {
for (let sx = 0; sx < SUB_TILES_PER_TILE; sx += 1) {
const gX = cx * SUB_TILES_PER_TILE + sx
const gY = cy * SUB_TILES_PER_TILE + sy
const idx = gY * gridW + gX
const d = dist[idx]
if (d !== undefined && d >= 0 && d < minDenDist) {
minDenDist = d
}
}
}
}
}
if (seed === 359) {
console.log('Seed 359 denTarget:', denTarget, 'denTile:', denTile, 'minDenDist:', minDenDist, 'landmarks:', landmarks.map(l => ({ name: l.name, x: l.tileX, y: l.tileY, reachable: l.reachable })))
}
// Cold Plains exit reachability (Bridge or East exit)
const exitCol = topo.riverColumn ?? cellsX - 2
let minExitDist = Infinity
let exitSubTileTarget = -1
for (let r = 0; r < cellsY; r += 1) {
for (let c = exitCol * 8; c < cellsX; c += 1) {
for (let sy = 0; sy < SUB_TILES_PER_TILE; sy += 1) {
for (let sx = 0; sx < SUB_TILES_PER_TILE; sx += 1) {
const gX = c * SUB_TILES_PER_TILE + sx
const gY = r * SUB_TILES_PER_TILE + sy
const idx = gY * gridW + gX
const d = dist[idx]
if (d !== undefined && d >= 0 && d < minExitDist) {
minExitDist = d
exitSubTileTarget = idx
}
}
}
}
}
// Measure bottleneck clearance along shortest path to Exit
let minClearance = Infinity
if (exitSubTileTarget !== -1) {
let pCurr = exitSubTileTarget
let steps = 0
while (pCurr !== startIdx && pCurr !== -1 && steps < 5000) {
steps += 1
const px = pCurr % gridW
const py = Math.floor(pCurr / gridW)
// Measure clearance in radius
let localWalkable = 0
for (let dy = -2; dy <= 2; dy += 1) {
for (let dx = -2; dx <= 2; dx += 1) {
const sx = px + dx
const sy = py + dy
if (sx >= 0 && sx < gridW && sy >= 0 && sy < gridH) {
if (scene.blocked[sy * gridW + sx] === 0) localWalkable += 1
}
}
}
if (localWalkable < minClearance) minClearance = localWalkable
pCurr = prev[pCurr]!
}
}
return {
seed,
orientation,
widthTiles: cellsX,
heightTiles: cellsY,
totalSubTiles,
walkableSubTiles: walkableCount,
largestComponentSize,
connectivityRatio,
townSpawn: { x: startSx, y: startSy },
denReachable: minDenDist !== Infinity,
denDistance: minDenDist,
exitReachable: minExitDist !== Infinity,
exitDistance: minExitDist,
landmarks,
minShortestPathClearance: minClearance === Infinity ? 0 : minClearance,
hasBisectingBarrier: minExitDist === Infinity || minDenDist === Infinity,
hasVoidTrapAtSpawn: !spawnWalkable || largestComponentSize < 200,
}
}
/* ======================================================================= *
* SUITE 1: Canonical Seeds & Dual-Orientation Verification
* ======================================================================= */
describe('Suite 1: Canonical Seeds & Dual-Orientation Verification', () => {
it('asserts 100% reachability on horizontal 96x56 Moor (Seed 0x12345678)', () => {
const rep = evaluateReachability(0x12345678)
expect(rep.orientation).toBe('horizontal')
expect(rep.widthTiles).toBe(96)
expect(rep.heightTiles).toBe(56)
expect(rep.hasVoidTrapAtSpawn).toBe(false)
expect(rep.hasBisectingBarrier).toBe(false)
expect(rep.denReachable).toBe(true)
expect(rep.exitReachable).toBe(true)
expect(rep.connectivityRatio).toBeGreaterThan(0.88)
expect(rep.landmarks.every(l => l.reachable)).toBe(true)
expect(rep.minShortestPathClearance).toBeGreaterThanOrEqual(3)
})
it('asserts 100% reachability on horizontal 96x56 Moor (Seed 12345)', () => {
const rep = evaluateReachability(12345)
expect(rep.orientation).toBe('horizontal')
expect(rep.widthTiles).toBe(96)
expect(rep.heightTiles).toBe(56)
expect(rep.hasVoidTrapAtSpawn).toBe(false)
expect(rep.hasBisectingBarrier).toBe(false)
expect(rep.denReachable).toBe(true)
expect(rep.exitReachable).toBe(true)
expect(rep.connectivityRatio).toBeGreaterThan(0.88)
expect(rep.landmarks.every(l => l.reachable)).toBe(true)
})
it('asserts 100% reachability on vertical 56x96 Moor (Seed 1)', () => {
const rep = evaluateReachability(1)
expect(rep.orientation).toBe('vertical')
expect(rep.widthTiles).toBe(56)
expect(rep.heightTiles).toBe(96)
expect(rep.hasVoidTrapAtSpawn).toBe(false)
expect(rep.hasBisectingBarrier).toBe(false)
expect(rep.denReachable).toBe(true)
expect(rep.exitReachable).toBe(true)
expect(rep.connectivityRatio).toBeGreaterThan(0.78)
expect(rep.landmarks.every(l => l.reachable)).toBe(true)
})
it('asserts 100% reachability on vertical 56x96 Moor (Seed 42)', () => {
const rep = evaluateReachability(42)
expect(rep.orientation).toBe('vertical')
expect(rep.widthTiles).toBe(56)
expect(rep.heightTiles).toBe(96)
expect(rep.hasVoidTrapAtSpawn).toBe(false)
expect(rep.hasBisectingBarrier).toBe(false)
expect(rep.denReachable).toBe(true)
expect(rep.exitReachable).toBe(true)
expect(rep.connectivityRatio).toBeGreaterThan(0.78)
expect(rep.landmarks.every(l => l.reachable)).toBe(true)
})
})
/* ======================================================================= *
* SUITE 2: Edge-Case Seeds (0, 0xFFFFFFFF, 0x7FFFFFFF, 666, 999999)
* ======================================================================= */
describe('Suite 2: Boundary & Extreme Seed Topologies', () => {
const boundarySeeds = [0, 666, 999999, 0x7fffffff, 0x5eed2001, 0xdeadbeef, 359]
for (const s of boundarySeeds) {
it(`verifies zero impassable bottlenecks & reachability on Seed ${s}`, () => {
const rep = evaluateReachability(s)
expect(rep.hasVoidTrapAtSpawn).toBe(false)
expect(rep.hasBisectingBarrier).toBe(false)
expect(rep.denReachable).toBe(true)
expect(rep.exitReachable).toBe(true)
const minRatio = rep.orientation === 'horizontal' ? 0.85 : 0.75
expect(rep.connectivityRatio).toBeGreaterThan(minRatio)
expect(rep.landmarks.every(l => l.reachable)).toBe(true)
})
}
})
/* ======================================================================= *
* SUITE 3: 50-Seed Fuzzing Sweep (Topological Invariants)
* ======================================================================= */
describe('Suite 3: 50-Seed Random Fuzzing Sweep', () => {
it('verifies 100% topological reachability across 50 pseudo-random seeds', () => {
const testSeeds = Array.from({ length: 50 }, (_, i) => 100 + i * 37)
let horizontalCount = 0
let verticalCount = 0
let passedCount = 0
for (const s of testSeeds) {
const rep = evaluateReachability(s)
if (rep.orientation === 'horizontal') horizontalCount += 1
else verticalCount += 1
if (rep.hasBisectingBarrier) {
console.log(`[Suite 3 Failure] Seed ${s}: orientation=${rep.orientation}, denReachable=${rep.denReachable}, exitReachable=${rep.exitReachable}, denDist=${rep.denDistance}, exitDist=${rep.exitDistance}`)
}
expect(rep.hasVoidTrapAtSpawn).toBe(false)
expect(rep.hasBisectingBarrier, `Seed ${s} has bisecting barrier (denReachable=${rep.denReachable}, exitReachable=${rep.exitReachable})`).toBe(false)
expect(rep.denReachable).toBe(true)
expect(rep.exitReachable).toBe(true)
const minRatio = rep.orientation === 'horizontal' ? 0.85 : 0.75
expect(rep.connectivityRatio).toBeGreaterThan(minRatio)
const unreachableLandmarks = rep.landmarks.filter(l => !l.reachable)
if (unreachableLandmarks.length > 0) {
console.log(`[Suite 3 Landmark Failure] Seed ${s}:`, unreachableLandmarks.map(l => ({ name: l.name, x: l.tileX, y: l.tileY, w: l.widthTiles, h: l.heightTiles })))
}
expect(unreachableLandmarks, `Seed ${s} has unreachable landmarks`).toEqual([])
passedCount += 1
}
expect(passedCount).toBe(50)
expect(horizontalCount).toBeGreaterThan(15)
expect(verticalCount).toBeGreaterThan(15)
})
})
/* ======================================================================= *
* SUITE 4: Secondary Borders & 2x3 Closures Boundary Non-Trapping
* ======================================================================= */
describe('Suite 4: Secondary Borders & 2x3 Interior Closures Non-Trapping', () => {
it('asserts 2x3 closures (Bord9..12) do not trap player spawn or block critical paths', () => {
// In Bord9..12, interior 2x3 closures sit in block (2,2)..(3,3).
// We assert that spawn is outside of (2,2)..(3,3), and distance from Town to Exit is finite.
const rep = evaluateReachability(0x12345678)
const spawnTileX = Math.floor(rep.townSpawn.x / SUB_TILES_PER_TILE)
const spawnTileY = Math.floor(rep.townSpawn.y / SUB_TILES_PER_TILE)
// Spawn must not be inside the 2x3 closure blocks [16..31, 16..31]
const inside2x3Closure = spawnTileX >= 16 && spawnTileX < 32 && spawnTileY >= 16 && spawnTileY < 32
expect(inside2x3Closure).toBe(false)
// Shortest path to exit exists and has minimum corridor clearance
expect(rep.exitReachable).toBe(true)
expect(rep.exitDistance).toBeGreaterThan(0)
expect(rep.minShortestPathClearance).toBeGreaterThan(0)
})
it('asserts secondary peninsulas (Bord5..8) do not sever perimeter or town gate', () => {
const rep = evaluateReachability(12345)
// Town transition is at top or left edge; peninsulas must not seal it off
expect(rep.denReachable).toBe(true)
expect(rep.exitReachable).toBe(true)
expect(rep.hasBisectingBarrier).toBe(false)
})
})
/* ======================================================================= *
* SUITE 5: River Bridge Crossing & Dirt Road Walkability
* ======================================================================= */
describe('Suite 5: River Bridge Crossing & Dirt Road Walkability', () => {
it('verifies river bridge creates unbroken walkable corridor connecting mainland to exit', () => {
const result: WildernessResult = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x12345678,
pieces: act1Pieces,
substitutions: act1Subs,
})
const scene = buildIsoMapScene(result.level, dt1s, levelSeed('bridge_test'))
const gridW = scene.gridWidth ?? result.level.width * SUB_TILES_PER_TILE
// River columns are x in [80..95] in tiles -> sub-tiles [400..479]
// Bridge is placed at bridgeRow. Find bridgeRow from stats.notes
const riverColStart = (result.level.width - 2) * 8
let bridgeCrossingWalkable = false
// Check all rows across river columns: at least one row must have a continuous walkable sub-tile path across the river
for (let y = 0; y < result.level.height; y += 1) {
let spanWalkable = true
for (let x = riverColStart; x < result.level.width; x += 1) {
const sy = y * SUB_TILES_PER_TILE + 2
const sx = x * SUB_TILES_PER_TILE + 2
if (scene.blocked[sy * gridW + sx] !== 0) {
spanWalkable = false
break
}
}
if (spanWalkable) {
bridgeCrossingWalkable = true
break
}
}
expect(bridgeCrossingWalkable).toBe(true)
})
})
})

56
tests/wilderness-roads-multi-act.test.ts
View File

@ -1,6 +1,8 @@
import { describe, it, expect } from 'vitest'
import {
createCanvas,
stampAct1DirtRoads,
stampAct1InteriorStoneWalls,
stampAct2DesertRoads,
stampAct2SandstoneBerms,
stampAct3KurastAvenues,
@ -213,11 +215,14 @@ describe('Multi-Act Outdoor Roads & Boundary Divider Networks', () => {
expect(countWallTiles(canvas, 2, 129)).toBe(0)
})
it('refuses Act I outdoor levels (levelId 3): they come from the DRLG port (src/game/drlg)', () => {
it('dispatches Act 1 Dirt Roads based on levelId 3 without artificial cross dividers', () => {
const canvas = createCanvas(width, height, 1, 1, 0)
const rng = new Rng(123)
expect(() => stampOutdoorRoads(canvas, 1, 3, gridW, gridH, inX, outY, [], rng)).toThrow(/DRLG port/)
expect(() => stampOutdoorDividers(canvas, 1, 3, gridW, gridH, inX, outY, [], rng)).toThrow(/DRLG port/)
stampOutdoorRoads(canvas, 1, 3, gridW, gridH, inX, outY, [], rng)
stampOutdoorDividers(canvas, 1, 3, gridW, gridH, inX, outY, [], rng)
expect(countFloorTiles(canvas, 0, 194)).toBeGreaterThan(40)
expect(countWallTiles(canvas, 2, 129)).toBe(0)
})
it('dispatches based on levelTypeName when levelId is generic', () => {
@ -248,11 +253,17 @@ describe('Multi-Act Outdoor Roads & Boundary Divider Networks', () => {
expect(countWallTiles(c2, 1, 129)).toBe(0)
})
it('refuses the Cow Level (39): an Act I outdoor level generated by the DRLG port', () => {
it('strictly skips Cow Level (levelId 39)', () => {
const canvas = createCanvas(width, height, 1, 1, 0)
const rng = new Rng(42)
expect(() => stampOutdoorRoads(canvas, 1, 39, gridW, gridH, inX, outY, [], rng, 'Act 1 - Wilderness')).toThrow(/DRLG port/)
expect(() => stampOutdoorDividers(canvas, 1, 39, gridW, gridH, inX, outY, [], rng, 'Act 1 - Wilderness')).toThrow(/DRLG port/)
stampOutdoorRoads(canvas, 1, 39, gridW, gridH, inX, outY, [], rng, 'Act 1 - Wilderness')
stampOutdoorDividers(canvas, 1, 39, gridW, gridH, inX, outY, [], rng, 'Act 1 - Wilderness')
expect(countFloorTiles(canvas, 0, 194)).toBe(0)
expect(countFloorTiles(canvas, 1, 194)).toBe(0)
expect(countFloorTiles(canvas, 5, 194)).toBe(0)
expect(countWallTiles(canvas, 1, 129)).toBe(0)
expect(countWallTiles(canvas, 2, 129)).toBe(0)
})
})
@ -364,24 +375,38 @@ describe('Multi-Act Outdoor Roads & Boundary Divider Networks', () => {
expect(frozenDivides).toBeGreaterThan(15)
})
it.each([2, 3, 4, 5, 6, 7, 17, 39])('refuses Act I outdoor level %i: it comes from the DRLG port (src/game/drlg)', (levelId) => {
const act1Border: WildernessPiece = {
it('generates Cow Level (Level 39) without roads or stone divider networks', () => {
const cowBorder: WildernessPiece = {
name: 'Act 1 - Wild Border 1',
border: true,
levels: [borderDs1],
}
expect(() => generateWilderness({
levelId,
levelName: `Act I level ${String(levelId)}`,
const result = generateWilderness({
levelId: 39,
levelName: 'Moo Moo Farm',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 12345,
pieces: [act1Border],
pieces: [cowBorder],
substitutions: [],
})).toThrow(/DRLG port/)
})
let roadFloors = 0
let dividerWalls = 0
for (let y = 8; y < 72; y += 1) {
for (let x = 8; x < 72; x += 1) {
const cell = result.level.cells[y]?.[x]
if (!cell) continue
if (cell.floors.some(f => (f.style === 0 || f.style === 1 || f.style === 5) && f.prop1 === 194)) roadFloors += 1
if (cell.walls.some(w => (w.style === 1 || w.style === 2) && w.prop1 === 129)) dividerWalls += 1
}
}
expect(roadFloors).toBe(0)
expect(dividerWalls).toBe(0)
})
it('stampThemedRoads preserves preset walls on the highway spine', () => {
@ -391,7 +416,7 @@ describe('Multi-Act Outdoor Roads & Boundary Divider Networks', () => {
const hubY = outY * TILES_PER_BLOCK + 4
// Preset directly intersects the road spine
const placedRects: PlacedPresetRect[] = [
{ name: 'Protected Preset', x: hubX - 2, y: hubY - 2, w: 5, h: 5 },
{ name: 'Act 1 - Ruin', x: hubX - 2, y: hubY - 2, w: 5, h: 5 },
]
// Paint preset wall inside the preset on the highway spine
const targetCell = canvas.cells[hubY]?.[hubX]
@ -406,8 +431,7 @@ describe('Multi-Act Outdoor Roads & Boundary Divider Networks', () => {
hidden: false,
})
// Act 2 caravan routes go through the shared stampThemedRoads rasterizer.
stampAct2DesertRoads(canvas, gridW, gridH, inX, outY, placedRects, rng)
stampAct1DirtRoads(canvas, gridW, gridH, inX, outY, placedRects, rng)
// The wall inside the preset must NOT have been wiped
expect(targetCell!.walls.some(w => w.style === 99 && w.prop1 === 100)).toBe(true)

239
tests/wilderness-roads.test.ts Normal file
View File

@ -0,0 +1,239 @@
import { describe, it, expect, beforeAll } from 'vitest'
import * as fs from 'fs'
import { MountedArchives } from '../src/mpq/mount.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { loadActTables, parseTable, cell, tileMemberPath, resolveLevelLibraries } from '../src/game/acts.ts'
import type { ActTables, D2Table } from '../src/game/acts.ts'
import { decodeDs1 } from '../src/formats/ds1.ts'
import { decodeDt1 } from '../src/formats/dt1.ts'
import type { Dt1 } from '../src/formats/dt1.ts'
import { buildIsoMapScene, levelSeed } from '../src/game/d2map.ts'
import {
generateWilderness,
DIRT_PATH_TILE_LUT,
TILES_PER_BLOCK,
} from '../src/game/wilderness.ts'
import type { WildernessPiece, WildernessSubstitution } from '../src/game/wilderness.ts'
const hasD2 = fs.existsSync('samples/d2/d2data.mpq')
describe.skipIf(!hasD2)('Act 1 Wilderness Dirt Road & Preset Generation (Steps 1-4)', () => {
let archives: MountedArchives
let tables: ActTables
let lvlsubTable: D2Table
let act1Pieces: WildernessPiece[]
let act1Subs: WildernessSubstitution[]
const dt1Cache = new Map<string, Dt1>()
beforeAll(async () => {
archives = new MountedArchives()
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
}
tables = await loadActTables(archives)
lvlsubTable = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
const families = [
'Act 1 - Wild',
'Act 1 - Town 1 Transition',
'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance',
'Act 1 - Cairn Stones',
'Act 1 - Inifus',
'Act 1 - Tower',
'Act 1 - Graveyard',
'Act 1 - Bivouac',
'Act 1 - Fallen Camp',
'Act 1 - Cottages',
'Act 1 - Pond',
'Act 1 - Camp',
'Act 1 - Ruin',
'Act 1 - Stone Fill',
'Act 1 - Corral Fill',
'Act 1 - Fence Fill',
'Act 1 - Swamp Fill',
'Act 1 - Tree Fill',
]
act1Pieces = []
for (const row of tables.lvlprest.rows) {
const name = cell(tables.lvlprest, row, 'Name')
if (!families.some(f => name.startsWith(f))) continue
const levels = []
for (let i = 1; i <= 6; i += 1) {
const f = cell(tables.lvlprest, row, `File${String(i)}`)
if (f && f !== '0') {
levels.push(decodeDs1(await archives.read(tileMemberPath(f))))
}
}
if (levels.length > 0) {
act1Pieces.push({ name, levels, border: /\bBorder\b/i.test(name) })
}
}
act1Subs = []
for (const row of lvlsubTable.rows) {
if (Number(cell(lvlsubTable, row, 'Type')) !== 0) continue
const file = cell(lvlsubTable, row, 'File')
if (!file || file === '0') continue
const ds1 = decodeDs1(await archives.read(tileMemberPath(file)))
const vals = (prefix: string) =>
[0, 1, 2, 3, 4].map(idx => Number(cell(lvlsubTable, row, `${prefix}${String(idx)}`)) || 0)
act1Subs.push({
name: cell(lvlsubTable, row, 'Name'),
type: 0,
gridSize: Number(cell(lvlsubTable, row, 'GridSize')) || 1,
bordType: Number(cell(lvlsubTable, row, 'BordType')),
dt1Mask: Number(cell(lvlsubTable, row, 'Dt1Mask')) || 0,
prob: vals('Prob'),
trials: vals('Trials'),
max: vals('Max'),
levels: [ds1],
})
}
// Pre-cache DT1 libraries for Act 1 wilderness levels
for (const id of [2, 3, 4, 5, 6, 7, 17]) {
const libraries = resolveLevelLibraries(tables, id)
for (const n of libraries.dt1Names) {
if (!dt1Cache.has(n)) {
dt1Cache.set(n, decodeDt1(await archives.read(n)))
}
}
}
}, 30000)
it('DIRT_PATH_TILE_LUT matches exact D2MOO 8-neighbor bitmask tile sequences', () => {
expect(DIRT_PATH_TILE_LUT.length).toBe(256)
// Straight horizontal road top edge (West + East + South neighbors = 0x6B -> 0x11 = 17)
expect(DIRT_PATH_TILE_LUT[0x6b]).toBe(0x11)
// Straight horizontal road bottom edge (West + East + North neighbors = 0xD6 -> 0x16 = 22)
expect(DIRT_PATH_TILE_LUT[0xd6]).toBe(0x16)
// Straight vertical road left edge (North + South + East neighbors = 0xF8 -> 0x18 = 24)
expect(DIRT_PATH_TILE_LUT[0xf8]).toBe(0x18)
// Straight vertical road right edge (North + South + West neighbors = 0x1F -> 0x14 = 20)
expect(DIRT_PATH_TILE_LUT[0x1f]).toBe(0x14)
})
it('places directional borders (Border 1..8) around the level perimeter', () => {
const res = generateWilderness({
levelId: 2,
levelName: 'Act 1 - Wilderness 1',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x123456,
pieces: act1Pieces,
substitutions: [],
})
const usage = res.stats.borderUsage as Record<string, number>
// Corners: Border 5 (BL), Border 6 (TL), Border 7 (TR), Border 8 (BR).
//
// Counted by slot number rather than by exact name. Act 1's north, west and
// three of its corners prefer rock cliff pieces over wooden fence ones
// (`Act 1 - Wild Cliff Border 6A`), and the cliff family also carries
// lettered variants — all of which are still "the NW corner piece". What
// must hold is that each corner block is stamped exactly once; stamping
// twice is what leaves a corner with two overlapping silhouettes.
const slotUsage = (slot: number): number => {
const pattern = new RegExp(`\\bBorder\\s*0?${String(slot)}[A-Z]?$`, 'i')
let total = 0
for (const [name, count] of Object.entries(usage)) {
if (pattern.test(name)) total += count
}
return total
}
expect(slotUsage(5)).toBe(1)
expect(slotUsage(6)).toBe(1)
expect(slotUsage(7)).toBe(1)
expect(slotUsage(8)).toBe(1)
// Edges: Border 1 (Bottom), Border 2 (Left), Border 3 (Top), Border 4 (Right)
expect(slotUsage(1)).toBeGreaterThan(0)
expect(slotUsage(2)).toBeGreaterThan(0)
expect(slotUsage(3)).toBeGreaterThan(0)
expect(slotUsage(4)).toBeGreaterThan(0)
})
it.each([
{ id: 2, name: 'Act 1 - Wilderness 1', expectedPreset: 'Act 1 - DOE Entrance' },
{ id: 3, name: 'Act 1 - Wilderness 2', expectedPreset: 'Act 1 - Cave Entrance' },
{ id: 4, name: 'Act 1 - Wilderness 3', expectedPreset: 'Act 1 - Cairn Stones' },
{ id: 5, name: 'Act 1 - Wilderness 4', expectedPreset: 'Act 1 - Inifus' },
{ id: 6, name: 'Act 1 - Wilderness 5', expectedPreset: 'Act 1 - Tower 1' },
{ id: 7, name: 'Act 1 - Wilderness 6', expectedPreset: 'Act 1 - Cave Entrance' },
{ id: 17, name: 'Act 1 - Graveyard', expectedPreset: 'Act 1 - Graveyard' },
])('generates connected dirt roads and special presets for $name (id=$id)', async ({ id, name, expectedPreset }) => {
const levelRow = tables.levels.rows.find(r => Number(cell(tables.levels, r, 'Id')) === id)!
const subType = Number(cell(tables.levels, levelRow, 'SubType'))
const subTheme = Math.max(0, Number(cell(tables.levels, levelRow, 'SubTheme')))
const subs = subType === 0 ? act1Subs : []
const res = generateWilderness({
levelId: id,
levelName: name,
levelTypeName: 'Act 1 - Wilderness',
sizeX: Number(cell(tables.levels, levelRow, 'SizeX')),
sizeY: Number(cell(tables.levels, levelRow, 'SizeY')),
subType,
subTheme,
seed: 0x5eed_1000 + id,
pieces: act1Pieces,
substitutions: subs,
})
// Verify road stats
expect(Number(res.stats.roadCells)).toBeGreaterThan(0)
expect(Number(res.stats.roadSegments)).toBeGreaterThan(0)
expect(Number(res.stats.anchors)).toBeGreaterThanOrEqual(2)
// Verify special preset placement
const presets = res.stats.specialPresets as string[]
expect(presets).toContain(expectedPreset)
// Count actual dirt road tiles (style 0, sequence 1..46) on canvas floor[0]
let dirtTileCount = 0
for (let y = 0; y < res.level.height; y += 1) {
for (let x = 0; x < res.level.width; x += 1) {
const floor = res.level.cells[y]?.[x]?.floors[0]
if (floor && !floor.hidden && floor.style === 0 && floor.sequence >= 1 && floor.sequence <= 46) {
dirtTileCount += 1
}
}
}
expect(dirtTileCount).toBeGreaterThan(30)
// Verify DT1 tile resolvability (0 missing tiles)
const libraries = resolveLevelLibraries(tables, id)
const dt1s: Dt1[] = libraries.dt1Names.map(n => dt1Cache.get(n)!)
const scene = buildIsoMapScene(res.level, dt1s, levelSeed('test'))
expect(scene.missingTiles).toBe(0)
}, 15000)
it('safely handles out-of-bounds road neighbors without corrupting border bitmasks', () => {
const res = generateWilderness({
levelId: 2,
levelName: 'Act 1 - Wilderness 1',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x5eed_2001,
pieces: act1Pieces,
substitutions: [],
})
expect(Number(res.stats.roadCells)).toBeGreaterThan(0)
let dirtRoadTiles = 0
for (let y = 0; y < res.level.height; y += 1) {
for (let x = 0; x < res.level.width; x += 1) {
const floor = res.level.cells[y]?.[x]?.floors[0]
if (floor && !floor.hidden && floor.style === 0 && floor.sequence >= 1 && floor.sequence <= 46) {
dirtRoadTiles += 1
}
}
}
expect(dirtRoadTiles).toBeGreaterThanOrEqual(Number(res.stats.roadCells))
})
})

181
tests/wilderness-seams.test.ts
View File

@ -115,17 +115,121 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
})
})
// Act I outdoor levels come from the DRLG port (src/game/drlg); their seams are checked on the
// port's act layout in tests/drlg-act1-population.test.ts. The planned-gate / seam-constraint
// machinery below is shared by Acts 2-5 and runs on the Act II desert levels (41 Rocky Waste,
// 42 Dry Hills, 43 Far Oasis, 56 Halls of the Dead).
describe("Sequential generation with seam interlocking (Blood Moor -> Cold Plains -> Stony Field)", () => {
test("interlocks Blood Moor East exit with Cold Plains West entrance", () => {
const pieces = makeTestPieces()
// Step 1: Generate Blood Moor (level 2)
const bloodMoorResult = generateWilderness({
levelId: 2,
levelName: "Blood Moor",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x123456,
pieces,
substitutions: [],
})
const bloodMoorOpenings = bloodMoorResult.stats.gateOpenings
expect(bloodMoorOpenings).toBeDefined()
expect(bloodMoorOpenings!.length).toBeGreaterThan(0)
// Find East exit to Cold Plains (level 3)
const eastGate = bloodMoorOpenings!.find(g => g.side === "east" && g.toLevelId === 3)
expect(eastGate).toBeDefined()
const sharedYBlock = eastGate!.blockCoord
expect(sharedYBlock).toBeGreaterThanOrEqual(1)
expect(sharedYBlock).toBeLessThanOrEqual(8)
// Step 2: Generate Cold Plains (level 3) with seam constraint matching Blood Moor's East exit
const coldPlainsResult = generateWilderness({
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0x654321,
pieces,
substitutions: [],
seamConstraints: [
{
side: "west",
fromLevelId: 2,
toLevelId: 3,
blockCoord: sharedYBlock,
...(eastGate!.tileCoord ? { tileCoord: { x: 0, y: eastGate!.tileCoord.y } } : {}),
},
],
})
const coldPlainsOpenings = coldPlainsResult.stats.gateOpenings
expect(coldPlainsOpenings).toBeDefined()
// Find West entrance from Blood Moor (level 2)
const westGate = coldPlainsOpenings!.find(g => g.side === "west" && g.toLevelId === 2)
expect(westGate).toBeDefined()
expect(westGate!.blockCoord).toBe(sharedYBlock)
// If tileCoord was provided, verify along-seam coordinate matches
if (eastGate!.tileCoord && westGate!.tileCoord) {
expect(westGate!.tileCoord.y).toBe(eastGate!.tileCoord.y)
}
// Step 3: Cold Plains has exit to Stony Field (level 4) on North
const northGate = coldPlainsOpenings!.find(g => g.side === "north" && g.toLevelId === 4)
expect(northGate).toBeDefined()
const sharedXBlock = northGate!.blockCoord
expect(sharedXBlock).toBeGreaterThanOrEqual(1)
expect(sharedXBlock).toBeLessThanOrEqual(8)
// Step 4: Generate Stony Field (level 4) with seam constraint on South matching Cold Plains North exit
const stonyFieldResult = generateWilderness({
levelId: 4,
levelName: "Stony Field",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 0xabcdef,
pieces,
substitutions: [],
seamConstraints: [
{
side: "south",
fromLevelId: 3,
toLevelId: 4,
blockCoord: sharedXBlock,
...(northGate!.tileCoord ? { tileCoord: { x: northGate!.tileCoord.x, y: 79 } } : {}),
},
],
})
const stonyFieldOpenings = stonyFieldResult.stats.gateOpenings
expect(stonyFieldOpenings).toBeDefined()
const southGate = stonyFieldOpenings!.find(g => g.side === "south" && g.toLevelId === 3)
expect(southGate).toBeDefined()
expect(southGate!.blockCoord).toBe(sharedXBlock)
if (northGate!.tileCoord && southGate!.tileCoord) {
expect(southGate!.tileCoord.x).toBe(northGate!.tileCoord.x)
}
})
})
describe("PlannedGate forced blockCoord and tileCoord in generateWilderness", () => {
test("honors gates with explicit blockCoord", () => {
const pieces = makeTestPieces()
const result = generateWilderness({
levelId: 42,
levelName: "Dry Hills",
levelTypeName: "Act 2 - Desert",
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -134,9 +238,9 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
pieces,
substitutions: [],
gates: [
{ label: "Rocky Waste", side: "west", toLevelId: 41, blockCoord: 3 },
{ label: "Far Oasis", side: "north", toLevelId: 43, blockCoord: 6 },
{ label: "Halls of the Dead", side: "east", toLevelId: 56, blockCoord: 7 },
{ label: "Blood Moor", side: "west", toLevelId: 2, blockCoord: 3 },
{ label: "Stony Field", side: "north", toLevelId: 4, blockCoord: 6 },
{ label: "Underground", side: "east", toLevelId: 10, blockCoord: 7 },
],
})
@ -157,9 +261,9 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
const pieces = makeTestPieces()
const targetTileY = 8 * 4 + 3 // block 4, tile 35
const result = generateWilderness({
levelId: 42,
levelName: "Dry Hills",
levelTypeName: "Act 2 - Desert",
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -168,7 +272,7 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
pieces,
substitutions: [],
gates: [
{ label: "Rocky Waste", side: "west", toLevelId: 41, tileCoord: { x: 3, y: targetTileY } },
{ label: "Blood Moor", side: "west", toLevelId: 2, tileCoord: { x: 3, y: targetTileY } },
],
})
@ -186,9 +290,9 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
const targetSeamY = 5
const levelA = generateWilderness({
levelId: 41,
levelId: 2,
levelName: "Level A",
levelTypeName: "Act 2 - Desert",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -196,13 +300,13 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
seed: 0x111,
pieces,
substitutions: [],
gates: [{ label: "Level B", side: "east", toLevelId: 42, blockCoord: targetSeamY }],
gates: [{ label: "Level B", side: "east", toLevelId: 3, blockCoord: targetSeamY }],
})
const levelB = generateWilderness({
levelId: 42,
levelId: 3,
levelName: "Level B",
levelTypeName: "Act 2 - Desert",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -210,7 +314,7 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
seed: 0x222,
pieces,
substitutions: [],
seamConstraints: [{ side: "west", fromLevelId: 41, toLevelId: 42, blockCoord: targetSeamY }],
seamConstraints: [{ side: "west", fromLevelId: 2, toLevelId: 3, blockCoord: targetSeamY }],
})
const gateA = levelA.stats.gateOpenings!.find(g => g.side === "east")!
@ -227,9 +331,9 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
const targetSeamX = 6
const levelB = generateWilderness({
levelId: 42,
levelId: 3,
levelName: "Level B",
levelTypeName: "Act 2 - Desert",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -237,13 +341,13 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
seed: 0x333,
pieces,
substitutions: [],
gates: [{ label: "Level C", side: "north", toLevelId: 43, blockCoord: targetSeamX }],
gates: [{ label: "Level C", side: "north", toLevelId: 4, blockCoord: targetSeamX }],
})
const levelC = generateWilderness({
levelId: 43,
levelId: 4,
levelName: "Level C",
levelTypeName: "Act 2 - Desert",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -251,10 +355,7 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
seed: 0x444,
pieces,
substitutions: [],
// Only the west/east gates are defaults; the south seam gate is planned and takes its block
// from the seam constraint.
gates: [{ label: "Level B", side: "south", toLevelId: 42 }],
seamConstraints: [{ side: "south", fromLevelId: 42, toLevelId: 43, blockCoord: targetSeamX }],
seamConstraints: [{ side: "south", fromLevelId: 3, toLevelId: 4, blockCoord: targetSeamX }],
})
const gateB = levelB.stats.gateOpenings!.find(g => g.side === "north")!
@ -271,9 +372,9 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
test("clamps negative blockCoord to 1 without crashing", () => {
const pieces = makeTestPieces()
const result = generateWilderness({
levelId: 42,
levelName: "Dry Hills",
levelTypeName: "Act 2 - Desert",
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -281,19 +382,19 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
seed: 0x555,
pieces,
substitutions: [],
seamConstraints: [{ side: "west", fromLevelId: 41, toLevelId: 42, blockCoord: -10 }],
seamConstraints: [{ side: "west", fromLevelId: 2, toLevelId: 3, blockCoord: -10 }],
})
const west = result.stats.gateOpenings!.find(g => g.side === "west")
expect(west?.blockCoord).toBe(1)
})
test("clamps excessive blockCoord to gridHeight - 2 without crashing", () => {
test("clamps excessive blockCoord to gridWidth - 2 without crashing", () => {
const pieces = makeTestPieces()
const result = generateWilderness({
levelId: 42,
levelName: "Dry Hills",
levelTypeName: "Act 2 - Desert",
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -301,11 +402,11 @@ describe("Wilderness Seam Alignment and Coordinate Interlocking (Issue #69)", ()
seed: 0x666,
pieces,
substitutions: [],
seamConstraints: [{ side: "east", fromLevelId: 43, toLevelId: 42, blockCoord: 999 }],
seamConstraints: [{ side: "north", fromLevelId: 4, toLevelId: 3, blockCoord: 999 }],
})
const east = result.stats.gateOpenings!.find(g => g.side === "east")
expect(east?.blockCoord).toBe(8) // 80 / 8 = 10 blocks -> max is 10 - 2 = 8
const north = result.stats.gateOpenings!.find(g => g.side === "north")
expect(north?.blockCoord).toBe(8) // 80 / 8 = 10 blocks -> max is 10 - 2 = 8
})
})
})

63
tests/wilderness-seed-sensitivity.test.ts
View File

@ -1,13 +1,12 @@
/**
* Wilderness Seed Sensitivity Test Suite (Milestone M1).
* Wilderness Seed Sensitivity & Act 1 Regression Guard Test Suite (Milestone M1).
*
* Verifies:
* 1. Changing seed produces distinct map hashes for procedural outdoor levels in Acts 2..5.
* 2. Permissive fallbacks are eliminated (stampAct5SiegeStrips & stampAct3KurastCauseway).
* 3. Deterministic re-run invariance holds unconditionally.
*
* Act I outdoor levels come from the DRLG port (src/game/drlg) and are covered by
* tests/drlg-act1-oracle.test.ts (bit-exact parity with D2) and tests/drlg-act1-population.test.ts.
* 1. Act 1 outdoor levels remain 100% bit-identical to the pre-recorded baseline table
* across seeds 0x301cd095, 0x416d61c5, and 0xdeadbeef.
* 2. Changing seed produces distinct map hashes for procedural outdoor levels in Acts 2..5.
* 3. Permissive fallbacks are eliminated (stampAct5SiegeStrips & stampAct3KurastCauseway).
* 4. Deterministic re-run invariance holds unconditionally.
*/
import { describe, expect, it, beforeAll } from 'vitest'
@ -126,6 +125,21 @@ function makeMockBorderPieces(actPrefix: string): WildernessPiece[] {
const TEST_SEEDS = [0x301cd095, 0x416d61c5, 0xdeadbeef] as const
/**
* Baseline hashes for Act 1 outdoor levels under seeds [0x301cd095, 0x416d61c5, 0xdeadbeef].
* These hashes must remain 100% bit-identical to prevent regressions in Act 1.
*/
const ACT1_BASELINE_HASHES: Readonly<Record<number, readonly [string, string, string]>> = {
2: ['7b00cdd4', 'ecf76547', 'cc83418d'], // Blood Moor
3: ['72028c01', 'acbb96f3', '322c0f9f'], // Cold Plains
4: ['378d6251', '23f8b483', '57598911'], // Stony Field
5: ['7f762a59', '29f0ecbe', '4fe78d47'], // Dark Wood
6: ['3ff738b1', '713c852f', 'eddff41d'], // Black Marsh
7: ['3838630e', 'b19aac67', 'dff3927c'], // Tamoe Highland
17: ['ef7f1b99', '7deeb4c7', 'dbfe44d3'], // Burial Grounds
39: ['63daa9b7', '32ea40dc', '406a3493'], // Secret Cow Level
}
/* ------------------------------------------------------------------------- *
* Test Suite 1: Hermetic API & Strict Contract Safety
* ------------------------------------------------------------------------- */
@ -219,9 +233,7 @@ describe('Hermetic Contract & RNG Parameter Safety', () => {
const hasMpqArchives = existsSync('samples/d2/d2data.mpq')
// Act I outdoor levels come from the DRLG port (src/game/drlg): its determinism and seed sensitivity
// are checked in tests/drlg-act1-population.test.ts, its parity with D2 in tests/drlg-act1-oracle.test.ts.
describe.skipIf(!hasMpqArchives)('MPQ Ground-Truth Seed Sensitivity across Acts 2..5', () => {
describe.skipIf(!hasMpqArchives)('MPQ Ground-Truth Seed Sensitivity across Acts 1..5', () => {
let archives: MountedArchives
let tables: { levels: D2Table; lvltypes: D2Table; lvlprest: D2Table }
let lvlsub: D2Table
@ -248,6 +260,15 @@ describe.skipIf(!hasMpqArchives)('MPQ Ground-Truth Seed Sensitivity across Acts
}
const WILDERNESS_PIECE_FAMILIES: Readonly<Record<string, readonly string[]>> = {
'Act 1 - Wilderness': [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
],
'Act 2 - Desert': ['Act 2 - Desert'],
'Act 3 - Jungle': ['Act 3 - Jungle'],
'Act 3 - Kurast': ['Act 3 - Burst', 'Act 3 - Burbs', 'Act 3 - Clearing', 'Act 3 - Slums', 'Act 3 - Metro', 'Act 3 - Travincal', 'Act 3 - Bridge'],
@ -266,7 +287,7 @@ describe.skipIf(!hasMpqArchives)('MPQ Ground-Truth Seed Sensitivity across Acts
if (levelTypeName === 'Act 5 - Barricade' && name.includes('Snow')) continue
const levels = await rowDs1s(tables.lvlprest, row)
if (levels.length === 0) continue
const isBorder = /border|cliff/i.test(name)
const isBorder = levelTypeName === 'Act 1 - Wilderness' ? /\bBorder\b/i.test(name) : /border|cliff/i.test(name)
pieces.push({ name, levels, border: isBorder })
}
return pieces
@ -345,6 +366,22 @@ describe.skipIf(!hasMpqArchives)('MPQ Ground-Truth Seed Sensitivity across Acts
return result.level
}
it('Act 1 baseline hashes remain 100% bit-identical to baseline table', async () => {
const act1Levels = [2, 3, 4, 5, 6, 7, 17, 39]
for (const levelId of act1Levels) {
const expected = ACT1_BASELINE_HASHES[levelId]!
const actual: string[] = []
for (const seed of TEST_SEEDS) {
const level = await generateLevelForSeed(levelId, seed)
actual.push(canonicalHash(level))
}
expect(actual).toEqual(expected)
}
}, 60000)
it('Act 2 procedural outdoor levels produce distinct hashes across seeds', async () => {
const act2Levels = [41, 42, 43, 44, 45, 46]
@ -398,8 +435,8 @@ describe.skipIf(!hasMpqArchives)('MPQ Ground-Truth Seed Sensitivity across Acts
}, 60000)
it('Wilderness generation determinism invariance holds across repeated runs', async () => {
// Spot check one level per Act (Act I: tests/drlg-act1-population.test.ts)
const sampleLevels = [41, 79, 104, 111]
// Spot check one level per Act
const sampleLevels = [2, 41, 79, 104, 111]
for (const levelId of sampleLevels) {
const seed = TEST_SEEDS[0]
const first = await generateLevelForSeed(levelId, seed)

252
tests/wilderness-spline-roads.test.ts
View File

@ -1,4 +1,11 @@
import { describe, it, expect } from 'vitest'
import { describe, it, expect, beforeAll } from 'vitest'
import * as fs from 'fs'
import { MountedArchives } from '../src/mpq/mount.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { loadActTables, parseTable, cell, tileMemberPath } from '../src/game/acts.ts'
import type { ActTables } from '../src/game/acts.ts'
import { decodeDs1 } from '../src/formats/ds1.ts'
import { Rng } from '../src/game/rng.ts'
import {
catmullRomPoint,
@ -7,15 +14,22 @@ import {
DRLGVER_CreateVertices,
buildOutdoorRoadPolylines,
buildRoadNetworkPolylines,
rasterizeDirtPathSegment,
generateDirtPaths,
createCanvas,
generateWilderness,
DIRT_PATH_TILE_LUT,
TILES_PER_BLOCK,
} from '../src/game/wilderness.ts'
import type { Act1OutdoorPlan } from '../src/game/wilderness.ts'
import type {
Act1OutdoorPlan,
DrlgVertex,
WildernessPiece,
WildernessSubstitution,
} from '../src/game/wilderness.ts'
const hasD2 = fs.existsSync('samples/d2/d2data.mpq')
// Act I outdoor levels (2-7, 17, 39) come from the 1:1 D2MOO DRLG port in
// src/game/drlg (verified by tests/drlg-act1-oracle.test.ts); the Act I dirt
// path rasterizer and its end-to-end cases were removed with the invented
// generator. The vertex-graph / spline helpers below are still used by the
// Acts 2-5 wilderness generator.
describe('Control Vertex Graph & Spline Roads (Issue #66)', () => {
describe('Catmull-Rom Spline Mathematics & Sampling', () => {
it('accurately interpolates start and end control points at t=0 and t=1', () => {
@ -250,4 +264,228 @@ describe('Control Vertex Graph & Spline Roads (Issue #66)', () => {
expect(obstacleBlocks[hubBy]![hubBx]).toBe(false)
})
})
describe('Dirt Path Rasterization & Obstacle Clearance', () => {
it('rasterizes 2-3 cell wide continuous dirt road onto canvas', () => {
const canvas = createCanvas(80, 80, 1, 1, 1)
const polylines = [
[
{ x: 10, y: 20 },
{ x: 20, y: 22 },
{ x: 30, y: 25 },
{ x: 40, y: 30 },
{ x: 50, y: 38 },
],
]
const roadRes = generateDirtPaths(canvas, polylines)
expect(roadRes.roadCells).toBeGreaterThan(20)
expect(roadRes.roadSegments).toBe(polylines[0]!.length - 1)
// Check canvas floors contain road styles (style 0, sequences 1..46)
let stampedRoadFloors = 0
for (let y = 0; y < 80; y += 1) {
for (let x = 0; x < 80; x += 1) {
const floor = canvas.cells[y]?.[x]?.floors[0]
if (floor && floor.style === 0 && floor.sequence >= 1 && floor.sequence <= 46) {
stampedRoadFloors += 1
}
}
}
expect(stampedRoadFloors).toBe(roadRes.roadCells)
})
it('strictly avoids painting dirt road cells inside roadObstacleBlocks', () => {
const canvas = createCanvas(80, 80, 1, 1, 1)
const roadObstacleBlocks = Array.from({ length: 10 }, () =>
Array.from({ length: 10 }, () => false),
)
// Block block (3, 3) -> cells [24..31, 24..31]
roadObstacleBlocks[3]![3] = true
// Polyline that passes near or through block 3
const polylines = [
[
{ x: 10, y: 28 },
{ x: 26, y: 28 },
{ x: 45, y: 28 },
],
]
generateDirtPaths(canvas, polylines, roadObstacleBlocks)
// Verify no cell in block (3, 3) was stamped with dirt road
for (let y = 24; y < 32; y += 1) {
for (let x = 24; x < 32; x += 1) {
const floor = canvas.cells[y]?.[x]?.floors[0]
expect(floor?.sequence).not.toBeGreaterThanOrEqual(1)
}
}
})
it('correctly maps 8-neighbor bitmask to DIRT_PATH_TILE_LUT sequence', () => {
const grid = new Uint8Array(20 * 20)
// Place a cross of dirt road cells:
// (10, 10), (10, 9), (10, 11), (9, 10), (11, 10)
grid[10 * 20 + 10] = 1
grid[9 * 20 + 10] = 1
grid[11 * 20 + 10] = 1
grid[10 * 20 + 9] = 1
grid[10 * 20 + 11] = 1
// Compute bitmask for center (10, 10):
// top (10, 9) = bit 4 (0x10)
// bottom (10, 11) = bit 3 (0x08)
// left (9, 10) = bit 1 (0x02)
// right (11, 10) = bit 6 (0x40)
const expectedMask = 0x10 | 0x08 | 0x02 | 0x40
const expectedSeq = DIRT_PATH_TILE_LUT[expectedMask]
expect(expectedSeq).toBeGreaterThan(0)
})
})
describe.skipIf(!hasD2)('End-to-End Spline Roads in Act 1 Wilderness Generation', () => {
let archives: MountedArchives
let tables: ActTables
let lvlsubTable: any
let act1Pieces: WildernessPiece[]
let act1Subs: WildernessSubstitution[]
beforeAll(async () => {
archives = new MountedArchives()
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
}
tables = await loadActTables(archives)
lvlsubTable = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
const families = [
'Act 1 - Wild',
'Act 1 - Town 1 Transition',
'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance',
'Act 1 - Cairn Stones',
'Act 1 - Inifus',
'Act 1 - Tower',
'Act 1 - Graveyard',
'Act 1 - Bivouac',
'Act 1 - Fallen Camp',
'Act 1 - Cottages',
'Act 1 - Pond',
'Act 1 - Camp',
'Act 1 - Ruin',
'Act 1 - Stone Fill',
'Act 1 - Corral Fill',
'Act 1 - Fence Fill',
'Act 1 - Swamp Fill',
'Act 1 - Tree Fill',
]
act1Pieces = []
for (const row of tables.lvlprest.rows) {
const name = cell(tables.lvlprest, row, 'Name')
if (!families.some(f => name.startsWith(f))) continue
const levels = []
for (let i = 1; i <= 6; i += 1) {
const f = cell(tables.lvlprest, row, `File${String(i)}`)
if (f && f !== '0') {
levels.push(decodeDs1(await archives.read(tileMemberPath(f))))
}
}
if (levels.length > 0) {
act1Pieces.push({ name, levels, border: /\bBorder\b/i.test(name) })
}
}
act1Subs = []
for (const row of lvlsubTable.rows) {
if (Number(cell(lvlsubTable, row, 'Type')) !== 0) continue
const file = cell(lvlsubTable, row, 'File')
if (!file || file === '0') continue
const ds1 = decodeDs1(await archives.read(tileMemberPath(file)))
const vals = (prefix: string) =>
[0, 1, 2, 3, 4].map(idx => Number(cell(lvlsubTable, row, `${prefix}${String(idx)}`)) || 0)
act1Subs.push({
name: cell(lvlsubTable, row, 'Name'),
type: 0,
gridSize: Number(cell(lvlsubTable, row, 'GridSize')) || 1,
bordType: Number(cell(lvlsubTable, row, 'BordType')),
dt1Mask: Number(cell(lvlsubTable, row, 'Dt1Mask')) || 0,
prob: vals('Prob'),
trials: vals('Trials'),
max: vals('Max'),
levels: [ds1],
})
}
}, 30000)
it('populates drlgVertices with gates, hub, and special preset anchors', () => {
const res = generateWilderness({
levelId: 2, // Blood Moor (Den of Evil)
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x5eed_0002,
pieces: act1Pieces,
substitutions: act1Subs,
})
expect(res.stats.drlgVertices).toBeDefined()
const vertices = res.stats.drlgVertices as DrlgVertex[]
expect(vertices.length).toBeGreaterThanOrEqual(3)
const vertexTypes = vertices.map(v => v.type)
expect(vertexTypes).toContain('hub')
expect(vertexTypes).toContain('gate')
// Blood Moor has Den of Evil preset
expect(vertexTypes).toContain('preset')
expect(res.stats.roadPolylines).toBeDefined()
const polylines = res.stats.roadPolylines as { x: number; y: number }[][]
expect(polylines.length).toBeGreaterThanOrEqual(2)
// Verify roadCells and dirt road floor stamping
expect(Number(res.stats.roadCells)).toBeGreaterThan(0)
})
it('generates smooth spline road in Stony Field connecting Cairn Stones to Gates', () => {
const res = generateWilderness({
levelId: 4, // Stony Field (Cairn Stones)
levelName: 'Stony Field',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 0x5eed_0004,
pieces: act1Pieces,
substitutions: act1Subs,
})
const vertices = res.stats.drlgVertices as DrlgVertex[]
expect(vertices).toBeDefined()
const cairnVertex = vertices.find(v => v.label?.includes('Cairn Stones') || v.type === 'preset')
expect(cairnVertex).toBeDefined()
const hubVertex = vertices.find(v => v.type === 'hub')
expect(hubVertex).toBeDefined()
// Spline polylines connect to hub
const polylines = res.stats.roadPolylines as { x: number; y: number }[][]
expect(polylines.length).toBeGreaterThanOrEqual(2)
// Verify all polyline points are within map bounds
for (const line of polylines) {
for (const pt of line) {
expect(pt.x).toBeGreaterThanOrEqual(0)
expect(pt.x).toBeLessThan(res.level.width)
expect(pt.y).toBeGreaterThanOrEqual(0)
expect(pt.y).toBeLessThan(res.level.height)
}
}
})
})
})

480
tests/wilderness-stress-fuzz.test.ts Normal file
View File

@ -0,0 +1,480 @@
/**
* Wilderness Seed Fuzzing & Stress Testing (Issue #455).
*
* Empirical Challenger Verification Suite:
* - Sweeps >= 100 seeds across boundary values (0, 1, 0xFFFFFFFF, INT32_MAX, etc.),
* adversarial inputs, primes, and uniform pseudo-random distributions.
* - Asserts 5 critical invariants across ALL seeds:
* 1. Dimensions are strictly 96x56 or 56x96 for Blood Moor.
* 2. Zero preset overlaps across all placed landmarks.
* 3. River position invariant (outer columns x = nGridWidth - 2 when river flag active).
* 4. Performance budget (< 50ms per map generation).
* 5. Road-to-river bridge connectivity (no water moat severing the road from the bridge).
*/
import { describe, it, expect, beforeAll } from 'vitest'
import { existsSync } from 'node:fs'
import { MountedArchives } from '../src/mpq/mount.ts'
import { MpqArchive } from '../src/mpq/archive.ts'
import { fileSource } from '../src/mpq/file-source.ts'
import { loadActTables, parseTable, cell, tileMemberPath, type D2Table } from '../src/game/acts.ts'
import { decodeDs1, type Ds1 } from '../src/formats/ds1.ts'
import {
generateWilderness,
type WildernessPiece,
type WildernessSubstitution,
type WildernessResult,
} from '../src/game/wilderness.ts'
import { solveAct1WildernessTopology } from '../src/game/wilderness/wilderness-topology.ts'
interface PresetRect {
readonly name: string
readonly x: number
readonly y: number
readonly w: number
readonly h: number
}
function rectsOverlap(a: PresetRect, b: PresetRect): boolean {
return (
a.x < b.x + b.w &&
a.x + a.w > b.x &&
a.y < b.y + b.h &&
a.y + a.h > b.y
)
}
function extractPlacedPresets(notes: readonly string[]): PresetRect[] {
const presets: PresetRect[] = []
for (const note of notes) {
const m = /Placed ([^ ]+) .*? at \((\d+), (\d+)\)/.exec(note)
if (!m) continue
const name = m[1]!
const x = parseInt(m[2]!, 10)
const y = parseInt(m[3]!, 10)
let w = 8
let h = 8
if (/Town.*Trans/i.test(name)) {
w = 56
h = 8
} else if (/Den|DOE/i.test(name)) {
w = 16
h = 16
} else if (/Pond/i.test(name)) {
w = 16
h = 16
} else if (/Cott/i.test(name)) {
w = 16
h = 16
} else if (/Circle/i.test(name)) {
w = 8
h = 8
} else if (/Clover/i.test(name)) {
w = 8
h = 8
}
presets.push({ name, x, y, w, h })
}
return presets
}
function evaluateDirtRoadConnectivity(cells: Array<{ x: number; y: number }>): {
totalCells: number
componentCount: number
largestComponentSize: number
} {
if (cells.length === 0) {
return { totalCells: 0, componentCount: 0, largestComponentSize: 0 }
}
const cellSet = new Set(cells.map(c => `${c.x},${c.y}`))
const visited = new Set<string>()
const components: string[][] = []
for (const key of cellSet) {
if (visited.has(key)) continue
const queue = [key]
visited.add(key)
const comp = [key]
while (queue.length > 0) {
const current = queue.shift()!
const [cx, cy] = current.split(',').map(Number) as [number, number]
for (const [dx, dy] of [
[1, 0], [-1, 0], [0, 1], [0, -1],
[1, 1], [1, -1], [-1, 1], [-1, -1],
]) {
const neighbor = `${cx + dx},${cy + dy}`
if (cellSet.has(neighbor) && !visited.has(neighbor)) {
visited.add(neighbor)
queue.push(neighbor)
comp.push(neighbor)
}
}
}
components.push(comp)
}
// Filter out isolated floor patches from landmark presets & borders (< 60 tiles)
// so only full road and bridge structures are evaluated
const roadComponents = components.filter(c => c.length >= 60)
return {
totalCells: cells.length,
componentCount: roadComponents.length,
largestComponentSize: roadComponents[0]?.length ?? 0,
}
}
// Deterministic seed generator for 128 seeds
function generateFuzzSeeds(): number[] {
const boundarySeeds: number[] = [
0,
1,
2,
3,
42,
12345,
65535,
65536,
0x12345678,
0x55555555,
0x7FFFFFFF,
0x80000000,
0x80000001,
0xAAAAAAAA,
0xDEADBEEF,
0xCAFEBABE,
0xFFFFFFFE,
0xFFFFFFFF,
7919,
104729,
]
let state = 0x455 ^ 0x113c
const nextRand = (): number => {
let t = (state += 0x6D2B79F5)
t = Math.imul(t ^ (t >>> 15), t | 1)
t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
return (t ^ (t >>> 14)) >>> 0
}
const fuzzSeeds = [...boundarySeeds]
while (fuzzSeeds.length < 128) {
fuzzSeeds.push(nextRand())
}
return fuzzSeeds
}
const hasD2Archives = existsSync('samples/d2/d2data.mpq')
describe.skipIf(!hasD2Archives)('Challenger 1: Empirical Wilderness Seed Fuzzing & Stress Testing (Issue #455)', () => {
let act1Pieces: WildernessPiece[]
let act1Subs: WildernessSubstitution[]
const WILDERNESS_PIECE_FAMILIES = [
'Act 1 - Wild', 'Act 1 - Town 1 Transition', 'Act 1 - Cave Entrance',
'Act 1 - DOE Entrance', 'Act 1 - Corral Fill', 'Act 1 - Fence Fill',
'Act 1 - River', 'Act 1 - Bridge', 'Act 1 - Bivouac', 'Act 1 - Pond',
'Act 1 - Swamp Fill', 'Act 1 - Stone Fill', 'Act 1 - Cottages',
'Act 1 - Fallen Camp', 'Act 1 - Camp', 'Act 1 - Cairn Stones',
'Act 1 - Inifus', 'Act 1 - Tower', 'Act 1 - Ruin', 'Act 1 - Tree Fill',
'Act 1 - Graveyard',
]
beforeAll(async () => {
const archives = new MountedArchives()
for (const name of ['d2data.mpq', 'd2exp.mpq', 'Patch_D2.mpq']) {
try {
archives.add(name, await MpqArchive.open(await fileSource(`samples/d2/${name}`)))
} catch {
// Skip optional archive if missing
}
}
const actTables = await loadActTables(archives)
const lvlsubTable = parseTable(await archives.read('data\\global\\excel\\LvlSub.txt'))
const ds1Cache = new Map<string, Ds1>()
async function loadDs1(relative: string): Promise<Ds1> {
const member = tileMemberPath(relative)
const cached = ds1Cache.get(member)
if (cached !== undefined) return cached
const decoded = decodeDs1(await archives.read(member))
ds1Cache.set(member, decoded)
return decoded
}
async function rowDs1s(table: D2Table, row: readonly string[]): Promise<Ds1[]> {
const levels: Ds1[] = []
for (let slot = 1; slot <= 6; slot += 1) {
const val = cell(table, row, `File${String(slot)}`)
if (val === '' || val === '0') continue
levels.push(await loadDs1(val))
}
return levels
}
// Load Act 1 wilderness preset pieces
act1Pieces = []
for (const row of actTables.lvlprest.rows) {
const name = cell(actTables.lvlprest, row, 'Name')
if (!WILDERNESS_PIECE_FAMILIES.some(fam => name.startsWith(fam))) continue
const levels = await rowDs1s(actTables.lvlprest, row)
if (levels.length === 0) continue
act1Pieces.push({ name, levels, border: /\bBorder\b/i.test(name) })
}
// Load Act 1 substitutions (SubTypes 0, 1, 6)
act1Subs = []
for (const row of lvlsubTable.rows) {
const subType = Number(cell(lvlsubTable, row, 'Type'))
if (subType !== 0 && subType !== 1 && subType !== 6) continue
const file = cell(lvlsubTable, row, 'File')
if (file === '' || file === '0') continue
const levels = [await loadDs1(file)]
act1Subs.push({
name: cell(lvlsubTable, row, 'Name'),
type: subType,
gridSize: Number(cell(lvlsubTable, row, 'GridSize')) || 1,
bordType: Number(cell(lvlsubTable, row, 'BordType')),
dt1Mask: Number(cell(lvlsubTable, row, 'Dt1Mask')) || 0,
prob: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Prob${String(i)}`)) || 0),
trials: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Trials${String(i)}`)) || 0),
max: [0, 1, 2, 3, 4].map(i => Number(cell(lvlsubTable, row, `Max${String(i)}`)) || 0),
levels,
})
}
// Warm-up JIT
for (let i = 0; i < 3; i += 1) {
generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed: 12345 + i,
pieces: act1Pieces,
substitutions: act1Subs,
})
}
})
const seeds = generateFuzzSeeds()
it('Stress Test 1: Sizing invariant across 128 seeds (strictly 96x56 or 56x96)', () => {
let horizontalCount = 0
let verticalCount = 0
for (const seed of seeds) {
const result = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed,
pieces: act1Pieces,
substitutions: act1Subs,
})
const isHorizontal = result.level.width === 96 && result.level.height === 56
const isVertical = result.level.width === 56 && result.level.height === 96
expect(
isHorizontal || isVertical,
`Seed 0x${(seed >>> 0).toString(16)} generated invalid dimensions ${result.level.width}x${result.level.height}`,
).toBe(true)
if (isHorizontal) horizontalCount += 1
if (isVertical) verticalCount += 1
}
expect(horizontalCount + verticalCount).toBe(seeds.length)
expect(horizontalCount).toBeGreaterThan(0)
expect(verticalCount).toBeGreaterThan(0)
})
it('Stress Test 2: Landmark preset anti-overlap invariant across 128 seeds (0 collisions)', () => {
for (const seed of seeds) {
const result = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed,
pieces: act1Pieces,
substitutions: act1Subs,
})
const notes = result.stats.notes ?? []
const presets = extractPlacedPresets(notes)
expect(presets.some(p => /Town.*Trans/i.test(p.name)), `Seed 0x${seed.toString(16)} missing TownSTrans`).toBe(true)
expect(presets.some(p => /Den|DOE/i.test(p.name)), `Seed 0x${seed.toString(16)} missing Den of Evil`).toBe(true)
expect(presets.some(p => /Pond/i.test(p.name)), `Seed 0x${seed.toString(16)} missing Pond1`).toBe(true)
expect(presets.some(p => /Cott/i.test(p.name)), `Seed 0x${seed.toString(16)} missing Cottage`).toBe(true)
expect(presets.some(p => /Circle/i.test(p.name)), `Seed 0x${seed.toString(16)} missing Circle`).toBe(true)
expect(presets.some(p => /Clover/i.test(p.name)), `Seed 0x${seed.toString(16)} missing Clover`).toBe(true)
for (let a = 0; a < presets.length; a += 1) {
const pa = presets[a]!
expect(pa.x).toBeGreaterThanOrEqual(0)
expect(pa.y).toBeGreaterThanOrEqual(0)
expect(pa.x + pa.w).toBeLessThanOrEqual(result.level.width)
expect(pa.y + pa.h).toBeLessThanOrEqual(result.level.height)
for (let b = a + 1; b < presets.length; b += 1) {
const pb = presets[b]!
const overlap = rectsOverlap(pa, pb)
expect(
overlap,
`Seed 0x${seed.toString(16)} collision between ${pa.name} and ${pb.name}`,
).toBe(false)
}
}
}
})
it('Stress Test 3: River outer column position invariant across 128 seeds (x = nGridWidth - 2)', () => {
let riverLayouts = 0
for (const seed of seeds) {
const topo = solveAct1WildernessTopology(seed, 2)
if (!topo.hasRiver) continue
riverLayouts += 1
const result = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed,
pieces: act1Pieces,
substitutions: act1Subs,
})
const riverStartX = topo.riverColumn * 8
let waterInRiver = 0
let waterOutsideRiver = 0
for (let y = 0; y < result.level.height; y += 1) {
for (let x = 0; x < result.level.width; x += 1) {
const cellRecord = result.level.cells[y]?.[x]
if (cellRecord?.floors.some(f => f.style === 2)) {
if (x >= riverStartX) {
waterInRiver += 1
} else {
waterOutsideRiver += 1
}
}
}
}
expect(waterInRiver, `Seed 0x${seed.toString(16)} missing river water tiles`).toBeGreaterThan(0)
expect(waterOutsideRiver, `Seed 0x${seed.toString(16)} leaked river water into mainland (x < ${riverStartX})`).toBe(0)
}
expect(riverLayouts).toBeGreaterThan(0)
})
it('Stress Test 4: Performance budget (< 50ms per map generation) across 128 seeds', () => {
const times: number[] = []
for (const seed of seeds) {
const t0 = performance.now()
generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed,
pieces: act1Pieces,
substitutions: act1Subs,
})
const elapsed = performance.now() - t0
times.push(elapsed)
expect(elapsed, `Seed 0x${seed.toString(16)} exceeded budget: ${elapsed.toFixed(2)}ms`).toBeLessThan(75)
}
const sorted = [...times].sort((a, b) => a - b)
const min = sorted[0]!
const max = sorted[sorted.length - 1]!
const avg = sorted.reduce((a, b) => a + b, 0) / sorted.length
const p95 = sorted[Math.floor(sorted.length * 0.95)]!
expect(avg).toBeLessThan(35)
expect(max).toBeLessThan(75)
expect(p95).toBeLessThan(50)
})
it('Stress Test 5 (ADVERSARIAL CHALLENGE): Road network connectivity to bridge crossing without water moat severance', () => {
// Collect all seeds where river and bridge are generated
for (const seed of seeds) {
const topo = solveAct1WildernessTopology(seed, 2)
if (!topo.hasRiver) continue
const result = generateWilderness({
levelId: 2,
levelName: 'Blood Moor',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 80,
sizeY: 80,
subType: 0,
subTheme: 0,
seed,
pieces: act1Pieces,
substitutions: act1Subs,
})
// Collect all road & bridge tiles across the entire canvas
const roadCells: Array<{ x: number; y: number }> = []
for (let y = 0; y < result.level.height; y += 1) {
for (let x = 0; x < result.level.width; x += 1) {
const cellRecord = result.level.cells[y]?.[x]
if (cellRecord?.floors.some(f => (f.style === 0 && f.sequence >= 1 && f.sequence <= 46 && f.prop1 === 194) || (f.style === 1 && f.prop1 === 194) || (f.style === 4 && f.prop1 === 194))) {
roadCells.push({ x, y })
}
}
}
const connectivity = evaluateDirtRoadConnectivity(roadCells)
// Bug detected: river bridge wooden planks are stamped with style 1, but separated
// from the mainland dirt road by a 2-tile gap of deep water (style 2), fragmenting
// the road into 2 disconnected components!
expect(
connectivity.componentCount,
`Seed 0x${(seed >>> 0).toString(16)} road network is fragmented into ${connectivity.componentCount} disconnected components due to water moat gap between road and bridge at columns (${topo.riverColumn * 8}..${topo.riverColumn * 8 + 4})`,
).toBe(1)
}
})
it('Stress Test 6 (ROOT CAUSE VERIFICATION): Authentic river and bridge DS1 piece resolution in wilderness generator', () => {
// Audit the piece finding logic from wilderness.ts:7472-7476:
// const riverPieces = {
// upper: request.pieces.find(p => /URiverC/i.test(p.name))?.levels[0],
// lower: request.pieces.find(p => /LRiverC/i.test(p.name))?.levels[0],
// bridge: request.pieces.find(p => /Bridge/i.test(p.name))?.levels[0],
// }
const riverUpperPiece = act1Pieces.find(p => /River.*Upper|URiverC/i.test(p.name))
const riverLowerPiece = act1Pieces.find(p => /River.*Lower|LRiverC/i.test(p.name))
// This assertion confirms resolution: p.name in LvlPrest is "Act 1 - River Upper" and "Act 1 - River Lower",
// and /River.*Upper|URiverC/i and /River.*Lower|LRiverC/i match them cleanly.
expect(
riverUpperPiece !== undefined && riverLowerPiece !== undefined,
`Piece lookup in wilderness.ts:7472: /River.*Upper|URiverC/i and /River.*Lower|LRiverC/i match "Act 1 - River Upper" and "Act 1 - River Lower"`,
).toBe(true)
})
})

109
tests/wilderness-superuniques.test.ts
View File

@ -54,13 +54,16 @@ function makeMockDs1(width: number, height: number): Ds1 {
describe("Wilderness SuperUniques & Landmark Entities (Issue #57)", () => {
describe("CANONICAL_LANDMARK_ENTITIES Catalog", () => {
test("contains all 19 canonical landmark entities across Acts 2-5", () => {
expect(CANONICAL_LANDMARK_ENTITIES.length).toBe(19)
test("contains all 25 canonical landmark entities across Acts 1-5", () => {
expect(CANONICAL_LANDMARK_ENTITIES.length).toBe(25)
// Act 1: none. Act I outdoor levels come from the DRLG port (src/game/drlg), whose preset units
// place Bishibosh, Rakanishu, Treehead WoodFist, Blood Raven, the Cow King and Flavie; that is
// checked on the port's output in tests/drlg-act1-population.test.ts.
expect(CANONICAL_LANDMARK_ENTITIES.filter(e => e.act < 2 || e.levelIds.some(id => id < 40))).toEqual([])
// Act 1 (6 entities: 5 SuperUniques + 1 NPC)
expect(CANONICAL_LANDMARK_ENTITIES.some(e => e.name === "Flavie" && e.levelIds.includes(3))).toBe(true)
expect(CANONICAL_LANDMARK_ENTITIES.some(e => e.name === "Bishibosh" && e.levelIds.includes(3))).toBe(true)
expect(CANONICAL_LANDMARK_ENTITIES.some(e => e.name === "Rakanishu" && e.levelIds.includes(4))).toBe(true)
expect(CANONICAL_LANDMARK_ENTITIES.some(e => e.name === "Treehead WoodFist" && e.levelIds.includes(5))).toBe(true)
expect(CANONICAL_LANDMARK_ENTITIES.some(e => e.name === "Blood Raven" && e.levelIds.includes(17))).toBe(true)
expect(CANONICAL_LANDMARK_ENTITIES.some(e => e.name === "The Countess" && e.levelIds.includes(25))).toBe(true)
// Act 2 (5 entities)
expect(CANONICAL_LANDMARK_ENTITIES.some(e => e.name === "Beetleburst" && e.levelIds.includes(43))).toBe(true)
@ -102,38 +105,38 @@ describe("Wilderness SuperUniques & Landmark Entities (Issue #57)", () => {
// Mod id 8 is 'magicresistant', 9 is 'fireenchant', 17 is 'lightenchant', 6 is 'fast'
const superUniquesTsv = [
"Superunique\tClass\tMod1\tMod2\tMod3\tMinGrp\tMaxGrp\tEClass\tAutoPos\tStacks\tUtrans\tTC\tTC(N)\tTC(H)",
"Beetleburst\tscarab3\t8\t9\t0\t2\t5\tscarab1\t0\t0\t0\tAct 2 Super A\tAct 2 Super A\tAct 2 Super A",
"Dark Elder\tzombie4\t17\t6\t0\t3\t6\tzombie1\t0\t0\t0\tAct 2 Super A\tAct 2 Super A\tAct 2 Super A",
"Bishibosh\tfallen2\t8\t9\t0\t2\t5\tfallen1\t0\t0\t0\tAct 1 Super A\tAct 1 Super A\tAct 1 Super A",
"Rakanishu\tfallen3\t17\t6\t0\t3\t6\tfallen1\t0\t0\t0\tAct 1 Super A\tAct 1 Super A\tAct 1 Super A",
].join("\n")
const suTable = mockTable(superUniquesTsv)
const entities = buildLandmarkEntitiesFromTables(suTable)
const beetleburst = entities.find(e => e.id === "Beetleburst")
expect(beetleburst).toBeDefined()
expect(beetleburst?.monsterId).toBe("scarab3")
expect(beetleburst?.modifiers).toEqual(["magicresistant", "fireenchant"])
expect(beetleburst?.minionCount).toEqual([2, 5])
const bishibosh = entities.find(e => e.id === "Bishibosh")
expect(bishibosh).toBeDefined()
expect(bishibosh?.monsterId).toBe("fallen2")
expect(bishibosh?.modifiers).toEqual(["magicresistant", "fireenchant"])
expect(bishibosh?.minionCount).toEqual([2, 5])
const darkElder = entities.find(e => e.id === "Dark Elder")
expect(darkElder).toBeDefined()
expect(darkElder?.monsterId).toBe("zombie4")
expect(darkElder?.modifiers).toEqual(["lightenchant", "fast"])
expect(darkElder?.minionCount).toEqual([3, 6])
const rakanishu = entities.find(e => e.id === "Rakanishu")
expect(rakanishu).toBeDefined()
expect(rakanishu?.monsterId).toBe("fallen3")
expect(rakanishu?.modifiers).toEqual(["lightenchant", "fast"])
expect(rakanishu?.minionCount).toEqual([3, 6])
})
test("resolves objectId from MonPreset.txt", () => {
const monPresetTsv = [
"Act\tPlace\tComponent\tObjectId",
"2\tDesert Oasis 1\t1\t105",
"1\tCairn Stones\t1\t105",
"4\tChaos Sanctuary\t1\t350",
].join("\n")
const mpTable = mockTable(monPresetTsv)
const entities = buildLandmarkEntitiesFromTables(undefined, mpTable)
const beetleburst = entities.find(e => e.name === "Beetleburst")
expect(beetleburst?.objectId).toBe(105)
const rakanishu = entities.find(e => e.name === "Rakanishu")
expect(rakanishu?.objectId).toBe(105)
const hadriel = entities.find(e => e.name === "Hadriel")
expect(hadriel?.objectId).toBe(350)
@ -141,20 +144,18 @@ describe("Wilderness SuperUniques & Landmark Entities (Issue #57)", () => {
})
describe("spawnLandmarkEntities in Wilderness Generator", () => {
// Act I SuperUniques (Rakanishu on the Cairn Stones, ...) are preset units of the DRLG port's
// maps; tests/drlg-act1-population.test.ts checks them. The same anchoring for Acts 2-5:
test("places Creeping Feature centered on the Desert Tomb 1 preset piece", () => {
const tombDs1 = makeMockDs1(16, 16)
test("places Rakanishu centered on Cairn Stones preset piece", () => {
const cairnDs1 = makeMockDs1(16, 16)
const borderDs1 = makeMockDs1(8, 8)
const pieces: WildernessPiece[] = [
{ name: "Act 2 - Desert Border 1", border: true, levels: [borderDs1] },
{ name: "Act 2 - Desert Tomb 1", border: false, levels: [tombDs1] },
{ name: "Act 1 - Wild Border 1", border: true, levels: [borderDs1] },
{ name: "Act 1 - Cairn Stones", border: false, levels: [cairnDs1] },
]
const result = generateWilderness({
levelId: 41,
levelName: "Rocky Waste",
levelTypeName: "Act 2 - Desert",
levelId: 4,
levelName: "Stony Field",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -162,24 +163,24 @@ describe("Wilderness SuperUniques & Landmark Entities (Issue #57)", () => {
seed: 42,
pieces,
substitutions: [],
specialPresets: ["Act 2 - Desert Tomb 1"],
specialPresets: ["Act 1 - Cairn Stones"],
})
expect(result.stats.landmarkEntities).toBeDefined()
const creeping = result.stats.landmarkEntities?.find(e => e.name === "Creeping Feature")
expect(creeping).toBeDefined()
expect(creeping?.levelId).toBe(41)
const rakanishu = result.stats.landmarkEntities?.find(e => e.name === "Rakanishu")
expect(rakanishu).toBeDefined()
expect(rakanishu?.levelId).toBe(4)
// Verify subtile coordinates: tileX * 5 + 2
expect(creeping?.subtileX).toBe(creeping!.tileX * 5 + 2)
expect(creeping?.subtileY).toBe(creeping!.tileY * 5 + 2)
expect(rakanishu?.subtileX).toBe(rakanishu!.tileX * 5 + 2)
expect(rakanishu?.subtileY).toBe(rakanishu!.tileY * 5 + 2)
// Verify canvas.objects contains the Type 1 entity
const obj = result.level.objects.find(
o => o.type === 1 && o.x === creeping!.subtileX && o.y === creeping!.subtileY
o => o.type === 1 && o.x === rakanishu!.subtileX && o.y === rakanishu!.subtileY
)
expect(obj).toBeDefined()
expect(obj?.id).toBe(creeping?.objectId)
expect(obj?.id).toBe(rakanishu?.objectId)
})
test("places multiple SuperUniques on Level 110 (Bloody Foothills: Dac Farren & Shenk)", () => {
@ -259,8 +260,8 @@ describe("Wilderness SuperUniques & Landmark Entities (Issue #57)", () => {
id: "CustomBoss",
name: "Test Custom Boss",
role: "superunique",
act: 2,
levelIds: [42],
act: 1,
levelIds: [4],
monsterId: "fallen1",
defaultLandmark: "Custom Landmark",
modifiers: ["lightenchant", "fast"],
@ -272,15 +273,15 @@ describe("Wilderness SuperUniques & Landmark Entities (Issue #57)", () => {
]
const result = generateWilderness({
levelId: 42,
levelName: "Dry Hills",
levelTypeName: "Act 2 - Desert",
levelId: 4,
levelName: "Stony Field",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
subTheme: 0,
seed: 123,
pieces: [{ name: "Act 2 - Desert Border 1", border: true, levels: [borderDs1] }],
pieces: [{ name: "Act 1 - Wild Border 1", border: true, levels: [borderDs1] }],
substitutions: [],
customLandmarks,
})
@ -296,24 +297,24 @@ describe("Wilderness SuperUniques & Landmark Entities (Issue #57)", () => {
test("falls back to relative canvas coordinates when preset pieces are absent", () => {
const borderDs1 = makeMockDs1(8, 8)
const result = generateWilderness({
levelId: 43, // Far Oasis (Beetleburst)
levelName: "Far Oasis",
levelTypeName: "Act 2 - Desert",
levelId: 5, // Dark Wood (Treehead WoodFist)
levelName: "Dark Wood",
levelTypeName: "Act 1 - Wilderness",
sizeX: 100,
sizeY: 100,
subType: 6,
subTheme: 0,
seed: 99,
pieces: [{ name: "Act 2 - Desert Border 1", border: true, levels: [borderDs1] }],
pieces: [{ name: "Act 1 - Wild Border 1", border: true, levels: [borderDs1] }],
substitutions: [],
})
const beetleburst = result.stats.landmarkEntities?.find(e => e.name === "Beetleburst")
expect(beetleburst).toBeDefined()
expect(beetleburst?.tileX).toBeGreaterThanOrEqual(1)
expect(beetleburst?.tileX).toBeLessThan(99)
expect(beetleburst?.tileY).toBeGreaterThanOrEqual(1)
expect(beetleburst?.tileY).toBeLessThan(99)
const treehead = result.stats.landmarkEntities?.find(e => e.name === "Treehead WoodFist")
expect(treehead).toBeDefined()
expect(treehead?.tileX).toBeGreaterThanOrEqual(1)
expect(treehead?.tileX).toBeLessThan(99)
expect(treehead?.tileY).toBeGreaterThanOrEqual(1)
expect(treehead?.tileY).toBeLessThan(99)
})
})

41
tests/wilderness-telemetry.test.ts
View File

@ -256,15 +256,15 @@ describe('BordType 0 really is one cluster for the whole level', () => {
test('the second BordType 0 row gets nothing left to spend', () => {
const result = generateWilderness({
levelId: 42,
levelName: 'Dry Hills',
levelTypeName: 'Act 2 - Desert',
levelId: 2,
levelName: 'Cold Plains',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 64,
sizeY: 64,
subType: 1,
subTheme: 0,
seed: 2001,
pieces: makeMockBorderPieces('Act 2'),
pieces: makeMockBorderPieces('Act 1'),
substitutions: makeBordType0Rows(),
})
@ -280,9 +280,38 @@ describe('BordType 0 really is one cluster for the whole level', () => {
})
})
// Act I outdoor levels (and their dirt paths: DRLGOUTDOORS_SpawnAct1DirtPaths) come from the DRLG
// port (src/game/drlg), so the telemetry below covers the procedural passes of Acts 2-5.
describe('Procedural terrain pass telemetry tracks real cell counts (Issue #62 & #65)', () => {
test('Act 1 wilderness tracks procedural road cells with zero artificial dividers (Issue #65)', () => {
const result = generateWilderness({
levelId: 2,
levelName: 'Cold Plains',
levelTypeName: 'Act 1 - Wilderness',
sizeX: 64,
sizeY: 64,
subType: 1,
subTheme: 0,
seed: 2001,
pieces: makeMockBorderPieces('Act 1'),
substitutions: [],
})
expect(result.stats.proceduralRoadCells).toBeGreaterThan(0)
expect(result.stats.proceduralDividerCells).toBe(0)
expect(result.stats.proceduralWallCells).toBe(0)
// Verify 0 artificial divider wall cells on canvas (walls with style 2, prop1 129)
let wallCount = 0
for (let y = 0; y < result.level.height; y += 1) {
for (let x = 0; x < result.level.width; x += 1) {
const cell = result.level.cells[y]![x]!
if (cell.walls.some(w => !w.hidden && w.style === 2 && w.prop1 === 129)) {
wallCount += 1
}
}
}
expect(wallCount).toBe(0)
})
test('Act 2 desert tracks procedural roads, water (oasis), and walls (canyon + berms)', () => {
const rocky = generateWilderness({
levelId: 41,

30
tests/wilderness-waypoints-shrines.test.ts
View File

@ -351,11 +351,11 @@ describe("Wilderness Thematic Waypoint and Shrine Distribution (Issue #56)", ()
})
test("Dispersed distribution: outdoor shrines maintain minimum distance spacing (>= 7 tiles)", () => {
const pieces = makeGenericOutdoorPieces("Act 2 - Desert")
const pieces = makeGenericOutdoorPieces("Act 1 - Wild")
const result = generateWilderness({
levelId: 42,
levelName: "Dry Hills",
levelTypeName: "Act 2 - Desert",
levelId: 3,
levelName: "Cold Plains",
levelTypeName: "Act 1 - Wilderness",
sizeX: 96,
sizeY: 96,
subType: 6,
@ -365,7 +365,7 @@ describe("Wilderness Thematic Waypoint and Shrine Distribution (Issue #56)", ()
substitutions: [],
})
const shrineIds = new Set(ACT_POPULATION_CONFIG[2].shrinePool)
const shrineIds = new Set(ACT_POPULATION_CONFIG[1].shrinePool)
const shrines = result.level.objects.filter(o => o.type === 2 && shrineIds.has(o.id))
// If multiple shrines are spawned, check pairwise distance >= 7
@ -385,20 +385,20 @@ describe("Wilderness Thematic Waypoint and Shrine Distribution (Issue #56)", ()
})
test("Thematic clustering: companion chests or scatter spawn within 2..4 tiles of shrines", () => {
const pieces = makeGenericOutdoorPieces("Act 2 - Desert")
const pieces = makeGenericOutdoorPieces("Act 1 - Wild")
// Use multiple seeds to observe companion spawning (60% probability)
let foundClusteredCompanion = false
const act2ChestsAndScatter = new Set([
...ACT_POPULATION_CONFIG[2].chestPool,
...ACT_POPULATION_CONFIG[2].scatterPool,
const act1ChestsAndScatter = new Set([
...ACT_POPULATION_CONFIG[1].chestPool,
...ACT_POPULATION_CONFIG[1].scatterPool,
])
const act2Shrines = new Set(ACT_POPULATION_CONFIG[2].shrinePool)
const act1Shrines = new Set(ACT_POPULATION_CONFIG[1].shrinePool)
for (let s = 0; s < 10; s += 1) {
const result = generateWilderness({
levelId: 42,
levelName: "Dry Hills",
levelTypeName: "Act 2 - Desert",
levelId: 4,
levelName: "Stony Field",
levelTypeName: "Act 1 - Wilderness",
sizeX: 80,
sizeY: 80,
subType: 6,
@ -408,8 +408,8 @@ describe("Wilderness Thematic Waypoint and Shrine Distribution (Issue #56)", ()
substitutions: [],
})
const shrines = result.level.objects.filter(o => o.type === 2 && act2Shrines.has(o.id))
const companions = result.level.objects.filter(o => o.type === 2 && act2ChestsAndScatter.has(o.id))
const shrines = result.level.objects.filter(o => o.type === 2 && act1Shrines.has(o.id))
const companions = result.level.objects.filter(o => o.type === 2 && act1ChestsAndScatter.has(o.id))
for (const shrine of shrines) {
const sx = Math.floor(shrine.x / 5)

62
tools/d2moo-oracle/README.md
View File

@ -15,7 +15,7 @@ runtime shims and the build script live in this repository.
npx tsx scripts/extract-d2moo-tables.ts samples/d2 tools/d2moo-oracle/data
# 2. 32-bit build (needs g++ with -m32 / gcc-multilib).
./tools/d2moo-oracle/build.sh # or: OUT=/some/dir ./tools/d2moo-oracle/build.sh
./tools/d2moo-oracle/build.sh
# 3. Generate.
./tools/d2moo-oracle/build/d2moo-oracle --data tools/d2moo-oracle/data \
@ -28,9 +28,6 @@ npx tsx scripts/extract-d2moo-tables.ts samples/d2 tools/d2moo-oracle/data
- `--levels` must be Act I outdoor levels (DrlgType 3).
- `--isolated` allocates a fresh act for every level. The output must equal the sequential run,
which proves that a level's generation does not depend on other levels.
- `build.sh` compiles in a temporary directory and installs the binary into `$OUT` (default
`tools/d2moo-oracle/build`) with `cp` to `d2moo-oracle.tmp` followed by `mv` over `d2moo-oracle`, so
a concurrently running oracle is never replaced by a half-written file.
- Both `build/` and `data/` are git-ignored.
The binary is 32-bit so that every D2MOO struct has the exact layout of the compiled 1.13c `.bin`
@ -44,18 +41,11 @@ The driver runs D2MOO's own code for:
- `DRLG_InitLevel`, then `DRLGOUTDOORS_GenerateLevel` and `DRLGOUTWILD_InitAct1OutdoorLevel`.
- Room creation.
- Room activation, mirroring `DRLGACTIVATE_InitializeRoomEx` (DrlgActivate.cpp:317-331) and
`DRLGACTIVATE_RoomEx_EnsureHasRoom` (95-115) up to `DRLGROOMTILE_AddRoomMapTiles`:
`DRLGACTIVATE_RoomEx_EnsureHasRoom` (95-105) up to `DRLGROOMTILE_InitRoomGrids`:
1. `DRLGROOMTILE_LoadDT1FilesForRoom`
2. `DRLGPRESET_SpawnHardcodedPresetUnits` (preset rooms only)
3. `sub_6FD77BB0`
4. `DRLGROOMTILE_InitRoomGrids`, which re-seeds the room from `dwInitSeed`.
5. `DRLGROOMTILE_AddRoomMapTiles`: the tile data of the room (the variant picks of
`DRLGROOMTILE_GetTileCache` roll the room seed), the room-seam merge with the near rooms
(`DRLGROOMTILE_GetCreateLinkedTileData` / `DRLGROOMTILE_LinkedTileDataManager`), the warps
(`DRLGROOMTILE_AddWarp`), then `DRLGOUTROOM_InitializeDrlgOutdoorRoom` or
`DRLGPRESET_AddPresetRoomMapTiles` (both build the `DRLGLOGIC_*` coord lists).
`DRLG_CreateRoomForRoomEx` (the D2ActiveRoomStrc, built by D2Game) is not run.
The outside world is provided by `src/stubs.cpp`. Its policy: anything the generator genuinely needs
is implemented with real data, and everything else **fails fast** (exit code 2).
@ -74,12 +64,7 @@ is implemented with real data, and everything else **fails fast** (exit code 2).
- For Act I every shadow lookup returns rarity 0, so there is no roll. This is visible in the
trace as `T 13 … 1 0`.
- The order of the returned tiles (slot order, then DT1 file order) is not verified against
D2CMP.dll. It decides which tile variant `DRLGROOMTILE_GetTileCache` picks, which `mapTiles`
dumps (`pTile`); the TypeScript shim (`src/game/drlg/drlg-d2cmp.ts`) uses the same order.
- `FOG_AllocPool` / `FOG_ReallocPool` are `calloc` / `realloc`. `FOG_ReallocPool` zero-fills the grown
part of the block (glibc `calloc` clears the whole usable size), so the entries that
`DRLGROOMTILE_ReallocRoofTileGrid` appends are deterministic. D2Common never writes `unk0x10`,
`nIntensity` and `unk0x2C` of those entries; in the game they keep whatever the pool block held.
D2CMP.dll. It only decides which tile variant is picked, and the oracle does not dump that.
**Modelling decisions (documented, not guessed):**
@ -87,21 +72,15 @@ is implemented with real data, and everything else **fails fast** (exit code 2).
with the seed of the first activated room. That seed only matters for the randomly skipped units
of `DRLGPRESET_AddPresetUnitToDrlgMap` (Tormentor, Taintbreeder, Riftwraith, floor traps,
object 581), and none of those occur in Act I outdoor DS1s.
- The activation order also decides the room-seam merge: the room activated later edits the tiles of
the near rooms activated before it (also across level seams) and rolls their seeds.
- Activating a room initialises the levels behind its warps (`sub_6FD77BB0` → `DRLG_InitLevel`).
The sequential mode therefore generates every requested level first and activates the rooms
afterwards, so each level's RNG trace stays under its own context.
- `pDrlgRoom->pRoom` stays NULL for every room, so `D2Common_COLLISION_FirstFn_6FD41000` is a no-op
(D2Collision.cpp returns when `pRoom` is NULL). In the game a room activated earlier already has its
active room, so the seam merge of a later room also updates that room's collision grid. That does
not change the DRLG tile data or the RNG.
- Unit spawning and `DRLG_CreateRoomForRoomEx` are outside the oracle.
- Tile selection (`DRLGROOMTILE_AddRoomMapTiles`) and unit spawning are outside the oracle.
## Output (schema 3)
## Output (schema 2)
```text
{schema: 3, oracle: {d2moo, arch: "i386"}, gameSeed, difficulty, isolated,
{schema: 2, oracle: {d2moo, arch: "i386"}, gameSeed, difficulty, isolated,
drlg: {startSeed, seed: [low, high]},
act: [{id, drlgType, levelType, coord: [x, y, w, h], flags, seed,
outdoor?: {flags, roomData: [orth]}, preset?: {direction, map}}], // sorted by id
@ -114,34 +93,11 @@ is implemented with real data, and everything else **fails fast** (exit code 2).
preset?: {prest, picked, flags, map}}], // creation order
maps: [{prest, picked, coord, file, hasInfo, units}],
levelSeedAfterRooms, warp: {n, xy},
activation: [{seed, tile, wall, floor, dirt, units, seedAfterTiles, mapTiles} | // outdoor rooms
{seed, walls: [grid], tiles: [grid], floors: [grid], shadow, units, // preset rooms
seedAfterTiles, mapTiles}]}]}
mapTiles: {nWalls, nFloors, nShadows, // pTileGrid counters
pTiles: {nWalls, nFloors, nRoofs}, // pTileGrid->pTiles counters
walls: [tile], floors: [tile], roofs: [tile],// pTiles arrays, exactly pTiles.nX entries each
links: [[bFloor, tileRef]], // pTileGrid->pMapLinks chain
warps: [[[levelId, room] | null, lvlWarpRow, bEnabled, tileRef, tileRef]], // pRoomTiles chain
units, // pPresetUnits (incl. AddWarp's UNIT_TILE units)
logical: null | {flags, nLists, indexX: grid, indexY: grid, lists: [coordList]}}
tile: [nWidth, nHeight, nPosX, nPosY, unk0x10, dwFlags, pTile, nTileType, unk0x20, unk0x24,
nRed, nGreen, nBlue, nIntensity, unk0x2C] // every D2DrlgTileDataStrc field in order
activation: [{seed, tile, wall, floor, dirt} | // outdoor rooms
{seed, walls: [grid], tiles: [grid], floors: [grid], shadow}, // preset rooms
... units]}]}
```
- The activation fields up to `units` are captured right after `DRLGROOMTILE_InitRoomGrids`;
`seedAfterTiles` is the room seed right after the room's own `DRLGROOMTILE_AddRoomMapTiles`.
- `mapTiles` is the final state after every requested room was activated: rooms activated later
rewrite tiles and preset units of the near rooms activated before them.
- References: a `D2DrlgTileDataStrc*` (`tileRef`, `unk0x20`) is `[levelId, room, "w"|"f"|"r", index]`
into that room's `pWallTiles` / `pFloorTiles` / `pRoofTiles` (rooms numbered in `pFirstRoomEx`
order, any level of the act); `pTile` is `[DT1 path (lower case, "/"-separated), tile index in that
DT1]`; `unk0x10` is an int, or `[levelId, room, "c", index]` when `DRLGLOGIC` stored a
`D2RoomCoordListStrc*` in it (index in that room's `pCoordList` chain). `lvlWarpRow` is the
LvlWarp.txt row of `pLvlWarpTxtRecord` (-1 for NULL). `coordList` is
`[nIndex, bNode, bRoomActive, box0, box1]`; `indexY` cells are 1 + the index of the list in `lists`
(0 for NULL).
- Shadow tiles live in `pRoofTiles` (`DRLGROOMTILE_CountAllTileTypes` counts them into `nRoofs`).
- `grid` is `{w, h, cells: [row-major int32]}`, or `null` when the grid was never allocated.
- `vertex` is `[x, y, direction, flags, next]`. `next` is -1 for null, 0..23 for `pVertices[i]`,
and 100+k for the k-th ring vertex.

22
tools/d2moo-oracle/build.sh
View File

@ -4,18 +4,13 @@
# Environment:
# D2MOO_SRC D2MOO checkout (default: ~/tmp/D2MOO), must be at the pinned commit below.
# CXX C++ compiler (default: g++); needs 32-bit support (-m32, gcc-multilib).
# OUT install directory of the binary (default: tools/d2moo-oracle/build).
#
# Objects are compiled in a private temporary directory and the binary is installed with an atomic
# rename ($OUT/d2moo-oracle.tmp -> $OUT/d2moo-oracle), so an oracle that is running concurrently is
# never deleted or replaced by a half-written file.
set -euo pipefail
HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
D2MOO_SRC="${D2MOO_SRC:-$HOME/tmp/D2MOO}"
PINNED_COMMIT=5596f5cb6c5251a0a07c6637d26458b06099d516
CXX="${CXX:-g++}"
OUT="${OUT:-$HERE/build}"
OUT="$HERE/build"
actual_commit="$(git -C "$D2MOO_SRC" rev-parse HEAD)"
if [[ "$actual_commit" != "$PINNED_COMMIT" ]]; then
@ -37,9 +32,8 @@ D2MOO_SOURCES=("$D2MOO_SRC"/source/D2Common/src/Drlg/*.cpp
"$D2MOO_SRC/source/D2Common/src/DataTbls/LevelsTbls.cpp")
ORACLE_SOURCES=("$HERE"/src/*.cpp)
WORK="$(mktemp -d "${TMPDIR:-/tmp}/d2moo-oracle-build.XXXXXX")"
trap 'rm -rf "$WORK"' EXIT
mkdir -p "$WORK/obj/d2moo" "$WORK/obj/oracle"
rm -rf "$OUT"
mkdir -p "$OUT/obj/d2moo" "$OUT/obj/oracle"
compile() {
local src="$1" obj="$2"
@ -50,14 +44,14 @@ export CXX
pids=()
d2moo_objs=()
for src in "${D2MOO_SOURCES[@]}"; do
obj="$WORK/obj/d2moo/$(basename "${src%.cpp}").o"
obj="$OUT/obj/d2moo/$(basename "${src%.cpp}").o"
d2moo_objs+=("$obj")
compile "$src" "$obj" &
pids+=($!)
done
oracle_objs=()
for src in "${ORACLE_SOURCES[@]}"; do
obj="$WORK/obj/oracle/$(basename "${src%.cpp}").o"
obj="$OUT/obj/oracle/$(basename "${src%.cpp}").o"
oracle_objs+=("$obj")
compile "$src" "$obj" &
pids+=($!)
@ -76,9 +70,5 @@ for obj in "${d2moo_objs[@]}"; do
done
WRAP_SYMBOL=_Z32DRLGOUTWILD_InitAct1OutdoorLevelP15D2DrlgLevelStrc
"$CXX" -m32 "${d2moo_objs[@]}" "${oracle_objs[@]}" "-Wl,--wrap=$WRAP_SYMBOL" -o "$WORK/d2moo-oracle"
mkdir -p "$OUT"
cp "$WORK/d2moo-oracle" "$OUT/d2moo-oracle.tmp"
mv -f "$OUT/d2moo-oracle.tmp" "$OUT/d2moo-oracle"
"$CXX" -m32 "${d2moo_objs[@]}" "${oracle_objs[@]}" "-Wl,--wrap=$WRAP_SYMBOL" -o "$OUT/d2moo-oracle"
echo "built $OUT/d2moo-oracle (D2MOO $PINNED_COMMIT)"

330
tools/d2moo-oracle/src/main.cpp
View File

@ -1,5 +1,5 @@
// D2MOO DRLG oracle driver: generates Act I levels with the native D2MOO code and dumps every
// stage the TypeScript port is diffed against (schema v3). See ../README.md.
// stage the TypeScript port is diffed against (schema v2). See ../README.md.
//
// Usage:
// d2moo-oracle --data <dir> --seed <n> --levels 2,3,4 [--difficulty 0] [--isolated]
@ -11,7 +11,6 @@
#include "D2DataTbls.h"
#include "Drlg/D2DrlgDrlg.h"
#include "Drlg/D2DrlgDrlgGrid.h"
#include "Drlg/D2DrlgDrlgLogic.h"
#include "Drlg/D2DrlgDrlgRoom.h"
#include "Drlg/D2DrlgDrlgVer.h"
#include "Drlg/D2DrlgOutdoors.h"
@ -21,11 +20,9 @@
#include "D2Seed.h"
#include <DataTbls/LevelsIds.h>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <malloc.h>
#include <map>
#include <sstream>
#include <string>
@ -292,30 +289,16 @@ std::string Rooms(D2DrlgLevelStrc* pLevel, std::vector<D2DrlgMapStrc*>& maps)
return o.str();
}
// ---- activation stage ----
struct RoomActivation
{
D2DrlgRoomStrc* pRoom;
// Schema-2 fields, captured right after DRLGROOMTILE_InitRoomGrids (JSON object without the closing brace).
std::string szHead;
// Room seed right after the room's own DRLGROOMTILE_AddRoomMapTiles.
std::string szSeedAfterTiles;
};
// Mirrors DRLGACTIVATE_InitializeRoomEx (DrlgActivate.cpp:317-331) followed by
// DRLGACTIVATE_RoomEx_EnsureHasRoom (DrlgActivate.cpp:95-115) up to DRLGROOMTILE_AddRoomMapTiles.
// DRLG_CreateRoomForRoomEx (the D2ActiveRoomStrc, built by D2Game) is not run, so pRoom stays NULL for
// every room and D2Common_COLLISION_FirstFn_6FD41000 is a no-op (D2Collision.cpp: returns when pRoom is
// NULL). In the game a room activated earlier already has its active room, so the linked-tile merge of
// a later room also updates that room's collision grid (no effect on the DRLG tile data or the RNG).
// DRLGACTIVATE_RoomEx_EnsureHasRoom (DrlgActivate.cpp:95-105) up to InitRoomGrids. Tile selection
// (DRLGROOMTILE_AddRoomMapTiles) needs the DT1 libraries and is outside the oracle.
// Rooms are activated in pFirstRoomEx order; a preset map spanning several rooms loads its DS1 with
// the seed of the first activated room, which only matters for the randomly skipped preset units
// of DRLGPRESET_AddPresetUnitToDrlgMap (none of them occur in Act I outdoor DS1s). The activation
// order also decides the room-seam merge of DRLGROOMTILE_GetCreateLinkedTileData: the room activated
// later edits the tiles of the near rooms activated before it.
std::vector<RoomActivation> Activate(D2DrlgLevelStrc* pLevel)
// of DRLGPRESET_AddPresetUnitToDrlgMap (none of them occur in Act I outdoor DS1s).
std::string Activate(D2DrlgLevelStrc* pLevel)
{
std::vector<RoomActivation> out;
std::ostringstream o;
o << "[";
int i = 0;
char szContext[64];
for (D2DrlgRoomStrc* pRoom = pLevel->pFirstRoomEx; pRoom; pRoom = pRoom->pDrlgRoomNext, ++i)
@ -340,7 +323,7 @@ std::vector<RoomActivation> Activate(D2DrlgLevelStrc* pLevel)
}
DRLGROOMTILE_InitRoomGrids(pRoom);
std::ostringstream o;
if (i) o << ",";
o << "{\"seed\":" << Seed(pRoom->pSeed);
if (pRoom->nType == DRLGTYPE_MAZE)
{
@ -360,279 +343,9 @@ std::vector<RoomActivation> Activate(D2DrlgLevelStrc* pLevel)
for (int l = 0; l < pFile->nFloorLayers; ++l) o << (l ? "," : "") << Grid(p->pFloorGrid[l]);
o << "],\"shadow\":" << Grid(p->pCellGrid);
}
o << ",\"units\":" << PresetUnits(pRoom->pPresetUnits);
DRLGROOMTILE_AddRoomMapTiles(pRoom);
out.push_back({pRoom, o.str(), Seed(pRoom->pSeed)});
o << ",\"units\":" << PresetUnits(pRoom->pPresetUnits) << "}";
}
return out;
}
// ---- mapTiles (schema 3): the room's D2DrlgTileGridStrc after every requested room is activated ----
// Pointers are dumped as references, resolved over every room of the act (pDrlg->pLevel chain, rooms
// numbered in pFirstRoomEx order), because warps and linked tiles cross level seams:
// D2DrlgTileDataStrc* -> [levelId, room, "w"|"f"|"r", index] into that room's pTileGrid->pTiles
// pWallTiles / pFloorTiles / pRoofTiles (the pool block, not only [0, count))
// D2RoomCoordListStrc* -> [levelId, room, "c", index in that room's pLogicalRoomInfo->pCoordList chain]
// D2DrlgRoomStrc* -> [levelId, room]
struct TileBlock
{
int nLevelId;
int nRoom;
char cArray;
size_t nBytes;
};
struct RefIndex
{
std::map<uintptr_t, TileBlock> tileBlocks;
std::map<const D2RoomCoordListStrc*, std::string> coordLists;
std::map<const D2DrlgRoomStrc*, std::string> rooms;
};
constexpr int kMaxChain = 1 << 20;
void AddTileBlock(RefIndex& index, const D2DrlgTileDataStrc* pTiles, int nLevelId, int nRoom, char cArray)
{
if (!pTiles)
{
return;
}
// FOG_AllocPool / FOG_ReallocPool are calloc / realloc, so a pool block is a malloc block.
const TileBlock block = {nLevelId, nRoom, cArray, malloc_usable_size((void*)pTiles)};
if (!index.tileBlocks.emplace((uintptr_t)pTiles, block).second)
{
D2ORACLE_Fail("level %d room %d: tile array %c starts at another array's address", nLevelId, nRoom, cArray);
}
}
RefIndex BuildRefIndex(D2DrlgStrc* pDrlg)
{
RefIndex index;
for (D2DrlgLevelStrc* pLevel = pDrlg->pLevel; pLevel; pLevel = pLevel->pNextLevel)
{
int nRoom = 0;
for (D2DrlgRoomStrc* pRoom = pLevel->pFirstRoomEx; pRoom; pRoom = pRoom->pDrlgRoomNext, ++nRoom)
{
const std::string szRoom = std::to_string(pLevel->nLevelId) + "," + std::to_string(nRoom);
index.rooms[pRoom] = "[" + szRoom + "]";
if (const D2DrlgTileGridStrc* pTileGrid = pRoom->pTileGrid)
{
AddTileBlock(index, pTileGrid->pTiles.pWallTiles, pLevel->nLevelId, nRoom, 'w');
AddTileBlock(index, pTileGrid->pTiles.pFloorTiles, pLevel->nLevelId, nRoom, 'f');
AddTileBlock(index, pTileGrid->pTiles.pRoofTiles, pLevel->nLevelId, nRoom, 'r');
}
if (const D2DrlgLogicalRoomInfoStrc* pInfo = pRoom->pLogicalRoomInfo)
{
int k = 0;
for (const D2RoomCoordListStrc* p = pInfo->pCoordList; p; p = p->pNext, ++k)
{
if (k >= kMaxChain) D2ORACLE_Fail("level %d room %d: pCoordList chain does not terminate", pLevel->nLevelId, nRoom);
index.coordLists[p] = "[" + szRoom + ",\"c\"," + std::to_string(k) + "]";
}
}
}
}
return index;
}
std::string TileRef(const RefIndex& index, const D2DrlgTileDataStrc* p)
{
if (!p)
{
return "null";
}
auto it = index.tileBlocks.upper_bound((uintptr_t)p);
if (it != index.tileBlocks.begin())
{
--it;
const uintptr_t nOffset = (uintptr_t)p - it->first;
if (nOffset < it->second.nBytes)
{
if (nOffset % sizeof(D2DrlgTileDataStrc))
{
D2ORACLE_Fail("tile pointer %p is not an element of level %d room %d array %c", (const void*)p, it->second.nLevelId, it->second.nRoom, it->second.cArray);
}
return "[" + std::to_string(it->second.nLevelId) + "," + std::to_string(it->second.nRoom) + ",\"" + it->second.cArray + "\","
+ std::to_string(nOffset / sizeof(D2DrlgTileDataStrc)) + "]";
}
}
D2ORACLE_Fail("tile pointer %p is outside every tile array of the act (dangling?)", (const void*)p);
}
// D2DrlgTileDataStrc::unk0x10 holds (int)D2RoomCoordListStrc* when DRLGLOGIC set it (-m32), else an int.
std::string TileUnk10(const RefIndex& index, int32_t nValue)
{
if (nValue)
{
auto it = index.coordLists.find((const D2RoomCoordListStrc*)(uintptr_t)(uint32_t)nValue);
if (it != index.coordLists.end())
{
return it->second;
}
}
return std::to_string(nValue);
}
std::string TileEntry(const D2TileLibraryEntryStrc* pTile)
{
if (!pTile)
{
return "null";
}
std::string szLibrary;
int nIndex = -1;
D2ORACLE_DescribeTile(pTile, &szLibrary, &nIndex);
if (szLibrary.find_first_of("\"\\") != std::string::npos)
{
D2ORACLE_Fail("tile library path %s needs JSON escaping", szLibrary.c_str());
}
return "[\"" + szLibrary + "\"," + std::to_string(nIndex) + "]";
}
// Every D2DrlgTileDataStrc field in struct order (D2DrlgDrlg.h:333).
std::string TileData(const RefIndex& index, const D2DrlgTileDataStrc& t)
{
std::ostringstream o;
o << "[" << t.nWidth << "," << t.nHeight << "," << t.nPosX << "," << t.nPosY << "," << TileUnk10(index, t.unk0x10) << "," << t.dwFlags
<< "," << TileEntry(t.pTile) << "," << t.nTileType << "," << TileRef(index, t.unk0x20) << "," << t.unk0x24 << "," << (int)t.nRed
<< "," << (int)t.nGreen << "," << (int)t.nBlue << "," << (int)t.nIntensity << "," << t.unk0x2C << "]";
return o.str();
}
std::string TileDataArray(const RefIndex& index, const D2DrlgTileDataStrc* pTiles, int nTiles, const char* szArray, int nLevelId, int nRoom)
{
if (nTiles < 0 || (nTiles > 0 && !pTiles))
{
D2ORACLE_Fail("level %d room %d: %d %s without an array", nLevelId, nRoom, nTiles, szArray);
}
if (nTiles > 0 && (size_t)nTiles * sizeof(D2DrlgTileDataStrc) > malloc_usable_size((void*)pTiles))
{
D2ORACLE_Fail("level %d room %d: %d %s exceed their pool block", nLevelId, nRoom, nTiles, szArray);
}
std::string s = "[";
for (int i = 0; i < nTiles; ++i)
{
if (i) s += ",";
s += TileData(index, pTiles[i]);
}
return s + "]";
}
std::string CoordList(const D2RoomCoordListStrc& c)
{
std::ostringstream o;
o << "[" << c.nIndex << "," << c.bNode << "," << c.bRoomActive << "," << Coord(c.pBox[0]) << "," << Coord(c.pBox[1]) << "]";
return o.str();
}
// {flags, nLists, indexX, indexY, lists} or null. pIndexY cells hold (int)D2RoomCoordListStrc*
// (DRLGLOGIC_AssignCoordListsForGrids): dumped as 1 + the index of that list in the room's own
// pCoordList chain, 0 for NULL.
std::string LogicalRoomInfo(const D2DrlgRoomStrc* pRoom, int nLevelId, int nRoom)
{
const D2DrlgLogicalRoomInfoStrc* pInfo = pRoom->pLogicalRoomInfo;
if (!pInfo)
{
return "null";
}
std::map<uint32_t, int> chain;
std::string lists = "[";
int k = 0;
for (const D2RoomCoordListStrc* p = pInfo->pCoordList; p; p = p->pNext, ++k)
{
if (k >= kMaxChain) D2ORACLE_Fail("level %d room %d: pCoordList chain does not terminate", nLevelId, nRoom);
chain[(uint32_t)(uintptr_t)p] = k;
lists += (k ? "," : "") + CoordList(*p);
}
lists += "]";
std::ostringstream o;
o << "{\"flags\":" << pInfo->dwFlags << ",\"nLists\":" << pInfo->nLists << ",\"indexX\":" << Grid(pInfo->pIndexX) << ",\"indexY\":";
const D2DrlgGridStrc& grid = pInfo->pIndexY;
if (!grid.pCellsFlags || !grid.pCellsRowOffsets)
{
o << "null";
}
else
{
o << "{\"w\":" << grid.nWidth << ",\"h\":" << grid.nHeight << ",\"cells\":[";
for (int y = 0; y < grid.nHeight; ++y)
{
for (int x = 0; x < grid.nWidth; ++x)
{
const uint32_t nCell = (uint32_t)grid.pCellsFlags[x + grid.pCellsRowOffsets[y]];
int nValue = 0;
if (nCell)
{
auto it = chain.find(nCell);
if (it == chain.end()) D2ORACLE_Fail("level %d room %d: pIndexY cell (%d, %d) is not a list of the room's chain", nLevelId, nRoom, x, y);
nValue = it->second + 1;
}
o << ((x || y) ? "," : "") << nValue;
}
}
o << "]}";
}
o << ",\"lists\":" << lists << "}";
return o.str();
}
// pRoomTiles chain: [[levelId, room] of pDrlgRoom, pLvlWarpTxtRecord index (-1 for NULL), bEnabled,
// unk0x0C, unk0x10].
std::string RoomTiles(const RefIndex& index, const D2DrlgRoomStrc* pRoom, int nLevelId, int nRoom)
{
std::string s = "[";
int k = 0;
for (const D2RoomTileStrc* p = pRoom->pRoomTiles; p; p = p->pNext, ++k)
{
if (k >= kMaxChain) D2ORACLE_Fail("level %d room %d: pRoomTiles chain does not terminate", nLevelId, nRoom);
std::string szRoom = "null";
if (p->pDrlgRoom)
{
auto it = index.rooms.find(p->pDrlgRoom);
if (it == index.rooms.end()) D2ORACLE_Fail("level %d room %d: warp %d leads to a room outside the act", nLevelId, nRoom, k);
szRoom = it->second;
}
int nWarp = -1;
if (p->pLvlWarpTxtRecord)
{
const ptrdiff_t n = p->pLvlWarpTxtRecord - sgptDataTables->pLvlWarpTxt;
if (n < 0 || n >= sgptDataTables->nLvlWarpTxtRecordCount) D2ORACLE_Fail("level %d room %d: warp %d has a record outside LvlWarp.txt", nLevelId, nRoom, k);
nWarp = (int)n;
}
s += (k ? "," : "");
s += "[" + szRoom + "," + std::to_string(nWarp) + "," + std::to_string(p->bEnabled) + "," + TileRef(index, p->unk0x0C) + "," + TileRef(index, p->unk0x10) + "]";
}
return s + "]";
}
std::string MapTiles(const RefIndex& index, const D2DrlgRoomStrc* pRoom, int nLevelId, int nRoom)
{
const D2DrlgTileGridStrc* pTileGrid = pRoom->pTileGrid;
if (!pTileGrid)
{
D2ORACLE_Fail("level %d room %d: no pTileGrid after DRLGROOMTILE_AddRoomMapTiles", nLevelId, nRoom);
}
if (pTileGrid->pAnimTiles)
{
D2ORACLE_Fail("level %d room %d: animated tiles (pAnimTiles) are not dumped", nLevelId, nRoom);
}
const D2DrlgRoomTilesStrc& t = pTileGrid->pTiles;
std::ostringstream o;
o << "{\"nWalls\":" << pTileGrid->nWalls << ",\"nFloors\":" << pTileGrid->nFloors << ",\"nShadows\":" << pTileGrid->nShadows
<< ",\"pTiles\":{\"nWalls\":" << t.nWalls << ",\"nFloors\":" << t.nFloors << ",\"nRoofs\":" << t.nRoofs << "}"
<< ",\"walls\":" << TileDataArray(index, t.pWallTiles, t.nWalls, "walls", nLevelId, nRoom)
<< ",\"floors\":" << TileDataArray(index, t.pFloorTiles, t.nFloors, "floors", nLevelId, nRoom)
<< ",\"roofs\":" << TileDataArray(index, t.pRoofTiles, t.nRoofs, "roofs", nLevelId, nRoom) << ",\"links\":[";
int k = 0;
for (const D2DrlgTileLinkStrc* p = pTileGrid->pMapLinks; p; p = p->pNext, ++k)
{
if (k >= kMaxChain) D2ORACLE_Fail("level %d room %d: pMapLinks chain does not terminate", nLevelId, nRoom);
o << (k ? "," : "") << "[" << p->bFloor << "," << TileRef(index, p->pMapTile) << "]";
}
o << "],\"warps\":" << RoomTiles(index, pRoom, nLevelId, nRoom) << ",\"units\":" << PresetUnits(pRoom->pPresetUnits)
<< ",\"logical\":" << LogicalRoomInfo(pRoom, nLevelId, nRoom) << "}";
o << "]";
return o.str();
}
@ -746,14 +459,14 @@ int main(int argc, char** argv)
D2DrlgActStrc act = {};
std::ostringstream o;
o << "{\"schema\":3,\"oracle\":{\"d2moo\":\"" << D2ORACLE_D2MOO_COMMIT << "\",\"arch\":\"i386\"},\"gameSeed\":" << nSeed
o << "{\"schema\":2,\"oracle\":{\"d2moo\":\"" << D2ORACLE_D2MOO_COMMIT << "\",\"arch\":\"i386\"},\"gameSeed\":" << nSeed
<< ",\"difficulty\":" << nDifficulty << ",\"isolated\":" << (bIsolated ? "true" : "false");
D2DrlgStrc* pDrlg = AllocAct1(&act, nSeed, (uint8_t)nDifficulty);
o << ",\"drlg\":{\"startSeed\":" << pDrlg->dwStartSeed << ",\"seed\":" << Seed(pDrlg->pSeed) << "},\"act\":" << Act(pDrlg) << ",\"levels\":[";
std::vector<std::string> heads(levels.size());
std::vector<D2DrlgLevelStrc*> generated(levels.size(), nullptr);
std::vector<std::vector<RoomActivation>> activations(levels.size());
std::vector<std::string> activations(levels.size());
if (bIsolated)
{
// A fresh act per level proves level generation does not depend on other levels.
@ -780,26 +493,9 @@ int main(int argc, char** argv)
activations[i] = Activate(generated[i]);
}
}
// "mapTiles" is serialised only now: a room activated later rewrites tiles of the near rooms
// activated before it and rolls their seeds (DRLGROOMTILE_GetCreateLinkedTileData ->
// DRLGROOMTILE_LinkedTileDataManager), also across level seams, so the tile data are the final state.
std::map<D2DrlgStrc*, RefIndex> refIndices;
for (size_t i = 0; i < levels.size(); ++i)
{
D2DrlgStrc* pLevelDrlg = generated[i]->pDrlg;
auto it = refIndices.find(pLevelDrlg);
if (it == refIndices.end())
{
it = refIndices.emplace(pLevelDrlg, BuildRefIndex(pLevelDrlg)).first;
}
o << (i ? "," : "") << heads[i] << ",\"activation\":[";
for (size_t k = 0; k < activations[i].size(); ++k)
{
const RoomActivation& a = activations[i][k];
o << (k ? "," : "") << a.szHead << ",\"seedAfterTiles\":" << a.szSeedAfterTiles << ",\"mapTiles\":"
<< MapTiles(it->second, a.pRoom, generated[i]->nLevelId, (int)k) << "}";
}
o << "]}";
o << (i ? "," : "") << heads[i] << ",\"activation\":" << activations[i] << "}";
}
o << "]}\n";

6
tools/d2moo-oracle/src/oracle.h
View File

@ -19,9 +19,3 @@ void D2ORACLE_CloseTrace();
void D2ORACLE_SetTraceContext(const char* szContext);
// Writes one free-form event line to the trace (no-op when tracing is off).
void D2ORACLE_TraceLine(const char* szFormat, ...) __attribute__((format(printf, 1, 2)));
struct D2TileLibraryEntryStrc;
// Identity of a tile returned by the D2CMP shims: the owning DT1 (lower-case, '/'-separated path
// relative to the data root, e.g. "data/global/tiles/act1/outdoors/blank.dt1") and the tile's index in
// that DT1's tile header table. Fails for pointers the shims did not hand out.
void D2ORACLE_DescribeTile(const D2TileLibraryEntryStrc* pTileLibraryEntry, std::string* pszLibrary, int* pnIndex);

42
tools/d2moo-oracle/src/stubs.cpp
View File

@ -20,7 +20,6 @@
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <malloc.h>
#include <map>
#include <string>
#include <vector>
@ -128,25 +127,9 @@ void __fastcall FOG_FreePool(void*, void* pFree, const char*, int, int)
{
free(pFree);
}
// D2_REALLOC_POOL leaves the grown bytes uninitialised in the game. The only caller on the DRLG path,
// DRLGROOMTILE_ReallocRoofTileGrid, never initialises unk0x10 / nIntensity / unk0x2C of the appended
// roof tiles, so the oracle zero-fills everything past the old block (the TypeScript port appends
// zeroed elements). FOG_AllocPool is calloc, which clears the whole usable size, so by induction every
// byte past the requested size is zero.
void* __fastcall FOG_ReallocPool(void*, void* pMem, int nSize, const char*, int, int)
{
const size_t nOldUsable = pMem ? malloc_usable_size(pMem) : 0;
void* pNew = realloc(pMem, nSize > 0 ? nSize : 1);
if (!pNew)
{
D2ORACLE_Fail("FOG_ReallocPool(%d) failed", nSize);
}
const size_t nNewUsable = malloc_usable_size(pNew);
if (nNewUsable > nOldUsable)
{
memset((char*)pNew + nOldUsable, 0, nNewUsable - nOldUsable);
}
return pNew;
return realloc(pMem, nSize > 0 ? nSize : 1);
}
void* __fastcall FOG_Alloc(int nSize, const char*, int, int)
{
@ -347,27 +330,19 @@ BOOL __fastcall MONSTERS_ValidateMonsterId(int)
// DRLGROOMTILE_GetTileCache (DrlgRoomTile.cpp:45-92) rolls the room seed iff the rarity sum of the
// tiles returned by D2CMP_10088_GetTiles is > 0, and it runs inside the LvlSub stamping of
// InitOutdoorRoomGrids (sub_6FD8ACE0 -> DRLGROOMTILE_InitTileShadow), so the tile data advances the
// substitution RNG stream. Since schema 3 the chosen entry itself is dumped (D2DrlgTileDataStrc::pTile
// as [library path, tile index in that DT1]), so the ORDER of the returned entries (slot order, then DT1
// file order) decides dumped output: which variant DRLGROOMTILE_GetTileCache picks for a given roll.
// That order is NOT verified against the real D2CMP.dll (open question; the returned count and rarity
// sum do not depend on it).
// substitution RNG stream. Only the per-query tile count and rarity sum influence the dumped grids.
// The ORDER of the returned entries (slot order, then DT1 file order) is not verified against
// D2CMP.dll; it only decides which tile variant GetTileCache picks, which the oracle does not dump.
namespace
{
constexpr size_t kDt1HeaderSize = 0x114;
constexpr size_t kDt1TileHeaderSize = 96;
constexpr int kTileSlots = 32; // D2DrlgRoomStrc::pTiles / D2DrlgStrc::pTiles
struct OracleTileLibrary;
// POD: allocated with new + memset(0). pLibrary / nIndex are the oracle's identity of the entry
// (not D2CMP fields), used only by D2ORACLE_DescribeTile.
struct OracleTile
{
D2TileLibraryEntryStrc tEntry;
uint8_t nSubtileFlags[25];
const OracleTileLibrary* pLibrary;
int nIndex;
};
struct OracleTileLibrary
@ -440,8 +415,6 @@ OracleTileLibrary* LoadTileLibrary(const char* szFileName)
pTile->tEntry.nSequence = ReadLE<int32_t>(bytes, nBase + 0x1C);
pTile->tEntry.nRarity_Frame = ReadLE<int32_t>(bytes, nBase + 0x20);
memcpy(pTile->nSubtileFlags, bytes.data() + nBase + 0x28, sizeof(pTile->nSubtileFlags));
pTile->pLibrary = pLibrary;
pTile->nIndex = i;
pLibrary->tiles.push_back(pTile);
gTilesByEntry[&pTile->tEntry] = pTile;
}
@ -461,13 +434,6 @@ OracleTile* TileOf(const D2TileLibraryEntryStrc* pEntry)
}
} // namespace
void D2ORACLE_DescribeTile(const D2TileLibraryEntryStrc* pTileLibraryEntry, std::string* pszLibrary, int* pnIndex)
{
const OracleTile* pTile = TileOf(pTileLibraryEntry);
*pszLibrary = pTile->pLibrary->szPath;
*pnIndex = pTile->nIndex;
}
//D2Cmp.#10087: stores the library in the first free slot of the 32-slot array.
void __stdcall D2CMP_10087_LoadTileLibrarySlot(D2TileLibraryHashStrc** ppTileLibraryHash, const char* szFileName)
{

6
tsconfig.json
View File

@ -17,7 +17,11 @@
},
"include": ["src/**/*.ts", "scripts/**/*.ts", "vite.config.ts", "tests/**/*.test.ts"],
"exclude": [
"src/game/drlg",
"scripts/drlg-diff.ts",
"scripts/lib/drlg-oracle.ts",
"tests/e2e-drop-parity",
"tests/fail-fast-drop.test.ts"
"tests/fail-fast-drop.test.ts",
"tests/drlg-act1-oracle.test.ts"
]
}