275 lines
11 KiB
JavaScript
275 lines
11 KiB
JavaScript
import { edge, node } from '../lib/builders.mjs';
|
||
import { inView, LANES, MAKE_OBJECT } from './lib/scaffold.mjs';
|
||
|
||
/**
|
||
* What a game asks the collision about, and platforms one jumps through: one-way colliders (#155),
|
||
* the Raycast node (#153) and On collision stay with an interval and contact data (#149). What only a
|
||
* running editor shows: the switch in the inspector, the engine and Move landing on a platform and
|
||
* passing it from below, the ray drawn in the Scene tab by the editor run, and a stay that fires on
|
||
* its own clock.
|
||
*/
|
||
|
||
const FALL = 300;
|
||
/** Falls with Move and "Collide with solids"; 1.5 s after it starts it drops through one-way platforms. */
|
||
const dropGraph = {
|
||
nodes: [
|
||
node('qd-update', 'OnUpdate', 0, 0),
|
||
node('qd-owner', 'Owner', 0, 160),
|
||
node('qd-move', 'Move', 300, 0, { dy: 1, scale: FALL, collide: true }),
|
||
node('qd-timer', 'OnTimer', 0, 320, { interval: 1.5 }),
|
||
node('qd-drop', 'IgnoreOneWay', 300, 320, { seconds: 0.3 }),
|
||
],
|
||
edges: [
|
||
edge('qd-e1', 'qd-update', 'exec', 'qd-move', 'exec'),
|
||
edge('qd-e2', 'qd-update', 'dt', 'qd-move', 'dt'),
|
||
edge('qd-e3', 'qd-owner', 'object', 'qd-move', 'object'),
|
||
edge('qd-e4', 'qd-timer', 'exec', 'qd-drop', 'exec'),
|
||
edge('qd-e5', 'qd-owner', 'object', 'qd-drop', 'object'),
|
||
],
|
||
};
|
||
|
||
/** Shoots its owner – a dynamic body below the platform – straight up in On start. */
|
||
const jumpGraph = {
|
||
nodes: [
|
||
node('qj-start', 'OnStart', 0, 0),
|
||
node('qj-owner', 'Owner', 0, 160),
|
||
node('qj-shoot', 'SetVelocity', 300, 0, { x: 0, y: -700 }),
|
||
],
|
||
edges: [
|
||
edge('qj-e1', 'qj-start', 'exec', 'qj-shoot', 'exec'),
|
||
edge('qj-e2', 'qj-owner', 'object', 'qj-shoot', 'object'),
|
||
],
|
||
};
|
||
|
||
/** Casts a ray straight down from its owner every frame. */
|
||
const eyeGraph = {
|
||
nodes: [
|
||
node('qe-update', 'OnUpdate', 0, 0),
|
||
node('qe-owner', 'Owner', 0, 160),
|
||
node('qe-where', 'GetPosition', 250, 160),
|
||
node('qe-ray', 'Raycast', 500, 0, { dirX: 0, dirY: 1, length: 500 }),
|
||
],
|
||
edges: [
|
||
edge('qe-e1', 'qe-update', 'exec', 'qe-ray', 'exec'),
|
||
edge('qe-e2', 'qe-owner', 'object', 'qe-where', 'object'),
|
||
edge('qe-e3', 'qe-where', 'worldX', 'qe-ray', 'fromX'),
|
||
edge('qe-e4', 'qe-where', 'worldY', 'qe-ray', 'fromY'),
|
||
],
|
||
};
|
||
|
||
/** Logs how its owner touches the ground (normal y, then impulse) each half second it stays on it. */
|
||
const STAY = 0.5;
|
||
const feelGraph = {
|
||
nodes: [
|
||
node('qf-stay', 'OnCollisionStay', 0, 0, { interval: STAY }),
|
||
node('qf-log-n', 'Log', 300, 0),
|
||
node('qf-log-i', 'Log', 550, 0),
|
||
],
|
||
edges: [
|
||
edge('qf-e1', 'qf-stay', 'exec', 'qf-log-n', 'exec'),
|
||
edge('qf-e2', 'qf-stay', 'normalY', 'qf-log-n', 'message'),
|
||
edge('qf-e3', 'qf-log-n', 'exec', 'qf-log-i', 'exec'),
|
||
edge('qf-e4', 'qf-stay', 'impulse', 'qf-log-i', 'message'),
|
||
],
|
||
};
|
||
|
||
export async function queries(t) {
|
||
const {
|
||
check,
|
||
json,
|
||
evaluate,
|
||
mutate,
|
||
select,
|
||
click,
|
||
object,
|
||
settle,
|
||
sleep,
|
||
play,
|
||
stop,
|
||
shot,
|
||
consoleLog,
|
||
} = t;
|
||
const Y = LANES.queries;
|
||
const GROUND_TOP = Y + 280;
|
||
const PLATFORM_TOP = Y + 95;
|
||
const setup = (body) =>
|
||
mutate(`
|
||
const scene = __gm.state.activeScene;
|
||
const assets = __gm.state.project.assets;
|
||
${MAKE_OBJECT}
|
||
const collider = (id, props) =>
|
||
assets.push({ id, type: 'collider', name: id, props: { shape: 'box', width: 40, height: 40, radius: 20, isTrigger: false, ...props } });
|
||
const behavior = (id, name, graph) => {
|
||
const asset = structuredClone(assets.find((a) => a.id === 'mover'));
|
||
Object.assign(asset, { id, name, props: { enabled: true, runInEditor: false }, variables: [], graph });
|
||
assets.push(asset);
|
||
};
|
||
const put = (id, assetId, parentId, x, y, name, overrides = {}) => {
|
||
const o = make(id, assetId, parentId, y, name);
|
||
o.position.x = x;
|
||
o.overrides = overrides;
|
||
scene.objects.push(o);
|
||
};
|
||
${body}
|
||
__gm.state.select(null)`);
|
||
const clear = () =>
|
||
mutate(`
|
||
const p = __gm.state.project;
|
||
const scene = __gm.state.activeScene;
|
||
scene.objects = scene.objects.filter((o) => !o.id.startsWith('q-'));
|
||
p.assets = p.assets.filter((a) => !a.id.startsWith('q-'));
|
||
__gm.state.select(null)`);
|
||
const sample = async (seconds, ids) => {
|
||
await evaluate(`(() => {
|
||
const out = (window.__querySamples = []);
|
||
const start = performance.now();
|
||
const sample = () => {
|
||
const w = __gm.world();
|
||
if (!w) return;
|
||
const y = (id) => w.entities.find((e) => e.objectId === id)?.worldY;
|
||
out.push({ t: (performance.now() - start) / 1000, ...Object.fromEntries(${JSON.stringify(ids)}.map((id) => [id, y(id)])) });
|
||
if (performance.now() - start < ${seconds * 1000}) requestAnimationFrame(sample);
|
||
};
|
||
requestAnimationFrame(sample);
|
||
})()`);
|
||
await sleep(seconds * 1000 + 300);
|
||
return json('window.__querySamples');
|
||
};
|
||
|
||
// 43a. A platform one jumps through (#155), switched to one-way in the inspector. A crate falls
|
||
// onto it with Move and drops through 1.5 s later; a dynamic crate shot up from below
|
||
// passes it and lands on it.
|
||
await setup(`
|
||
collider('q-col-ground', { width: 800, height: 40 });
|
||
collider('q-col-platform', { width: 300, height: 10 });
|
||
collider('q-col-box', {});
|
||
assets.push({ id: 'q-rb', type: 'rigidbody', name: 'q-rb', props: { bodyType: 'dynamic', mass: 0, fixedRotation: true } });
|
||
behavior('q-drop', 'Query drop', ${JSON.stringify(dropGraph)});
|
||
behavior('q-jump', 'Query jump', ${JSON.stringify(jumpGraph)});
|
||
const box = { width: 40, height: 40 };
|
||
put('q-ground', 'crate', '', 0, ${Y + 300}, 'Query ground', { width: 800, height: 40 });
|
||
put('q-ground-col', 'q-col-ground', 'q-ground', 0, 0);
|
||
put('q-platform', 'crate', '', 0, ${Y + 100}, 'Query platform', { width: 300, height: 10 });
|
||
put('q-platform-col', 'q-col-platform', 'q-platform', 0, 0, 'Platform collider');
|
||
put('q-dropper', 'crate', '', -100, ${Y}, 'Dropper', box);
|
||
put('q-dropper-col', 'q-col-box', 'q-dropper', 0, 0);
|
||
put('q-dropper-go', 'q-drop', 'q-dropper', 0, 0);
|
||
put('q-jumper', 'crate', '', 100, ${Y + 200}, 'Jumper', box);
|
||
put('q-jumper-col', 'q-col-box', 'q-jumper', 0, 0);
|
||
put('q-jumper-rb', 'q-rb', 'q-jumper', 0, 0);
|
||
put('q-jumper-go', 'q-jump', 'q-jumper', 0, 0);`);
|
||
await select({
|
||
kind: 'object',
|
||
holderId: 'scene1',
|
||
objectId: 'q-platform-col',
|
||
objectIds: ['q-platform-col'],
|
||
});
|
||
const toggle = await inView(t, '__gm.inspectorRect()', "__gm.inspectorField('One-way')");
|
||
// Side and angle mean nothing on a collider blocking from everywhere, so they wait for the switch (#159).
|
||
const hidden = await json(
|
||
"[__gm.inspectorField('Blocks from'), __gm.inspectorField('One-way angle')].every((f) => f === null)",
|
||
);
|
||
if (toggle) await click(toggle.x, toggle.y);
|
||
await settle();
|
||
const blocksFrom = await inView(t, '__gm.inspectorRect()', "__gm.inspectorField('Blocks from')");
|
||
const angleRow = await inView(t, '__gm.inspectorRect()', "__gm.inspectorField('One-way angle')");
|
||
check(
|
||
'Blocks from and One-way angle show only once One-way is switched on',
|
||
hidden === true && Boolean(blocksFrom) && Boolean(angleRow),
|
||
JSON.stringify({ hidden, blocksFrom, angleRow }),
|
||
);
|
||
check(
|
||
"a collider's One-way switch in the inspector turns it one-way, blocking from above",
|
||
Boolean(toggle) &&
|
||
Boolean(blocksFrom) &&
|
||
(await object('q-platform-col'))?.overrides?.oneWay === true &&
|
||
(await t.has('Above')),
|
||
JSON.stringify({ toggle, blocksFrom, overrides: (await object('q-platform-col'))?.overrides }),
|
||
);
|
||
await select(null);
|
||
await evaluate(`__gm.lookAt(0, ${Y + 150})`);
|
||
await settle();
|
||
await shot('43-one-way');
|
||
|
||
await play();
|
||
const run = await sample(2.8, ['q-dropper', 'q-jumper']);
|
||
await stop();
|
||
const at = (seconds) =>
|
||
run.reduce((best, s) => (Math.abs(s.t - seconds) < Math.abs(best.t - seconds) ? s : best));
|
||
const onPlatform = PLATFORM_TOP - 20;
|
||
const onGround = GROUND_TOP - 20;
|
||
check(
|
||
'Move lands on the one-way platform, and Ignore one-way drops it through onto the ground',
|
||
run.length > 60 &&
|
||
Math.abs(at(0.7)['q-dropper'] - onPlatform) < 0.01 &&
|
||
Math.abs(run.at(-1)['q-dropper'] - onGround) < 0.01,
|
||
JSON.stringify({ frames: run.length, early: at(0.7), last: run.at(-1), onPlatform, onGround }),
|
||
);
|
||
const highest = Math.min(...run.map((s) => s['q-jumper']));
|
||
check(
|
||
'a dynamic body shot up from below passes through the platform and lands on top of it',
|
||
highest < PLATFORM_TOP - 60 && Math.abs(run.at(-1)['q-jumper'] - onPlatform) < 1,
|
||
JSON.stringify({ highest, last: run.at(-1)['q-jumper'], onPlatform }),
|
||
);
|
||
await clear();
|
||
|
||
// 43b. The Raycast node in the editor run (#153): a crate casting down every frame, the ray drawn
|
||
// in the Scene tab to where it meets the ground.
|
||
await setup(`
|
||
collider('q-col-ground', { width: 800, height: 40 });
|
||
collider('q-col-box', {});
|
||
behavior('q-eye', 'Query eye', ${JSON.stringify(eyeGraph)});
|
||
put('q-ground', 'crate', '', 0, ${Y + 300}, 'Query ground', { width: 800, height: 40 });
|
||
put('q-ground-col', 'q-col-ground', 'q-ground', 0, 0);
|
||
put('q-eyebox', 'crate', '', 200, ${Y}, 'Eye', { width: 40, height: 40 });
|
||
put('q-eyebox-col', 'q-col-box', 'q-eyebox', 0, 0);
|
||
put('q-eyebox-go', 'q-eye', 'q-eyebox', 0, 0, 'Eye logic', { runInEditor: true });`);
|
||
await evaluate(`__gm.lookAt(0, ${Y + 150})`);
|
||
await sleep(500);
|
||
const rays = await json('__gm.rays()');
|
||
const ray = rays.at(-1);
|
||
check(
|
||
'the editor run casts the ray and the Scene tab draws it, down to the ground it met',
|
||
(await json('__gm.editorRun()')).running === true &&
|
||
ray?.hit === true &&
|
||
ray.from.x === 200 &&
|
||
ray.from.y === Y &&
|
||
Math.abs(ray.to.y - GROUND_TOP) < 1e-6,
|
||
JSON.stringify({ count: rays.length, ray, groundTop: GROUND_TOP }),
|
||
);
|
||
await shot('43-ray');
|
||
await clear();
|
||
await sleep(300);
|
||
|
||
// 43c. On collision stay with an interval (#149): a crate resting on the ground logs how it touches
|
||
// every half second – the normal from the ground towards it, and the impulse holding it up.
|
||
const logFrom = consoleLog.length;
|
||
await setup(`
|
||
collider('q-col-ground', { width: 800, height: 40 });
|
||
collider('q-col-box', {});
|
||
assets.push({ id: 'q-rb', type: 'rigidbody', name: 'q-rb', props: { bodyType: 'dynamic', mass: 0, fixedRotation: true } });
|
||
behavior('q-feel', 'Query feel', ${JSON.stringify(feelGraph)});
|
||
put('q-ground', 'crate', '', 0, ${Y + 300}, 'Query ground', { width: 800, height: 40 });
|
||
put('q-ground-col', 'q-col-ground', 'q-ground', 0, 0);
|
||
put('q-rest', 'crate', '', -300, ${Y + 220}, 'Rester', { width: 40, height: 40 });
|
||
put('q-rest-col', 'q-col-box', 'q-rest', 0, 0);
|
||
put('q-rest-rb', 'q-rb', 'q-rest', 0, 0);
|
||
put('q-rest-go', 'q-feel', 'q-rest', 0, 0, 'Feel');`);
|
||
await play();
|
||
await sleep(2200);
|
||
await stop();
|
||
const logged = consoleLog
|
||
.slice(logFrom)
|
||
.filter((line) => line.startsWith('[behavior Feel]'))
|
||
.map((line) => Number(line.split(']').pop()));
|
||
const pairs = Array.from({ length: Math.floor(logged.length / 2) }, (_, i) =>
|
||
logged.slice(2 * i, 2 * i + 2),
|
||
);
|
||
check(
|
||
'On collision stay with an interval fires every half second, with the normal and the impulse of the contact',
|
||
pairs.length >= 2 && pairs.length <= 4 && pairs.every(([ny, impulse]) => ny === -1 && impulse > 0),
|
||
JSON.stringify({ pairs, interval: STAY }),
|
||
);
|
||
await clear();
|
||
}
|