@origingame/create-game 0.0.0-stage → 0.1.1

package/archetypes/rhythm/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "origin-rhythm",
+  "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.1"
+  }
+}

package/archetypes/rhythm/project.ogt

@@ -0,0 +1,14 @@
+type project
+version 1
+---
+name "Three-Lane Beat"
+id "rhythm"
+engine "0.1.1"
+entry "src/main.ts"
+profile "2d"
+tick 60
+seed 1
+publish {
+  probe player
+  out "dist"
+}

package/archetypes/rhythm/src/components.ts

@@ -0,0 +1,147 @@
+// Every piece of Three-Lane Beat's state lives in these reflected types:
+// dumps, the probe, Tune and the command channel's `get` and `set` read and
+// write them by name.
+//
+// The play (Game), the knobs (Tuning) and the player's settings with the
+// calibrated offset (Prefs) are resources. The chart is a scene
+// (assets/charts/*.ogt): its `Song` row and one `Note` row per note. The
+// stems, the lanes' receptors and the voices are rows spawned in `start`.
+
+import { bool, defineComponent, defineResource, f32, f64, i32, u32 } from "@origingame/engine";
+
+/** The screen the game is on. */
+export const Phase = { Title: 0, Play: 1, Results: 2, Calibrate: 3 } as const;
+
+/** A note's judgement (Note.judged - 1, Game.lastJudgement). */
+export const Judgement = { Perfect: 0, Great: 1, Good: 2, Miss: 3 } as const;
+export const JUDGEMENTS = ["perfect", "great", "good", "miss"] as const;
+
+/** The lanes. */
+export const LANES = 3;
+
+/** Sound requests: bits of Game.sfx that the Voices system plays once each. */
+export const Sound = { Tap0: 1, Tap1: 2, Tap2: 4, Miss: 8, Clear: 16, Fail: 32, Move: 64, Break: 128 } as const;
+
+/** The play: the song's clock, the judgements, the score, the groove, the calibration, the best. */
+export const Game = defineResource("Game", {
+  phase: u32(Phase.Title, { doc: "Phase.* of src/components.ts." }),
+  leftTitle: bool(false, { doc: "The player has left the title the game opened on: from then on the title enters with the skin's entrance (the opening one is built settled, og.ui.mainMenu's instant: the web draws it behind the play gate)." }),
+  paused: bool(false),
+  settingsOpen: bool(false),
+  held: bool(false, { doc: "The time scale is held at 0 (paused or in the settings)." }),
+  songStart: f64(0, { unit: "s", doc: "The world time of bar 1's first beat (og.Music.start): every note's time is songStart + beat × 60 / bpm." }),
+  pausedAt: f64(-1, { unit: "s", doc: "The world time the play was paused at (-1 not paused)." }),
+  countTo: f64(0, { unit: "s", doc: "The count-in ends at this world time (after a start or a resume)." }),
+  score: u32(0),
+  combo: u32(0),
+  maxCombo: u32(0),
+  perfect: u32(0),
+  great: u32(0),
+  good: u32(0),
+  miss: u32(0),
+  hits: u32(0, { doc: "Notes hit (perfect, great or good)." }),
+  judged: u32(0, { doc: "Notes judged (hit or missed)." }),
+  notes: u32(0, { doc: "Notes in the chart." }),
+  taps: u32(0, { doc: "Lane presses." }),
+  groove: f32(0.5, { doc: "The life gauge, 0 to 1: hits fill it, misses drain it; empty fails the song." }),
+  failed: bool(false),
+  cleared: bool(false),
+  lastJudgement: i32(-1, { doc: "Judgement.* of the last judged note." }),
+  lastOffsetMs: f32(0, { unit: "ms", doc: "The last hit's error: negative early, positive late." }),
+  lastLane: i32(-1),
+  scheduled: u32(0, { doc: "Notes put on the highway so far by og.MusicBeat (the next note to schedule)." }),
+  nextBar: u32(0, { doc: "The bar whose stems the Band starts next." }),
+  endAt: f64(0, { unit: "s", doc: "The world time the results come up (a beat after the last note, or after the groove ran out)." }),
+  calTaps: u32(0, { doc: "Calibration taps so far (of 8)." }),
+  calSum: f64(0, { unit: "ms", doc: "The calibration taps' errors, summed." }),
+  best: u32(0),
+  bestRequest: u32(0),
+  bestRevision: u32(0),
+  bestWrite: u32(0),
+  newBest: bool(false),
+  padLane: i32(-1, { doc: "A lane a command pressed this tick (-1 none)." }),
+  bpm: f32(120, { unit: "bpm", doc: "The chart's tempo (its Song row)." }),
+  bars: u32(0, { doc: "The chart's length in bars." }),
+  pressMask: u32(0, { doc: "The lanes pressed this tick (bit per lane)." }),
+  hitMask: u32(0, { doc: "The lanes whose press hit a note this tick." }),
+  resetNotes: bool(false, { doc: "A new play: the Play system clears every note's judgement this tick." }),
+  fromBeat: f32(0, { unit: "beats", doc: "Where this play started (play:<bar> starts later): earlier notes are skipped, not judged." }),
+  scheduleUpTo: f32(-1, { unit: "beats", doc: "A start or a resume puts the notes up to this beat on the highway (-1 none); og.MusicBeat does the rest." }),
+  countShown: i32(-1, { doc: "The count-in number last shown." }),
+  over: bool(false, { doc: "The play is over: the Ui system shows the results." }),
+  stopBand: bool(false, { doc: "Stop every stem this tick (a pause, a fail, the title)." }),
+  bandFrom: u32(0, { doc: "A start or a resume: the bar the Band starts at Game.countTo, after the count-in's clicks (0 none)." }),
+  bandBeat: f64(0, { doc: "Where in the song (beats from bar 1) the Band starts at Game.countTo: a bar line after a start, the beat it paused on after a resume, so the bar's stems start part-way (AudioSource.startOffset)." }),
+  noteTexture: f64(0, { doc: "The note's texture handle." }),
+  sfx: u32(0),
+  laneW: f32(1.5, { unit: "m", doc: "A lane's width (src/ui.ts sets the layout for the surface)." }),
+  hitY: f32(-3.2, { unit: "m", doc: "The hit line's height." }),
+  topY: f32(4.8, { unit: "m", doc: "Where notes appear." }),
+  viewW: f32(0, { unit: "cssPx" }),
+  viewH: f32(0, { unit: "cssPx" }),
+  language: u32(0),
+});
+
+/** The knobs. Tune reads the tunable fields; `set:Tuning.<field>=<value>` writes them. */
+export const Tuning = defineResource("Tuning", {
+  perfectMs: f32(45, { min: 5, max: 200, step: 1, unit: "ms", tunable: true, label: "Perfect window", doc: "A hit within this of the note's time (either side) is Perfect." }),
+  greatMs: f32(90, { min: 5, max: 250, step: 1, unit: "ms", tunable: true, label: "Great window" }),
+  goodMs: f32(135, { min: 5, max: 300, step: 1, unit: "ms", tunable: true, label: "Good window", doc: "Past this late, an unhit note is a Miss." }),
+  scrollBeats: f32(2, { min: 0.5, max: 8, step: 0.25, unit: "beats", tunable: true, label: "Scroll", doc: "How many beats ahead a note appears at the top." }),
+  countInBeats: u32(4, { min: 1, max: 4, tunable: true, label: "Count-in", doc: "Beats of clicks before the song, and before it resumes." }),
+  grooveStart: f32(0.5, { min: 0.05, max: 1, step: 0.05, tunable: true, label: "Groove at the start" }),
+  grooveGain: f32(0.03, { min: 0, max: 0.5, step: 0.005, tunable: true, label: "Groove per hit" }),
+  grooveLoss: f32(0.1, { min: 0, max: 1, step: 0.01, tunable: true, label: "Groove per miss" }),
+  perfectPoints: u32(300, { min: 0, max: 10000, tunable: true }),
+  greatPoints: u32(200, { min: 0, max: 10000, tunable: true }),
+  goodPoints: u32(100, { min: 0, max: 10000, tunable: true }),
+  comboStep: u32(10, { min: 1, max: 100, tunable: true, label: "Combo per multiplier", doc: "Every this many in a row raises the multiplier by one, up to four." }),
+});
+
+/** The player's settings: kept in og.platform's settings, restored on the first ticks. */
+export const Prefs = defineResource("Prefs", {
+  master: f32(1, { min: 0, max: 1 }),
+  music: f32(0.8, { min: 0, max: 1 }),
+  effects: f32(0.8, { min: 0, max: 1 }),
+  language: u32(0, { doc: "0 English, 1 简体中文 (LANGUAGES in src/ui.ts)." }),
+  reducedMotion: bool(false),
+  offsetMs: f32(0, { min: -250, max: 250, unit: "ms", doc: "How late this device's sound and picture reach the player (calibrated): a press is judged this much earlier." }),
+  loadRequest: u32(0),
+  saves: u32(0),
+});
+
+/** The chart's song: tempo, metre and length (one row, from the chart scene). */
+export const Song = defineComponent("Song", {
+  bpm: f32(120, { unit: "bpm" }),
+  beatsPerBar: u32(4),
+  bars: u32(0),
+  notes: u32(0),
+});
+
+/** A note of the chart (a row from the chart scene): its lane and beat, then how it went. */
+export const Note = defineComponent("Note", {
+  index: u32(0, { doc: "Its place in the chart, in time order." }),
+  lane: u32(0, { doc: "0 left, 1 middle, 2 right." }),
+  beat: f32(0, { unit: "beats", doc: "From 0 at bar 1's first beat." }),
+  live: bool(false, { doc: "On the highway (scheduled by og.MusicBeat, not yet judged)." }),
+  judged: u32(0, { doc: "0 not yet, else Judgement.* + 1 (5: skipped, before a play that started later)." }),
+  errorMs: f32(0, { unit: "ms", doc: "How early (negative) or late it was hit." }),
+});
+
+/** A stem of the song: started on its bar lines by the Band. */
+export const Stem = defineComponent("Stem", {
+  part: u32(0, { doc: "PARTS index in src/systems.ts." }),
+  starts: u32(0, { doc: "Times started." }),
+});
+
+/** A lane's receptor at the hit line: it flashes and squashes on a press. */
+export const Receptor = defineComponent("Receptor", {
+  lane: u32(0),
+  presses: u32(0),
+});
+
+/** One voice: plays its sound once when Game.sfx asks for its bit. */
+export const Sfx = defineComponent("Sfx", {
+  bit: u32(0),
+  plays: u32(0),
+});

package/archetypes/rhythm/src/main.ts

@@ -0,0 +1,202 @@
+// Three-Lane Beat, the rhythm archetype (2D profile): notes fall down three
+// lanes to the hit line in time with "Neon Pulse" (120 BPM, 24 bars); hit
+// each as it crosses the line (A S D, the arrows, a finger on the lane, the
+// pad). Every hit is judged by how far it was from the note's exact time
+// (Perfect, Great, Good), every note let past is a Miss; hits build the
+// combo and its multiplier and fill the groove, misses drain it, and an
+// empty groove ends the song early. A calibration measures how late this
+// device's sound and picture reach the player.
+//
+// The song is its stems, started on bar lines through og.Music (src/
+// systems.ts's Band); the chart is a scene (assets/charts/neon-pulse.ogt)
+// of a Song row and a Note row per note. `start` loads them, the skin, the
+// strings and the sounds, and spawns the clock, the stems, the receptors
+// and the voices. The systems are in src/systems.ts, the screens in
+// src/ui.ts and the state in src/components.ts.
+
+import { og } from "@origingame/engine";
+import type { World } from "@origingame/engine";
+import { Game, LANES, Prefs, Receptor, Sfx, Song, Sound, Stem, Tuning } from "./components.ts";
+import { Band, Clock, LANE_COLOURS, Lanes, PARTS, Play, Voices, worldTime } from "./systems.ts";
+import { accuracy, begin, calibrate, LANGUAGES, pause, resume, Ui } from "./ui.ts";
+
+/** The night, linear. */
+const NIGHT = { r: 0.002, g: 0.006, b: 0.014 };
+
+function must<T>(r: { ok: true; value: T } | { ok: false; reason: string }): T;
+function must(r: { ok: true } | { ok: false; reason: string }): void;
+function must<T>(r: { ok: true; value?: T } | { ok: false; reason: string }): T | void {
+  if (!r.ok) throw new Error(r.reason);
+  return r.value;
+}
+
+function start(world: World): void {
+  for (const l of LANGUAGES) must(og.i18n.load(world, `strings/${l.code}.ogt`));
+  const skin = must(og.load.skin(world, "skins/lanebeat/skin.ogt"));
+  const sound = (path: string) => must(og.load.sound(world, path));
+  must(og.ui.configure(world, { skin, sounds: { press: sound("audio/ui-press.ogt"), open: sound("audio/ui-open.ogt"), close: sound("audio/ui-close.ogt"), error: sound("audio/ui-error.ogt"), success: sound("audio/ui-success.ogt") } }));
+
+  const settings = must(world.resource(og.RenderSettings));
+  settings.environmentIntensity = 0;
+  settings.toneMapped = false;
+  const camera = must(world.resource(og.Camera));
+  camera.orthographic = true;
+  camera.height = 10;
+  camera.position = { x: 0, y: 0, z: 50 };
+  camera.background = NIGHT;
+
+  // The chart: a Song row and a Note row per note.
+  must(world.instantiate(must(og.load.scene(world, "charts/neon-pulse.ogt")), { name: "chart" }));
+  const songRow = world.find("song");
+  if (songRow === null) throw new Error("charts/neon-pulse.ogt has no entity named song");
+  const song = must(world.get(songRow, Song));
+  const game = must(world.resource(Game));
+  game.bpm = song.bpm;
+  game.bars = song.bars;
+  game.notes = song.notes;
+  const texture = (path: string) => must(og.load.texture(world, path));
+  game.noteTexture = texture("sprites/note.png") as unknown as number;
+
+  // The clock the stems start on (og.Music; the Clock system keeps it on Game.songStart).
+  const clock = must(world.spawn({ name: "clock" }));
+  must(world.insert(clock, og.Music, { bpm: song.bpm, beatsPerBar: song.beatsPerBar, start: 1e6 }));
+  PARTS.forEach((part, i) => {
+    const e = must(world.spawn({ name: `stem-${part}` }));
+    const click = part.startsWith("click");
+    must(world.insert(e, og.AudioSource, { sound: sound(`audio/${click ? "click" : part}.wav`), playing: false, bus: click ? "ui" : "music", volume: click ? 0.6 : part === "drums" ? 0.8 : 0.6, priority: 240, fade: 0.004 }));
+    must(world.insert(e, Stem, { part: i }));
+  });
+
+  // The highway: three lanes' glow, the hit line's receptors (with their bursts).
+  const lane = texture("sprites/lane.png");
+  const ring = texture("sprites/ring.png");
+  const hit = must(og.load.emitter(world, "fx/hit.ogt"));
+  for (let i = 0; i < LANES; i++) {
+    const c = LANE_COLOURS[i]!;
+    const glow = must(world.spawn({ name: `lane-${i}`, position: { x: (i - 1) * 1.5, y: -0.2, z: 0 } }));
+    must(world.insert(glow, og.Sprite, { texture: lane, width: 1.4, height: 9.6, color: c, opacity: 0.22, blend: "additive", layer: 1 }));
+    const r = must(world.spawn({ name: `receptor-${i}`, position: { x: (i - 1) * 1.5, y: -3.2, z: 0 } }));
+    must(world.insert(r, og.Sprite, { texture: ring, width: 1.29, height: 0.54, color: c, opacity: 0.6, layer: 5, visible: false }));
+    must(world.insert(r, og.ParticleSystem, { emitter: hit, seed: i + 1, visible: false }));
+    must(world.insert(r, Receptor, { lane: i }));
+  }
+
+  const voices: [string, number, "sfx" | "ui", number][] = [
+    ["audio/tap0.wav", Sound.Tap0, "ui", 0.45],
+    ["audio/tap1.wav", Sound.Tap1, "ui", 0.45],
+    ["audio/tap2.wav", Sound.Tap2, "ui", 0.45],
+    ["audio/miss.wav", Sound.Miss, "sfx", 0.5],
+    ["audio/miss.wav", Sound.Break, "sfx", 0.8],
+    ["audio/clear.wav", Sound.Clear, "sfx", 0.7],
+    ["audio/fail.wav", Sound.Fail, "sfx", 0.7],
+    ["audio/ui-press.ogt", Sound.Move, "ui", 0.3],
+  ];
+  for (const [path, bit, bus, volume] of voices) {
+    const v = must(world.spawn({ name: `sfx-${bit}` }));
+    must(world.insert(v, og.AudioSource, { sound: sound(path), playing: false, bus, volume, priority: 200 }));
+    must(world.insert(v, Sfx, { bit }));
+  }
+}
+
+function gameOf(world: World) {
+  return must(world.resource(Game));
+}
+
+function num(s: string | undefined, what: string): number {
+  const n = Number(s);
+  if (s === undefined || !Number.isFinite(n)) throw new Error(`${what} is a number`);
+  return n;
+}
+
+/** `play[:<bar>]`: start the song now, as Play does; from a later bar, the notes before it skipped. */
+function play(world: World, args: readonly string[]): void {
+  begin(world, gameOf(world), args[0] === undefined ? 1 : num(args[0], "bar"));
+}
+
+/** `hit:<lane>`: press a lane this tick, as a key or a finger does. */
+function hit(world: World, args: readonly string[]): void {
+  const lane = num(args[0], "lane");
+  if (lane < 0 || lane >= LANES) throw new Error("the lane is 0, 1 or 2");
+  gameOf(world).padLane = lane;
+}
+
+/** `groove:<0-1>`: set the groove. */
+function groove(world: World, args: readonly string[]): void {
+  gameOf(world).groove = num(args[0], "groove");
+}
+
+/** `offset:<ms>`: set the calibrated offset. */
+function offset(world: World, args: readonly string[]): void {
+  must(world.resource(Prefs)).offsetMs = num(args[0], "ms");
+}
+
+/** `viewport:<desktop|phone>`: lay the UI out for a phone in portrait. */
+function viewport(world: World, args: readonly string[]): void {
+  const phone = { width: 390, height: 844, dpr: 3, safeArea: { left: 0, top: 47, right: 0, bottom: 34 }, coarsePointer: true, breakpoint: "phonePortrait" } as const;
+  og.ui.previewViewport(world, args[0] === "phone" ? phone : null);
+}
+
+/** `language:<en|zh-CN>`. */
+function language(world: World, args: readonly string[]): void {
+  const p = must(world.resource(Prefs));
+  const at = LANGUAGES.findIndex((l) => l.code === args[0]);
+  if (at < 0) throw new Error("write language:<en|zh-CN>");
+  p.language = at;
+  og.i18n.setLocale(world, LANGUAGES[at]!.code);
+}
+
+export default og.game({
+  tick: 60,
+  seed: 1,
+  resources: [Game, Tuning, Prefs],
+  systems: [Ui, Clock, Play, Band, Lanes, Voices],
+  render: { antialias: "msaa4" },
+  start,
+  commands: {
+    play,
+    hit,
+    groove,
+    offset,
+    calibrate: (world: World) => calibrate(world, gameOf(world)),
+    hold: (world: World) => pause(world, gameOf(world)),
+    unhold: (world: World) => resume(world, gameOf(world)),
+    viewport,
+    language,
+  },
+  commandHelp: {
+    play: { usage: "[<bar>]", doc: "Start the song now, as Play does (the count-in, then bar 1); from a later bar, the earlier notes skipped." },
+    hit: { usage: "<lane 0-2>", doc: "Press a lane this tick, as a key or a finger does." },
+    groove: { usage: "<0-1>", doc: "Set the groove (the life gauge)." },
+    offset: { usage: "<ms>", doc: "Set the calibrated offset." },
+    calibrate: { usage: "", doc: "Open the calibration, as Calibrate does." },
+    hold: { usage: "", doc: "Pause the play, as Escape does." },
+    unhold: { usage: "", doc: "Resume the play, as Resume does (on its phrase's bar line, after a count-in)." },
+    viewport: { usage: "<desktop|phone>", doc: "Lay the UI out for a phone in portrait (390×844 at 3×)." },
+    language: { usage: "<en|zh-CN>", doc: "Switch the language as the settings do." },
+  },
+  facts: (world) => {
+    const game = world.resource(Game);
+    if (!game.ok) return null;
+    const g = game.value;
+    return {
+      phase: ["title", "play", "results", "calibrate"][g.phase],
+      time: worldTime(world) - g.songStart,
+      score: g.score,
+      combo: g.combo,
+      maxCombo: g.maxCombo,
+      perfect: g.perfect,
+      great: g.great,
+      good: g.good,
+      miss: g.miss,
+      judged: g.judged,
+      notes: g.notes,
+      groove: g.groove,
+      accuracy: accuracy(g),
+      cleared: g.cleared,
+      failed: g.failed,
+      best: g.best,
+      language: LANGUAGES[g.language]!.code,
+    };
+  },
+});
+