like2d 2.9.0 → 2.10.1

package/dist/math/vector2.js

@@ -1,129 +1,111 @@
-import { mod as mmod } from ".";
-/** Library of Vec2 functions. See {@link Vector2} for overview. */
-export var Vec2;
-(function (Vec2) {
-    function add(a, b) {
-        return [a[0] + b[0], a[1] + b[1]];
-    }
-    Vec2.add = add;
-    function sub(a, b) {
-        return [a[0] - b[0], a[1] - b[1]];
-    }
-    Vec2.sub = sub;
-    function mul(v, other) {
-        if (typeof other === 'number') {
-            return [v[0] * other, v[1] * other];
-        }
-        return [v[0] * other[0], v[1] * other[1]];
-    }
-    Vec2.mul = mul;
-    function div(v, other) {
-        if (typeof other === 'number') {
-            return [v[0] / other, v[1] / other];
-        }
-        return [v[0] / other[0], v[1] / other[1]];
-    }
-    Vec2.div = div;
-    function mod(v, other) {
-        if (typeof other === 'number') {
-            return [mmod(v[0], other), mmod(v[1], other)];
-        }
-        return [mmod(v[0], other[0]), mmod(v[1], other[1])];
-    }
-    Vec2.mod = mod;
-    function eq(v, other) {
-        return v[0] == other[0] && v[1] == other[1];
-    }
-    Vec2.eq = eq;
-    function dot(a, b) {
+import { mod as mmod } from "./index.js";
+/**
+ * According to benchmarks, constructing funcs with these helpers is just as fast as loose coords in v8.
+ * Why not, then?
+ * If you're writing hyper-optimized Vector2 code, just use loose math anyway
+ * -- it will likely logically optimize down further, if you do the algebra.
+ */
+/** @see {@link Vec2.map} */
+function map2x1(op) {
+    return (a) => [op(a[0]), op(a[1])];
+}
+/** @see {@link Vec2.map2} */
+function map2x2(op) {
+    return (a, b) => typeof b == "object" && b instanceof Array
+        ? [op(a[0], b[0]), op(a[1], b[1])]
+        : [op(a[0], b), op(a[1], b)];
+}
+export const Vec2 = {
+    /**
+     * Turn a unary function into a pair-wise unary function.
+     * @param op A function that takes one arg and returns something.
+     * @returns A function that takes a pair such as `[number, number]` (Vector2) and transforms it with `op`.
+     */
+    map: map2x1,
+    /**
+     * Turn a binary function into a pair-wise binary function, for example one that operates on two `Vector2`s.
+     * @param op A function that takes two values and calculates one.
+     * @returns A function that runs `op` pair-wise on both arguments, constructing a new pair.
+     */
+    map2: map2x2,
+    add: map2x2((a, b) => a + b),
+    sub: map2x2((a, b) => a - b),
+    mul: map2x2((a, b) => a * b),
+    div: map2x2((a, b) => a / b),
+    /** Returns the maximum of two coordinates,
+     * i.e. the lower right corner of a bounding box containing them. */
+    max: map2x2(Math.max),
+    /** Returns the minimum of two coordinates,
+     * i.e. the upper left corner of a bounding box containing them. */
+    min: map2x2(Math.min),
+    /** Apply a true modulus (i.e. where -1 % 3 == 2) to a Vector2.
+     *
+     * For JS-style modulus (who wants that?) use `Vec2.map2((a,b) => a % b)` */
+    mod: map2x2(mmod),
+    /** Apply deep (not referential) equality to a pair of Vec2s.
+     * @param epsilon Tolerance factor for inexact matches.
+     */
+    eq(v, other, epsilon) {
+        return epsilon == 0
+            ? v[0] == other[0] && v[1] == other[1]
+            : Vec2.lengthSq(Vec2.sub(v, other)) < epsilon ** 2;
+    },
+    dot(a, b) {
         return a[0] * b[0] + a[1] * b[1];
-    }
-    Vec2.dot = dot;
-    function cross(a, b) {
+    },
+    cross(a, b) {
         return a[0] * b[1] - a[1] * b[0];
-    }
-    Vec2.cross = cross;
-    function lengthSq(v) {
+    },
+    lengthSq(v) {
         return v[0] * v[0] + v[1] * v[1];
-    }
-    Vec2.lengthSq = lengthSq;
-    function length(v) {
-        return Math.sqrt(lengthSq(v));
-    }
-    Vec2.length = length;
-    function normalize(v) {
-        const len = length(v);
+    },
+    length(v) {
+        return Math.sqrt(this.lengthSq(v));
+    },
+    /** Set the length of a Vector2 to 1.0 while preserving its angle. */
+    normalize(v) {
+        const len = this.length(v);
         if (len === 0)
             return [0, 0];
-        return div(v, len);
-    }
-    Vec2.normalize = normalize;
-    function distance(a, b) {
-        return length(sub(a, b));
-    }
-    Vec2.distance = distance;
-    function lerp(a, b, t) {
+        return this.div(v, len);
+    },
+    distance(a, b) {
+        return this.length(this.sub(a, b));
+    },
+    lerp(a, b, t) {
         return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
-    }
-    Vec2.lerp = lerp;
-    function toPolar(v) {
+    },
+    toPolar(v) {
         return {
-            r: Vec2.length(v),
-            angle: Vec2.angle(v),
+            r: this.length(v),
+            angle: this.angle(v),
         };
-    }
-    Vec2.toPolar = toPolar;
-    function fromPolar(r, angle) {
+    },
+    fromPolar(r, angle) {
         return [r * Math.cos(angle), r * Math.sin(angle)];
-    }
-    Vec2.fromPolar = fromPolar;
-    function angle(v) {
+    },
+    angle(v) {
         return Math.atan2(v[1], v[0]);
-    }
-    Vec2.angle = angle;
-    function rotate(v, angle) {
+    },
+    rotate(v, angle) {
         const cos = Math.cos(angle);
         const sin = Math.sin(angle);
         return [v[0] * cos - v[1] * sin, v[0] * sin + v[1] * cos];
-    }
-    Vec2.rotate = rotate;
-    function negate(v) {
-        return [-v[0], -v[1]];
-    }
-    Vec2.negate = negate;
-    function floor(v) {
-        return [Math.floor(v[0]), Math.floor(v[1])];
-    }
-    Vec2.floor = floor;
-    function ceil(v) {
-        return [Math.ceil(v[0]), Math.ceil(v[1])];
-    }
-    Vec2.ceil = ceil;
-    function round(v) {
-        return [Math.round(v[0]), Math.round(v[1])];
-    }
-    Vec2.round = round;
-    function min(a, b) {
-        return [Math.min(a[0], b[0]), Math.min(a[1], b[1])];
-    }
-    Vec2.min = min;
-    function max(a, b) {
-        return [Math.max(a[0], b[0]), Math.max(a[1], b[1])];
-    }
-    Vec2.max = max;
-    function clamp(v, min, max) {
+    },
+    negate: map2x1((a) => -a),
+    floor: map2x1(Math.floor),
+    ceil: map2x1(Math.ceil),
+    round: map2x1(Math.round),
+    clamp(v, min, max) {
         return [
             Math.max(min[0], Math.min(v[0], max[0])),
             Math.max(min[1], Math.min(v[1], max[1])),
         ];
-    }
-    Vec2.clamp = clamp;
-    function fromAngle(angle, len = 1) {
+    },
+    fromAngle(angle, len = 1) {
         return [Math.cos(angle) * len, Math.sin(angle) * len];
-    }
-    Vec2.fromAngle = fromAngle;
-    function zero() {
+    },
+    zero() {
         return [0, 0];
-    }
-    Vec2.zero = zero;
-})(Vec2 || (Vec2 = {}));
+    },
+};

package/dist/prefab-scenes/index.d.ts

@@ -4,4 +4,5 @@
  * A set of built-in scenes to aid with game development.
  */
 export { StartScreen } from "./startScreen";
+export { MapGamepad, buttonSetAll, buttonSetNES, buttonSetPS1, buttonSetSNES } from "./mapGamepad";
 //# sourceMappingURL=index.d.ts.map

package/dist/prefab-scenes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prefab-scenes/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prefab-scenes/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/prefab-scenes/index.js

@@ -4,3 +4,4 @@
  * A set of built-in scenes to aid with game development.
  */
 export { StartScreen } from "./startScreen";
+export { MapGamepad, buttonSetAll, buttonSetNES, buttonSetPS1, buttonSetSNES } from "./mapGamepad";

package/dist/prefab-scenes/mapGamepad.d.ts

@@ -0,0 +1,30 @@
+import type { Like } from "..";
+import { type LikeButton } from "../input";
+import { Scene } from "../scene";
+export declare const buttonSetNES: Set<LikeButton>;
+export declare const buttonSetGBA: Set<LikeButton>;
+export declare const buttonSetSNES: Set<LikeButton>;
+export declare const buttonSetPS1: Set<LikeButton>;
+export declare const buttonSetAll: Set<LikeButton>;
+export type MapMode = {
+    buttons: Set<LikeButton>;
+    stickCount: number;
+};
+export declare class MapGamepad implements Scene {
+    private mapMode;
+    private targetPad;
+    private next?;
+    private currentlyUnmapped;
+    private mapping;
+    private held?;
+    private alreadyMapped;
+    private frameWait;
+    constructor(mapMode: MapMode, targetPad: number, next?: Scene | undefined);
+    load(like: Like): void;
+    update(): void;
+    draw(like: Like): void;
+    gamepadpressed(like: Like, source: number, _name: LikeButton, num: number): void;
+    gamepadreleased(_like: Like, source: number, _name: LikeButton, num: number): void;
+    mousepressed(like: Like): void;
+}
+//# sourceMappingURL=mapGamepad.d.ts.map

package/dist/prefab-scenes/mapGamepad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapGamepad.d.ts","sourceRoot":"","sources":["../../src/prefab-scenes/mapGamepad.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,EAAE,KAAK,UAAU,EAAkC,MAAM,UAAU,CAAC;AAE3E,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAyBjC,eAAO,MAAM,YAAY,iBAA4C,CAAC;AACtE,eAAO,MAAM,YAAY,iBAA6C,CAAC;AACvE,eAAO,MAAM,aAAa,iBAA6C,CAAC;AACxE,eAAO,MAAM,YAAY,iBAA6C,CAAC;AACvE,eAAO,MAAM,YAAY,iBAAgC,CAAC;AA6D1D,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,qBAAa,UAAW,YAAW,KAAK;IAQpC,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,IAAI,CAAC;IATf,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,IAAI,CAAC,CAAa;IAC1B,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,SAAS,CAAK;gBAGZ,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,KAAK,YAAA;IAGtB,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IActB,MAAM,IAAI,IAAI;IAId,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAqCtB,cAAc,CACZ,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,MAAM,GACV,IAAI;IAaP,eAAe,CACb,KAAK,EAAE,IAAI,EACX,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,MAAM,GACV,IAAI;IAOP,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;CAG/B"}

package/dist/prefab-scenes/mapGamepad.js

@@ -0,0 +1,192 @@
+import { defaultMapping } from "../input";
+const mapOrder = [
+    "BRight",
+    "BBottom",
+    "Up",
+    "Down",
+    "Left",
+    "Right",
+    "MenuLeft",
+    "MenuRight",
+    // 8: NES buttons
+    "L1",
+    "R1",
+    // 10: GBA buttons
+    "BLeft",
+    "BTop",
+    // 12: SNES buttons
+    "L2",
+    "R2",
+    // 14: PS1 buttons
+    "LeftStick",
+    "RightStick",
+];
+export const buttonSetNES = new Set(mapOrder.slice(0, 8));
+export const buttonSetGBA = new Set(mapOrder.slice(0, 10));
+export const buttonSetSNES = new Set(mapOrder.slice(0, 12));
+export const buttonSetPS1 = new Set(mapOrder.slice(0, 14));
+export const buttonSetAll = new Set(mapOrder);
+const drawCircButt = (pos, size) => (like, color) => like.gfx.circle("fill", color, pos, size);
+const drawDpadPart = (rot) => (like, color) => {
+    like.gfx.push();
+    like.gfx.translate([2.5, 6]);
+    like.gfx.rotate(rot);
+    like.gfx.rectangle("fill", color, [0.5, -0.5, 1.3, 1]);
+    like.gfx.pop();
+};
+const drawShoulder = (y, width, flip) => (like, color) => {
+    const r = 0.8;
+    const rectPos = [5 - width, y];
+    const circPos = [5 - width - r, y];
+    like.gfx.push();
+    if (flip) {
+        like.gfx.translate([16, 0]);
+        like.gfx.scale([-1, 1]);
+    }
+    like.gfx.circle("fill", color, circPos, r, { arc: [Math.PI, Math.PI * 3 / 2], center: false });
+    like.gfx.rectangle("fill", color, [...rectPos, width, r]);
+    like.gfx.pop();
+};
+// Buttons assume a centered resolution of 16x9px. Transforms exist for a reason lol.
+//      LLLLL           .             RRRRR
+//     LLLLLLLLL        .          RRRRRRRRR
+//                      .                  
+//       DDD         S  .  S              B
+// -.....DDD.....................................
+//    DDD   DDD         .           B        B
+//       DDD      LS    .    RS
+//       DDD            .              B 
+//                      .   
+const buttonProps = {
+    BLeft: { draw: drawCircButt([12, 6], 0.8) },
+    BRight: { draw: drawCircButt([15, 6], 0.8) },
+    BTop: { draw: drawCircButt([13.5, 4.5], 0.8) },
+    BBottom: { draw: drawCircButt([13.5, 7.5], 0.8) },
+    MenuLeft: { draw: drawCircButt([6, 4], 0.5) },
+    MenuRight: { draw: drawCircButt([10, 4], 0.5) },
+    LeftStick: { draw: drawCircButt([6.5, 7], 1.4) },
+    RightStick: { draw: drawCircButt([9.5, 7], 1.4) },
+    L1: { draw: drawShoulder(2, 3, false) },
+    L2: { draw: drawShoulder(1, 2, false) },
+    R1: { draw: drawShoulder(2, 3, true) },
+    R2: { draw: drawShoulder(1, 2, true) },
+    Right: { draw: drawDpadPart(0) },
+    Up: { draw: drawDpadPart(-Math.PI / 2) },
+    Left: { draw: drawDpadPart(Math.PI) },
+    Down: { draw: drawDpadPart(Math.PI / 2) },
+};
+export class MapGamepad {
+    constructor(mapMode, targetPad, next) {
+        Object.defineProperty(this, "mapMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: mapMode
+        });
+        Object.defineProperty(this, "targetPad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: targetPad
+        });
+        Object.defineProperty(this, "next", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: next
+        });
+        Object.defineProperty(this, "currentlyUnmapped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "mapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "held", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "alreadyMapped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "frameWait", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    load(like) {
+        this.frameWait = 10;
+        this.mapping = like.gamepad.getMapping(this.targetPad) ?? defaultMapping(2);
+        const alreadyMapped = new Set(Object.values(this.mapping.buttons));
+        for (const btn of mapOrder.reverse()) {
+            if (this.mapMode.buttons.has(btn) && !alreadyMapped.has(btn)) {
+                this.currentlyUnmapped.push(btn);
+            }
+        }
+        like.canvas.setMode([320, 240]);
+    }
+    update() {
+        this.frameWait--;
+    }
+    draw(like) {
+        const centerText = {
+            font: "1px sans-serif",
+            align: "center",
+            width: 16,
+        };
+        const active = this.currentlyUnmapped.at(-1);
+        like.gfx.clear();
+        like.gfx.scale(20);
+        like.gfx.translate([0, 1]);
+        like.gfx.print("white", `Map gamepad ${this.targetPad}`, [8, 0.0], centerText);
+        for (const prop of this.mapMode.buttons.keys()) {
+            const color = this.held == prop
+                ? "green"
+                : active == prop
+                    ? "red"
+                    : this.mapMode.buttons.has(prop)
+                        ? "gray"
+                        : "black";
+            buttonProps[prop].draw(like, color);
+        }
+        like.gfx.print("white", active
+            ? `Press ${like.gamepad.fullButtonName(active)}!`
+            : "Press any button to resume.", [2, 10], { font: "1px sans-serif" });
+    }
+    gamepadpressed(like, source, _name, num) {
+        if (source !== this.targetPad || this.held || this.frameWait > 0)
+            return;
+        const active = this.currentlyUnmapped.pop();
+        if (active && !this.alreadyMapped.has(num)) {
+            this.alreadyMapped.add(num);
+            this.mapping.buttons[num] = active;
+            this.held = active;
+        }
+        else if (!active) {
+            like.gamepad.setMapping(this.targetPad, this.mapping);
+            setTimeout(() => like.setScene(this.next), 100);
+        }
+    }
+    gamepadreleased(_like, source, _name, num) {
+        if (source !== this.targetPad)
+            return;
+        if (this.held == this.mapping.buttons[num]) {
+            this.held = undefined;
+        }
+    }
+    mousepressed(like) {
+        like.setScene(this.next);
+    }
+}

package/dist/prefab-scenes/startScreen.d.ts

@@ -31,8 +31,8 @@ import { Like } from '..';
  *
  * ```ts
  * import { type Scene } from 'like/scene';
- * import type { ImageHandle } from 'like/core/graphics';
- * import { Vec2 } from 'like/math/vector2';
+ * import type { ImageHandle } from 'like/graphics';
+ * import { Vec2 } from 'like/math';
  * import { Like } from 'like';
  * ```
  *

package/dist/prefab-scenes/startScreen.js

@@ -31,8 +31,8 @@ const LOGO = 'data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0i
  *
  * ```ts
  * import { type Scene } from 'like/scene';
- * import type { ImageHandle } from 'like/core/graphics';
- * import { Vec2 } from 'like/math/vector2';
+ * import type { ImageHandle } from 'like/graphics';
+ * import { Vec2 } from 'like/math';
  * import { Like } from 'like';
  * ```
  *

package/dist/scene.d.ts

@@ -3,8 +3,8 @@
  * @description A helpful callback / state management layer, plus utility scenes.
  *
  */
-import type { LikeEvent, EventMap } from './core/events';
-import type { Like } from './core/like';
+import type { LikeEvent, EventMap } from './events';
+import type { Like } from './like';
 /**
  * An interface for creating scenes.
  *

package/dist/scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAEH,MAAM,MAAM,KAAK,GAAG;KACjB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI;CACnE,GAAG;IACF,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CAClD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAI3E,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAMvE,CAAA"}
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAEH,MAAM,MAAM,KAAK,GAAG;KACjB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI;CACnE,GAAG;IACF,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CAClD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAI3E,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAMvE,CAAA"}

package/dist/timer/index.d.ts

@@ -0,0 +1,2 @@
+export { type Timer } from "./timer";
+//# sourceMappingURL=index.d.ts.map

package/dist/timer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/timer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC"}

package/dist/timer/index.js

@@ -0,0 +1 @@
+export {};

package/dist/timer/timer.d.ts

@@ -0,0 +1,32 @@
+import { EngineProps } from "../engine";
+export declare class Timer {
+    private currentDelta;
+    private totalTime;
+    private frameCount;
+    private fps;
+    private fpsAccumulator;
+    private sleepUntil;
+    constructor(props: EngineProps<never>);
+    private update;
+    /** Get `dt` (from the update loop) anywhere.
+     * AKA the time since the last frame.
+     */
+    getDelta(): number;
+    /** Get an estimated FPS based on one-second average. */
+    getFPS(): number;
+    /** Get the ingame time. */
+    getTime(): number;
+    /**
+     * Whether or not the game is (supposed to be) frozen.
+     * The only callback while sleeping is `draw`, and
+     * calling this outside of `draw` will always return
+     * false -- except if you have a custom runtime.
+     */
+    isSleeping(): boolean;
+    /**
+     * Freeze the whole game for a time. Audio will keep playing,
+     * but update functions won't be called and events won't fire.
+     */
+    sleep(duration: number): void;
+}
+//# sourceMappingURL=timer.d.ts.map

package/dist/timer/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/timer/timer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,qBAAa,KAAK;IAChB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,UAAU,CAAuB;gBAE7B,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC;IAIrC,OAAO,CAAC,MAAM;IAcd;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB,wDAAwD;IACxD,MAAM,IAAI,MAAM;IAIhB,2BAA2B;IAC3B,OAAO,IAAI,MAAM;IAIjB;;;;;OAKG;IACH,UAAU,IAAI,OAAO;IAUrB;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAG9B"}

package/dist/{core → timer}/timer.js

@@ -1,5 +1,5 @@
-export class TimerInternal {
-    constructor() {
+export class Timer {
+    constructor(props) {
         Object.defineProperty(this, "currentDelta", {
             enumerable: true,
             configurable: true,
@@ -36,8 +36,10 @@ export class TimerInternal {
             writable: true,
             value: null
         });
+        props.canvas.addEventListener("like:update", this.update.bind(this), { signal: props.abort });
     }
-    _update(dt) {
+    update(ev) {
+        const { dt } = ev.detail;
         this.currentDelta = dt;
         this.totalTime += dt;
         this.frameCount++;
@@ -48,15 +50,26 @@ export class TimerInternal {
             this.fpsAccumulator = 0;
         }
     }
+    /** Get `dt` (from the update loop) anywhere.
+     * AKA the time since the last frame.
+     */
     getDelta() {
         return this.currentDelta;
     }
+    /** Get an estimated FPS based on one-second average. */
     getFPS() {
         return this.fps;
     }
+    /** Get the ingame time. */
     getTime() {
         return this.totalTime;
     }
+    /**
+     * Whether or not the game is (supposed to be) frozen.
+     * The only callback while sleeping is `draw`, and
+     * calling this outside of `draw` will always return
+     * false -- except if you have a custom runtime.
+     */
     isSleeping() {
         if (this.sleepUntil === null)
             return false;
@@ -67,6 +80,10 @@ export class TimerInternal {
         this.sleepUntil = null;
         return false;
     }
+    /**
+     * Freeze the whole game for a time. Audio will keep playing,
+     * but update functions won't be called and events won't fire.
+     */
     sleep(duration) {
         this.sleepUntil = performance.now() + (duration * 1000);
     }