littlejsengine 1.24.2 → 1.25.0

package/plugins/render3dLevel.js

@@ -15,6 +15,16 @@
 
 const LEVEL3D_VERSION = 1; // the format a level's littlejs3D names
 
+/** A 3D level as it is saved, what level3DLoad takes and the 3D level editor edits
+ *  @typedef {Object} Level3D
+ *  @property {number} [littlejs3D] - The format's version, 1
+ *  @property {Array<Object>} objects - Each {id, type, pos, rotation, scale, properties}, all but type optional
+ *  @property {Object} [scene] - The scene block: sky, ambient, sunDirection, sunColor, fog, fogColor, shadows, lensFlare
+ *  @property {Object} [voxels] - A block map: {pos, size, blocks}
+ *  @property {Object} [terrain] - A height map: {pos, size, height, color, heights, paint}
+ *  @property {Object} [prefabs] - The level's own prefabs by name, each {objects, attached}
+ *  @memberof Level3D */
+
 // the types a level's objects are made from, by name
 const level3DTypes = new Map;
 
@@ -33,7 +43,7 @@ const level3DBaseScale = new WeakMap;
  *  - Adding a name again replaces it, Box, Sphere, Cylinder and Light too
  *  @param {string} name - The type the objects have in the level
  *  @param {Function} make - A class made at each object's position, or a function called with it
- *  @param {Object} [defaults] - Properties of each one made, the level editor shows inputs for them
+ *  @param {Object<string, any>} [defaults] - Properties of each one made, the level editor shows inputs for them
  *  @param {TileInfo} [tileInfo] - An icon for the level editor
  *  @memberof Level3D
  *  @example
@@ -87,7 +97,7 @@ function level3DAddMesh(name, mesh, tileInfo, color=WHITE)
  *    sunColor, fog, its start and end, fogColor, the horizon color when not given, shadows, and lensFlare, the
  *    sun's lens flare; what the block leaves out stays as the game set it, and a level with no block changes
  *    nothing
- *  @param {Object} level - The level, the level editor edits this same object
+ *  @param {Level3D} level - The level, the level editor edits this same object
  *  @return {Array<any>} - What each object's type made, a function that made nothing is left out
  *  @memberof Level3D */
 function level3DLoad(level)
@@ -420,7 +430,7 @@ function level3DMakeAt(object, pos, rotation, scale)
  *  @param {Vector3} [pos3D]
  *  @param {Vector3} [rotation3D] - In radians, as an object has it
  *  @param {Vector3} [scale3D] - Times the scale the type makes it with
- *  @param {Object} [properties] - Over the type's defaults
+ *  @param {Object<string, any>} [properties] - Over the type's defaults
  *  @return {any} - What the type made, a Prefab3D for a prefab, undefined when there is no such type
  *  @memberof Level3D
  *  @example
@@ -459,7 +469,8 @@ const level3DPrefabMaking = [];
  *    by hand does
  *  - Adding a name again replaces it
  *  @param {string} name - The type its instances have in a level
- *  @param {Object} prefab - {objects, attached}
+ *  @param {{objects: Array<Object>, attached?: boolean}} prefab - Its objects, about its own origin, and whether
+ *    they are attached
  *  @memberof Level3D
  *  @example
  *  level3DAddPrefab('Tower', {objects: [{type: 'Box', pos: [0, 1, 0], scale: [2, 2, 2]},

package/plugins/textureSheet.js

@@ -37,6 +37,8 @@ let textureSheetPendingCount = 0;
 const textureSheetLoaded = new Map;
 // a load's key: what it was given, a vector by its numbers
 const textureSheetLoadKey = (...parts)=> parts.map((p)=> isVector2(p) ? p.x + ',' + p.y : String(p)).join('|');
+// a load whose file failed is forgotten, so loading it again tries again, as when the server comes back
+const textureSheetLoadFailed = (key, loaded)=> textureSheetLoaded.get(key) === loaded && textureSheetLoaded.delete(key);
 
 /**
  * Texture Sheet - A texture that images are packed into as they load
@@ -193,7 +195,8 @@ class TextureSheet
  *  - Pass frameSize for animations, then step through them with TileInfo.frame
  *  - Grid images keep their layout and frames wrap down to the next row
  *  - Pass sourcePadding if the source image has padding baked in around frames
- *  - The same image loaded again with the same settings gives back what the first load did, packed once
+ *  - The same image loaded again with the same settings gives back what the first load did, packed once, unless
+ *    that load failed
  *  @param {string} src - Image source path
  *  @param {Vector2|number} [frameSize] - Size of each animation frame in pixels, or the whole image less its
  *  source padding if not passed
@@ -248,7 +251,7 @@ function loadSprite(src, frameSize, padding=textureSheetPadding, sourcePadding=0
             if (!added)
             {
                 // leave the tile empty, no sheet can hold it
-                LOG('loadSprite image is too large to fit on a texture sheet:', src);
+                console.warn('loadSprite image is too large to fit on a texture sheet:', src);
                 return;
             }
             Object.assign(tileInfo, added.tile);
@@ -257,7 +260,8 @@ function loadSprite(src, frameSize, padding=textureSheetPadding, sourcePadding=0
         else
         {
             // leave the tile empty if the image failed to load
-            LOG('loadSprite failed to load image:', src);
+            console.warn('loadSprite failed to load image:', src);
+            textureSheetLoadFailed(key, tileInfo);
         }
     });
 
@@ -275,7 +279,8 @@ function loadSprite(src, frameSize, padding=textureSheetPadding, sourcePadding=0
  *    is not read, cut it into its tiles first
  *  - An image that fails to load, or that no sheet can hold, adds no tiles and says so in the console, so the tiles
  *    of the images after it move up
- *  - The same images loaded again with the same settings give back what the first load did, packed once
+ *  - The same images loaded again with the same settings give back what the first load did, packed once, unless
+ *    an image of it failed
  *  @param {Array<string>} sources - Image source paths
  *  @param {Vector2|number} [tileSize] - Size of a tile in pixels
  *  @param {number} [padding] - How many pixels padding around each tile on the sheet
@@ -317,6 +322,7 @@ function loadTiles(sources, tileSize=tileDefaultSize, padding=textureSheetPaddin
             // the whole tiles of it, an edge past the last one left out
             const columns = image.width / size.x | 0, rows = image.height / size.y | 0, count = columns * rows;
             const added = count && textureSheetAdd(vec2(columns * size.x, rows * size.y), size, padding, 0);
+            image.width || textureSheetLoadFailed(key, set);
             if (!added)
                 return console.warn('loadTiles: ' + src + (count ? ' does not fit on a texture sheet' :
                     ' failed to load, or is smaller than a tile') + ', its tiles are left out');
@@ -335,7 +341,8 @@ function loadTiles(sources, tileSize=tileDefaultSize, padding=textureSheetPaddin
  *  - Aseprite frame tags become animations, so do names like run_0, run_1
  *  - Trimmed frames are restored to their full source size when packed
  *  - Rotated frames are rotated back upright when packed
- *  - The same atlas loaded again by its paths, with the same padding, gives back what the first load did, packed once
+ *  - The same atlas loaded again by its paths, with the same padding, gives back what the first load did, packed
+ *    once, unless that load failed
  *  @param {string} imageSrc - Atlas image path
  *  @param {string|Object} jsonSrc - Atlas json path, or already parsed json data
  *  @param {number} [padding] - How many pixels padding around each frame
@@ -390,7 +397,7 @@ function loadAtlas(imageSrc, jsonSrc, padding=textureSheetPadding)
                 const added = textureSheetAdd(blockSize, sourceSize, padding);
                 if (!added)
                 {
-                    LOG('loadAtlas frames are too large to fit on a texture sheet:', group.name);
+                    console.warn('loadAtlas frames are too large to fit on a texture sheet:', group.name);
                     continue;
                 }
                 const {sheet, tile} = added;
@@ -424,7 +431,8 @@ function loadAtlas(imageSrc, jsonSrc, padding=textureSheetPadding)
         else
         {
             // leave the atlas empty if either file failed to load
-            LOG('loadAtlas failed to load:', imageSrc, jsonSrc);
+            console.warn('loadAtlas failed to load:', imageSrc, jsonSrc);
+            textureSheetLoadFailed(key, atlas);
         }
     });
 

package/plugins/tweenSystem.js

@@ -11,7 +11,8 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// Module-private list of tweens currently running, each with its active flag set while it is in it.
+// Module-private list of tweens currently running, each with its active flag set while it is in it; a stopped
+// one stays listed, inactive, until the next update takes it out, so stopping many is not a search for each
 const tweenActive = [];
 const tweenUpdateList = []; // the tweens an update moves, the ones active when it began
 let tweenUpdatePass = 0; // counts the updates, a tween started during one waits for the next
@@ -22,14 +23,10 @@ function tweenActivate(tween)
     tween.activePass = tweenUpdatePass; // started again, even while active, so this update leaves it alone
     if (tween.active) return;
     tween.active = true;
-    tweenActive.push(tween);
-}
-function tweenDeactivate(tween)
-{
-    if (!tween.active) return;
-    tween.active = false;
-    tweenActive.splice(tweenActive.indexOf(tween), 1);
+    tween.listed || tweenActive.push(tween); // one stopped this update is still listed, in its place
+    tween.listed = true;
 }
+function tweenDeactivate(tween) { tween.active = false; }
 
 // True if the value is an instance of a class that exposes a numeric-percent
 // `lerp(other, percent)` method (Vector2, Color, or any future class).
@@ -57,9 +54,9 @@ class Tween
      *  callback receives the interpolated value (a number, or a fresh instance
      *  for lerp-able types). Both endpoints must be the same type.
      *  @param {function(NonNullable<T>):void} callback - Called with the interpolated value each frame
-     *  @param {T} [start=0] - Starting value
-     *  @param {T} [end=1] - Ending value
-     *  @param {number} [duration=1] - Duration in seconds
+     *  @param {T} [start] - Starting value
+     *  @param {T} [end] - Ending value
+     *  @param {number} [duration] - Duration in seconds
      *  @param {Object} [options]
      *  @param {function(number):number} [options.ease] - Easing function (defaults to LINEAR)
      *  @param {boolean} [options.useRealTime=false] - Advance even when the game is paused (matches Timer's useRealTime)
@@ -111,9 +108,12 @@ class Tween
         /** Remaining iterations including the current run (loop/pingPong only).
          *  @private */
         this.loopRemaining = 0;
-        /** Whether it is in the active list, see isActive
+        /** Whether it is running, see isActive
          *  @private */
         this.active = false;
+        /** Whether it is in the active list, which a stopped one leaves at the next update
+         *  @private */
+        this.listed = false;
         /** The update it was started in, it first moves on the one after
          *  @private */
         this.activePass = 0;
@@ -134,7 +134,7 @@ class Tween
 
     /** Set the easing curve and return this for chaining.
      *  @param {function(number):number} easeFn
-     *  @returns {Tween<T>} */
+     *  @return {Tween<T>} */
     setEase(easeFn)
     {
         this.ease = easeFn;
@@ -149,7 +149,7 @@ class Tween
      *  - It is kept by `restart`, so a restarted tween calls it again when it completes
      *  - `stop` and `tweenStopAll` end a tween without calling it
      *  @param {function():void} callback
-     *  @returns {Tween<T>} */
+     *  @return {Tween<T>} */
     then(callback)
     {
         this.onComplete = callback;
@@ -165,7 +165,7 @@ class Tween
      *  A `then` callback, set before or after, is called when the last
      *  iteration ends.
      *  @param {number} [count=Infinity]
-     *  @returns {Tween<T>} */
+     *  @return {Tween<T>} */
     loop(count = Infinity)
     {
         this.loopRemaining = count;
@@ -180,7 +180,7 @@ class Tween
      *  A `then` callback, set before or after, is called when the last
      *  iteration ends.
      *  @param {number} [count=Infinity]
-     *  @returns {Tween<T>} */
+     *  @return {Tween<T>} */
     pingPong(count = Infinity)
     {
         this.loopRemaining = count;
@@ -213,7 +213,7 @@ class Tween
     }
 
     /** True if this tween is in the active list and not paused.
-     *  @returns {boolean} */
+     *  @return {boolean} */
     isActive()
     {
         return !this.paused && this.active;
@@ -221,7 +221,7 @@ class Tween
 
     /** Get how far this tween has progressed, from 0 (just started) to 1
      *  (completed). Clamped — overshoot past completion still reads 1.
-     *  @returns {number} */
+     *  @return {number} */
     getPercent()
     {
         return percent(this.duration - this.life, 0, this.duration);
@@ -230,7 +230,7 @@ class Tween
     /** Get the current interpolated value (the value most recently passed to
      *  the callback). Returns a number, Vector2, Vector3 or Color depending on the
      *  tween's start/end types.
-     *  @returns {T} */
+     *  @return {T} */
     getValue()
     {
         return this.interp(this.life);
@@ -242,7 +242,7 @@ class Tween
      *  - A vector goes past its ends as far as the easing does, as a number does; a Color stays between them,
      *    so its channels stay in range, and any other type goes as far as its own lerp takes it
      *  @param {number} life
-     *  @returns {T} */
+     *  @return {T} */
     interp(life)
     {
         // the ends of whatever type it tweens, each kind is handled below
@@ -285,44 +285,44 @@ const Ease =
 {
     /** Linear (identity) curve.
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease */
     LINEAR: (x) => x,
 
     /** Power curve factory: `Ease.POWER(n)` returns `x => x**n`.
      *  Use n=2 for quadratic, n=3 for cubic, etc.
      *  @param {number} n
-     *  @returns {function(number):number}
+     *  @return {function(number):number}
      *  @memberof TweenSystem.Ease */
     POWER: (n) => (x) => x ** n,
 
     /** Sine ease-in curve: starts slow, ends fast.
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease */
     SINE: (x) => 1 - cos(x * (PI / 2)),
 
     /** Circular ease-in curve.
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease */
     CIRC: (x) => 1 - (1 - x * x)**.5,
 
     /** Exponential ease-in curve (`2^(10x-10)`).
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease */
     EXPO: (x) => x === 0 ? 0 : 2 ** (10 * x - 10),
 
     /** Back ease-in: overshoots backward at the start before snapping forward.
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease */
     BACK: (x) => x * x * (2.70158 * x - 1.70158),
 
     /** Elastic ease-in: oscillations that grow toward the end.
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease */
     ELASTIC: (x) =>
         x === 0 ? 0 :
@@ -332,7 +332,7 @@ const Ease =
     /** Spring ease-in: wobbles around the start before springing to the end;
      *  `Ease.OUT(Ease.SPRING)` overshoots and settles on the target.
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease */
     SPRING: (x) =>
         1 -
@@ -346,7 +346,7 @@ const Ease =
      *  classic "object falls and hits the ground" shape (bounces near x=1),
      *  wrap with `Ease.OUT`: `Ease.OUT(Ease.BOUNCE)`.
      *  @param {number} x
-     *  @returns {number}
+     *  @return {number}
      *  @memberof TweenSystem.Ease
      *  @example
      *  Ease.BOUNCE                  // ease-in bounce (bouncy at start)
@@ -369,7 +369,7 @@ const Ease =
      *  convention, so wrapping a curve in `IN` is a no-op — useful when
      *  picking the direction programmatically.
      *  @param {function(number):number} f - Curve to use as ease-in (returned unchanged)
-     *  @returns {function(number):number}
+     *  @return {function(number):number}
      *  @memberof TweenSystem.Ease
      *  @example
      *  // Pick direction at runtime
@@ -380,7 +380,7 @@ const Ease =
 
     /** Reverse a curve so it eases out instead of in: `x => 1 - f(1 - x)`.
      *  @param {function(number):number} f
-     *  @returns {function(number):number}
+     *  @return {function(number):number}
      *  @memberof TweenSystem.Ease
      *  @example
      *  Ease.OUT(Ease.POWER(2)) // ease-out quadratic
@@ -389,7 +389,7 @@ const Ease =
 
     /** Combine the first half of `f` with `Ease.OUT(f)` for a symmetric curve.
      *  @param {function(number):number} f
-     *  @returns {function(number):number}
+     *  @return {function(number):number}
      *  @memberof TweenSystem.Ease */
     IN_OUT: (f) => Ease.PIECEWISE(f, Ease.OUT(f)),
 
@@ -397,7 +397,7 @@ const Ease =
      *  Each curve is mapped to its section: section i runs over [i/n, (i+1)/n]
      *  and its output is mapped to [i/n, (i+1)/n] of the overall range.
      *  @param {...function(number):number} fns
-     *  @returns {function(number):number}
+     *  @return {function(number):number}
      *  @memberof TweenSystem.Ease */
     PIECEWISE: (...fns) =>
     {
@@ -415,7 +415,7 @@ const Ease =
      *  @param {number} y1
      *  @param {number} x2
      *  @param {number} y2
-     *  @returns {function(number):number}
+     *  @return {function(number):number}
      *  @memberof TweenSystem.Ease
      *  @example
      *  Ease.BEZIER(0.25, 0.1, 0.25, 1) // CSS "ease"
@@ -465,12 +465,12 @@ const Ease =
  *  @param {string} propertyPath - Dot-separated path, e.g. `'pos.x'` or `'color'`
  *  @param {T} start - Starting value
  *  @param {T} end - Ending value
- *  @param {number} [duration=1] - Duration in seconds
+ *  @param {number} [duration] - Duration in seconds
  *  @param {Object} [options] - Same options as the Tween constructor
  *  @param {function(number):number} [options.ease] - Easing function (defaults to LINEAR)
  *  @param {boolean} [options.useRealTime=false] - Advance even when the game is paused
  *  @param {boolean} [options.paused=false] - Start in paused state
- *  @returns {Tween<T>}
+ *  @return {Tween<T>}
  *  @memberof TweenSystem
  *  @example
  *  // Numeric: slide an object's x with an ease-out sine curve
@@ -591,8 +591,13 @@ function tweenUpdate(gameDelta, realDelta)
     // from the next update. Newest first, as the list has always been walked.
     // a callback that calls tweenUpdate itself gets a list of its own, the outer update is still walking this one
     const list = tweenUpdateList.length ? [] : tweenUpdateList, pass = ++tweenUpdatePass;
+    let kept = 0;
     for (const t of tweenActive)
-        list.push(t);
+        if (t.active)
+            list.push(tweenActive[kept++] = t);
+        else
+            t.listed = false; // stopped since the last update, out of the list now
+    tweenActive.length = kept;
     // the list is let go however the walk ends: a callback that throws must not leave it held, or every
     // update after would take it for an update still going and make a list of its own
     try
@@ -645,7 +650,7 @@ function tweenUpdate(gameDelta, realDelta)
 function tweenStopAll()
 {
     for (const t of tweenActive)
-        t.thenCallback = undefined, t.active = false;
+        t.thenCallback = undefined, t.active = t.listed = false;
     tweenActive.length = 0;
 }
 

package/plugins/uiSystem.js

@@ -35,8 +35,14 @@ let uiDebug = 0;
 function uiSetDebug(debugMode)
 { uiDebug = typeof debugMode === 'boolean' ? (debugMode ? 1 : 0) : debugMode; }
 
+/**
+ * @callback DragAndDropCallback - Callback for drag and drop events
+ * @param {DragEvent} event - The drag event
+ * @memberof UISystem
+ */
+
 ///////////////////////////////////////////////////////////////////////////////
-/** 
+/**
  * UI System Global Object
  * @memberof UISystem
  */
@@ -513,7 +519,7 @@ class UISystemPlugin
     *  @param {'left'|'center'|'right'} [align]
     *  @param {string}  [font=uiSystem.defaultFont]
     *  @param {string}  [fontStyle]
-    *  @param {boolean} [applyMaxWidth=true]
+    *  @param {boolean} [applyMaxWidth]
     *  @param {Vector2} [textShadow]
     *  @param {Color}   [shadowColor]
     *  @param {number}  [shadowBlur]
@@ -528,12 +534,6 @@ class UISystemPlugin
         context.shadowColor = '#0000';
     }
 
-    /**
-     * @callback DragAndDropCallback - Callback for drag and drop events
-     * @param {DragEvent} event - The drag event
-     * @memberof UISystem
-     */
-
     /** Setup drag and drop event handlers
     *  Automatically prevents defaults and calls the given functions
     *  @param {DragAndDropCallback} [onDrop] - when a file is dropped
@@ -1212,19 +1212,24 @@ class UIObject
     /** Called when the navigation button is pressed on this object */
     navigatePressed() { this.click(); }
 
-    /** @return {boolean} - Is the mouse hovering over this element */
+    /** Is the mouse hovering over this element
+     *  @return {boolean} */
     isHoverObject() { return uiSystem.hoverObject === this; }
 
-    /** @return {boolean} - Is the mouse held onto this element */
+    /** Is the mouse held onto this element
+     *  @return {boolean} */
     isActiveObject() { return uiSystem.activeObject === this; }
 
-    /** @return {boolean} - Is the gamepad or keyboard navigation object */
+    /** Is the gamepad or keyboard navigation object
+     *  @return {boolean} */
     isNavigationObject() { return uiSystem.navigationObject === this; }
 
-    /** @return {boolean} - Is this object in keyboard input mode */
+    /** Is this object in keyboard input mode
+     *  @return {boolean} */
     isKeyInputObject() { return uiSystem.keyInputObject === this; }
 
-    /** @return {boolean} - Can it be interacted with, it and every parent visible and enabled */
+    /** Can it be interacted with, it and every parent visible and enabled
+     *  @return {boolean} */
     isInteractive() { return this.interactive && uiObjectIsUsable(this); }
 
     /** Returns string containing info about this object for debugging
@@ -1755,9 +1760,9 @@ class UIVideo extends UIObject
      *  @param {Vector2} pos
      *  @param {Vector2} size
      *  @param {string} src - Video file path or URL
-     *  @param {boolean} [autoplay=false] - Start playing immediately?
-     *  @param {boolean} [loop=false] - Loop the video?
-     *  @param {number} [volume=1] - Volume percent scaled by global volume (0-1)
+     *  @param {boolean} [autoplay] - Start playing immediately?
+     *  @param {boolean} [loop] - Loop the video?
+     *  @param {number} [volume] - Volume percent scaled by global volume (0-1)
      */
     constructor(pos, size, src, autoplay=false, loop=false, volume=1)
     {
@@ -1912,10 +1917,10 @@ class UILayout extends UIObject
 {
     /** Create a UILayout container that auto-arranges children
      *  @param {Vector2} [pos]
-     *  @param {number}  [columns=1]     - Number of columns (1 = vertical list)
-     *  @param {number}  [gap=10]        - Space between children
-     *  @param {number}  [padding=10]    - Space between container border and children
-     *  @param {boolean} [transparent=false] - If true, draws no background, outline, or shadow
+     *  @param {number}  [columns]     - Number of columns (1 = vertical list)
+     *  @param {number}  [gap]        - Space between children
+     *  @param {number}  [padding]    - Space between container border and children
+     *  @param {boolean} [transparent] - If true, draws no background, outline, or shadow
      */
     constructor(pos, columns=1, gap=10, padding=10, transparent=false)
     {

package/src/engine.js

@@ -32,7 +32,7 @@ const engineName = 'LittleJS';
  *  @type {string}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.24.2';
+const engineVersion = '1.25.0';
 
 /** Frames per second to update
  *  @type {number}
@@ -165,7 +165,7 @@ let timeFixedStart = 0, frameFixedStart = 0;
 let windowWidthLast = 0, windowHeightLast = 0, windowPixelRatioLast = 0;
 let engineUpdateInternal; // assigned by engineInit so engineStep can drive it
 let engineFrameScheduled = false; // a frame of the loop is asked for and has not run yet
-let engineFrameErrors = 0; // errors a release build's loop went on past
+let engineFrameErrorLast; // the last error a release build's loop went on past, as text
 
 // the pairs of objects asked about a collision this update, so the other's own physics does not ask again: each
 // asker's others, with true for a pair both said to resolve, and false for one left overlapping, ignored or only
@@ -319,7 +319,8 @@ function engineLoadingScreenDraw(elapsed)
  *    ()=> { drawHUD(); },                 // gameRenderPost
  *    ['tiles.png', 'tilesLevel.png']       // images to load
  *  );
- *  @memberof Engine */
+ *  @memberof Engine
+ *  @return {Promise<void>} - Done when the images have loaded and gameInit has run */
 async function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, imageSources=[], rootElement)
 {
     showEngineVersion && console.log(`${engineName} Engine v${engineVersion}`);
@@ -419,20 +420,30 @@ async function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, game
                 frameTimeBufferMS = 0;
             }
 
-            // update multiple frames if necessary in case of slow framerate
-            for (; frameTimeBufferMS >= 0; frameTimeBufferMS -= 1e3 / frameRate)
+            // update multiple frames if necessary in case of slow framerate; a tick that throws still spends its time
+            // and the smoothing still comes back, so a release build going on past an error each tick keeps its rate
+            try
             {
-                // read again each tick, so a pause set by the game stops the rest of this frame's catch-up ticks
-                const frozenTick = paused || !(timeScale * debugScale);
-
-                // increment frame and update time, frozen does not advance time
-                if (!frozenTick)
-                    time = timeFixedStart + (frame++ - frameFixedStart) / frameRate;
-                engineTick(frozenTick);
+                while (frameTimeBufferMS >= 0)
+                {
+                    try
+                    {
+                        // read again each tick, so a pause set by the game stops the rest of this frame's catch-up ticks
+                        const frozenTick = paused || !(timeScale * debugScale);
+
+                        // increment frame and update time, frozen does not advance time
+                        if (!frozenTick)
+                            time = timeFixedStart + (frame++ - frameFixedStart) / frameRate;
+                        engineTick(frozenTick);
+                    }
+                    finally { frameTimeBufferMS -= 1e3 / frameRate; }
+                }
+            }
+            finally
+            {
+                // add the time smoothing back in
+                frameTimeBufferMS += deltaSmooth;
             }
-
-            // add the time smoothing back in
-            frameTimeBufferMS += deltaSmooth;
         }
 
         // one tick of the loop: update game and objects, when frozen update everything except them
@@ -729,9 +740,13 @@ function engineScheduleFrame()
         try { engineUpdateInternal(frameTimeMS); }
         catch (error)
         {
-            // a release build goes on past an error in a frame, a frozen game is the worst a player can get; only the
-            // first is logged, one every frame would flood the console
-            engineFrameErrors++ || console.error(error);
+            // a release build goes on past an error in a frame, a frozen game is the worst a player can get; an error
+            // is logged when it is not the last one again, one every frame would flood the console
+            const text = String(error);
+            text === engineFrameErrorLast || console.error(error);
+            engineFrameErrorLast = text;
+            // the frame's input is cleared as its tick would have, or a key press that threw would be pressed again
+            inputUpdatePost();
             engineScheduleFrame();
         }
     };
@@ -805,9 +820,12 @@ function engineObjectsUpdate()
         const start = engineChildStack.length;
         for (const child of children)
             engineChildStack.push(child);
-        for (let i = start; i < engineChildStack.length; ++i)
-            updateChildObject(engineChildStack[i]);
-        engineChildStack.length = start;
+        try
+        {
+            for (let i = start; i < engineChildStack.length; ++i)
+                updateChildObject(engineChildStack[i]);
+        }
+        finally { engineChildStack.length = start; } // put back when an update throws too, or it keeps them
     }
     const pass = engineObjectsUpdateCount;
     function updateChildObject(o)