@origingame/create-game 0.0.0-stage → 0.1.0

package/archetypes/topdown/assets/sprites/hero.ogt

@@ -0,0 +1,58 @@
+type flipbook
+version 1
+---
+# Written by tools/make-assets.py. Rows: down, up, side (facing right; flipX
+# faces left); columns: four walk frames, then the attack's wind-up and
+# strike. The clip order is the code's (src/art.ts): idle, walk, attack,
+# each down, up, side.
+texture "hero.png"
+pivot 0.5 0
+grid 16 16 6 3
+clip idle_down {
+  frames 0
+  fps 1
+}
+clip idle_up {
+  frames 6
+  fps 1
+}
+clip idle_side {
+  frames 12
+  fps 1
+}
+clip walk_down {
+  frames 0 1 2 3
+  fps 8
+  event 0 "step"
+  event 2 "step"
+}
+clip walk_up {
+  frames 6 7 8 9
+  fps 8
+  event 0 "step"
+  event 2 "step"
+}
+clip walk_side {
+  frames 12 13 14 15
+  fps 8
+  event 0 "step"
+  event 2 "step"
+}
+clip attack_down {
+  frames 4 5
+  durations 0.07 0.18
+  mode once
+  event 1 "hit"
+}
+clip attack_up {
+  frames 10 11
+  durations 0.07 0.18
+  mode once
+  event 1 "hit"
+}
+clip attack_side {
+  frames 16 17
+  durations 0.07 0.18
+  mode once
+  event 1 "hit"
+}

package/archetypes/topdown/assets/sprites/hero.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Pixel art: lossless, no mips, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/topdown/assets/sprites/items.ogt

@@ -0,0 +1,15 @@
+type flipbook
+version 1
+---
+# Written by tools/make-assets.py: a spinning coin and a key.
+texture "items.png"
+pivot 0.5 0
+grid 16 16 5 1
+clip coin {
+  frames 0 1 2 3
+  fps 10
+}
+clip key {
+  frames 4
+  fps 1
+}

package/archetypes/topdown/assets/sprites/items.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Pixel art: lossless, no mips, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/topdown/assets/sprites/slime.ogt

@@ -0,0 +1,17 @@
+type flipbook
+version 1
+---
+# Written by tools/make-assets.py: a four-frame bob and a hurt frame.
+texture "slime.png"
+pivot 0.5 0
+grid 16 16 5 1
+clip bob {
+  frames 0 1 2 3
+  fps 6
+  mode pingPong
+}
+clip hurt {
+  frames 4
+  durations 0.25
+  mode once
+}

package/archetypes/topdown/assets/sprites/slime.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Pixel art: lossless, no mips, sampled nearest.
+texture {
+  kind pixel
+}

package/archetypes/topdown/assets/tiles/dungeon.ogt

@@ -0,0 +1,65 @@
+type tileset
+version 1
+---
+# Written by tools/make-assets.py: tiles 0-46 are the wall terrain's 47 blob
+# shapes, 47-49 floor, 50 moss, 51-53 the torch, 54-55 the door.
+texture "tiles/dungeon.png"
+grid 16 16 8 8
+filter nearest
+solid 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
+tile 51 {
+  frames 51 52 53 52
+  fps 7
+}
+terrain wall {
+  mode blob47
+  rule 0 0
+  rule 1 1
+  rule 4 2
+  rule 5 3
+  rule 7 4
+  rule 16 5
+  rule 17 6
+  rule 20 7
+  rule 21 8
+  rule 23 9
+  rule 28 10
+  rule 29 11
+  rule 31 12
+  rule 64 13
+  rule 65 14
+  rule 68 15
+  rule 69 16
+  rule 71 17
+  rule 80 18
+  rule 81 19
+  rule 84 20
+  rule 85 21
+  rule 87 22
+  rule 92 23
+  rule 93 24
+  rule 95 25
+  rule 112 26
+  rule 113 27
+  rule 116 28
+  rule 117 29
+  rule 119 30
+  rule 124 31
+  rule 125 32
+  rule 127 33
+  rule 193 34
+  rule 197 35
+  rule 199 36
+  rule 209 37
+  rule 213 38
+  rule 215 39
+  rule 221 40
+  rule 223 41
+  rule 241 42
+  rule 245 43
+  rule 247 44
+  rule 253 45
+  rule 255 46
+  default 46
+  edge filled
+}

package/archetypes/topdown/assets/tiles/dungeon.png.ogt

@@ -0,0 +1,7 @@
+type import
+version 1
+---
+# Pixel art: lossless, no mips, sampled nearest.
+texture {
+  kind pixel
+}

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

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

@@ -0,0 +1,14 @@
+type project
+version 1
+---
+name "Tomb Room"
+id "topdown"
+engine "0.1.0"
+entry "src/main.ts"
+profile "2d"
+tick 60
+seed 1
+publish {
+  probe player
+  out "dist"
+}

package/archetypes/topdown/src/art.ts

@@ -0,0 +1,48 @@
+// The flipbook sheets (assets/sprites/*.ogt, written by tools/make-assets.py)
+// and their clips, looked up by name once in `start`.
+
+import { og } from "@origingame/engine";
+import type { FlipbookInfo, World } from "@origingame/engine";
+import { Facing } from "./components.ts";
+
+export interface Sheets {
+  readonly hero: FlipbookInfo;
+  readonly slime: FlipbookInfo;
+  readonly items: FlipbookInfo;
+}
+
+export function loadSheets(world: World): Sheets {
+  const load = (path: string): FlipbookInfo => {
+    const r = og.load.flipbook(world, path);
+    if (!r.ok) throw new Error(`${path}: ${r.reason}`);
+    return r.value;
+  };
+  return { hero: load("sprites/hero.ogt"), slime: load("sprites/slime.ogt"), items: load("sprites/items.ogt") };
+}
+
+/** A clip's index by name; a missing clip is an authoring error. */
+export function clip(info: FlipbookInfo, name: string): number {
+  const i = og.anim.clip(info, name);
+  if (i < 0) throw new Error(`the sheet has no clip '${name}' (its clips: ${info.clips.map((c) => c.name).join(", ")})`);
+  return i;
+}
+
+/**
+ * The hero's clips are authored in this order (assets/sprites/hero.ogt):
+ * idle, walk and attack, each down, up, side. So a clip is its action's
+ * base plus the facing's row; left is the side row drawn with flipX.
+ */
+export const HeroClip = { Idle: 0, Walk: 3, Attack: 6 } as const;
+
+export function heroClip(action: number, facing: number): number {
+  const row = facing === Facing.Down ? 0 : facing === Facing.Up ? 1 : 2;
+  return action + row;
+}
+
+/** Checks the hero sheet's order against HeroClip once, in `start`. */
+export function checkHeroClips(info: FlipbookInfo): void {
+  const names = ["idle_down", "idle_up", "idle_side", "walk_down", "walk_up", "walk_side", "attack_down", "attack_up", "attack_side"];
+  names.forEach((n, i) => {
+    if (clip(info, n) !== i) throw new Error(`assets/sprites/hero.ogt: clip '${n}' must be clip ${i} (src/art.ts reads clips by position)`);
+  });
+}

package/archetypes/topdown/src/components.ts

@@ -0,0 +1,128 @@
+// Every piece of Tomb Room's state lives in these reflected types: dumps,
+// the probe, Tune and the command channel's `set` read and write them by
+// name.
+//
+// The run's state (Game) and the knobs (Tuning) are resources, so every
+// system reads them without carrying them on its rows. The actors are
+// components: one Hero, one Slime, the Pickups and the Sfx voices.
+
+import { bool, defineComponent, defineResource, f32, f64, i32, u32 } from "@origingame/engine";
+
+/** Which way the hero faces: the clip row of src/art.ts and the attack's direction. */
+export const Facing = { Down: 0, Up: 1, Left: 2, Right: 3 } as const;
+
+/** What a pickup is. */
+export const PickupKind = { Coin: 1, Key: 2 } as const;
+
+/** Sound requests: bits of Game.sfx that the Sfx system plays once each. */
+export const Sound = { Hit: 1, Hurt: 2, Coin: 4, Key: 8, Door: 16, Step: 32 } as const;
+
+/** The run: the hero's health and purse, the door, the room and the effects' bookkeeping. */
+export const Game = defineResource("Game", {
+  hp: u32(3, { doc: "The hero's hearts left." }),
+  hpMax: u32(3, { doc: "Hearts at the start." }),
+  coins: u32(0, { doc: "Coins picked up." }),
+  coinsTotal: u32(0, { doc: "Coins the map placed (worked out in start)." }),
+  hasKey: bool(false, { doc: "The key is picked up." }),
+  doorOpen: bool(false, { doc: "The doorway between the rooms is open." }),
+  room: u32(1, { doc: "The room the hero stands in: 1 west, 2 east." }),
+  enemyHp: u32(0, { doc: "The slime's health (0 once it is dead)." }),
+  enemyHits: u32(0, { doc: "Hits the slime has taken; the third is a crit." }),
+  heroX: f32(0, { unit: "m", doc: "The hero's feet, written by Control for the other systems." }),
+  heroY: f32(0, { unit: "m" }),
+  facing: u32(Facing.Down, { doc: "Facing.* of src/components.ts." }),
+  swing: bool(false, { doc: "The sword's strike frame fired this tick (the hero's 'hit' flipbook event)." }),
+  swingX: f32(0, { unit: "m", doc: "The strike's centre." }),
+  swingY: f32(0, { unit: "m" }),
+  swings: u32(0, { doc: "Strikes so far." }),
+  steps: u32(0, { doc: "Footsteps (the walk clips' 'step' events)." }),
+  iframes: u32(0, { unit: "ticks", doc: "Ticks the hero is invulnerable for after a hurt." }),
+  hurts: u32(0, { doc: "Times the hero was hurt." }),
+  downTicks: u32(0, { unit: "ticks", doc: "Ticks since hp reached 0; the hero stands up at the spawn after a while." }),
+  spawnX: f32(0, { unit: "m", doc: "The map's spawn point." }),
+  spawnY: f32(0, { unit: "m" }),
+  knockX: f32(0, { unit: "m/s", doc: "The hero's knockback velocity; it decays every tick." }),
+  knockY: f32(0, { unit: "m/s" }),
+  doorX: f32(0, { unit: "m", doc: "The doorway's centre (from the map's door object)." }),
+  doorY: f32(0, { unit: "m" }),
+  doorCellX: u32(0, { doc: "The doorway's first cell (map columns and rows)." }),
+  doorCellY: u32(0),
+  doorCellsW: u32(0),
+  doorCellsH: u32(0),
+  roomSplit: f32(20, { unit: "m", doc: "The x where the east room starts (from the room objects)." }),
+  lockedFor: u32(0, { unit: "ticks", doc: "Ticks before the locked door speaks again." }),
+  sfx: u32(0, { doc: "Sound.* bits waiting to play." }),
+  font: f64(0, { doc: "The UI Font handle." }),
+});
+
+/** The knobs. Tune reads the tunable fields; `set:Tuning.<field>=<value>` writes them. */
+export const Tuning = defineResource("Tuning", {
+  speed: f32(4.5, { min: 1, max: 10, step: 0.25, unit: "m/s", tunable: true, label: "Walk speed" }),
+  dashSpeed: f32(13, { min: 4, max: 24, step: 0.5, unit: "m/s", tunable: true, label: "Dash speed" }),
+  dashTicks: u32(9, { min: 2, max: 30, step: 1, unit: "ticks", tunable: true, label: "Dash length" }),
+  dashCooldown: u32(36, { min: 0, max: 120, step: 1, unit: "ticks", tunable: true, label: "Dash cooldown" }),
+  reach: f32(0.75, { min: 0.2, max: 2, step: 0.05, unit: "m", tunable: true, label: "Sword reach", doc: "The strike's radius around a point one reach ahead of the hero's chest." }),
+  hitStop: u32(4, { min: 0, max: 12, step: 1, unit: "ticks", tunable: true, label: "Hit stop" }),
+  shake: f32(0.25, { min: 0, max: 1, step: 0.05, tunable: true, label: "Hit shake", doc: "Camera trauma per hit." }),
+  slimeSpeed: f32(1.6, { min: 0, max: 6, step: 0.1, unit: "m/s", tunable: true, label: "Slime speed", doc: "The chase (assets/ai/slime.ogt reads it as `speed Tuning.slimeSpeed`)." }),
+  slimeSight: f32(5, { min: 0, max: 12, step: 0.5, unit: "m", tunable: true, label: "Slime sight", doc: "How far the slime sees (its og.Perception.sight); walls hide the hero." }),
+  knockback: f32(9, { min: 0, max: 20, step: 0.5, unit: "m/s", tunable: true, label: "Knockback" }),
+  iframes: u32(50, { min: 0, max: 180, step: 5, unit: "ticks", tunable: true, label: "Invulnerable ticks" }),
+});
+
+/** The hero: the attack and dash timers and the clip on show. */
+export const Hero = defineComponent("Hero", {
+  attack: u32(0, { unit: "ticks", doc: "Ticks left in the current swing; input waits until 0." }),
+  dash: u32(0, { unit: "ticks", doc: "Ticks left in the current dash." }),
+  dashCooldown: u32(0, { unit: "ticks" }),
+  dashX: f32(0, { doc: "The dash's direction." }),
+  dashY: f32(0),
+  dashes: u32(0, { doc: "Dashes so far." }),
+  moving: bool(false, { doc: "Walk input was held this tick." }),
+});
+
+/** A slime: health, its own knockback and the death. What it does is assets/ai/slime.ogt (og.ai) moving it on the map's grid (og.nav). */
+export const Slime = defineComponent("Slime", {
+  hp: u32(50, { doc: "Health; the sword deals 12, 12, then a 26 crit. Below 30 the behaviour flees." }),
+  knockX: f32(0, { unit: "m/s" }),
+  knockY: f32(0, { unit: "m/s" }),
+  stun: u32(0, { unit: "ticks", doc: "Ticks it neither moves nor bites after a hit or a bite." }),
+  bites: u32(0, { doc: "Bites that hurt the hero." }),
+  dead: bool(false),
+  deadTicks: u32(0, { unit: "ticks", doc: "Ticks since it died; it hides once the death tween is over." }),
+  bob: i32(0, { doc: "The bob clip's index (src/art.ts)." }),
+  hurt: i32(0, { doc: "The hurt clip's index." }),
+});
+
+/** A coin or the key, taken by overlap. */
+export const Pickup = defineComponent("Pickup", {
+  kind: u32(PickupKind.Coin, { doc: "PickupKind.* of src/components.ts." }),
+  taken: bool(false),
+  takenTicks: u32(0, { unit: "ticks" }),
+  baseY: f32(0, { unit: "m", doc: "Where it rests; it hovers around this." }),
+});
+
+/**
+ * The run's facts, copied from Game onto the hero every tick by the Hud
+ * system: `dump_entity:hero` shows them, which is how the playtests read the
+ * run (the command channel dumps entities, not resources).
+ */
+export const Report = defineComponent("Report", {
+  room: u32(1),
+  hp: u32(0),
+  coins: u32(0),
+  hasKey: bool(false),
+  doorOpen: bool(false),
+  enemyHp: u32(0),
+  hits: u32(0, { doc: "Hits the slime took." }),
+  swings: u32(0),
+  steps: u32(0),
+  hurts: u32(0),
+  facing: u32(0),
+  doorWall: i32(0, { doc: "og.tilemap.getTile of the walls terrain at the doorway's first cell: the auto-tiled wall tile while closed, -1 once open." }),
+});
+
+/** One voice: plays its sound once when Game.sfx asks for its bit. */
+export const Sfx = defineComponent("Sfx", {
+  bit: u32(0, { doc: "Sound.* of src/components.ts." }),
+});