@silkweaver/build 1.3.1 → 1.3.2

package/dist/build.js

@@ -277,7 +277,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}`
@@ -534,6 +536,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 +551,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.js

@@ -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',
@@ -239,19 +226,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 +568,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.2",
     "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",