@silkweaver/build 1.0.0 → 1.2.0

package/dist/object_format.js

@@ -44,15 +44,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_ORDER = void 0;
 exports.parse_object = parse_object;
+exports.this_members = this_members;
 exports.set_static = set_static;
 exports.remove_static = remove_static;
 exports.set_field = set_field;
 exports.remove_field = remove_field;
 exports.add_method = add_method;
 exports.remove_method = remove_method;
+exports.get_event_body = get_event_body;
+exports.set_event_body = set_event_body;
+exports.normalize_object = normalize_object;
 exports.scaffold_object = scaffold_object;
 const ts = __importStar(require("typescript"));
+/** Canonical GMS-style order of `on_*` event methods (used to keep events ordered in code). */
+exports.EVENT_ORDER = [
+    'on_create', 'on_destroy',
+    'on_step_begin', 'on_step', 'on_step_end',
+    'on_draw_begin', 'on_draw', 'on_draw_end', 'on_draw_gui',
+    'on_alarm',
+    'on_key_press', 'on_key_release', 'on_key_held',
+    'on_mouse_left_press', 'on_mouse_left_release', 'on_mouse_right_press',
+    'on_collision',
+    'on_room_start', 'on_room_end', 'on_game_start', 'on_game_end',
+    'on_animation_end', 'on_path_end', 'on_outside_room', 'on_intersect_boundary',
+    'on_no_more_lives', 'on_no_more_health', 'on_user',
+];
 // =========================================================================
 // Parsing
 // =========================================================================
@@ -126,6 +144,42 @@ function _string_literal(node) {
         return node.text;
     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).
+ */
+function this_members(src) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls)
+        return [];
+    const names = new Set();
+    for (const m of cls.members) {
+        if (ts.isPropertyDeclaration(m) && !_is_static(m)) {
+            const n = _name_of(m);
+            if (n)
+                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.
+    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.name)) {
+            names.add(node.left.name.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(cls);
+    return [...names];
+}
 function _apply(src, e) {
     return src.slice(0, e.start) + e.text + src.slice(e.end);
 }
@@ -139,6 +193,20 @@ function _insert_member(src, text) {
     const prefix = pos > 0 && src[pos - 1] !== '\n' ? '\n' : ''; // guard against mashing onto the prior line
     return _apply(src, { start: pos, end: pos, text: prefix + text });
 }
+/** Inserts `text` (a full member incl. trailing newline) on its own line before the member at `pos`. */
+function _insert_before(src, pos, text) {
+    const line_start = src.lastIndexOf('\n', pos - 1) + 1;
+    return src.slice(0, line_start) + text + src.slice(line_start);
+}
+/** Inserts `text` (a full member incl. trailing newline) on its own line after the member ending at `end`. */
+function _insert_after(src, end, text) {
+    let i = end;
+    while (i < src.length && src[i] !== '\n')
+        i++; // to the end of the member's own line
+    if (i < src.length && src[i] === '\n')
+        i++; // past the line terminator
+    return src.slice(0, i) + text + src.slice(i);
+}
 function _find_member(cls, pred) {
     return cls.members.find(pred);
 }
@@ -178,13 +246,25 @@ function set_field(src, name, expr) {
     if (existing) {
         return _apply(src, { start: existing.getStart(sf), end: existing.getEnd(), text: `${name} = ${expr}` });
     }
-    return _insert_member(src, `    ${name} = ${expr}\n`);
+    // New variable: keep all instance variables grouped at the TOP of the class, in add-order, so
+    // every event below can reference them — and a later variable's initializer can safely read an
+    // earlier one. Insert after the last existing variable; if none, before the first member.
+    const stub = `    ${name} = ${expr}\n`;
+    const vars = cls.members.filter(m => ts.isPropertyDeclaration(m) && !_is_static(m));
+    if (vars.length)
+        return _insert_after(src, vars[vars.length - 1].getEnd(), stub);
+    if (cls.members.length)
+        return _insert_before(src, cls.members[0].getStart(sf), stub);
+    return _insert_member(src, stub);
 }
 /** Removes an instance variable field. */
 function remove_field(src, name) {
     return _remove_member(src, m => ts.isPropertyDeclaration(m) && !_is_static(m) && _name_of(m) === name);
 }
-/** Adds an `on_*` event method stub if it is not already present. */
+/**
+ * Adds an `on_*` event method stub if it is not already present, inserted in canonical event
+ * order (before the first existing event method that comes later in EVENT_ORDER).
+ */
 function add_method(src, method, params = '', body = '') {
     const sf = _source(src);
     const cls = _find_class(sf);
@@ -193,6 +273,17 @@ function add_method(src, method, params = '', body = '') {
     if (_find_member(cls, m => ts.isMethodDeclaration(m) && _name_of(m) === method))
         return src;
     const stub = `    ${method}(${params}): void {\n${body ? '        ' + body + '\n' : ''}    }\n`;
+    const order = exports.EVENT_ORDER.indexOf(method);
+    if (order >= 0) {
+        const after = cls.members.find(m => {
+            if (!ts.isMethodDeclaration(m))
+                return false;
+            const n = _name_of(m);
+            return !!n && exports.EVENT_ORDER.indexOf(n) > order;
+        });
+        if (after)
+            return _insert_before(src, after.getStart(sf), stub);
+    }
     return _insert_member(src, stub);
 }
 /** Removes an event method by name. */
@@ -222,6 +313,196 @@ function _remove_member(src, pred) {
     return _apply(src, { start, end, text: '' });
 }
 // =========================================================================
+// Event body extract / pack — per-event "virtual file" editing
+// =========================================================================
+//
+// An event is edited as its OWN buffer: get_event_body returns just the method's body,
+// de-indented to column 0, so the editor is a normal standalone file (Ctrl+A, auto-indent,
+// autocomplete — no hidden areas, no live brace-matching). set_event_body packs that buffer
+// back into the method, re-indented. Both are AST-based, so they're robust to braces/strings.
+/** Strips common leading indentation + surrounding blank lines (method body → editable buffer). */
+function _dedent(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    while (lines.length && lines[0].trim() === '')
+        lines.shift();
+    while (lines.length && lines[lines.length - 1].trim() === '')
+        lines.pop();
+    if (lines.length === 0)
+        return '';
+    let min = Infinity;
+    for (const l of lines) {
+        if (l.trim() === '')
+            continue;
+        const w = /^[ \t]*/.exec(l)[0].length;
+        if (w < min)
+            min = w;
+    }
+    if (!isFinite(min))
+        min = 0;
+    return lines.map(l => (l.trim() === '' ? '' : l.slice(min))).join('\n');
+}
+/** Re-applies an indent prefix to each non-blank line (editable buffer → method body). */
+function _indent(text, indent) {
+    return text.replace(/\r\n?/g, '\n').split('\n').map(l => (l.trim() === '' ? '' : indent + l)).join('\n');
+}
+/** Returns the leading whitespace of the line containing `pos`. */
+function _line_indent(src, pos) {
+    const line_start = src.lastIndexOf('\n', pos - 1) + 1;
+    return /^[ \t]*/.exec(src.slice(line_start, pos))?.[0] ?? '';
+}
+function _find_event_method(cls, method) {
+    return cls.members.find(m => ts.isMethodDeclaration(m) && _name_of(m) === method);
+}
+/**
+ * Returns one event method's body as an editable, de-indented buffer, or null if absent/bodyless.
+ * @param method - The on_* method to extract (e.g. 'on_step')
+ */
+function get_event_body(src, method) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls)
+        return null;
+    const m = _find_event_method(cls, method);
+    if (!m || !m.body)
+        return null;
+    const inner = src.slice(m.body.getStart(sf) + 1, m.body.getEnd() - 1); // between the braces
+    return _dedent(inner);
+}
+/**
+ * Replaces an event method's body with `body` (an edited, de-indented buffer), re-indenting it to
+ * the method's level. Returns the full updated source; a no-op if the method is absent.
+ * @param method - The on_* method to update
+ * @param body   - The new body (column-0 / de-indented, as edited)
+ */
+function set_event_body(src, method, body) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls)
+        return src;
+    const m = _find_event_method(cls, method);
+    if (!m || !m.body)
+        return src;
+    const open = m.body.getStart(sf); // position of '{'
+    const close = m.body.getEnd() - 1; // position of '}'
+    const method_indent = _line_indent(src, m.getStart(sf));
+    const dedented = _dedent(body);
+    const inner = dedented === '' ? '' : _indent(dedented, method_indent + '    ');
+    const block = '{\n' + (inner ? inner + '\n' : '') + method_indent + '}';
+    return src.slice(0, open) + block + src.slice(close + 1);
+}
+// =========================================================================
+// Normalize — variables-first + canonical event order + indentation (full class view)
+// =========================================================================
+/**
+ * Re-indents code by bracket/brace/paren depth (leading whitespace only — never touches content or
+ * spacing). Strings and comments are skipped. Good for typical game code; deeply nested `({`-style
+ * continuations may be off by a level (cosmetic, not corrupting).
+ */
+function _reindent(code, unit = '    ') {
+    const lines = code.replace(/\r\n?/g, '\n').split('\n');
+    const out = [];
+    let depth = 0;
+    let in_block = false; // inside a /* … */ comment spanning lines
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (line === '') {
+            out.push('');
+            continue;
+        }
+        let delta = 0, first_is_closer = false, started = false;
+        let i = 0;
+        let line_block = in_block;
+        while (i < line.length) {
+            if (line_block) {
+                if (line[i] === '*' && line[i + 1] === '/') {
+                    line_block = false;
+                    i += 2;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            const c = line[i], n = line[i + 1];
+            if (c === '/' && n === '/')
+                break;
+            if (c === '/' && n === '*') {
+                line_block = true;
+                i += 2;
+                continue;
+            }
+            if (c === '"' || c === "'" || c === '`') {
+                const q = c;
+                i++;
+                while (i < line.length && line[i] !== q) {
+                    if (line[i] === '\\')
+                        i++;
+                    i++;
+                }
+                i++;
+                continue;
+            }
+            const opener = c === '{' || c === '(' || c === '[';
+            const closer = c === '}' || c === ')' || c === ']';
+            if (opener)
+                delta++;
+            else if (closer)
+                delta--;
+            if (!started && (opener || closer || /\S/.test(c))) {
+                started = true;
+                if (closer)
+                    first_is_closer = true;
+            }
+            i++;
+        }
+        in_block = line_block;
+        const this_depth = Math.max(0, depth - (first_is_closer ? 1 : 0));
+        out.push(unit.repeat(this_depth) + line);
+        depth = Math.max(0, depth + delta);
+    }
+    return out.join('\n');
+}
+/**
+ * Reorders all class members into canonical groups, preserving each member's attached comments:
+ *   1. instance variables — in their existing relative order (field-init order can matter; one
+ *      field's initializer may read another), so they're grouped but never shuffled among themselves;
+ *   2. `on_*` event methods — in canonical EVENT_ORDER;
+ *   3. everything else (statics, helper methods) — in place.
+ * Variables-before-events is the whole point: every event can reference every variable. A no-op if
+ * the order is already canonical.
+ */
+function _reorder_members(src) {
+    const sf = _source(src);
+    const cls = _find_class(sf);
+    if (!cls || cls.members.length <= 1)
+        return src;
+    const members = cls.members;
+    const event_idx = (m) => {
+        const n = _name_of(m);
+        return n && ts.isMethodDeclaration(m) ? exports.EVENT_ORDER.indexOf(n) : -1;
+    };
+    const is_var = (m) => ts.isPropertyDeclaration(m) && !_is_static(m);
+    const vars = members.filter(is_var);
+    const events = members.filter(m => event_idx(m) >= 0).sort((a, b) => event_idx(a) - event_idx(b));
+    const others = members.filter(m => !is_var(m) && event_idx(m) < 0);
+    const ordered = [...vars, ...events, ...others];
+    if (ordered.every((m, i) => m === members[i]))
+        return src; // already canonical
+    // Rebuild the class body from each member's full text (getFullStart → getEnd includes the leading
+    // trivia — newlines/indent/comments — so comments travel with their member). The class header up
+    // to `{` and the closing `}` + trailing trivia are preserved verbatim.
+    const chunk = (m) => src.slice(m.getFullStart(), m.getEnd());
+    const prefix = src.slice(0, members[0].getFullStart());
+    const suffix = src.slice(members[members.length - 1].getEnd());
+    return prefix + ordered.map(chunk).join('') + suffix;
+}
+/**
+ * Normalizes a class-per-object file for display in the full code view: variables hoisted above all
+ * events, canonical event order, then consistent indentation. Unchanged if there's no class.
+ */
+function normalize_object(src) {
+    return _reindent(_reorder_members(src));
+}
+// =========================================================================
 // Scaffolding
 // =========================================================================
 /** Generates a minimal class-file source for a new object. Imports are auto-managed (none needed). */

package/dist/templates.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Starter templates for the New Project flow.
+ *
+ * Each template is a real, ready-to-build project folder bundled under `../templates/<id>/`
+ * (sprites and all). Creating a project from a template is just a recursive copy of that folder
+ * into the destination — no codegen — so the templates stay editable/diffable in the repo and a
+ * dogfooded example game *is* the template. Pure Node (fs/path), reusable from the IDE or CLI.
+ */
+export interface template_info {
+    id: string;
+    label: string;
+    description: string;
+    display_color: string;
+}
+/** Returns the available starter templates — only those whose folder is actually installed. */
+export declare function list_templates(): template_info[];
+/**
+ * Materializes a starter template into `dest_folder` by recursively copying its bundled project
+ * folder, then (optionally) setting the display name in project.json.
+ * @param template_id - 'empty' | 'platformer' | 'topdown'
+ * @param dest_folder - Absolute path of the new project folder (created if missing)
+ * @param name        - Optional display name to write into project.json
+ */
+export declare function create_from_template(template_id: string, dest_folder: string, name?: string): Promise<void>;

package/dist/templates.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Starter templates for the New Project flow.
+ *
+ * Each template is a real, ready-to-build project folder bundled under `../templates/<id>/`
+ * (sprites and all). Creating a project from a template is just a recursive copy of that folder
+ * into the destination — no codegen — so the templates stay editable/diffable in the repo and a
+ * dogfooded example game *is* the template. Pure Node (fs/path), reusable from the IDE or CLI.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list_templates = list_templates;
+exports.create_from_template = create_from_template;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const build_js_1 = require("./build.js");
+/** Ordered registry of the bundled starter templates (folders live under ../templates/<id>). */
+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).' },
+];
+/** Absolute path to the bundled templates directory (sibling of dist/). */
+function templates_dir() {
+    return path.join(__dirname, '..', 'templates');
+}
+/** Names never copied into a new project (build artifacts / VCS / deps), as a defensive guard. */
+const COPY_DENYLIST = new Set(['_entry.ts', '_engine_globals.ts', 'node_modules', '.git', 'exports', 'game.js', '.engine']);
+/** Returns the available starter templates — only those whose folder is actually installed. */
+function list_templates() {
+    const out = [];
+    for (const t of TEMPLATE_REGISTRY) {
+        let display_color = '#1a1a2e';
+        try {
+            const j = JSON.parse(fs.readFileSync(path.join(templates_dir(), t.id, 'project.json'), 'utf8'));
+            if (typeof j?.settings?.displayColor === 'string')
+                display_color = j.settings.displayColor;
+        }
+        catch {
+            continue;
+        } // folder missing/unreadable → omit it
+        out.push({ id: t.id, label: t.label, description: t.description, display_color });
+    }
+    return out;
+}
+/**
+ * Materializes a starter template into `dest_folder` by recursively copying its bundled project
+ * folder, then (optionally) setting the display name in project.json.
+ * @param template_id - 'empty' | 'platformer' | 'topdown'
+ * @param dest_folder - Absolute path of the new project folder (created if missing)
+ * @param name        - Optional display name to write into project.json
+ */
+async function create_from_template(template_id, dest_folder, name) {
+    if (!TEMPLATE_REGISTRY.some(t => t.id === template_id))
+        throw new Error(`Unknown template: ${template_id}`);
+    const src = path.join(templates_dir(), template_id);
+    if (!fs.existsSync(path.join(src, 'project.json')))
+        throw new Error(`Template '${template_id}' is not installed`);
+    if (fs.existsSync(path.join(dest_folder, 'project.json')))
+        throw new Error('A project already exists in that folder');
+    await fs.promises.mkdir(dest_folder, { recursive: true });
+    await fs.promises.cp(src, dest_folder, {
+        recursive: true,
+        filter: (s) => !COPY_DENYLIST.has(path.basename(s)),
+    });
+    if (name && name.trim()) {
+        const proj_path = path.join(dest_folder, 'project.json');
+        try {
+            const j = JSON.parse(await fs.promises.readFile(proj_path, 'utf8'));
+            j.name = name.trim();
+            await fs.promises.writeFile(proj_path, JSON.stringify(j, null, 2) + '\n', 'utf8');
+        }
+        catch { /* keep the template's bundled name */ }
+    }
+    // Vendor the current engine into the new project so it's pinned to this version (a later IDE
+    // update won't change it). Best-effort: if it fails, the project still builds against the
+    // toolchain engine via the resolve_engine fallback.
+    try {
+        await (0, build_js_1.vendor_engine)(dest_folder);
+    }
+    catch { /* falls back to the toolchain engine */ }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@silkweaver/build",
-    "version": "1.0.0",
+    "version": "1.2.0",
     "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",
@@ -23,14 +23,15 @@
     },
     "files": [
         "dist",
-        "assets"
+        "assets",
+        "templates"
     ],
     "scripts": {
         "build": "tsc -p ."
     },
     "dependencies": {
-        "@silkweaver/engine": "1.0.0",
-        "@silkweaver/project": "1.0.0",
+        "@silkweaver/engine": "^1.0.0",
+        "@silkweaver/project": "^1.0.0",
         "@electron/packager": "^19.0.5",
         "esbuild": "^0.27.2",
         "typescript": "^5.9.3"

package/templates/empty/project.json

@@ -0,0 +1,27 @@
+{
+  "name": "Empty",
+  "version": "1.0.0",
+  "engineVersion": "1.0.0",
+  "settings": {
+    "roomSpeed": 60,
+    "windowWidth": 640,
+    "windowHeight": 480,
+    "startRoom": "room_main",
+    "displayColor": "#1a1a2e"
+  },
+  "resources": {
+    "sprites": {},
+    "sounds": {},
+    "backgrounds": {},
+    "paths": {},
+    "scripts": {},
+    "fonts": {},
+    "timelines": {},
+    "objects": {},
+    "rooms": {
+      "room_main": {
+        "name": "room_main"
+      }
+    }
+  }
+}

package/templates/empty/rooms/room_main/room.json

@@ -0,0 +1,16 @@
+{
+  "width": 640,
+  "height": 480,
+  "room_speed": 60,
+  "persistent": false,
+  "creation_code": "",
+  "instances": [],
+  "backgrounds": [],
+  "views": [],
+  "tiles": [],
+  "bg_color": "#1a1a2e",
+  "bg_show_color": true,
+  "physics_world": false,
+  "physics_gravity_x": 0,
+  "physics_gravity_y": 10
+}

package/templates/platformer/objects/_col.ts

@@ -0,0 +1,3 @@
+export class _col extends gm_object {
+    static visible = false
+}

package/templates/platformer/objects/obj_platform.ts

@@ -0,0 +1,10 @@
+export class obj_platform extends gm_object {
+    on_create(): void {
+    }
+
+    // block width
+    // block height
+
+    static parent = _col
+    static sprite = 'spr_platform'
+}

package/templates/platformer/objects/obj_player.ts

@@ -0,0 +1,73 @@
+export class obj_player extends gm_object {
+    spd = 5;
+    jump_force = 15;
+    weight = 1;
+
+    on_create(): void {
+        this.grounded = false;
+        this.vertical_acc = 0.0;
+        this.vertical_vel = 0.0;
+        this.horizontal_vel = 0.0;
+    }
+
+    on_step(): void {
+        // controlls
+        let key_left = keyboard_check(ord("A"));
+        let key_right = keyboard_check(ord("D"));
+        let key_jump = keyboard_check(vk_space);
+
+        // ------------------------------
+        // left to right
+        // ------------------------------
+
+        // motion
+        let dir = 0;
+        if (key_left) {
+            dir = -1;
+        }
+
+        if (key_right) {
+            dir = 1;
+        }
+
+        // movenemt
+        this.horizontal_vel = dir * this.spd;
+        if (!this.place_meeting(this.x + this.horizontal_vel, this.y, _col)) {
+            this.x += this.horizontal_vel;
+        }
+
+        // ------------------------------
+        // jump and gravity
+        // ------------------------------
+
+        // grounding
+        if (this.place_meeting(this.x, this.y + 1, _col)) {
+            this.grounded = true;
+            this.vertical_vel = 0;
+            this.vertical_acc = 0;
+        } else {
+            this.grounded = false;
+        }
+
+        // vertical acceleration (gravity pulls down while airborne)
+        if (!this.grounded) {
+            this.vertical_acc = -this.weight;
+        }
+
+        // jump
+        if (key_jump && this.grounded) {
+            this.vertical_acc = this.jump_force;
+        }
+
+        // apply acceleration, then move — snapping flush against anything in the way
+        this.vertical_vel += this.vertical_acc;
+        if (this.place_meeting(this.x, this.y - this.vertical_vel, _col)) {
+            while (!this.place_meeting(this.x, this.y - sign(this.vertical_vel), _col)) {
+                this.y -= sign(this.vertical_vel);
+            }
+            this.vertical_vel = 0;
+        }
+        this.y -= this.vertical_vel;
+    }
+    static sprite = 'spr_player'
+}