@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/GameKit/web/lamp-phaser.js

@@ -0,0 +1,128 @@
+// Lamp's game runtime for a 2D game drawn with Phaser. Lamp writes this file before every build; don't edit it.
+//
+// A 2D game is Phaser scenes run by Lamp's runtime (lamp-game.js), which stays the one frame loop: Phaser's own loop is
+// put to sleep once it has started, and each of the runtime's frames steps Phaser once, with the runtime's time. So the
+// game is played at 1920x1080 scaled to the screen wherever it goes, as a three.js game is. Everything the player plays with comes from the
+// runtime, not from Phaser: the controllers, the keyboard and the touch controls are one pad, `pad()` here, read in a
+// scene's update; sound is lamp-game.js's `sound` (Phaser's own is off); saves are `save()` and `load()`. Phaser's
+// keyboard and gamepad input are off, so a key is never heard twice; its pointer input (clicks on the Mac) is on.
+//
+//   import * as Phaser from 'phaser';
+//   import { phaser, pad } from './lamp-phaser.js';
+//   import { BUTTON, STICK, sound, save, load, random, log, label, glyph, onInput } from './lamp-game.js';
+//   class Play extends Phaser.Scene {
+//       constructor() { super('play'); }
+//       preload() { this.load.image('hero', 'art/hero.png'); }
+//       create() { this.hero = this.physics.add.sprite(200, 800, 'hero'); }
+//       update(time, delta) { this.hero.setVelocityX(pad().lx * 600); }
+//   }
+//   phaser({ scenes: [Play], physics: { default: 'arcade', arcade: { gravity: { y: 2000 } } } });
+
+import * as Phaser from 'phaser';
+import { game, WIDTH, HEIGHT, random, log } from './lamp-game.js';
+
+const still = { connected: false, lx: 0, ly: 0, rx: 0, ry: 0, lt: 0, rt: 0, down: 0, pressed: 0, released: 0 };
+
+// The frame the runtime is stepping now: dt and time in seconds, number, and the pads.
+let current = null;
+
+// A controller as this frame reads it, pads[0] the first (the keyboard and the touch controls are part of it): lx, ly,
+// rx, ry -1 to 1 with up positive, lt and rt 0 to 1, buttons as BUTTON bits in down, pressed and released. Read it in a
+// scene's update; pressed and released hold for the one frame a button went down or up.
+export function pad(index = 0) {
+    return (current && current.pads[index]) || still;
+}
+
+// This frame as the runtime gives it ({ dt, time, number, pads, phones }), for what wants seconds rather than Phaser's ms.
+export function frame() { return current; }
+
+// The Phaser.Game, once phaser() has started it.
+export let phaserGame = null;
+
+// A scene not yet started stays at INIT, so only these are on their way to running. A scene started from another's
+// create (Boot's `this.scene.start('play')`) is first only an operation in the scene manager's queue, with no status
+// of its own: it's on its way too, so that the game's first scenes are all made before the game is said to have
+// started (and read pendingRestore() while it still gives the snapshot).
+const STARTING = new Set([Phaser.Scenes.START, Phaser.Scenes.LOADING, Phaser.Scenes.CREATING]);
+const queued = m => (m._queue && m._queue.length > 0) || (m._pending && m._pending.length > 0);
+const starting = g => !g.isRunning || !g.scene.isBooted || queued(g.scene) || g.scene.scenes.some(s => STARTING.has(s.sys.settings.status));
+
+// Waits, without stepping the game, until no scene is loading or being made: the loader's files arrive on their own,
+// and the scene manager's queue (a scene started from another's create) is taken in as the game's step would.
+async function settled(g) {
+    const began = performance.now();
+    let waited = 0;
+    while (starting(g)) {
+        await new Promise(done => setTimeout(done, 5));
+        if (g.scene.isBooted) {
+            g.scene.processQueue();
+            for (const s of g.scene.scenes) if (s.sys.settings.status === Phaser.Scenes.LOADING) s.sys.load.update();
+        }
+        if (++waited > 6000 || performance.now() - began > 30000) { log('Lamp: a scene was still loading after 30 s; playing on.'); return; }
+    }
+}
+
+// Starts the game: `scenes` its Phaser.Scene classes, the first one started; `pixelArt` true for pixel art (sharp pixels,
+// no smoothing, positions rounded); `physics` Phaser's physics config (Arcade for most games); `background` the color
+// behind everything; `touch`, `keyboard` and `keyboardHints` as game() in lamp-game.js takes them (the touch buttons a
+// phone shows, or false for a game that draws its own; keyboard: false for a game that reads keys itself;
+// keyboardHints: { leftStick: 'arrows' } for a game whose prompts name the arrow keys). `config` is anything more of
+// Phaser's game config (`render`, `fps`…), never its size, scale, input, audio or loop, which are Lamp's. `snapshot`,
+// `restore`, `busy`, `assetChanged` and `dispose` keep the player's place through a change, as game() takes them; when
+// the game's code runs again for a change, this Phaser.Game goes and the new code's starts. The scenes are
+// made during game()'s init, so the state a game registered (`hot(import.meta).state`) is back by the first scene's init
+// or create, as is what pendingRestore() from lamp-game.js gives, and a game goes straight to where the player was
+// without showing its title.
+export async function phaser({ scenes, pixelArt = false, physics, background = '#000000', touch, keyboard, keyboardHints, config = {},
+                               snapshot, restore, busy, assetChanged, dispose }) {
+    // What lamp-game.js fits to the screen at 1920x1080's shape: Phaser fits its canvas inside it (Phaser's FIT, so a
+    // click is read where it lands however big the window is).
+    const stage = document.createElement('div');
+    const renderer = {
+        domElement: stage,
+        // Phaser draws its canvas at the game's own size; lamp-game.js's smaller drawing when frames are slow is a
+        // three.js renderer's, so a Phaser game is always `sharp` (the log still says how fast frames come).
+        setPixelRatio() {}, setSize() {},
+    };
+    let g = null;
+    return game({
+        renderer, touch, keyboard, keyboardHints, sharp: true, flat: true, snapshot, restore, busy, assetChanged,
+        async dispose() {
+            if (dispose) await dispose();
+            // Phaser takes a game away at its next step, which a sleeping loop never takes: it goes now.
+            if (g) { g.destroy(true); g.runDestroy(); g = null; }
+        },
+        async init() {
+            g = phaserGame = new Phaser.Game(Object.assign({}, config, {
+                type: config.type ?? Phaser.AUTO, parent: stage, width: WIDTH, height: HEIGHT,
+                scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.NO_CENTER, expandParent: false },
+                backgroundColor: background, pixelArt, physics, scene: scenes,
+                input: { keyboard: false, gamepad: false, mouse: true, touch: true },
+                audio: { noAudio: true }, banner: false, disableContextMenu: true, canvasStyle: 'display:block',
+                // Phaser's own random numbers (Phaser.Math.RND) start from the runtime's.
+                seed: [String(random())],
+            }));
+            await new Promise(done => g.isRunning ? done() : g.events.once(Phaser.Core.Events.READY, () => setTimeout(done, 0)));
+            // One loop: the runtime's, so the game is stepped with the runtime's time.
+            g.loop.sleep();
+            log(`Lamp: Phaser ${Phaser.VERSION}, drawn with ${g.renderer && g.renderer.type === Phaser.WEBGL ? 'WebGL' : 'a 2D canvas'}.`);
+            await settled(g);
+        },
+        frame(f) {
+            current = f;
+            const ms = f.time * 1000, delta = f.dt * 1000;
+            g.loop.now = g.loop.time = ms;
+            g.loop.delta = g.loop.rawDelta = delta;
+            g.loop.frame = f.number;
+            // Phaser keeps each scene's update as the scene was made (Systems' sceneUpdate): a scene's class swapped while
+            // the game runs (lamp-game.js, "Changes while it's played") has a new one, which runs from this frame. Only a
+            // running scene's: while one loads, Phaser holds its update back until create() has run.
+            for (const scene of g.scene.scenes) {
+                if (scene.sys.settings.status === Phaser.Scenes.RUNNING && typeof scene.update === 'function'
+                    && scene.sys.sceneUpdate !== scene.update) scene.sys.sceneUpdate = scene.update;
+            }
+            // A scene that starts loading mid-play loads while the game goes on.
+            g.step(ms, delta);
+        },
+    });
+}

package/Resources/WebHost/WebView2-LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (C) Microsoft Corporation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * The name of Microsoft Corporation, or the names of its contributors 
+may not be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.