rootandClaude Opus 5
fe3c63c48c
Next move held four clusters of Set variable in a row, fourteen single nodes
in all; clear-lines read three variables one after the other. They are now
one plural node each, which takes Next move 40 -> 30 nodes and clear-lines
25 -> 23. Every remaining single node was checked and really is single: ok/no
are the same variable in opposite branches, take/keep the same one across a
write, and the three key setters hang on three different events.
Two contracts carry those merges, both pinned as tests. Set variables writes
per port with writeTyped exactly as the singular node does, so a Pack{rot}
still merges instead of overwriting - without it, turning would have erased
the other three fields. And the interpreter collects every input before the
node runs, so no input may come from a variable the same node writes; a data
node is evaluated once per pulse and keeps its answer. That second rule is
invisible in the game, because OnUpdate re-reads each frame and heals it, so
it lives in a unit test rather than in the smoke.
/opt/node22 and /opt/npm are gone from the tree. build.sh ran into the empty
path once they were moved away; the other seven mentions were documentation.
e2e.sh and check.sh replace the bare npm calls. A long run does not survive
the end of its shell - four full e2e runs died mid-suite with oom_kill 0 -
so e2e.sh start hands the run to a transient game-maker-e2e.service, which
does. e2e.sh status reports the running job or the last result, and calls a
log without a closing line ABORTED rather than reporting the passes it got
to. Both scripts end on an explicit exit line, because set -o pipefail inside
a script does not protect the caller: measured, ./check.sh | tail still
reports 0. Logs carry a timestamp and land in logs/, which is ignored.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
466 lines
19 KiB
JavaScript
466 lines
19 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* Writes the example game: a small jump and run built entirely from assets, behaviors and the
|
||
* node graph – no engine code is involved.
|
||
*
|
||
* Title screen (a container with a panel, texts and a clickable Start button)
|
||
* Level (ground, platforms, walls, ten coins, the player and the HUD labels)
|
||
* Coin (sprite plus trigger collider – placed ten times inside the level container)
|
||
* Win / Lose (containers shown when the coins are collected or the time is up)
|
||
*
|
||
* Screens are containers that are switched on and off with the `enabled` property – the same
|
||
* switch the inspector shows for every object. Everything else is nodes: gravity and jumping
|
||
* on the player, timer, coin counter and screen flow on the "Game" behavior.
|
||
*
|
||
* Usage: node tools/seed-jumprun.mjs [projectId] [baseUrl]
|
||
*/
|
||
import { edge, node, sceneObject, variable } from './lib/builders.mjs';
|
||
import { PROJECTS, cliArgs, writeProject } from './lib/projects.mjs';
|
||
|
||
const { projectId, baseUrl } = cliArgs('seed-jumprun.mjs', PROJECTS.jumpRun);
|
||
|
||
const SKY = 0x151821;
|
||
const STONE = 0x3c4454;
|
||
const GRASS = 0x4a7d3a;
|
||
const PLAYER = 0x63c74d;
|
||
const COIN = 0xf5c542;
|
||
const PANEL = 0x11141c;
|
||
const BUTTON = 0x63c74d;
|
||
const WHITE = 0xf2f5f7;
|
||
const HINT = 0x9aa3b2;
|
||
const BUTTON_TEXT = 0x10240a;
|
||
|
||
// The camera shows x −320…320, y −180…180; +y is down.
|
||
|
||
/** A solid box: the sprite plus a collider child of the same size. */
|
||
const solid = (id, x, y, w, h, color) => [
|
||
sceneObject(id, 'box', { x, y, overrides: { width: w, height: h, color } }),
|
||
sceneObject(`${id}-c`, 'solid', { parentId: id, overrides: { width: w, height: h } }),
|
||
];
|
||
|
||
const text = (
|
||
id,
|
||
x,
|
||
y,
|
||
content,
|
||
{ size = 28, color = WHITE, align = 'center', name = '', parentId = '', z = 1 } = {},
|
||
) =>
|
||
sceneObject(id, 'label', {
|
||
name,
|
||
x,
|
||
y,
|
||
z,
|
||
parentId,
|
||
overrides: { text: content, fontSize: size, color, align },
|
||
});
|
||
|
||
/** One placed coin: the container object; its content comes from the coin template. */
|
||
const coin = (id, x, y) => sceneObject(id, 'coin', { name: 'Coin', x, y });
|
||
|
||
/** The coin: a sprite with a trigger collider child, so it reports the touch without blocking. */
|
||
const coinTemplate = [
|
||
sceneObject('coin-body', 'coin-sprite', { z: 1 }),
|
||
sceneObject('coin-body-c', 'trigger', { parentId: 'coin-body' }),
|
||
];
|
||
|
||
const levelTemplate = [
|
||
...solid('ground', 0, 165, 660, 30, GRASS),
|
||
...solid('wall-l', -315, 0, 10, 360, STONE),
|
||
...solid('wall-r', 315, 0, 10, 360, STONE),
|
||
...solid('p1', -170, 90, 120, 16, STONE),
|
||
...solid('p2', -30, 30, 140, 16, STONE),
|
||
...solid('p3', 170, 60, 140, 16, STONE),
|
||
...solid('p4', 60, -50, 120, 16, STONE),
|
||
...solid('p5', -230, -30, 120, 16, STONE),
|
||
...solid('p6', 255, -60, 110, 16, STONE),
|
||
// Ten coins: three on the ground, one above each platform, one in the far corner.
|
||
coin('c1', -150, 128),
|
||
coin('c2', 0, 128),
|
||
coin('c3', 150, 128),
|
||
coin('c4', -170, 60),
|
||
coin('c5', -30, 0),
|
||
coin('c6', 170, 30),
|
||
coin('c7', 60, -80),
|
||
coin('c8', -230, -60),
|
||
coin('c9', 255, -90),
|
||
coin('c10', 290, 128),
|
||
sceneObject('player', 'player-sprite', { name: 'Player', x: -270, y: 125, z: 2 }),
|
||
sceneObject('player-c', 'solid', { parentId: 'player', overrides: { width: 30, height: 40 } }),
|
||
sceneObject('player-logic', 'player', { parentId: 'player', y: -60 }),
|
||
// HUD, top left and top right of the camera frame.
|
||
text('time-label', -300, -160, 'Time 30', { size: 22, align: 'left', name: 'TimeLabel', z: 3 }),
|
||
text('coin-label', 300, -160, 'Coins 0/10', { size: 22, align: 'right', name: 'CoinLabel', z: 3 }),
|
||
];
|
||
|
||
/** A full-frame panel with a headline, a line of help text and a button carrying a behavior. */
|
||
const screenTemplate = (prefix, headline, hint, buttonLabel, behaviorId) => [
|
||
sceneObject(`${prefix}-panel`, 'box', { overrides: { width: 640, height: 360, color: PANEL } }),
|
||
text(`${prefix}-title`, 0, -70, headline, { size: 52 }),
|
||
text(`${prefix}-hint`, 0, -10, hint, { size: 20, color: HINT }),
|
||
sceneObject(`${prefix}-button`, 'box', {
|
||
y: 80,
|
||
z: 1,
|
||
overrides: { width: 240, height: 60, color: BUTTON },
|
||
}),
|
||
text(`${prefix}-button-label`, 0, 0, buttonLabel, {
|
||
size: 26,
|
||
color: BUTTON_TEXT,
|
||
parentId: `${prefix}-button`,
|
||
}),
|
||
sceneObject(`${prefix}-button-logic`, behaviorId, { parentId: `${prefix}-button`, y: -60 }),
|
||
];
|
||
|
||
const templates = {
|
||
level: levelTemplate,
|
||
coin: coinTemplate,
|
||
title: screenTemplate('title', 'JUMP & RUN', 'Arrow keys to move, Space to jump.', 'START', 'start-button'),
|
||
win: screenTemplate('win', 'YOU WIN!', 'All ten coins collected in time.', 'PLAY AGAIN', 'restart-button'),
|
||
lose: screenTemplate('lose', 'TIME UP', 'The time is over - try again.', 'PLAY AGAIN', 'restart-button'),
|
||
};
|
||
|
||
/**
|
||
* "Player": gravity, walking, jumping and picking coins up – three strands.
|
||
*
|
||
* On update vy += gravity·dt, then Move(owner) by (axis·speed, vy)·dt with collisions on.
|
||
* Blocked vertically while falling means standing: vy back to 0, onGround true.
|
||
* On key down Space while onGround shoots vy up (negative is up).
|
||
* On collision Touching a coin adds one to the "Game" behavior's counter and destroys the coin –
|
||
* the collider reports its body (the sprite), the coin itself is the container above.
|
||
*/
|
||
const playerGraph = {
|
||
nodes: [
|
||
node('p-upd', 'OnUpdate', 0, 0),
|
||
node('p-owner', 'Owner', 0, 140),
|
||
node('p-axis', 'AxisInput', 0, 220, { left: 'ArrowLeft', right: 'ArrowRight', up: '', down: '' }),
|
||
node('p-speed', 'GetVariable', 0, 360, { variable: 'speed' }),
|
||
node('p-mulx', 'Multiply', 220, 300),
|
||
node('p-vy', 'GetVariable', 0, 440, { variable: 'vy' }),
|
||
node('p-grav', 'GetVariable', 0, 520, { variable: 'gravity' }),
|
||
node('p-mulg', 'Multiply', 220, 500),
|
||
node('p-addvy', 'Add', 420, 460),
|
||
node('p-setvy', 'SetVariable', 620, 0, { variable: 'vy' }),
|
||
node('p-vy2', 'GetVariable', 620, 340, { variable: 'vy' }),
|
||
node('p-move', 'Move', 840, 0, { collide: true }),
|
||
node('p-br', 'Branch', 1080, 0),
|
||
node('p-seq', 'Sequence', 1260, 0),
|
||
node('p-vy3', 'GetVariable', 1080, 260, { variable: 'vy' }),
|
||
node('p-cmp', 'Compare', 1260, 260, { op: '>=', b: 0 }),
|
||
node('p-ground', 'SetVariable', 1460, 0, { variable: 'onGround' }),
|
||
node('p-zero', 'SetVariable', 1460, 140, { variable: 'vy', value: 0 }),
|
||
node('p-air', 'SetVariable', 1260, 400, { variable: 'onGround', value: false }),
|
||
|
||
node('p-key', 'OnKeyDown', 0, 700, { key: ' ' }),
|
||
node('p-og', 'GetVariable', 0, 820, { variable: 'onGround' }),
|
||
node('p-brj', 'Branch', 240, 700),
|
||
node('p-jump', 'GetVariable', 240, 880, { variable: 'jumpSpeed' }),
|
||
node('p-neg', 'Multiply', 440, 880, { b: -1 }),
|
||
node('p-setjump', 'SetVariable', 660, 700, { variable: 'vy' }),
|
||
|
||
node('p-col', 'OnCollisionEnter', 0, 1060),
|
||
node('p-iscoin', 'IsAsset', 260, 1180, { asset: 'coin-sprite' }),
|
||
node('p-brc', 'Branch', 480, 1060),
|
||
node('p-seqc', 'Sequence', 680, 1060),
|
||
node('p-game', 'ObjectByName', 680, 1280, { name: 'Game' }),
|
||
node('p-coins', 'GetProperty', 880, 1280, { property: 'coins' }),
|
||
node('p-add1', 'Add', 1080, 1280, { b: 1 }),
|
||
node('p-setcoins', 'SetProperty', 1280, 1060, { property: 'coins' }),
|
||
node('p-coinroot', 'Parent', 1080, 1420),
|
||
node('p-destroy', 'Destroy', 1280, 1200),
|
||
],
|
||
edges: [
|
||
edge('pe1', 'p-upd', 'exec', 'p-setvy', 'exec'),
|
||
edge('pe2', 'p-vy', 'value', 'p-addvy', 'a'),
|
||
edge('pe3', 'p-grav', 'value', 'p-mulg', 'a'),
|
||
edge('pe4', 'p-upd', 'dt', 'p-mulg', 'b'),
|
||
edge('pe5', 'p-mulg', 'result', 'p-addvy', 'b'),
|
||
edge('pe6', 'p-addvy', 'result', 'p-setvy', 'value'),
|
||
edge('pe7', 'p-setvy', 'exec', 'p-move', 'exec'),
|
||
edge('pe8', 'p-owner', 'object', 'p-move', 'object'),
|
||
edge('pe9', 'p-axis', 'x', 'p-mulx', 'a'),
|
||
edge('pe10', 'p-speed', 'value', 'p-mulx', 'b'),
|
||
edge('pe11', 'p-mulx', 'result', 'p-move', 'dx'),
|
||
edge('pe12', 'p-vy2', 'value', 'p-move', 'dy'),
|
||
edge('pe13', 'p-upd', 'dt', 'p-move', 'dt'),
|
||
edge('pe14', 'p-move', 'exec', 'p-br', 'exec'),
|
||
edge('pe15', 'p-move', 'blockedY', 'p-br', 'condition'),
|
||
edge('pe16', 'p-br', 'then', 'p-seq', 'exec'),
|
||
edge('pe17', 'p-seq', 'a', 'p-ground', 'exec'),
|
||
edge('pe18', 'p-vy3', 'value', 'p-cmp', 'a'),
|
||
edge('pe19', 'p-cmp', 'result', 'p-ground', 'value'),
|
||
edge('pe20', 'p-seq', 'b', 'p-zero', 'exec'),
|
||
edge('pe21', 'p-br', 'else', 'p-air', 'exec'),
|
||
|
||
edge('pe22', 'p-key', 'exec', 'p-brj', 'exec'),
|
||
edge('pe23', 'p-og', 'value', 'p-brj', 'condition'),
|
||
edge('pe24', 'p-brj', 'then', 'p-setjump', 'exec'),
|
||
edge('pe25', 'p-jump', 'value', 'p-neg', 'a'),
|
||
edge('pe26', 'p-neg', 'result', 'p-setjump', 'value'),
|
||
|
||
edge('pe27', 'p-col', 'exec', 'p-brc', 'exec'),
|
||
edge('pe28', 'p-col', 'other', 'p-iscoin', 'object'),
|
||
edge('pe29', 'p-iscoin', 'result', 'p-brc', 'condition'),
|
||
edge('pe30', 'p-brc', 'then', 'p-seqc', 'exec'),
|
||
edge('pe31', 'p-seqc', 'a', 'p-setcoins', 'exec'),
|
||
edge('pe32', 'p-game', 'object', 'p-coins', 'object'),
|
||
edge('pe33', 'p-coins', 'value', 'p-add1', 'a'),
|
||
edge('pe34', 'p-add1', 'result', 'p-setcoins', 'value'),
|
||
edge('pe35', 'p-game', 'object', 'p-setcoins', 'object'),
|
||
edge('pe36', 'p-seqc', 'b', 'p-destroy', 'exec'),
|
||
edge('pe37', 'p-col', 'other', 'p-coinroot', 'object'),
|
||
edge('pe38', 'p-coinroot', 'parent', 'p-destroy', 'object'),
|
||
],
|
||
};
|
||
|
||
/**
|
||
* "Game": owns the run. On start it shows the title and hides everything else; while `running`
|
||
* it counts the clock down, writes both HUD labels and decides win (coins reached) or loss (time
|
||
* gone) by switching the screens.
|
||
*/
|
||
const gameGraph = {
|
||
nodes: [
|
||
node('g-start', 'OnStart', 0, 0),
|
||
node('g-title', 'ObjectByName', 0, 140, { name: 'Title' }),
|
||
node('g-level', 'ObjectByName', 0, 220, { name: 'Level' }),
|
||
node('g-win', 'ObjectByName', 0, 300, { name: 'Win' }),
|
||
node('g-lose', 'ObjectByName', 0, 380, { name: 'Lose' }),
|
||
node('g-on1', 'SetEnabled', 260, 0, { enabled: true }),
|
||
node('g-off1', 'SetEnabled', 480, 0, { enabled: false }),
|
||
node('g-off2', 'SetEnabled', 700, 0, { enabled: false }),
|
||
node('g-off3', 'SetEnabled', 920, 0, { enabled: false }),
|
||
|
||
node('g-upd', 'OnUpdate', 0, 520),
|
||
node('g-running', 'GetVariable', 0, 640, { variable: 'running' }),
|
||
node('g-brrun', 'Branch', 220, 520),
|
||
node('g-time', 'GetVariable', 220, 700, { variable: 'timeLeft' }),
|
||
node('g-sub', 'Subtract', 420, 700),
|
||
node('g-max', 'Max', 600, 700, { b: 0 }),
|
||
node('g-settime', 'SetVariable', 440, 520, { variable: 'timeLeft' }),
|
||
|
||
node('g-timelabel', 'ObjectByName', 440, 860, { name: 'TimeLabel' }),
|
||
node('g-time2', 'GetVariable', 440, 940, { variable: 'timeLeft' }),
|
||
node('g-ceil', 'Ceil', 640, 940),
|
||
node('g-join', 'Join', 840, 940, { a: 'Time ' }),
|
||
node('g-settext', 'SetText', 700, 520),
|
||
|
||
node('g-coinlabel', 'ObjectByName', 700, 1080, { name: 'CoinLabel' }),
|
||
node('g-coins', 'GetVariable', 700, 1160, { variable: 'coins' }),
|
||
node('g-totext2', 'ToText', 900, 1160, { decimals: 0 }),
|
||
node('g-join2', 'Join', 1080, 1160, { a: 'Coins ' }),
|
||
node('g-join3', 'Join', 1260, 1160, { b: '/10' }),
|
||
node('g-settext2', 'SetText', 960, 520),
|
||
|
||
node('g-needed', 'GetVariable', 960, 700, { variable: 'needed' }),
|
||
node('g-cmpwin', 'Compare', 1160, 700, { op: '>=' }),
|
||
node('g-brwin', 'Branch', 1220, 520),
|
||
node('g-stop1', 'SetVariable', 1420, 440, { variable: 'running', value: false }),
|
||
node('g-leveloff1', 'SetEnabled', 1620, 440, { enabled: false }),
|
||
node('g-winon', 'SetEnabled', 1820, 440, { enabled: true }),
|
||
|
||
node('g-cmplose', 'Compare', 1160, 860, { op: '<=', b: 0 }),
|
||
node('g-brlose', 'Branch', 1420, 640),
|
||
node('g-stop2', 'SetVariable', 1620, 640, { variable: 'running', value: false }),
|
||
node('g-leveloff2', 'SetEnabled', 1820, 640, { enabled: false }),
|
||
node('g-loseon', 'SetEnabled', 2020, 640, { enabled: true }),
|
||
],
|
||
edges: [
|
||
edge('ge1', 'g-start', 'exec', 'g-on1', 'exec'),
|
||
edge('ge2', 'g-title', 'object', 'g-on1', 'object'),
|
||
edge('ge3', 'g-on1', 'exec', 'g-off1', 'exec'),
|
||
edge('ge4', 'g-level', 'object', 'g-off1', 'object'),
|
||
edge('ge5', 'g-off1', 'exec', 'g-off2', 'exec'),
|
||
edge('ge6', 'g-win', 'object', 'g-off2', 'object'),
|
||
edge('ge7', 'g-off2', 'exec', 'g-off3', 'exec'),
|
||
edge('ge8', 'g-lose', 'object', 'g-off3', 'object'),
|
||
|
||
edge('ge9', 'g-upd', 'exec', 'g-brrun', 'exec'),
|
||
edge('ge10', 'g-running', 'value', 'g-brrun', 'condition'),
|
||
edge('ge11', 'g-brrun', 'then', 'g-settime', 'exec'),
|
||
edge('ge12', 'g-time', 'value', 'g-sub', 'a'),
|
||
edge('ge13', 'g-upd', 'dt', 'g-sub', 'b'),
|
||
edge('ge14', 'g-sub', 'result', 'g-max', 'a'),
|
||
edge('ge15', 'g-max', 'result', 'g-settime', 'value'),
|
||
|
||
edge('ge16', 'g-settime', 'exec', 'g-settext', 'exec'),
|
||
edge('ge17', 'g-timelabel', 'object', 'g-settext', 'object'),
|
||
edge('ge18', 'g-time2', 'value', 'g-ceil', 'value'),
|
||
edge('ge19', 'g-ceil', 'result', 'g-join', 'b'),
|
||
edge('ge20', 'g-join', 'text', 'g-settext', 'text'),
|
||
|
||
edge('ge21', 'g-settext', 'exec', 'g-settext2', 'exec'),
|
||
edge('ge22', 'g-coinlabel', 'object', 'g-settext2', 'object'),
|
||
edge('ge23', 'g-coins', 'value', 'g-totext2', 'value'),
|
||
edge('ge24', 'g-totext2', 'text', 'g-join2', 'b'),
|
||
edge('ge25', 'g-join2', 'text', 'g-join3', 'a'),
|
||
edge('ge26', 'g-join3', 'text', 'g-settext2', 'text'),
|
||
|
||
edge('ge27', 'g-settext2', 'exec', 'g-brwin', 'exec'),
|
||
edge('ge28', 'g-coins', 'value', 'g-cmpwin', 'a'),
|
||
edge('ge29', 'g-needed', 'value', 'g-cmpwin', 'b'),
|
||
edge('ge30', 'g-cmpwin', 'result', 'g-brwin', 'condition'),
|
||
edge('ge31', 'g-brwin', 'then', 'g-stop1', 'exec'),
|
||
edge('ge32', 'g-stop1', 'exec', 'g-leveloff1', 'exec'),
|
||
edge('ge33', 'g-level', 'object', 'g-leveloff1', 'object'),
|
||
edge('ge34', 'g-leveloff1', 'exec', 'g-winon', 'exec'),
|
||
edge('ge35', 'g-win', 'object', 'g-winon', 'object'),
|
||
|
||
edge('ge36', 'g-brwin', 'else', 'g-brlose', 'exec'),
|
||
edge('ge37', 'g-time2', 'value', 'g-cmplose', 'a'),
|
||
edge('ge38', 'g-cmplose', 'result', 'g-brlose', 'condition'),
|
||
edge('ge39', 'g-brlose', 'then', 'g-stop2', 'exec'),
|
||
edge('ge40', 'g-stop2', 'exec', 'g-leveloff2', 'exec'),
|
||
edge('ge41', 'g-level', 'object', 'g-leveloff2', 'object'),
|
||
edge('ge42', 'g-leveloff2', 'exec', 'g-loseon', 'exec'),
|
||
edge('ge43', 'g-lose', 'object', 'g-loseon', 'object'),
|
||
],
|
||
};
|
||
|
||
/** "Start button": a click resets the counters on the Game behavior and swaps title for level. */
|
||
const startButtonGraph = {
|
||
nodes: [
|
||
node('s-click', 'OnClick', 0, 0),
|
||
node('s-game', 'ObjectByName', 0, 160, { name: 'Game' }),
|
||
node('s-title', 'ObjectByName', 0, 240, { name: 'Title' }),
|
||
node('s-level', 'ObjectByName', 0, 320, { name: 'Level' }),
|
||
node('s-coins', 'SetProperty', 240, 0, { property: 'coins', value: 0 }),
|
||
node('s-time', 'SetProperty', 460, 0, { property: 'timeLeft', value: 30 }),
|
||
node('s-run', 'SetProperty', 680, 0, { property: 'running', value: true }),
|
||
node('s-hide', 'SetEnabled', 900, 0, { enabled: false }),
|
||
node('s-show', 'SetEnabled', 1120, 0, { enabled: true }),
|
||
],
|
||
edges: [
|
||
edge('se1', 's-click', 'exec', 's-coins', 'exec'),
|
||
edge('se2', 's-game', 'object', 's-coins', 'object'),
|
||
edge('se3', 's-coins', 'exec', 's-time', 'exec'),
|
||
edge('se4', 's-game', 'object', 's-time', 'object'),
|
||
edge('se5', 's-time', 'exec', 's-run', 'exec'),
|
||
edge('se6', 's-game', 'object', 's-run', 'object'),
|
||
edge('se7', 's-run', 'exec', 's-hide', 'exec'),
|
||
edge('se8', 's-title', 'object', 's-hide', 'object'),
|
||
edge('se9', 's-hide', 'exec', 's-show', 'exec'),
|
||
edge('se10', 's-level', 'object', 's-show', 'object'),
|
||
],
|
||
};
|
||
|
||
/** "Restart button": one click, one node – the scene starts over from its saved state. */
|
||
const restartButtonGraph = {
|
||
nodes: [node('r-click', 'OnClick', 0, 0), node('r-restart', 'RestartGame', 260, 0)],
|
||
edges: [edge('re1', 'r-click', 'exec', 'r-restart', 'exec')],
|
||
};
|
||
|
||
const project = {
|
||
formatVersion: 2,
|
||
id: projectId,
|
||
name: 'Jump and Run',
|
||
activeSceneId: 'scene1',
|
||
assets: [
|
||
{
|
||
id: 'scene1',
|
||
type: 'scene',
|
||
name: 'Level 1',
|
||
props: { backgroundColor: SKY },
|
||
objects: [
|
||
sceneObject('L', 'level', { name: 'Level' }),
|
||
// All three screens sit on the camera frame; the Game behavior decides on `On start` which
|
||
// one is up. Editor offsets pull them apart in the scene view so they do not cover the level.
|
||
sceneObject('T', 'title', {
|
||
name: 'Title',
|
||
z: 10,
|
||
overrides: { enabled: true },
|
||
editorOffset: { x: -750, y: -500 },
|
||
}),
|
||
sceneObject('W', 'win', {
|
||
name: 'Win',
|
||
z: 10,
|
||
overrides: { enabled: true },
|
||
editorOffset: { x: 0, y: -500 },
|
||
}),
|
||
sceneObject('B', 'lose', {
|
||
name: 'Lose',
|
||
z: 10,
|
||
overrides: { enabled: true },
|
||
editorOffset: { x: 750, y: -500 },
|
||
}),
|
||
sceneObject('ocam', 'cam', { name: 'Main Camera' }),
|
||
sceneObject('ogame', 'game', { name: 'Game', x: -200, y: -220 }),
|
||
],
|
||
},
|
||
{ id: 'cam', type: 'camera', name: 'Main Camera', props: { width: 640, height: 360, zoom: 1 } },
|
||
{ id: 'box', type: 'sprite', name: 'Box', props: { width: 100, height: 100, color: STONE } },
|
||
{
|
||
id: 'player-sprite',
|
||
type: 'sprite',
|
||
name: 'Player Sprite',
|
||
props: { width: 30, height: 40, color: PLAYER },
|
||
},
|
||
{ id: 'coin-sprite', type: 'sprite', name: 'Coin Sprite', props: { width: 24, height: 24, color: COIN } },
|
||
{
|
||
id: 'label',
|
||
type: 'text',
|
||
name: 'Label',
|
||
props: { text: 'Text', fontSize: 28, color: WHITE, align: 'center' },
|
||
},
|
||
{
|
||
id: 'solid',
|
||
type: 'collider',
|
||
name: 'Solid Collider',
|
||
props: { shape: 'box', width: 100, height: 100, radius: 50, isTrigger: false },
|
||
},
|
||
{
|
||
id: 'trigger',
|
||
type: 'collider',
|
||
name: 'Coin Trigger',
|
||
props: { shape: 'box', width: 24, height: 24, radius: 12, isTrigger: true },
|
||
},
|
||
{
|
||
id: 'player',
|
||
type: 'behavior',
|
||
name: 'Player',
|
||
props: { speed: 170, jumpSpeed: 480, gravity: 1200, vy: 0, onGround: false },
|
||
variables: [
|
||
variable('speed', 'number', 0),
|
||
variable('jumpSpeed', 'number', 0),
|
||
variable('gravity', 'number', 0),
|
||
variable('vy', 'number', 0),
|
||
variable('onGround', 'boolean', false),
|
||
],
|
||
graph: playerGraph,
|
||
},
|
||
{
|
||
id: 'game',
|
||
type: 'behavior',
|
||
name: 'Game',
|
||
props: { timeLeft: 30, coins: 0, needed: 10, running: false },
|
||
variables: [
|
||
variable('timeLeft', 'number', 30),
|
||
variable('coins', 'number', 0),
|
||
variable('needed', 'number', 10),
|
||
variable('running', 'boolean', false),
|
||
],
|
||
graph: gameGraph,
|
||
},
|
||
{
|
||
id: 'start-button',
|
||
type: 'behavior',
|
||
name: 'Start Button',
|
||
props: {},
|
||
variables: [],
|
||
graph: startButtonGraph,
|
||
},
|
||
{
|
||
id: 'restart-button',
|
||
type: 'behavior',
|
||
name: 'Restart Button',
|
||
props: {},
|
||
variables: [],
|
||
graph: restartButtonGraph,
|
||
},
|
||
{ id: 'coin', type: 'container', name: 'Coin', props: {}, objects: templates.coin },
|
||
{ id: 'level', type: 'container', name: 'Level', props: {}, objects: templates.level },
|
||
{ id: 'title', type: 'container', name: 'Title screen', props: {}, objects: templates.title },
|
||
{ id: 'win', type: 'container', name: 'Win screen', props: {}, objects: templates.win },
|
||
{ id: 'lose', type: 'container', name: 'Lose screen', props: {}, objects: templates.lose },
|
||
],
|
||
};
|
||
|
||
await writeProject(projectId, baseUrl, project);
|