@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/match3/assets/scenes/main.ogt

@@ -0,0 +1,24 @@
+type scene
+version 1
+---
+# The match3 scene: the board, with the round's tuning. `start` in
+# src/main.ts gives it its nine-sliced panel and adds the backdrop, the
+# checker tilemap, the 49 gems and the selection frame.
+name "Main"
+entity "board" {
+  Transform {
+    position 0 -0.4 -2
+    quaternion 0 0 0 1
+    scale 1 1 1
+  }
+  # Tune's parameters: edit them here, live with `set:board.Tuning.<field>=<value>`.
+  Tuning {
+    moves 20
+    target 1500
+    colours 5
+    tileScore 10
+    swapTicks 8
+    clearTicks 12
+    fallSpeed 14
+  }
+}

package/archetypes/match3/assets/sprites/board.ogt

@@ -0,0 +1,21 @@
+type tilemap
+version 1
+---
+# Written by tools/make-assets.py: the 7 x 7 checker under the gems, one world unit a cell;
+# src/main.ts places its top-left corner at the board's.
+size 7 7
+tile 64 64
+unit 1
+tileset "sprites/cells.ogt"
+layer cells {
+  z 0
+  legend "a" 0
+  legend "b" 1
+  row "abababa"
+  row "bababab"
+  row "abababa"
+  row "bababab"
+  row "abababa"
+  row "bababab"
+  row "abababa"
+}

package/archetypes/match3/assets/sprites/cells.ogt

@@ -0,0 +1,7 @@
+type tileset
+version 1
+---
+# Written by tools/make-assets.py: the board's two checker cells.
+texture "sprites/cells.png"
+grid 64 64 2 1
+filter nearest

package/archetypes/match3/assets/sprites/cells.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Written by tools/make-assets.py: lossless RGBA8 (a tileset, drawn one texel to a pixel).
+texture {
+  kind pixel
+}

package/archetypes/match3/assets/sprites/gems.ogt

@@ -0,0 +1,75 @@
+type flipbook
+version 1
+---
+# Written by tools/make-assets.py. Clip 2c is colour c's idle loop, 2c + 1 its clear
+# burst (src/art.ts relies on that order).
+texture "gems.png"
+filter linear
+pivot 0.5 0.5
+grid 80 80 8 6
+clip idle_ruby {
+  frames 0 1 2 3
+  durations 2.4 0.05 0.06 0.05
+  mode loop
+}
+clip clear_ruby {
+  frames 4 5 6 7
+  fps 24
+  mode once
+  event 1 "burst"
+}
+clip idle_sky {
+  frames 8 9 10 11
+  durations 2.4 0.05 0.06 0.05
+  mode loop
+}
+clip clear_sky {
+  frames 12 13 14 15
+  fps 24
+  mode once
+  event 1 "burst"
+}
+clip idle_leaf {
+  frames 16 17 18 19
+  durations 2.4 0.05 0.06 0.05
+  mode loop
+}
+clip clear_leaf {
+  frames 20 21 22 23
+  fps 24
+  mode once
+  event 1 "burst"
+}
+clip idle_sun {
+  frames 24 25 26 27
+  durations 2.4 0.05 0.06 0.05
+  mode loop
+}
+clip clear_sun {
+  frames 28 29 30 31
+  fps 24
+  mode once
+  event 1 "burst"
+}
+clip idle_plum {
+  frames 32 33 34 35
+  durations 2.4 0.05 0.06 0.05
+  mode loop
+}
+clip clear_plum {
+  frames 36 37 38 39
+  fps 24
+  mode once
+  event 1 "burst"
+}
+clip idle_coral {
+  frames 40 41 42 43
+  durations 2.4 0.05 0.06 0.05
+  mode loop
+}
+clip clear_coral {
+  frames 44 45 46 47
+  fps 24
+  mode once
+  event 1 "burst"
+}

package/archetypes/match3/gitattributes

@@ -0,0 +1,22 @@
+# Media to Git LFS, as the platform's other scaffolds route them; text stays
+# diffable (.ogt scenes and settings are line-based text by design).
+*.glb filter=lfs diff=lfs merge=lfs -text
+*.gltf filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.ktx2 filter=lfs diff=lfs merge=lfs -text
+*.hdr filter=lfs diff=lfs merge=lfs -text
+*.exr filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.woff2 filter=lfs diff=lfs merge=lfs -text
+*.ogt text eol=lf
+*.ts text eol=lf

package/archetypes/match3/host.d.ts

@@ -0,0 +1,46 @@
+// The host this project's playtest helpers (tests/*.ts) touch under bun:
+// `node:` modules, `process`, `Buffer`, `TextEncoder`, `import.meta.url`.
+// Declared here because the project type-checks with `types: []` (no
+// @types/node, no bun-types): `og check` reads them through tsconfig.json's
+// include. Game code (src/) uses none of them.
+
+declare module "node:fs" {
+  export function existsSync(path: string): boolean;
+  export function readFileSync(path: string): Uint8Array;
+  export function readFileSync(path: string, encoding: string): string;
+  export function writeFileSync(path: string, data: string | Uint8Array): void;
+  export function mkdirSync(path: string, options?: { recursive?: boolean }): void;
+  export function copyFileSync(from: string, to: string): void;
+}
+
+declare module "node:path" {
+  export function dirname(path: string): string;
+  export function join(...parts: string[]): string;
+  export function resolve(...parts: string[]): string;
+}
+
+declare module "node:url" {
+  export function fileURLToPath(url: string | URL): string;
+}
+
+declare module "node:zlib" {
+  export function inflateSync(data: Uint8Array): Uint8Array;
+  export function deflateSync(data: Uint8Array, options?: { level?: number }): Uint8Array;
+}
+
+declare const process: {
+  readonly env: Record<string, string | undefined>;
+  cwd(): string;
+  readonly stdout: { write(text: string): boolean };
+};
+declare const Buffer: { concat(chunks: readonly Uint8Array[]): Uint8Array };
+declare class TextEncoder {
+  encode(text: string): Uint8Array;
+}
+declare class URL {
+  constructor(url: string, base?: string | URL);
+  readonly href: string;
+}
+interface ImportMeta {
+  readonly url: string;
+}

package/archetypes/match3/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "origin-match3",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "og dev .",
+    "start": "og run .",
+    "build": "og build .",
+    "publish-build": "og build . --publish",
+    "cook": "og cook .",
+    "check": "og check .",
+    "test": "og test ."
+  },
+  "dependencies": {
+    "@origingame/engine": "0.1.0"
+  }
+}

package/archetypes/match3/project.ogt

@@ -0,0 +1,18 @@
+type project
+version 1
+---
+name "Tile Swap"
+id "match3"
+engine "0.1.0"
+entry "src/main.ts"
+profile "2d"
+tick 60
+seed 1
+scenes {
+  main "scenes/main.ogt"
+}
+scene main
+publish {
+  probe player
+  out "dist"
+}

package/archetypes/match3/src/art.ts

@@ -0,0 +1,54 @@
+// The art: assets/sprites, written by tools/make-assets.py and loaded once in
+// `start`. The gems are one flipbook sheet (gems.ogt over gems.png): clip 2c
+// is colour c's idle loop (a long hold, then a glint), clip 2c + 1 its clear
+// burst (once). The board is a nine-sliced panel with a hand-written 7 x 7
+// tilemap of checker cells on it; the selection frame and the backdrop are
+// plain textures.
+
+import { og } from "@origingame/engine";
+import type { FlipbookSheet, Texture, TilemapAsset, World } from "@origingame/engine";
+
+/** Gem colours, by Piece.colour. Six cuts, so colour is never the only cue. */
+export const GEMS = ["ruby", "sky", "leaf", "sun", "plum", "coral"] as const;
+
+/** The idle clip of a colour (an index into the sheet's clips). */
+export const idleClip = (colour: number): number => colour * 2;
+/** The clear burst of a colour. */
+export const clearClip = (colour: number): number => colour * 2 + 1;
+
+/** Seconds of one idle cycle (gems.ogt: 2.4 s of hold, then 0.16 s of glint). */
+export const IDLE_CYCLE = 2.56;
+
+/** The panel's nine-slice insets in texture pixels (tools/make-assets.py PANEL_INSET). */
+export const PANEL_INSET = 32;
+
+export interface Art {
+  readonly gems: FlipbookSheet;
+  readonly gemTexture: Texture;
+  readonly panel: Texture;
+  readonly backdrop: Texture;
+  readonly ring: Texture;
+  readonly board: TilemapAsset;
+}
+
+function must<T>(r: { ok: true; value: T } | { ok: false; reason: string }, what: string): T {
+  if (!r.ok) throw new Error(`${what}: ${r.reason} (run tools/make-assets.py and og cook)`);
+  return r.value;
+}
+
+export function loadArt(world: World): Art {
+  const sheet = must(og.load.flipbook(world, "sprites/gems.ogt"), "sprites/gems.ogt");
+  GEMS.forEach((name, c) => {
+    if (sheet.clips[idleClip(c)]?.name !== `idle_${name}` || sheet.clips[clearClip(c)]?.name !== `clear_${name}`) {
+      throw new Error(`sprites/gems.ogt does not list idle_${name} and clear_${name} as clips ${idleClip(c)} and ${clearClip(c)}`);
+    }
+  });
+  return {
+    gems: sheet.sheet,
+    gemTexture: sheet.texture,
+    panel: must(og.load.texture(world, "sprites/panel.png"), "sprites/panel.png"),
+    backdrop: must(og.load.texture(world, "sprites/backdrop.png"), "sprites/backdrop.png"),
+    ring: must(og.load.texture(world, "sprites/ring.png"), "sprites/ring.png"),
+    board: must(og.load.tilemap(world, "sprites/board.ogt"), "sprites/board.ogt").map,
+  };
+}

package/archetypes/match3/src/board.ts

@@ -0,0 +1,112 @@
+// Pure board logic over a colour grid: line detection, the "is there a move"
+// test and the deal. A grid is SIZE * SIZE colour indices, row-major from the
+// bottom row (cell = row * SIZE + col); -1 is an empty cell. Nothing here
+// touches the world, so systems and commands share it.
+
+import { SIZE } from "./layout.ts";
+
+export type Grid = Int32Array;
+
+export const cellOf = (col: number, row: number) => row * SIZE + col;
+export const colOf = (cell: number) => cell % SIZE;
+export const rowOf = (cell: number) => Math.floor(cell / SIZE);
+
+/** Whether two cells share an edge. */
+export function adjacent(a: number, b: number): boolean {
+  if (a < 0 || b < 0) return false;
+  const dc = Math.abs(colOf(a) - colOf(b));
+  const dr = Math.abs(rowOf(a) - rowOf(b));
+  return dc + dr === 1;
+}
+
+/** Cells in horizontal or vertical runs of three or more of one colour. */
+export function findLines(g: Grid): Uint8Array {
+  const marked = new Uint8Array(SIZE * SIZE);
+  for (let r = 0; r < SIZE; r++) {
+    for (let c = 0; c < SIZE; ) {
+      const colour = g[cellOf(c, r)]!;
+      let n = 1;
+      while (c + n < SIZE && colour >= 0 && g[cellOf(c + n, r)] === colour) n++;
+      if (colour >= 0 && n >= 3) for (let k = 0; k < n; k++) marked[cellOf(c + k, r)] = 1;
+      c += n;
+    }
+  }
+  for (let c = 0; c < SIZE; c++) {
+    for (let r = 0; r < SIZE; ) {
+      const colour = g[cellOf(c, r)]!;
+      let n = 1;
+      while (r + n < SIZE && colour >= 0 && g[cellOf(c, r + n)] === colour) n++;
+      if (colour >= 0 && n >= 3) for (let k = 0; k < n; k++) marked[cellOf(c, r + k)] = 1;
+      r += n;
+    }
+  }
+  return marked;
+}
+
+export function count(marked: Uint8Array): number {
+  let n = 0;
+  for (const m of marked) n += m;
+  return n;
+}
+
+/** Whether some swap of neighbours makes a line. */
+export function hasMove(g: Grid): boolean {
+  const t = Int32Array.from(g);
+  for (let cell = 0; cell < SIZE * SIZE; cell++) {
+    for (const other of [cell + 1, cell + SIZE]) {
+      if (other >= SIZE * SIZE || !adjacent(cell, other)) continue;
+      [t[cell], t[other]] = [t[other]!, t[cell]!];
+      const lines = count(findLines(t)) > 0;
+      [t[cell], t[other]] = [t[other]!, t[cell]!];
+      if (lines) return true;
+    }
+  }
+  return false;
+}
+
+/** A source of dice: Rng or an RngStream. */
+export interface Dice {
+  integer(low: number, high: number): number;
+}
+
+/**
+ * A fresh board from the dice: no ready line, at least one move. A cell's
+ * colour is redrawn while it would complete a line with the two cells to its
+ * left or below it; the whole board is redrawn while it has no move.
+ */
+export function deal(dice: Dice, colours: number): Grid {
+  const g = new Int32Array(SIZE * SIZE);
+  for (let attempt = 0; ; attempt++) {
+    for (let r = 0; r < SIZE; r++) {
+      for (let c = 0; c < SIZE; c++) {
+        let colour = dice.integer(0, colours - 1);
+        for (let k = 0; k < 8 && makesLine(g, c, r, colour); k++) colour = dice.integer(0, colours - 1);
+        if (makesLine(g, c, r, colour)) colour = (colour + 1) % colours;
+        if (makesLine(g, c, r, colour)) colour = (colour + 1) % colours;
+        g[cellOf(c, r)] = colour;
+      }
+    }
+    if (hasMove(g) || attempt >= 20) return g;
+  }
+}
+
+function makesLine(g: Grid, c: number, r: number, colour: number): boolean {
+  const left = c >= 2 && g[cellOf(c - 1, r)] === colour && g[cellOf(c - 2, r)] === colour;
+  const below = r >= 2 && g[cellOf(c, r - 1)] === colour && g[cellOf(c, r - 2)] === colour;
+  return left || below;
+}
+
+/** A board written as text: SIZE lines of SIZE digits, the top row first (as it reads on screen), `/` between lines. */
+export function parseBoard(text: string, colours: number): Grid | string {
+  const lines = text.split("/");
+  if (lines.length !== SIZE || lines.some((l) => l.length !== SIZE)) return `write ${SIZE} lines of ${SIZE} digits joined by '/', the top row first`;
+  const g = new Int32Array(SIZE * SIZE);
+  for (let i = 0; i < SIZE; i++) {
+    for (let c = 0; c < SIZE; c++) {
+      const d = Number(lines[i]![c]);
+      if (!Number.isInteger(d) || d < 0 || d >= colours) return `'${lines[i]![c]}' is not a colour index below ${colours}`;
+      g[cellOf(c, SIZE - 1 - i)] = d;
+    }
+  }
+  return g;
+}

package/archetypes/match3/src/components.ts

@@ -0,0 +1,95 @@
+// Every piece of game state lives in these reflected components: dumps, the
+// probe, Tune and the command channel's `set` read and write them by name.
+//
+// Why every row carries Match and Tuning: a system sees exactly one query
+// (the AND of the components it declares), and inside a system the engine
+// reaches no other entity (a game resource it declares, yes). So the systems that
+// swap, clear and refill tiles must see the round's state on the same rows
+// as the tiles. Every row is spawned with the same six components
+// (og.Transform, og.Sprite, og.Flipbook, Piece, Match, Tuning) and the row whose
+// Piece.kind is Kind.Board, the entity named "board", is the authority: the
+// other rows' Match and Tuning keep their defaults and nothing reads them.
+// Tune and `set:board.Tuning.<field>=<value>` write that row.
+
+import { bool, defineComponent, defineResource, f32, f64, i32, u32 } from "@origingame/engine";
+
+import { SIZE } from "./layout.ts";
+
+/** What a row is. */
+export const Kind = { Backdrop: 1, Board: 2, Cell: 3, Tile: 4, Cursor: 5 } as const;
+
+/** Round phases. */
+export const Phase = { Title: 0, Idle: 1, Swap: 2, SwapBack: 3, Clear: 4, Fall: 5, Won: 6, Lost: 7 } as const;
+export const PHASE_NAMES = ["title", "idle", "swap", "swapBack", "clear", "fall", "won", "lost"] as const;
+
+/** One row: a tile (its cell and colour), or the board, a cell, the cursor or the backdrop. */
+export const Piece = defineComponent("Piece", {
+  kind: u32(0, { doc: "Kind.* of src/components.ts." }),
+  col: i32(0, { min: 0, max: SIZE - 1, doc: "The tile's column, 0 at the left." }),
+  row: i32(0, { min: 0, max: SIZE - 1, doc: "The tile's row, 0 at the bottom." }),
+  colour: i32(-1, { min: -1, max: 5, doc: "The tile's colour index (art.ts GEMS); -1 is an empty cell." }),
+  marked: bool(false, { doc: "Part of a line being cleared this step." }),
+});
+
+/** og.TweenCompleted tags: the tween group a phase waits for (Match.wait). */
+export const Tag = { None: 0, Swap: 1, SwapBack: 2, Clear: 3, Fall: 4, Deal: 5 } as const;
+
+/** The round. Authoritative on the board row. Cells are indexed row * SIZE + col; -1 is none. */
+export const Match = defineComponent("Match", {
+  phase: u32(Phase.Title, { doc: "PHASE_NAMES[phase]." }),
+  phaseTicks: u32(0, { unit: "ticks" }),
+  score: u32(0),
+  best: u32(0, { doc: "The best score since the game started." }),
+  movesLeft: u32(0, { doc: "Moves left this round; a swap that makes no line costs none." }),
+  chain: u32(0, { doc: "The cascade level of the current clear: 1 for the swap's own lines." }),
+  maxChain: u32(0, { doc: "The deepest cascade this round." }),
+  cleared: u32(0, { doc: "Tiles cleared this round." }),
+  lastCleared: u32(0, { doc: "Tiles the last clear step removed." }),
+  rounds: u32(0),
+  shuffles: u32(0, { doc: "Boards dealt again because no swap made a line." }),
+  selected: i32(-1, { doc: "The selected cell (tap-tap swaps)." }),
+  swapA: i32(-1),
+  swapB: i32(-1),
+  dragFrom: i32(-1, { doc: "The cell a held press started on (drag swaps)." }),
+  pressX: f32(0, { unit: "m" }),
+  pressY: f32(0, { unit: "m" }),
+  viewHeight: f32(12, { unit: "m", doc: "The camera's visible height, set in start." }),
+  viewCentreY: f32(0.5, { unit: "m", doc: "The camera's centre height, set in start." }),
+  pxPerM: f32(60, { doc: "CSS pixels of the play surface per metre, worked out by Pick every tick from og.ui.viewport." }),
+  screenX0: f32(640, { doc: "Surface x of the world origin (Pick)." }),
+  screenY0: f32(390, { doc: "Surface y of the world origin (Pick)." }),
+  wait: u32(0, { doc: "The Tag.* of the tween group the phase waits for; 0 once its og.TweenCompleted arrived." }),
+  font: f64(0, { doc: "The Font handle, for the floating scores Resolve spawns." }),
+});
+
+/** Tune's parameters. Authoritative on the board row. */
+export const Tuning = defineComponent("Tuning", {
+  moves: u32(20, { min: 1, max: 60, step: 1, tunable: true, label: "Moves", doc: "The move budget of a round." }),
+  target: u32(1500, { min: 10, max: 10000, step: 50, tunable: true, label: "Target score", doc: "Reach it before the moves run out to win." }),
+  colours: u32(5, { min: 3, max: 6, step: 1, tunable: true, label: "Colours", doc: "Tile colours dealt; fewer colours, more lines." }),
+  tileScore: u32(10, { min: 1, max: 100, step: 1, tunable: true, label: "Points per tile", doc: "Each cleared tile scores this times the cascade level." }),
+  swapTicks: u32(8, { min: 1, max: 30, step: 1, unit: "ticks", tunable: true, label: "Swap time" }),
+  clearTicks: u32(12, { min: 1, max: 40, step: 1, unit: "ticks", tunable: true, label: "Clear time" }),
+  fallSpeed: f32(14, { min: 2, max: 60, step: 1, unit: "cells/s", tunable: true, label: "Fall speed" }),
+});
+
+/** The HUD's font and where the board sits. On the board row only. */
+export const Hud = defineComponent("Hud", {
+  font: f64(0, { doc: "The Font handle." }),
+  top: f32(6, { unit: "m", doc: "The top of the view." }),
+  halfWidth: f32(8, { unit: "m" }),
+});
+
+/** Sound requests: bits of Sounds.sfx that the Voices system plays once each. */
+export const Sound = { Select: 1, Swap: 2, Refused: 4, Clear: 8, Cascade: 16, Won: 32, Lost: 64 } as const;
+
+/** The sounds asked for this tick (a resource: the systems that ask see no voice rows). */
+export const Sounds = defineResource("Sounds", {
+  sfx: u32(0, { doc: "Sound.* bits waiting to play." }),
+});
+
+/** One voice: plays its sound once when Sounds.sfx asks for its bit. */
+export const Sfx = defineComponent("Sfx", {
+  bit: u32(0, { doc: "Sound.* of src/components.ts." }),
+  plays: u32(0, { doc: "Times Voices has started it." }),
+});

package/archetypes/match3/src/layout.ts

@@ -0,0 +1,25 @@
+// Where the board sits, in metres (no engine imports, so playtests read it too).
+
+/** The board is SIZE x SIZE cells. */
+export const SIZE = 7;
+/** Cell pitch. */
+export const PITCH = 1;
+/** A gem's size in its cell. */
+export const GEM_SIZE = 0.92;
+/** The board's centre height. */
+export const BOARD_Y = -0.4;
+
+/** The centre of a cell. */
+export function cellCentre(col: number, row: number): { x: number; y: number } {
+  return { x: (col - (SIZE - 1) / 2) * PITCH, y: BOARD_Y + (row - (SIZE - 1) / 2) * PITCH };
+}
+
+/** The cell under a world point, or -1 off the board. */
+export function cellAt(x: number, y: number): number {
+  const col = Math.floor(x / PITCH + SIZE / 2);
+  const row = Math.floor((y - BOARD_Y) / PITCH + SIZE / 2);
+  return col >= 0 && col < SIZE && row >= 0 && row < SIZE ? row * SIZE + col : -1;
+}
+
+/** The board's top edge. */
+export const BOARD_TOP = BOARD_Y + (SIZE / 2) * PITCH;