rootandClaude Opus 5
8143130ed2
game-maker / suite (push) Failing after 8m59s
This reverses the design of the previous commit. `PropertyDef.scope` is gone without replacement: a behavior variable is an object property again, without exception, and sharing is something you point at rather than something you declare twice. A **Variables asset** is declarations and nothing else -- no graph, no position, never placed, no tab of its own (`TAB_OF_ASSET` is already `Partial<>`, so that costs no line). A `Variables` node names one through its new `variablesAsset` setting, empty meaning the behavior's own variables as before, and then reads and writes one value per key for the whole run. Its property list follows the chosen source, which was the actual request: a value another graph declared is now offerable, where before every participant had to declare the name itself. That deletes more than it adds (-72 lines net): `globalConflicts` and its run-stopping kind clash, `SetVariableScopeCommand`, the scope picker, both object-inspector filters and the "shared by the whole run" note on the placed object. A typo is no longer a silent second variable -- naming an asset is picking from a list. And two Variables assets may carry the same key without meeting, because the asset is the key, not the name. The one shape it copies is the one that already existed: `Set state` picks its machine the same way. Lifetime is unchanged. The bag is built at `BehaviorSystem.start()` from the declarations and never written back, so playing in the editor cannot change the project -- which is the whole reason a counter must not be an object property (`World.syncToModel` would `commit()` it, and the coin counter would stand at 7 for good). Full symmetry across that gap, without mirroring anything. Two named wires: `Inspector.liveVariables` shows the values as they stand while a run is on and falls back to the declarations when it ends, and `adoptDeclarations()` takes a key into the run *only where the document changed it since the last sync*. Without that condition any unrelated project edit would snap a running counter back to its starting value; a counter-test bends exactly that and falls over. Nothing was ever cached, incidentally: `GraphInterpreter` only pulse-caches nodes without a `read`, and the variable node has one. The wire was missing. The state machine `Scope` row is now an ordinary `enum` row through `createFieldRow`. It was hand-built from an `HStack` with a ghost dropdown and began ~34px left of every value above it; the explanations beside `Local` and `Global` are gone from the menu, the sentence below the row keeps saying it. Machine scope is otherwise untouched -- `StateMachineAsset.scope`, `SetMachineScopeCommand`, `stateBag()` and its persistence all stand, so #59 stays closed as built and `Scope` as a type now carries machines alone. Six counter-proofs, each biting at its own guard. One of them did not bite at first: the suggestion list was computed twice, in `nodeSection` and `portSection`, so only the browser test covered the request itself. It is one named function now, `variableChoices`, with a unit test of its own. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
43 lines
1.9 KiB
TypeScript
43 lines
1.9 KiB
TypeScript
/**
|
||
* What `+ Variable` offers on a Variables node. The node's own setting decides: empty means the
|
||
* behavior it sits in, a Variables asset means that asset's declarations – which is the only way
|
||
* one graph reaches a value another graph writes.
|
||
*/
|
||
import { describe, expect, it } from 'vitest';
|
||
import { CreateAssetCommand } from '../../src/core/commands/assetCommands';
|
||
import { AddNodeCommand } from '../../src/core/commands/graphCommands';
|
||
import { AddVariableCommand } from '../../src/core/commands/variableCommands';
|
||
import { VARIABLES, VARIABLES_PARAM } from '../../src/core/graph';
|
||
import { variableChoices } from '../../src/editor/inspector/portSection';
|
||
import { makeBehavior, makeProject } from '../helpers';
|
||
|
||
describe('the variables a node offers', () => {
|
||
const scene = () => {
|
||
const f = makeProject();
|
||
const behavior = makeBehavior(f, 'Counter', ['own']);
|
||
const shared = new CreateAssetCommand('variables', 'Score');
|
||
f.stack.execute(shared);
|
||
f.stack.execute(new AddVariableCommand(shared.asset.id, 'score', 'number'));
|
||
const add = (source: string) => {
|
||
const command = new AddNodeCommand(behavior.id, VARIABLES, 0, 0, { [VARIABLES_PARAM]: source });
|
||
f.stack.execute(command);
|
||
return variableChoices(f.project, behavior.id, command.node).map((def) => def.key);
|
||
};
|
||
return { add, sharedId: shared.asset.id };
|
||
};
|
||
|
||
it('offers the behavior’s own when no asset is named', () => {
|
||
expect(scene().add('')).toEqual(['own']);
|
||
});
|
||
|
||
it('offers the asset’s declarations when one is named, and not the behavior’s', () => {
|
||
const { add, sharedId } = scene();
|
||
expect(add(sharedId)).toEqual(['score']);
|
||
});
|
||
|
||
/** Falling back to the behavior would offer names the node cannot reach at runtime. */
|
||
it('offers nothing when the named asset is gone', () => {
|
||
expect(scene().add('no-such-asset')).toEqual([]);
|
||
});
|
||
});
|