rootandClaude Opus 5
d1fcfe8b81
A variable or a state machine declared `global` keeps one value for the whole run instead of one per behavior instance. The scope sits on the declaration -- `PropertyDef.scope` and `StateMachineAsset.scope`, both optional, absence meaning `local` -- and `local` is never written, so every project made before this saves back unchanged. **The name is the key.** Two behaviors declaring a global `score` mean one variable; a behavior declaring `score` locally keeps its own. Kinds that disagree about one global name stop the run before it starts, with the two behaviors named; starting values that disagree are a warning on the behavior that declares it, and the first declaration wins (`globalConflicts`). The runtime needs no redirection layer. A global variable falls out of `schemaForObject`, so it never reaches `entity.props` -- and then the whole rule is "whoever declares the name takes their own value" (`graph/sharedState.ts`). The `Variables` node is untouched and stays transparent: switching a variable to global breaks no existing graph, because `GraphInterpreter.readAll` builds a fresh object per read anyway and only asks `port.key in all`. That same cut answers the inspector. A shared value has no owner, so the placed object shows no row for it and can hold no override -- `SetVariableScopeCommand` takes the deviations that were there and undo gives them back. Both places say it in words rather than leaving a glyph to be guessed: the declaration explains the mark below the list, and the placed object names the variable it no longer holds instead of claiming the behavior declares none -- which is what it said before, untruthfully. Screenshots of the e2e run turned that up; no check had been looking at it. `SharedState` hangs off `NodeContext`, is built in `BehaviorSystem.start()` from the *declarations* rather than from any instance (a global variable exists before its behavior is placed), and is thrown away with the run: nothing is written back, not even in the editor run. `GraphInterpreter.call` passes it on through `...ctx` while nested calls keep getting fresh local variables, which is why `program.defaults` is stripped of global keys. Two traps this hit. `defSignature`/`assetSignature` have to carry the scope or the inspector does not rebuild after the switch -- and a state machine has no rows at all, so its scope is appended to the signature by hand. And the object inspector does not go through `schemaForObject` for behaviors, it reads `asset.variables` directly; filtering in one place was not enough, and no unit test covered that path. The e2e caught it (`global: true` where false belonged), and the rule now lives in one named function, `objectRows`. Scopes `object` and `scene` are deliberately not built. The object case already has a route (`Object by name` -> `Properties`), and a run knows exactly one scene, so `scene` would be indistinguishable from `global` until #39 exists. Closes #59: a machine's scope is a word on the machine asset, not a setting per `Set state` node, so the same machine cannot live in two places at once. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
28 lines
1.2 KiB
TypeScript
28 lines
1.2 KiB
TypeScript
/**
|
||
* What the inspector of a *placed* behavior lists. A global variable has no value of this object's
|
||
* own, so it gets no row here – the switch on the declaration is the only place it is edited.
|
||
*/
|
||
import { describe, expect, it } from 'vitest';
|
||
import { SetVariableScopeCommand } from '../../src/core/commands/variableCommands';
|
||
import { findAsset } from '../../src/core/model/Project';
|
||
import { objectRows } from '../../src/editor/inspector/objectSection';
|
||
import { makeBehavior, makeSpriteScene, place } from '../helpers';
|
||
|
||
describe('the rows of a placed behavior', () => {
|
||
it('lists a local variable and leaves out a global one', () => {
|
||
const f = makeSpriteScene();
|
||
const behavior = makeBehavior(f, 'Counter', ['score', 'lives']);
|
||
const objectId = place(f, behavior.id, { x: 0, y: 0 });
|
||
const rows = () => {
|
||
const asset = findAsset(f.project, behavior.id)!;
|
||
return objectRows(f.project, asset, f.object(objectId)).map((def) => def.key);
|
||
};
|
||
|
||
expect(rows()).toEqual(['score', 'lives']);
|
||
f.stack.execute(new SetVariableScopeCommand(behavior.id, 'score', 'global'));
|
||
expect(rows()).toEqual(['lives']);
|
||
f.stack.undo();
|
||
expect(rows()).toEqual(['score', 'lives']);
|
||
});
|
||
});
|