like2d 2.12.0 → 2.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "like2d",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "A web-native game framework inspired by Love2D",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,10 +15,6 @@
       "import": "./dist/math/index.js",
       "types": "./dist/math/index.d.ts"
     },
-    "./prefab-scenes": {
-      "import": "./dist/prefab-scenes/index.js",
-      "types": "./dist/prefab-scenes/index.d.ts"
-    },
     "./graphics": {
       "types": "./dist/graphics/index.d.ts"
     },
@@ -33,6 +29,14 @@
     "./timer": {
       "import": "./dist/timer/index.js",
       "types": "./dist/timer/index.d.ts"
+    },
+    "./scene": {
+      "import": "./dist/scene/index.js",
+      "types": "./dist/scene/index.d.ts"
+    },
+    "./scene/prefab/*": {
+      "import": "./dist/scene/prefab/*.js",
+      "types": "./dist/scene/prefab/*.d.ts"
     }
   },
   "files": [
@@ -61,9 +65,10 @@
   ],
   "author": "",
   "license": "MIT",
+  "homepage": "https://likeorg.github.io/Like2D/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/44100hertz/Like2D"
+    "url": "https://github.com/likeOrg/Like2D"
   },
   "devDependencies": {
     "typescript": "^5.9.3"

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

@@ -1,10 +0,0 @@
-/**
- * A set of built-in scenes to aid with game development.
- *
- * To learn more about scenes, see {@link index.Scene}.
- *
- * @module prefab-scenes
- */
-export { StartScreen } from "./startScreen";
-export { MapGamepad, buttonSetAll, buttonSetNES, buttonSetPS1, buttonSetSNES, type MapMode } from "./mapGamepad";
-//# sourceMappingURL=index.d.ts.map

package/dist/prefab-scenes/index.js

@@ -1,9 +0,0 @@
-/**
- * A set of built-in scenes to aid with game development.
- *
- * To learn more about scenes, see {@link index.Scene}.
- *
- * @module prefab-scenes
- */
-export { StartScreen } from "./startScreen";
-export { MapGamepad, buttonSetAll, buttonSetNES, buttonSetPS1, buttonSetSNES } from "./mapGamepad";

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

@@ -1,42 +0,0 @@
-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;
-};
-/**
- * An automagical gamepad mapper.
- *
- * ```ts
- * like.gamepadconnected = (index) =>
- *   like.pushScene(new MapGamepad({buttons: buttonSetGBA, sticks: 0}), index)
- * ```
- *
- * Add this to your codebase and activating a gamepad causes a button mapping screen to pop up.
- * It will request to map any buttons not already covered by the automapping database.
- *
- * Note: many browsers do this on first button press, so always writing "P2: press any button" is a fine idea.
- */
-export declare class MapGamepad implements Scene {
-    private mapMode;
-    private targetPad;
-    private currentlyUnmapped;
-    private mapping;
-    private held?;
-    private alreadyMapped;
-    private frameWait;
-    constructor(mapMode: MapMode, targetPad: number);
-    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.js

@@ -1,199 +0,0 @@
-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.withTransform(() => {
-        like.gfx.translate([2.5, 6]);
-        like.gfx.rotate(rot);
-        like.gfx.rectangle("fill", color, [0.5, -0.5, 1.3, 1]);
-    });
-};
-const drawShoulder = (y, width, flip) => (like, color) => {
-    const r = 0.8;
-    const rectPos = [5 - width, y];
-    const circPos = [5 - width - r, y];
-    like.gfx.withTransform(() => {
-        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]);
-    });
-};
-// 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) },
-};
-/**
- * An automagical gamepad mapper.
- *
- * ```ts
- * like.gamepadconnected = (index) =>
- *   like.pushScene(new MapGamepad({buttons: buttonSetGBA, sticks: 0}), index)
- * ```
- *
- * Add this to your codebase and activating a gamepad causes a button mapping screen to pop up.
- * It will request to map any buttons not already covered by the automapping database.
- *
- * Note: many browsers do this on first button press, so always writing "P2: press any button" is a fine idea.
- */
-export class MapGamepad {
-    constructor(mapMode, targetPad) {
-        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, "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.popScene(), 100);
-        }
-    }
-    gamepadreleased(_like, source, _name, num) {
-        if (source !== this.targetPad)
-            return;
-        if (this.held == this.mapping.buttons[num]) {
-            this.held = undefined;
-        }
-    }
-    mousepressed(like) {
-        like.popScene();
-    }
-}

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

@@ -1,58 +0,0 @@
-import { type Scene } from '../scene';
-import { Like } from '..';
-/**
- * ## Why
- *
- *  1. Because the LIKE logo looks awesome.
- *  2. Autoplay restriction, doesn't let you play audio until the page is clicked.
- *  3. You have to click on the game in order to send inputs, anyway.
- *  4. It's polite.
- *
- * ## Usage
- *
- * ```typescript
- * import { createLike, StartScreen } from 'like';
- * import { GameScene } from './game';
- *
- * const container = document.getElementById("myGame");
- * const like = createLike(container);
- *
- * // these callbacks will be ignored until the scene is clicked
- * like.update = function () { ... }
- * like.draw = function () { ... }
- *
- * // Set up the start screen
- * like.pushScene(new StartScreen())
- * like.start();
- * ```
- *
- * Alternatively, copy-paste this code into your own project and modify it freely.
- * Update imports:
- *
- * ```ts
- * import { type Scene } from 'like/scene';
- * import type { ImageHandle } from 'like/graphics';
- * import { Vec2 } from 'like/math';
- * import { Like } from 'like';
- * ```
- *
- * ## Custom Rendering
- *
- * Pass a custom draw function to replace the default logo:
- *
- * ```typescript
- * const startup = new StartupScene(gameScene, (like) => {
- *   like.gfx.clear([0, 0, 0, 1]);
- *   like.gfx.print([1, 1, 1], 'Click to Start', [100, 100]);
- * });
- * ```
- */
-export declare class StartScreen implements Scene {
-    private onDraw?;
-    private logo;
-    constructor(onDraw?: ((like: Like) => void) | undefined);
-    load(like: Like): void;
-    draw(like: Like): void;
-    mousepressed(like: Like): void;
-}
-//# sourceMappingURL=startScreen.d.ts.map

package/dist/scene.d.ts

@@ -1,143 +0,0 @@
-import type { LikeEvent, EventMap } from './events';
-import type { Like } from './like';
-/**
- * An interface for creating scenes.
- *
- * ## Why Scenes?
- *
- * For any game with more than one scene, we have to either:
- *  - switch-case on game state in every single callback
- *  - rebind all of the callbacks ourselves
- *  - wrap handleEvent (hint: that's what this does)
- *
- * Also, no need to pass around a `like` object.
- * Here, `like` instead piggybacks on a closure that follows around
- * your running scene and shows up as an additional first argument
- * to every callback.
- *
- * ## The scene stack
- *
- * There is a stack of scenes for state management and/or overlays.
- *
- * Use {@link Like.pushScene} and {@link Like.popScene} to manage the stack.
- *
- * {@link like.setScene} Sets the top of the stack only, replacing the current scene if any.
- *
- * ## Quick Start
- *
- * Have a scene handle all the callbacks, disabling global
- * callbacks.
- * ```typescript
- * // set up a scene
- * class MagicalGrowingRectangle implements Scene {
- *   rectangleSize = 10;
- *   constructor() {}
- *
- *   keypressed(_like: Like) {
- *     this.rectangleSize += 10;
- *   }
- *
- *   draw(like: Like) {
- *     like.gfx.rectangle('fill', 'green',
- *       [10, 10, this.rectangleSize, this.rectangleSize])
- *   }
- * }
- *
- * like.pushScene(new MagicalGrowingRectangle(), false);
- * ```
- *
- * To get back to global callbacks, just use {@link Like.popScene}
- *
- * ## Scene Lifecycle
- *
- * Works a lot like global callbacks.
- *
- * 1. `like.setScene(scene)` or `like.pushScene(scene)` is called
- * 2. Scene's `load` callback fires immediately
- * 3. `update` and `draw` begin on next frame
- * 4. Scene receives input events as they occur
- *
- * ## Composing scenes
- *
- * Thought you'd never ask.
- * Just like the `like` object, scenes have handleEvent on them.
- * So, you could layer them like this, for example:
- *
- * ```typescript
- * class UI implements Scene {
- *   constructor(public game: Scene) {}
- *
- *   handleEvent(like: Like, event: LikeEvent) {
- *     // Block mouse events in order to create a top bar.
- *     const mouseY = like.mouse.getPosition()[1];
- *     if (!event.type.startsWith('mouse') || mouseY > 100) {
- *       sceneDispatch(this.game, like, event);
- *     }
- *
- *     // Then, call my own callbacks.
- *     // By calling it here, the UI draws on top.
- *     callSceneHandlers(this, like, event);
- *   }
- *   ...
- * }
- *
- * class Game implements Scene {
- *   ...
- * }
- *
- * like.pushScene(new UI(new Game()), false)
- * ```
- *
- * Composing scenes lets you filter events, layer game elements,
- * and more. Don't sleep on it.
- *
- * The main advance of composing scenes versus the stack-overlay
- * technique is that the parent scene knows about its child.
- * Because there's a **known interface**, the two scenes
- * can communicate.
- *
- * This makes it perfect for reusable UI,
- * level editors, debug viewers, and more.
- *
- * ## Overlay scenes
- *
- * You might assume that the purpose of a scene stack is
- * visual: first push the BG, then the FG, etc.
- *
- * Actually, composing scenes (above) is a
- * better pattern for that, since it's both explicit
- * _and_ the parent can have a known interface on its child.
- * Here, the **upper** scene only knows that the
- * **lower** scene _is_ a scene.
- *
- * That's the tradeoff. Overlay scenes are good for things
- * like pause screens or gamepad overlays. Anything where
- * the upper doesn't care _what_ the lower is, and where
- * the upper scene should be easily addable/removable.
- *
- * Using `like.getScene(-2)`, the overlay scene can see
- * the lower scene and choose how to propagate events.
- *
- * The only technical difference between overlay and
- * opaque is whether or not the scene we've pushed
- * on top of stays loaded.
- *
- */
-export type Scene = {
-    [K in keyof EventMap]?: (like: Like, ...args: EventMap[K]) => void;
-} & {
-    handleEvent?(like: Like, event: LikeEvent): void;
-};
-/**
- * Used to call a scene's own handlers like `update` or `draw`,
- * typically at the end of handleEvent
- * after modifying the event stream or composing sub-scenes.
- */
-export declare const callSceneHandlers: (scene: Scene, like: Like, event: LikeEvent) => void;
-/**
- * Used to call sub scenes while respecting potential `handleEvent` within them.
- * The main scene is similar to a sub-scene of the root (like) object in this
- * regard.
- */
-export declare const sceneDispatch: (scene: Scene, like: Like, event: LikeEvent) => void;
-//# sourceMappingURL=scene.d.ts.map

package/dist/scene.js

@@ -1,23 +0,0 @@
-/**
- * Used to call a scene's own handlers like `update` or `draw`,
- * typically at the end of handleEvent
- * after modifying the event stream or composing sub-scenes.
- */
-export const callSceneHandlers = (scene, like, event) => {
-    if (event.type in scene) {
-        scene[event.type](like, ...event.args);
-    }
-};
-/**
- * Used to call sub scenes while respecting potential `handleEvent` within them.
- * The main scene is similar to a sub-scene of the root (like) object in this
- * regard.
- */
-export const sceneDispatch = (scene, like, event) => {
-    if (scene.handleEvent) {
-        scene.handleEvent(like, event);
-    }
-    else {
-        callSceneHandlers(scene, like, event);
-    }
-};