feat: 1995

scripts/gen-assets.ts

@@ -0,0 +1,173 @@
+import { deflateSync } from "node:zlib"
+
+// Procedurally draw the placeholder textures and write them to /assets as PNGs.
+// One-shot dev tool: `bun run assets`. Swap the output files for real art
+// anytime; the filenames are the contract the game loads.
+
+const CRC_TABLE = buildCrcTable()
+
+function buildCrcTable(): Uint32Array {
+  const table = new Uint32Array(256)
+  for (let n = 0; n < 256; n++) {
+    let c = n
+    for (let k = 0; k < 8; k++) {
+      c = (c & 1) === 1 ? 0xEDB88320 ^ (c >>> 1) : c >>> 1
+    }
+    table[n] = c >>> 0
+  }
+  return table
+}
+
+function crc32(bytes: Uint8Array): number {
+  let c = 0xFFFFFFFF
+  for (let i = 0; i < bytes.length; i++) {
+    c = CRC_TABLE[(c ^ bytes[i]) & 0xFF] ^ (c >>> 8)
+  }
+  return (c ^ 0xFFFFFFFF) >>> 0
+}
+
+function chunk(type: string, data: Uint8Array): Uint8Array {
+  const body = new Uint8Array(4 + data.length)
+  for (let i = 0; i < 4; i++) {
+    body[i] = type.charCodeAt(i)
+  }
+  body.set(data, 4)
+  const out = new Uint8Array(8 + body.length)
+  const view = new DataView(out.buffer)
+  view.setUint32(0, data.length)
+  out.set(body, 4)
+  view.setUint32(4 + body.length, crc32(body))
+  return out
+}
+
+function concat(parts: Uint8Array[]): Uint8Array {
+  const total = parts.reduce((n, p) => n + p.length, 0)
+  const out = new Uint8Array(total)
+  let offset = 0
+  for (const part of parts) {
+    out.set(part, offset)
+    offset += part.length
+  }
+  return out
+}
+
+/** Encode 8-bit RGBA pixels as a PNG byte stream. */
+function encodePng(width: number, height: number, rgba: Uint8Array): Uint8Array {
+  const signature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
+  const ihdr = new Uint8Array(13)
+  const view = new DataView(ihdr.buffer)
+  view.setUint32(0, width)
+  view.setUint32(4, height)
+  ihdr[8] = 8 // bit depth
+  ihdr[9] = 6 // color type: RGBA
+  const stride = width * 4
+  const raw = new Uint8Array((stride + 1) * height)
+  for (let y = 0; y < height; y++) {
+    raw[y * (stride + 1)] = 0 // filter type: none
+    raw.set(rgba.subarray(y * stride, y * stride + stride), y * (stride + 1) + 1)
+  }
+  const idat = new Uint8Array(deflateSync(raw))
+  return concat([signature, chunk("IHDR", ihdr), chunk("IDAT", idat), chunk("IEND", new Uint8Array(0))])
+}
+
+type Shade = (x: number, y: number) => [number, number, number, number]
+
+function draw(width: number, height: number, shade: Shade): Uint8Array {
+  const rgba = new Uint8Array(width * height * 4)
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const [r, g, b, a] = shade(x, y)
+      const i = (y * width + x) * 4
+      rgba[i] = clamp(r)
+      rgba[i + 1] = clamp(g)
+      rgba[i + 2] = clamp(b)
+      rgba[i + 3] = clamp(a)
+    }
+  }
+  return rgba
+}
+
+function clamp(v: number): number {
+  return Math.max(0, Math.min(255, Math.round(v)))
+}
+
+/** Deterministic value noise in roughly [-1, 1] from integer coords. */
+function noise(x: number, y: number): number {
+  const n = Math.sin(x * 12.9898 + y * 78.233) * 43758.5453
+  return (n - Math.floor(n)) * 2 - 1
+}
+
+// --- Textures ------------------------------------------------------------
+
+const floor: Shade = (x, y) => {
+  const grout = x % 32 < 2 || y % 32 < 2
+  if (grout) {
+    return [58, 58, 70, 255]
+  }
+  const n = noise(x, y) * 14
+  return [132 + n, 130 + n, 120 + n, 255]
+}
+
+const wall: Shade = (x, y) => {
+  const row = Math.floor(y / 16)
+  const bx = (x + (row % 2) * 16) % 32
+  const mortar = y % 16 < 2 || bx < 2
+  if (mortar) {
+    return [48, 44, 44, 255]
+  }
+  const n = noise(x, y) * 12
+  return [150 + n, 72 + n, 56 + n, 255]
+}
+
+const crate: Shade = (x, y) => {
+  const edge = x < 3 || x > 60 || y < 3 || y > 60
+  const band = (x > 29 && x < 35) || (y > 29 && y < 35)
+  const bolt = (x - 8) ** 2 + (y - 8) ** 2 < 6 || (x - 55) ** 2 + (y - 55) ** 2 < 6
+  const n = noise(x, y) * 10 + Math.sin(y * 0.5) * 8
+  if (bolt) {
+    return [60, 46, 26, 255]
+  }
+  if (edge || band) {
+    return [96, 62, 30, 255]
+  }
+  return [140 + n, 96 + n, 46 + n, 255]
+}
+
+// 48x64, transparent background, a simple round-topped figure with eyes.
+const npc: Shade = (x, y) => {
+  const dx = (x - 24) / 17
+  const dy = (y - 34) / 24
+  const d = dx * dx + dy * dy
+  if (d > 1) {
+    return [0, 0, 0, 0]
+  }
+  const outline = d > 0.82
+  const eye = (x - 17) ** 2 + (y - 28) ** 2 < 9 || (x - 31) ** 2 + (y - 28) ** 2 < 9
+  const pupil = (x - 17) ** 2 + (y - 29) ** 2 < 2 || (x - 31) ** 2 + (y - 29) ** 2 < 2
+  if (pupil) {
+    return [20, 20, 30, 255]
+  }
+  if (eye) {
+    return [235, 235, 240, 255]
+  }
+  if (outline) {
+    return [30, 70, 50, 255]
+  }
+  const n = noise(x, y) * 12
+  return [70 + n, 165 + n, 110 + n, 255]
+}
+
+// --- Write ---------------------------------------------------------------
+
+const assets: Array<[string, number, number, Shade]> = [
+  ["floor", 64, 64, floor],
+  ["wall", 64, 64, wall],
+  ["crate", 64, 64, crate],
+  ["npc", 48, 64, npc],
+]
+
+for (const [name, w, h, shade] of assets) {
+  const png = encodePng(w, h, draw(w, h, shade))
+  await Bun.write(`assets/${name}.png`, png)
+  console.log(`assets/${name}.png (${w}x${h}, ${png.length} bytes)`)
+}