Spaces:
Sleeping
Sleeping
| /** | |
| * engine.js — Single-player grid world for the browser game. | |
| * Pure ES module, zero dependencies. | |
| */ | |
| // ─── Constants ─────────────────────────────────────────────────────────────── | |
| export const EMOJIS = { | |
| tree: '🌳', rock: '🪨', blank: '⬜', diamond: '💎', agent: '🤖', | |
| }; | |
| export const DIRECTIONS = { | |
| up: { dx: 0, dy: -1 }, | |
| down: { dx: 0, dy: 1 }, | |
| left: { dx: -1, dy: 0 }, | |
| right: { dx: 1, dy: 0 }, | |
| }; | |
| export const DEFAULTS = { | |
| WORLD_WIDTH: 600, | |
| WORLD_HEIGHT: 600, | |
| DIAMOND_COUNT: 500, | |
| VIEWPORT_RADIUS: 6, | |
| LOOP_DELAY_MS: 500, | |
| TERRAIN_SCALE: 0.1, | |
| TERRAIN_THRESHOLDS: [ | |
| { emoji: '🌳', threshold: 0.4 }, | |
| { emoji: '🪨', threshold: 0.5 }, | |
| ], | |
| }; | |
| // ─── Seedable PRNG (mulberry32) — used when a seed is passed; otherwise Math.random ── | |
| function mulberry32(a) { | |
| return function () { | |
| let t = (a += 0x6d2b79f5); | |
| t = Math.imul(t ^ (t >>> 15), t | 1); | |
| t ^= t + Math.imul(t ^ (t >>> 7), t | 61); | |
| return ((t ^ (t >>> 14)) >>> 0) / 4294967296; | |
| }; | |
| } | |
| // ─── Perlin Noise ──────────────────────────────────────────────────────────── | |
| function makePerlin(rng = Math.random) { | |
| const p = Array.from({ length: 256 }, () => Math.floor(rng() * 256)); | |
| const perm = [...p, ...p]; | |
| const fade = t => t * t * t * (t * (t * 6 - 15) + 10); | |
| const lerp = (t, a, b) => a + t * (b - a); | |
| const grad = (h, x, y) => { | |
| const u = (h & 3) < 2 ? x : y, v = (h & 3) < 2 ? y : x; | |
| return (h & 1 ? -u : u) + (h & 2 ? -2 * v : 2 * v); | |
| }; | |
| return (x, y) => { | |
| const X = Math.floor(x) & 255, Y = Math.floor(y) & 255; | |
| x -= Math.floor(x); y -= Math.floor(y); | |
| const u = fade(x), v = fade(y); | |
| const A = perm[X] + Y, B = perm[X + 1] + Y; | |
| return lerp(v, | |
| lerp(u, grad(perm[A], x, y), grad(perm[B], x - 1, y)), | |
| lerp(u, grad(perm[A + 1], x, y - 1), grad(perm[B + 1], x - 1, y - 1)) | |
| ); | |
| }; | |
| } | |
| // ─── World Generation ──────────────────────────────────────────────────────── | |
| function generateWorld( | |
| width = DEFAULTS.WORLD_WIDTH, | |
| height = DEFAULTS.WORLD_HEIGHT, | |
| thresholds = DEFAULTS.TERRAIN_THRESHOLDS, | |
| scale = DEFAULTS.TERRAIN_SCALE, | |
| rng = Math.random, | |
| ) { | |
| const perlin = makePerlin(rng); | |
| const tiles = new Array(width * height); | |
| for (let y = 0; y < height; y++) { | |
| for (let x = 0; x < width; x++) { | |
| const n = (perlin(x * scale, y * scale) + 1) / 2; | |
| let tile = EMOJIS.blank; | |
| for (const { emoji, threshold } of thresholds) { | |
| if (n < threshold) { tile = emoji; break; } | |
| } | |
| tiles[y * width + x] = tile; | |
| } | |
| } | |
| return { width, height, tiles }; | |
| } | |
| function getTile(world, x, y) { | |
| if (x < 0 || y < 0 || x >= world.width || y >= world.height) return EMOJIS.rock; | |
| return world.tiles[y * world.width + x]; | |
| } | |
| function isPassable(world, x, y) { | |
| if (x < 0 || y < 0 || x >= world.width || y >= world.height) return false; | |
| return world.tiles[y * world.width + x] === EMOJIS.blank; | |
| } | |
| function findRandomEmpty(world, occupied = [], maxAttempts = 1000, rng = Math.random) { | |
| for (let i = 0; i < maxAttempts; i++) { | |
| const x = Math.floor(rng() * world.width); | |
| const y = Math.floor(rng() * world.height); | |
| if (isPassable(world, x, y) && !occupied.some(p => p.x === x && p.y === y)) { | |
| return { x, y }; | |
| } | |
| } | |
| throw new Error('Could not find empty cell'); | |
| } | |
| // ─── Viewport Rendering ────────────────────────────────────────────────────── | |
| function renderViewport(world, objects, viewerAgent, radius = DEFAULTS.VIEWPORT_RADIUS) { | |
| let out = ''; | |
| for (let dy = -radius; dy <= radius; dy++) { | |
| for (let dx = -radius; dx <= radius; dx++) { | |
| const wx = viewerAgent.x + dx, wy = viewerAgent.y + dy; | |
| if (wx === viewerAgent.x && wy === viewerAgent.y) { out += viewerAgent.emoji; continue; } | |
| const obj = objects.find(o => o.x === wx && o.y === wy); | |
| if (obj) { out += obj.emoji; continue; } | |
| out += getTile(world, wx, wy); | |
| } | |
| out += '\n'; | |
| } | |
| return out; | |
| } | |
| // ─── SinglePlayerGame ──────────────────────────────────────────────────────── | |
| export class SinglePlayerGame { | |
| constructor(opts = {}) { | |
| const { | |
| width = DEFAULTS.WORLD_WIDTH, | |
| height = DEFAULTS.WORLD_HEIGHT, | |
| diamondCount = DEFAULTS.DIAMOND_COUNT, | |
| seed = null, // null → Math.random; integer → deterministic mulberry32 | |
| } = typeof opts === 'object' ? opts : { width: opts }; | |
| const rng = seed != null ? mulberry32(seed) : Math.random; | |
| this.world = generateWorld(width, height, undefined, undefined, rng); | |
| this.objects = []; | |
| this.agent = { x: 0, y: 0, emoji: EMOJIS.agent }; | |
| this.inventory = []; | |
| this.stats = { moves: 0, diamonds: 0, picks: 0 }; | |
| for (let i = 0; i < diamondCount; i++) { | |
| const pos = findRandomEmpty(this.world, this.objects, 1000, rng); | |
| this.objects.push({ x: pos.x, y: pos.y, emoji: EMOJIS.diamond }); | |
| } | |
| const agentPos = findRandomEmpty(this.world, this.objects, 1000, rng); | |
| this.agent.x = agentPos.x; | |
| this.agent.y = agentPos.y; | |
| } | |
| getViewport(radius = DEFAULTS.VIEWPORT_RADIUS) { | |
| return renderViewport(this.world, this.objects, this.agent, radius); | |
| } | |
| move(direction) { | |
| const d = DIRECTIONS[direction]; | |
| if (!d) throw new Error('Invalid direction'); | |
| const nx = this.agent.x + d.dx, ny = this.agent.y + d.dy; | |
| if (!isPassable(this.world, nx, ny)) throw new Error('Cannot move into obstacle'); | |
| // Disallow moving onto a pickable object — the agent must use `pick` instead. | |
| // The error string names the right tool so the model can self-correct next turn. | |
| const blocker = this.objects.find(o => o.x === nx && o.y === ny); | |
| if (blocker) { | |
| throw new Error(`Cannot move onto ${blocker.emoji} — use pick ${direction} instead`); | |
| } | |
| this.agent.x = nx; | |
| this.agent.y = ny; | |
| this.stats.moves++; | |
| return { x: nx, y: ny }; | |
| } | |
| pick(direction) { | |
| const d = DIRECTIONS[direction]; | |
| if (!d) throw new Error('Invalid direction'); | |
| const tx = this.agent.x + d.dx, ty = this.agent.y + d.dy; | |
| const idx = this.objects.findIndex(o => o.x === tx && o.y === ty); | |
| if (idx === -1) throw new Error('No object in that direction'); | |
| const obj = this.objects.splice(idx, 1)[0]; | |
| this.inventory.push(obj.emoji); | |
| this.stats.picks++; | |
| if (obj.emoji === EMOJIS.diamond) this.stats.diamonds++; | |
| return { pickedUp: obj.emoji }; | |
| } | |
| executeAction(action) { | |
| if (action.action === 'move') return this.move(action.detail); | |
| if (action.action === 'pick') return this.pick(action.detail); | |
| } | |
| } | |