@silkweaver/build 1.3.1 → 1.3.3

package/dist/build.js

@@ -218,10 +218,13 @@ async function generate_entry_code(project_folder, proj, asset_mode, engine_path
             if ((inst.rotation ?? 0) !== 0)
                 lines.push(`    ${v}.image_angle = ${inst.rotation}`);
             lines.push(`    ${v}.register_events()`);
-            lines.push(`    game_loop.register(EVENT_TYPE.create, ${v}.on_create.bind(${v}))`);
-            // Per-instance creation code runs after the object's Create event (bound: this = instance).
+            // Queue the Create event (+ optional per-instance creation code) via the engine helper,
+            // which runs them under the active-instance context so `sw`/`inst` resolve inside.
             if (inst.creation_code && inst.creation_code.trim()) {
-                lines.push(`    game_loop.register(EVENT_TYPE.create, (function(this: any){\n${inst.creation_code}\n}).bind(${v}))`);
+                lines.push(`    instance_queue_create(${v}, (function(this: any){\n${inst.creation_code}\n}).bind(${v}))`);
+            }
+            else {
+                lines.push(`    instance_queue_create(${v})`);
             }
             return lines.join('\n');
         }).filter(Boolean).join('\n');
@@ -277,7 +280,9 @@ async function generate_entry_code(project_folder, proj, asset_mode, engine_path
 ${var_name}.room_width  = ${rm_data.width ?? 640}
 ${var_name}.room_height = ${rm_data.height ?? 480}
 ${var_name}.room_speed  = ${rm_data.room_speed ?? 60}
-${var_name}.room_persistent = ${rm_data.persistent ?? false}
+${var_name}.room_persistent = ${rm_data.persistent ?? false}${room_physics[room_name]
+            ? `\n${var_name}.physics_world = true\n${var_name}.physics_gravity_x = ${room_physics[room_name].gx}\n${var_name}.physics_gravity_y = ${room_physics[room_name].gy}`
+            : ''}
 ${var_name}.background_show_color  = ${rm_data.bg_show_color ?? true}
 ${var_name}.background_solid_color = ${hex_to_bgr(rm_data.bg_color ?? '#000000')}${rm_data.creation_code && rm_data.creation_code.trim()
             ? `\n${var_name}.creation_code = () => {\n${rm_data.creation_code}\n}`
@@ -510,7 +515,7 @@ async function _load_sound(name: string, meta_url: string, base: string): Promis
 // ── Bootstrap ───────────────────────────────────────────────────────────────
 export default async function init(canvas: HTMLCanvasElement): Promise<void> {
     renderer.init(canvas, ${proj.settings.windowWidth ?? 640}, ${proj.settings.windowHeight ?? 480})
-    // Background clear color: ${proj.settings.displayColor ?? '#000000'}
+    renderer.set_clear_color(${JSON.stringify(proj.settings.displayColor ?? '#000000')})   // window/clear color (Game Settings)
     game_loop.init_input(canvas)
 
     // Load sprites
@@ -534,6 +539,9 @@ export default async function init(canvas: HTMLCanvasElement): Promise<void> {
     // Set up rooms
     ${room_setups.join('\n')}
 
+    // Register rooms by name (room_goto('rm_x') / room_get('rm_x') / room_exists('rm_x'))
+    ${room_names.map(n => `room_register_name('${n}', _room_${n})`).join('\n    ')}
+
     // Link room order
     ${room_var_names.map((v, i) => {
         const prev = room_var_names[i - 1];
@@ -546,7 +554,9 @@ export default async function init(canvas: HTMLCanvasElement): Promise<void> {
 
     const start = ${start_var}
     if (!start) { console.error('[Game] No rooms defined.'); return }
-${room_physics[start_room] ? `    physics_world_create(${room_physics[start_room].gx}, ${room_physics[start_room].gy})\n` : ''}    game_loop.start(start)
+    // The physics world is (re)created per-room in room.build_for_entry() from the room's
+    // physics_world/gravity fields — so it's fresh on every entry AND every restart.
+    game_loop.start(start)
 }
 `;
     return entry_code;

package/dist/object_format.d.ts

@@ -33,13 +33,14 @@ export interface object_model {
 /** Extracts the object model from a class-file source. */
 export declare function parse_object(src: string): object_model;
 /**
- * Collects every instance member reachable through `this.` in a class: declared instance fields
- * *plus* members created/assigned at runtime inside any event (e.g. `this.velocity = 0` in on_create,
- * read in on_step). This drives `this.` autocomplete, so a variable made in one event surfaces in all
- * the others — matching the usual split of constants on the object, runtime state in Create. Static
- * fields and method/event names are excluded (engine members are merged in separately).
+ * Collects the object's OWN variables: declared instance fields *plus* members created/assigned at
+ * runtime via the `inst.` namespace inside any event (e.g. `inst.velocity = 0` in on_create, read in
+ * on_step). This drives `inst.` autocomplete, so a variable made in one event surfaces in all the
+ * others. Static fields (object metadata) and method/event names are excluded. The engine's built-in
+ * instance API is NOT collected here — it lives on `sw.` and is typed from the engine directly — so
+ * `this.x`/`sw.x` style writes never leak into the author's own-variable list.
  */
-export declare function this_members(src: string): string[];
+export declare function object_vars(src: string): string[];
 /**
  * Sets (adds or updates) a static metadata field. `expr` is the raw initializer
  * text (e.g. `'spr_player'`, `true`, `-5`, `obj_base`).

package/dist/object_format.js

@@ -46,7 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVENT_ORDER = exports.META_ORDER = void 0;
 exports.parse_object = parse_object;
-exports.this_members = this_members;
+exports.object_vars = object_vars;
 exports.set_static = set_static;
 exports.remove_static = remove_static;
 exports.set_field = set_field;
@@ -63,19 +63,6 @@ exports.META_ORDER = [
     'sprite', 'parent', 'solid', 'visible', 'persistent', 'depth',
     'physics', 'physics_shape', 'physics_density', 'physics_restitution', 'physics_friction', 'physics_sensor',
 ];
-/**
- * Explicit type annotations for static fields whose base-class type is narrower than what TypeScript
- * would infer from the literal initializer. Without this, `static physics_shape = 'box'` widens to
- * `string`, which doesn't satisfy the base's `'box' | 'circle'` and the subclass fails to compile.
- */
-const META_TYPES = {
-    physics_shape: `'box' | 'circle'`,
-};
-/** Renders a `static <name>[: <type>] = <expr>;` declaration, adding an annotation where one is needed. */
-function _static_decl(name, expr) {
-    const ann = META_TYPES[name];
-    return `static ${name}${ann ? `: ${ann}` : ''} = ${expr};`;
-}
 /** Canonical GMS-style order of `on_*` event methods (used to keep events ordered in code). */
 exports.EVENT_ORDER = [
     'on_create', 'on_destroy',
@@ -164,13 +151,14 @@ function _string_literal(node) {
     return null;
 }
 /**
- * Collects every instance member reachable through `this.` in a class: declared instance fields
- * *plus* members created/assigned at runtime inside any event (e.g. `this.velocity = 0` in on_create,
- * read in on_step). This drives `this.` autocomplete, so a variable made in one event surfaces in all
- * the others — matching the usual split of constants on the object, runtime state in Create. Static
- * fields and method/event names are excluded (engine members are merged in separately).
+ * Collects the object's OWN variables: declared instance fields *plus* members created/assigned at
+ * runtime via the `inst.` namespace inside any event (e.g. `inst.velocity = 0` in on_create, read in
+ * on_step). This drives `inst.` autocomplete, so a variable made in one event surfaces in all the
+ * others. Static fields (object metadata) and method/event names are excluded. The engine's built-in
+ * instance API is NOT collected here — it lives on `sw.` and is typed from the engine directly — so
+ * `this.x`/`sw.x` style writes never leak into the author's own-variable list.
  */
-function this_members(src) {
+function object_vars(src) {
     const sf = _source(src);
     const cls = _find_class(sf);
     if (!cls)
@@ -183,14 +171,14 @@ function this_members(src) {
                 names.add(n);
         }
     }
-    // Any `this.<name> = …` (or compound assignment) anywhere in the class body — including nested
-    // blocks/closures — counts as an instance member the user can reference elsewhere.
+    // Any `inst.<name> = …` (or compound assignment) anywhere in the class body — including nested
+    // blocks/closures — counts as an author variable the user can reference elsewhere.
     const visit = (node) => {
         if (ts.isBinaryExpression(node)
             && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment
             && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
             && ts.isPropertyAccessExpression(node.left)
-            && node.left.expression.kind === ts.SyntaxKind.ThisKeyword
+            && ts.isIdentifier(node.left.expression) && node.left.expression.text === 'inst'
             && ts.isIdentifier(node.left.name)) {
             names.add(node.left.name.text);
         }
@@ -239,19 +227,16 @@ function set_static(src, name, expr) {
     if (!cls)
         return src;
     const existing = _find_member(cls, m => ts.isPropertyDeclaration(m) && _is_static(m) && _name_of(m) === name);
+    if (existing?.initializer) {
+        return _apply(src, { start: existing.initializer.getStart(sf), end: existing.initializer.getEnd(), text: expr });
+    }
     if (existing) {
-        // For annotated fields (e.g. physics_shape) replace the whole member so the type annotation is
-        // always present/correct — updating just the initializer could leave it un-annotated (→ widens
-        // to string and fails to compile). For plain fields, the cheaper initializer-only edit is fine.
-        if (META_TYPES[name])
-            return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: _static_decl(name, expr) });
-        if (existing.initializer)
-            return _apply(src, { start: existing.initializer.getStart(sf), end: existing.initializer.getEnd(), text: expr });
-        return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: _static_decl(name, expr) });
+        // declared without initializer — replace the whole member
+        return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: `static ${name} = ${expr};` });
     }
     // New static: metadata lives at the TOP, ordered by META_ORDER. Insert before the first static
     // that sorts after it; else before the first non-static member (so statics stay grouped up top).
-    const stub = `    ${_static_decl(name, expr)}\n`;
+    const stub = `    static ${name} = ${expr};\n`;
     const order = exports.META_ORDER.indexOf(name);
     if (order >= 0) {
         const after = cls.members.find(m => {
@@ -584,7 +569,7 @@ function scaffold_object(class_name, kind = 'normal') {
     if (kind === 'physics') {
         return `export class ${class_name} extends gm_object {
     static physics = true;
-    static physics_shape: 'box' | 'circle' = 'box';
+    static physics_shape = 'box';
     static physics_density = 0.5;
     static physics_restitution = 0.1;
     static physics_friction = 0.2;

package/dist/templates.js

@@ -51,6 +51,7 @@ const TEMPLATE_REGISTRY = [
     { id: 'empty', label: 'Empty', description: 'A blank project with a single empty room.' },
     { id: 'platformer', label: 'Platformer', description: 'A/D to move, Space to jump — gravity, solid platforms, parent-based collision.' },
     { id: 'topdown', label: 'Top-down', description: 'WASD movement with parent-based wall collision (place_meeting + a _col parent).' },
+    { id: 'physics_ball', label: 'Physics Ball', description: 'Bounce a ball on a mouse paddle for score — matter.js physics (circle/box bodies, restitution, instance_nearest).' },
 ];
 /** Absolute path to the bundled templates directory (sibling of dist/). */
 function templates_dir() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@silkweaver/build",
-    "version": "1.3.1",
+    "version": "1.3.3",
     "description": "Silkweaver toolchain — compiles a project folder into a runnable game (HTML5 / desktop executable). Usable from a CLI or the IDE.",
     "type": "commonjs",
     "license": "GPL-3.0",