@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/runner/assets/fonts/ui.ttf.ogt

@@ -0,0 +1,11 @@
+type import
+version 1
+---
+# Written by tools/make-assets.py: the atlas holds Latin-1 and the HUD's own
+# CJK characters (CHARS there); add a character to CHARS before showing it.
+font {
+  charset latin
+  chars "屋顶快跑点击或按空格开始小跳住高再来一次"
+  em_px 48
+  px_range 6
+}

package/archetypes/runner/assets/maps/far.ogt

@@ -0,0 +1,25 @@
+type tilemap
+version 1
+---
+# The far skyline, 0.5 units a tile (tools/make-assets.py).
+size 40 9
+tile 16 16
+unit 0.5
+tileset "tiles/city.ogt"
+layer far {
+  z 0
+  repeat x
+  legend "#" 4
+  legend "w" 5
+  legend "^" 6
+  legend "a" 7
+  row ".............a.................a........"
+  row "....a........^^.......a........^........"
+  row "....^^^......##......^^^.......w........"
+  row "....#w#..^^..##...^..###..^^...#..^^...."
+  row ".^^.w##..w#.^#w^..#..###^.##.^^#..w#..^^"
+  row ".##^###.^##.#w##^^w..##w#^##.###^^##..w#"
+  row "^#w####^###.w####w#^^#w####w^###w###^.##"
+  row "#w####w####^####w####w####w####w####w^##"
+  row "w####w####w####w####w####w####w####w####"
+}

package/archetypes/runner/assets/maps/near.ogt

@@ -0,0 +1,25 @@
+type tilemap
+version 1
+---
+# The near buildings, 0.65 units a tile (tools/make-assets.py).
+size 24 6
+tile 16 16
+unit 0.65
+tileset "tiles/city.ogt"
+layer near {
+  z 0
+  repeat x
+  legend "n" 8
+  legend "L" 9
+  legend "l" 14
+  legend "d" 10
+  legend "c" 11
+  legend "t" 12
+  legend "s" 13
+  row "................ccc....."
+  row "....cccc........Lnl....."
+  row "....nlnd..ccccc.nln....."
+  row "ccc.lndl..lnslL.lnd.cccc"
+  row "lLn.ndlL..ndlLn.ndl.nlnd"
+  row "Lnl.dlLn.tdlLnl.dlL.lndl"
+}

package/archetypes/runner/assets/maps/roofs.ogt

@@ -0,0 +1,19 @@
+type tilemap
+version 1
+---
+# The roof the courier runs on, 0.65 units a tile (tools/make-assets.py).
+size 16 3
+tile 16 16
+unit 0.65
+tileset "tiles/city.ogt"
+layer roofs {
+  z 0
+  repeat x
+  legend "=" 0
+  legend "b" 1
+  legend "L" 2
+  legend "D" 3
+  row "================"
+  row "bLbDbbLbDbbLbDbb"
+  row "bbbbbbbbbbbbbbbb"
+}

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

@@ -0,0 +1,35 @@
+type scene
+version 1
+---
+# The runner's scene: the runner with its hit box and tuning. `start` in src/main.ts adds the courier's
+# sprite, the sky, the city's tilemaps and the pools of crates, fences, coins and dust around the runner.
+name "Main"
+entity "runner" {
+  Transform {
+    position -5 0 0
+    # Given whole: a field left out loads as 0, not its default (an engine bug), and a 0 scale hides the sprite.
+    quaternion 0 0 0 1
+    scale 1 1 1
+  }
+  # The position is the courier's feet; the hit box is centred 0.8125 m above them, narrower than the
+  # sprite (1.3 x 1.625 m) and clear of the shoes.
+  Actor {
+    kind 6
+    w 0.5
+    h 1.2
+    parallax 0
+  }
+  # Tune's parameters: edit them here, live with `set:runner.Tuning.<field>=<value>`.
+  Tuning {
+    speed 6
+    speedRamp 0.12
+    speedMax 12
+    jumpHeight 2
+    timeToApex 0.333
+    jumpCut 1.8
+    apexGravity 0.75
+    fallGravity 1.15
+    spawnInterval 1.3
+    coinValue 10
+  }
+}

package/archetypes/runner/assets/sprites/coin.ogt

@@ -0,0 +1,11 @@
+type flipbook
+version 1
+---
+# The coin (tools/make-assets.py): six frames of a turn.
+texture "coin.png"
+grid 16 16 6 1
+spacing 2
+clip spin {
+  frames 0 1 2 3 4 5
+  fps 10
+}

package/archetypes/runner/assets/sprites/coin.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Written by tools/make-assets.py: pixel art, lossless, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/runner/assets/sprites/courier.ogt

@@ -0,0 +1,32 @@
+type flipbook
+version 1
+---
+# The courier (tools/make-assets.py): 32 x 40 frames standing on their feet
+# (the pivot: the entity's position is the feet, so a squash keeps them down).
+texture "courier.png"
+pivot 0.5 0
+grid 32 40 8 2
+spacing 2
+clip idle {
+  frames 14 15
+  fps 2
+}
+clip run {
+  frames 0 1 2 3 4 5 6 7
+  fps 14
+  event 2 "step"
+  event 6 "step"
+}
+clip jump {
+  frames 8
+  fps 1
+}
+clip fall {
+  frames 9
+  fps 1
+}
+clip crash {
+  frames 10 11 12 13
+  fps 12
+  mode once
+}

package/archetypes/runner/assets/sprites/courier.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Written by tools/make-assets.py: pixel art, lossless, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/runner/assets/sprites/props.ogt

@@ -0,0 +1,21 @@
+type flipbook
+version 1
+---
+# Props (tools/make-assets.py): one frame each, 2 texels apart.
+texture "props.png"
+frame crate 0 0 16 16
+frame fence 18 0 16 32
+frame moon 36 0 32 32
+frame cloud 0 36 64 24
+clip crate {
+  frames crate
+}
+clip fence {
+  frames fence
+}
+clip moon {
+  frames moon
+}
+clip cloud {
+  frames cloud
+}

package/archetypes/runner/assets/sprites/props.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Written by tools/make-assets.py: pixel art, lossless, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/runner/assets/sprites/sky.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Written by tools/make-assets.py: pixel art, lossless, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/runner/assets/tiles/city.ogt

@@ -0,0 +1,18 @@
+type tileset
+version 1
+---
+# The city (tools/make-assets.py): 0 roof, 1-3 bricks, 4-7 far skyline,
+# 8-14 near buildings, 15 the antenna's light on.
+texture "tiles/city.png"
+grid 16 16 4 4
+spacing 2
+filter nearest
+# A window that goes on and off, and an antenna light that blinks.
+tile 9 {
+  frames 9 14 9 10
+  durations 2.5 0.4 1.8 0.6
+}
+tile 7 {
+  frames 7 15
+  durations 0.9 0.5
+}

package/archetypes/runner/assets/tiles/city.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Written by tools/make-assets.py: pixel art, lossless, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/runner/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/runner/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/runner/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "origin-runner",
+  "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/runner/project.ogt

@@ -0,0 +1,18 @@
+type project
+version 1
+---
+name "Runner"
+id "runner"
+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/runner/src/art.ts

@@ -0,0 +1,57 @@
+// The art: pixel-art flipbook sheets and the city's tilemaps, all made by
+// tools/make-assets.py and loaded once in `start` from the cooked bundle.
+//
+// - sprites/courier.ogt: the courier's clips (COURIER below, in sheet order),
+// - sprites/props.ogt: crate, fence, moon and cloud, one frame each,
+// - sprites/coin.ogt: the coin's turn,
+// - sprites/sky.png: the sky's colour bands, stretched over the view,
+// - maps/far.ogt, near.ogt, roofs.ogt: the three parallax strips (tilemaps
+//   with `repeat x` over tiles/city.ogt).
+
+import { og } from "@origingame/engine";
+import type { FlipbookInfo, Texture, TilemapInfo, World } from "@origingame/engine";
+
+/** The courier's clips, by index in sprites/courier.ogt (checked against the sheet in `loadArt`). */
+export const COURIER = { idle: 0, run: 1, jump: 2, fall: 3, crash: 4 } as const;
+/** The props' clips, by index in sprites/props.ogt. */
+export const PROPS = { crate: 0, fence: 1, moon: 2, cloud: 3 } as const;
+
+export interface Art {
+  readonly courier: FlipbookInfo;
+  readonly props: FlipbookInfo;
+  readonly coin: FlipbookInfo;
+  readonly sky: Texture;
+  readonly far: TilemapInfo;
+  readonly near: TilemapInfo;
+  readonly roofs: TilemapInfo;
+}
+
+function ok<T>(r: { ok: true; value: T } | { ok: false; reason: string }, what: string): T {
+  if (!r.ok) throw new Error(`${what}: ${r.reason} (run python3 tools/make-assets.py and og cook .)`);
+  return r.value;
+}
+
+function expectClips(info: FlipbookInfo, clips: Readonly<Record<string, number>>, path: string): void {
+  for (const [name, index] of Object.entries(clips)) {
+    const found = og.anim.clip(info, name);
+    if (found !== index) throw new Error(`${path}: clip ${name} is ${found}, the code expects ${index}`);
+  }
+}
+
+/** Loads every sheet, texture and map; the cooked bundle has them ready at once. */
+export function loadArt(world: World): Art {
+  const courier = ok(og.load.flipbook(world, "sprites/courier.ogt"), "sprites/courier.ogt");
+  const props = ok(og.load.flipbook(world, "sprites/props.ogt"), "sprites/props.ogt");
+  const coin = ok(og.load.flipbook(world, "sprites/coin.ogt"), "sprites/coin.ogt");
+  expectClips(courier, COURIER, "sprites/courier.ogt");
+  expectClips(props, PROPS, "sprites/props.ogt");
+  return {
+    courier,
+    props,
+    coin,
+    sky: ok(og.load.texture(world, "sprites/sky.png"), "sprites/sky.png"),
+    far: ok(og.load.tilemap(world, "maps/far.ogt"), "maps/far.ogt"),
+    near: ok(og.load.tilemap(world, "maps/near.ogt"), "maps/near.ogt"),
+    roofs: ok(og.load.tilemap(world, "maps/roofs.ogt"), "maps/roofs.ogt"),
+  };
+}

package/archetypes/runner/src/components.ts

@@ -0,0 +1,94 @@
+// 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 actor row carries Run 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 move obstacles, collect coins and end the run must see the run's
+// state on the same rows as the actors. Every actor is spawned with
+// og.Transform, Actor, Run and Tuning (plus og.Sprite, og.Flipbook or
+// og.Tilemap for what it draws), and the row whose Actor.kind is
+// Kind.Runner, the entity named "runner", is the authority: the other rows'
+// Run and Tuning keep their defaults and nothing reads them. Tune and
+// `set:runner.Tuning.<field>=<value>` write that row.
+
+import { bool, defineComponent, defineResource, f32, f64, u32 } from "@origingame/engine";
+
+/** What an actor row is. */
+export const Kind = {
+  Sky: 1,
+  Moon: 2,
+  Cloud: 3,
+  City: 4,
+  Dust: 5,
+  Runner: 6,
+  Crate: 7,
+  Fence: 8,
+  Coin: 9,
+} as const;
+
+/** Run phases. */
+export const Phase = { Title: 0, Running: 1, Over: 2 } as const;
+
+/** One thing in the world: its kind, hit box and scroll behaviour. */
+export const Actor = defineComponent("Actor", {
+  kind: u32(0, { doc: "Kind.* of src/components.ts." }),
+  active: bool(false, { doc: "Pooled obstacles and coins collide while true; a collected coin is inactive while its pop plays, parked rows wait at x = -1000." }),
+  w: f32(1, { min: 0, unit: "m", doc: "Hit box width, centred on the position (the runner's: on its feet plus RUNNER_SIZE.y / 2)." }),
+  h: f32(1, { min: 0, unit: "m", doc: "Hit box height, centred like the width." }),
+  parallax: f32(1, { min: 0, max: 1, doc: "The fraction of the run speed this row scrolls left at (0 never moves)." }),
+  wrap: f32(0, { min: 0, unit: "m", doc: "Scenery: the span a row jumps right by once it has scrolled that far (a tilemap's width); 0 for pooled rows." }),
+  vy: f32(0, { unit: "m/s", doc: "Vertical velocity (the runner)." }),
+});
+
+/** The run: phase, pace, score. Authoritative on the runner row. */
+export const Run = defineComponent("Run", {
+  phase: u32(Phase.Title, { doc: "0 title, 1 running, 2 over." }),
+  phaseTicks: u32(0, { unit: "ticks", doc: "Ticks since the phase began." }),
+  speed: f32(0, { unit: "m/s", doc: "The current run speed." }),
+  distance: f64(0, { unit: "m", doc: "Metres run this round." }),
+  coins: u32(0, { doc: "Coins collected this round." }),
+  score: u32(0, { doc: "floor(distance) + coins * Tuning.coinValue." }),
+  best: u32(0, { doc: "The best score: this session's, or the player's store's (og.platform) when higher." }),
+  bestRequest: u32(0, { doc: "The og.platform request reading the stored best (0 once answered)." }),
+  rounds: u32(0, { doc: "Rounds started." }),
+  spawnIn: f32(0, { unit: "s", doc: "Seconds until the next obstacle pattern." }),
+  grounded: bool(true, { doc: "The runner stands on the roof (og.PlatformerController.grounded after the last step)." }),
+  startHeld: bool(false, { doc: "The press that started the round is still held: it does not also jump." }),
+  kick: bool(false, { doc: "Director or Collide set Actor.vy this tick: Jump hands it to the body." }),
+});
+
+/** Tune's parameters. Authoritative on the runner row. */
+export const Tuning = defineComponent("Tuning", {
+  speed: f32(6, { min: 3, max: 12, step: 0.5, unit: "m/s", tunable: true, label: "Start speed", doc: "The run speed when a round starts." }),
+  speedRamp: f32(0.12, { min: 0, max: 1, step: 0.02, unit: "m/s²", tunable: true, label: "Speed ramp", doc: "How fast the run speeds up." }),
+  speedMax: f32(12, { min: 4, max: 20, step: 0.5, unit: "m/s", tunable: true, label: "Top speed" }),
+  jumpHeight: f32(2, { min: 0.5, max: 6, step: 0.1, unit: "m", tunable: true, label: "Jump height", doc: "How high a held jump goes (og.PlatformerController.jumpHeight)." }),
+  timeToApex: f32(0.333, { min: 0.15, max: 1, step: 0.01, unit: "s", tunable: true, label: "Time to apex", doc: "How long a held jump takes to peak; with jumpHeight it sets gravity and the take-off speed." }),
+  jumpCut: f32(1.8, { min: 1, max: 6, step: 0.1, tunable: true, label: "Jump cut", doc: "Gravity times this while rising with the press released: a tap is a hop, a hold a full jump." }),
+  apexGravity: f32(0.75, { min: 0.2, max: 1, step: 0.05, tunable: true, label: "Apex hang", doc: "Gravity times this near the top of a held jump (1: no hang)." }),
+  fallGravity: f32(1.15, { min: 1, max: 3, step: 0.05, tunable: true, label: "Fall gravity", doc: "Gravity times this on the way down (above 1: a snappier landing)." }),
+  spawnInterval: f32(1.3, { min: 0.5, max: 60, step: 0.1, unit: "s", tunable: true, label: "Spawn interval", doc: "Seconds between obstacle patterns, before the dice (×0.85–1.25)." }),
+  coinValue: u32(10, { min: 0, max: 100, step: 1, tunable: true, label: "Coin value" }),
+});
+
+/** Where the HUD draws: the font and the visible area, worked out in `start`. On the runner row only. */
+export const Hud = defineComponent("Hud", {
+  font: f64(0, { doc: "The Font handle." }),
+  halfWidth: f32(8.9, { unit: "m" }),
+  top: f32(8.5, { unit: "m" }),
+  bottom: f32(-1.5, { unit: "m" }),
+});
+
+/** Sound requests: bits of Sounds.sfx that the Voices system plays once each. */
+export const Sound = { Jump: 1, Coin: 2, Crash: 4, Start: 8, Hold: 16 } 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." }),
+});