126 lines
4.5 KiB
TypeScript
126 lines
4.5 KiB
TypeScript
// Pure, seeded world generation — no DB, no Date, no Math.random. The same seed always
|
||
// yields the same world, which is what makes unit tests (and save regeneration) deterministic.
|
||
|
||
export interface WorldSystem {
|
||
name: string
|
||
x: number // 0–100 coordinate space, rendered directly by NodeGraph
|
||
y: number
|
||
}
|
||
|
||
export const START_X = 50
|
||
export const START_Y = 50
|
||
|
||
const START_RING = 6 // neighbours around the starting system on a new game
|
||
const EXPAND_RING = 4 // new neighbours generated when jumping into an undiscovered system
|
||
const MIN_SPACING = 16 // minimum distance between any two systems in the 0–100 space
|
||
|
||
// mulberry32 — small fast seeded PRNG; plenty for name/position picking.
|
||
export function mulberry32(seed: number): () => number {
|
||
let a = seed >>> 0
|
||
return () => {
|
||
a |= 0
|
||
a = (a + 0x6d2b79f5) | 0
|
||
let t = Math.imul(a ^ (a >>> 15), 1 | a)
|
||
t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
|
||
return ((t ^ (t >>> 14)) >>> 0) / 4294967296
|
||
}
|
||
}
|
||
|
||
const FIRST = [
|
||
'KEPLER', 'VESPER', 'HOLLOW', 'CINDER', 'LANTERN', 'SABLE', 'ORPHEUS', 'MIRE',
|
||
'THALASSA', 'KUIPER', 'AURELLE', 'BRIMSTONE', 'EMBER', 'FROST', 'GALE', 'IRON',
|
||
]
|
||
const SECOND = ['DRIFT', 'REACH', 'GATE', 'FIELD', 'VOID', 'DEEP', 'BEND', 'SHARD']
|
||
|
||
function title(word: string): string {
|
||
return word.charAt(0) + word.slice(1).toLowerCase()
|
||
}
|
||
|
||
// Picks a name not in `taken` and adds it, so callers can't accidentally reuse one.
|
||
export function makeName(rng: () => number, taken: Set<string>): string {
|
||
for (;;) {
|
||
const name = `${title(FIRST[Math.floor(rng() * FIRST.length)])} ${title(SECOND[Math.floor(rng() * SECOND.length)])}`
|
||
if (!taken.has(name)) {
|
||
taken.add(name)
|
||
return name
|
||
}
|
||
}
|
||
}
|
||
|
||
function clamp(v: number): number {
|
||
return Math.min(96, Math.max(4, v))
|
||
}
|
||
|
||
// Places `count` systems on a ring around (cx,cy), nudging each candidate until it is at
|
||
// least MIN_SPACING away from every known position. After 12 tries it accepts the last
|
||
// candidate anyway — ponytail: a slightly crowded node beats an infinite loop; with ≤6
|
||
// rings per region and spacing 16 in a 0–100 box this never triggers in practice.
|
||
function placeRing(
|
||
rng: () => number,
|
||
cx: number,
|
||
cy: number,
|
||
count: number,
|
||
takenNames: Set<string>,
|
||
takenPositions: WorldSystem[],
|
||
): WorldSystem[] {
|
||
const placed: WorldSystem[] = []
|
||
for (let i = 0; i < count; i++) {
|
||
const baseAngle = (i / count) * Math.PI * 2 + (rng() - 0.5) * 0.6
|
||
let x = cx
|
||
let y = cy
|
||
for (let attempt = 0; attempt < 12; attempt++) {
|
||
const angle = baseAngle + attempt * 0.45
|
||
const radius = 26 + rng() * 8
|
||
x = clamp(cx + Math.cos(angle) * radius)
|
||
y = clamp(cy + Math.sin(angle) * radius)
|
||
if ([...takenPositions, ...placed].every((p) => Math.hypot(p.x - x, p.y - y) >= MIN_SPACING)) break
|
||
}
|
||
placed.push({ name: makeName(rng, takenNames), x, y })
|
||
}
|
||
return placed
|
||
}
|
||
|
||
// Edges for a ring of n members around an anchor at index 0: anchor↔each member plus the
|
||
// cycle connecting consecutive members (so every system has ≥2 routes and you can always
|
||
// get back). Pairs are indices into [anchor, ...members].
|
||
function ringEdges(n: number): [number, number][] {
|
||
const edges: [number, number][] = []
|
||
for (let i = 0; i < n; i++) {
|
||
edges.push([0, i + 1])
|
||
edges.push([i + 1, ((i + 1) % n) + 1])
|
||
}
|
||
return edges
|
||
}
|
||
|
||
export interface StartRegion {
|
||
start: WorldSystem
|
||
neighbors: WorldSystem[]
|
||
edges: [number, number][] // indices into [start, ...neighbors]
|
||
}
|
||
|
||
// New game: the starting system at chart centre plus a ring of undiscovered neighbours.
|
||
export function generateStartRegion(rng: () => number): StartRegion {
|
||
const taken = new Set<string>()
|
||
const start: WorldSystem = { name: makeName(rng, taken), x: START_X, y: START_Y }
|
||
const neighbors = placeRing(rng, START_X, START_Y, START_RING, taken, [start])
|
||
return { start, neighbors, edges: ringEdges(neighbors.length) }
|
||
}
|
||
|
||
export interface RingRegion {
|
||
systems: WorldSystem[]
|
||
edges: [number, number][] // indices into [anchor, ...systems] — index 0 is the anchor itself
|
||
}
|
||
|
||
// Jumping into an undiscovered system grows the chart: a fresh ring of (undiscovered)
|
||
// neighbours around it. `takenNames`/`takenPositions` are every system already in the save.
|
||
export function generateRing(
|
||
rng: () => number,
|
||
anchorX: number,
|
||
anchorY: number,
|
||
takenNames: Set<string>,
|
||
takenPositions: WorldSystem[],
|
||
): RingRegion {
|
||
const systems = placeRing(rng, anchorX, anchorY, EXPAND_RING, takenNames, takenPositions)
|
||
return { systems, edges: ringEdges(systems.length) }
|
||
}
|