littlejsengine 1.24.2 → 1.25.0

package/plugins/newgrounds.js

@@ -25,7 +25,7 @@ let newgrounds;
 const newgroundsUnlocksToResend = new Set; // pending medals whose request did not reach the server
 const newgroundsUnlocksRefused = new Set; // medals the server refused this visit, asked again they answer no unsent
 const newgroundsSecureComponents = ['Medal.unlock', 'ScoreBoard.postScore']; // the calls encrypted with a cipher
-const newgroundsSessionErrors = [104, 110, 111]; // expired session, login required, session cancelled
+const newgroundsSessionErrors = [104, 110, 111]; // expired session, login required, session canceled
 const newgroundsTimeoutMS = 15e3; // how long a request may take before it fails
 
 // whether the server answered that the session is gone, as opposed to a request that failed on the way
@@ -181,9 +181,6 @@ class NewgroundsPlugin
         this.ready = this.init();
     }
 
-    /** @deprecated since 1.20, the view is logged when the plugin starts, so this does nothing */
-    logView() {}
-
     /** Log the view, check the session, fetch the medals and scoreboards, then keep the session alive; the constructor runs it once
      *  @private */
     async init()

package/plugins/particleEffects.js

@@ -162,7 +162,6 @@ function particleEffectSanitize(raw)
     const text = typeof raw?.name === 'string' ? raw.name.replace(/[\x00-\x1f\x7f]+/g, ' ').trim() : '';
     const name = text ? text.slice(0, 60).trim() : 'Effect'; // no space left where it was cut
     const input = raw?.settings && typeof raw.settings === 'object' ? {...raw.settings} : {};
-    input.collideLevel ??= input.collideTiles; // its name before 1.20
     // a library saved before shapes names its tile and no shape, it keeps its tile
     if (input.shape === undefined && isNumber(input.tileIndex))
         input.shape = '';
@@ -212,10 +211,10 @@ function particleEffectSanitize(raw)
 }
 
 /** A copy of an effect with its four colors turned around the color wheel and their saturation scaled; lightness and
- *  alpha stay, and grey and white have no hue to turn
+ *  alpha stay, and gray and white have no hue to turn
  *  @param {Object} effect
  *  @param {number} [hue] - How far around the wheel, 1 is all the way
- *  @param {number} [saturation] - Multiplies the saturation, 0 is grey, clamped to 1
+ *  @param {number} [saturation] - Multiplies the saturation, 0 is gray, clamped to 1
  *  @return {Object}
  *  @memberof ParticleEffects */
 function particleEffectRecolor(effect, hue=0, saturation=1)
@@ -505,7 +504,7 @@ function particleEffectResolve(nameOrEffect, options)
  *  @param {Object} [options] - What to change for this play, each left out when not wanted:
  *    scale grows the whole effect, the built-ins fit a one unit object at 1;
  *    hue turns its colors around the color wheel, 1 is all the way;
- *    saturation multiplies its saturation, 0 is grey;
+ *    saturation multiplies its saturation, 0 is gray;
  *    angle is its direction, 0 is up, the effect's own angle when not given;
  *    tileInfo, a TileInfo or a TextureInfo, is the game's own art to draw with in place of the effect's shape,
  *    tinted by its colors, a whole texture drawn as one tile;

package/plugins/pathFinder.js

@@ -26,7 +26,8 @@ const PATHFINDER_TILE_VEC = vec2(1);
  *  @memberof PathFinding */
 class PathFinderNode
 {
-    /** @param {number} x - Tile x
+    /** Make the node of a grid cell, as PathFinder does for each
+     *  @param {number} x - Tile x
      *  @param {number} y - Tile y */
     constructor(x, y)
     {
@@ -66,7 +67,8 @@ class PathFinderNode
     /** Reset per-search state and walkability (called by buildNodeData). */
     reset() { this.walkable = false; this.cost = 0; this.resetSearch(); }
 
-    /** True if walkable and not blocked by cost. */
+    /** True if walkable and not blocked by cost.
+     *  @return {boolean} */
     isClear()
     {
         return this.walkable && this.cost === 0;
@@ -88,7 +90,8 @@ class PathFinderNode
  */
 class PathFinder
 {
-    /** @param {TileCollisionLayer|Vector2} source - Either a TileCollisionLayer
+    /** Make a path finder over a tile layer or a grid
+     *  @param {TileCollisionLayer|Vector2} source - Either a TileCollisionLayer
      *  (size and walkability auto-derived) or a Vector2 grid size (user
      *  overrides isWalkable). */
     constructor(source)
@@ -157,7 +160,7 @@ class PathFinder
      *  the instance or via a subclass.
      *  @param {number} x - Tile x
      *  @param {number} y - Tile y
-     *  @returns {boolean} */
+     *  @return {boolean} */
     isWalkable(x, y)
     {
         if (!this.tileLayer) return true;
@@ -168,7 +171,7 @@ class PathFinder
      *  Override to add cost-weighted terrain (mud, swamp, etc).
      *  @param {number} x - Tile x
      *  @param {number} y - Tile y
-     *  @returns {number} */
+     *  @return {number} */
     getCost(x, y)
     {
         return 0;
@@ -177,7 +180,7 @@ class PathFinder
     /** Get the node at tile coords, or null if out of bounds.
      *  @param {number} x
      *  @param {number} y
-     *  @returns {PathFinderNode|null} */
+     *  @return {PathFinderNode|null} */
     getNode(x, y)
     {
         if (x < 0 || y < 0 || x >= this.size.x || y >= this.size.y) return null;
@@ -186,7 +189,7 @@ class PathFinder
 
     /** Convert a world-space position to integer tile coords (no clamping).
      *  @param {Vector2} worldPos
-     *  @returns {Vector2} */
+     *  @return {Vector2} */
     worldToTile(worldPos)
     {
         const ox = this.tileLayer ? this.tileLayer.pos.x : 0;
@@ -197,7 +200,7 @@ class PathFinder
     /** Convert integer tile coords to the world-space center of that tile.
      *  @param {number} x
      *  @param {number} y
-     *  @returns {Vector2} */
+     *  @return {Vector2} */
     tileToWorld(x, y)
     {
         const ox = this.tileLayer ? this.tileLayer.pos.x : 0;
@@ -241,7 +244,7 @@ class PathFinder
      *  reached; false on disconnected goal or maxLoop exhaustion, which sets searchGaveUp.
      *  @param {PathFinderNode} startNode
      *  @param {PathFinderNode} endNode
-     *  @returns {boolean}
+     *  @return {boolean}
      *  @private */
     aStarSearch(startNode, endNode)
     {
@@ -385,9 +388,9 @@ class PathFinder
      *  unchanged walkability, pass `rebuild=false` and call `buildNodeData()`
      *  once externally to avoid redundant work.
      *  @param {Vector2} worldPos
-     *  @param {number} [searchRange=10] - Max box-radius in tiles
-     *  @param {boolean} [rebuild=true] - Whether to call buildNodeData first
-     *  @returns {PathFinderNode|null} */
+     *  @param {number} [searchRange] - Max box-radius in tiles
+     *  @param {boolean} [rebuild] - Whether to call buildNodeData first
+     *  @return {PathFinderNode|null} */
     getNearestClearNode(worldPos, searchRange = 10, rebuild = true)
     {
         ASSERT(isVector2(worldPos), 'worldPos must be a Vector2');
@@ -550,20 +553,36 @@ class PathFinder
     {
         if (path.length <= 2) return;
 
-        // Greedy: from each kept node, jump to the furthest node with a clear
-        // line to it, or else the next node. Every segment is one isLineClear
+        // Greedy: from each kept node, jump to the furthest corner with a clear
+        // line to it, then on along the straight run past it as far as one is
+        // clear, or else the next node. Every segment is one isLineClear
         // accepted or one the path already had, so none can cross a wall.
-        const original = path.slice();
+        // Corners first, so a winding path costs a check per corner and not
+        // per cell of it.
+        const original = path.slice(), last = original.length - 1;
+        const corners = [];
+        for (let i = 1; i < last; ++i)
+        {
+            const a = original[i - 1].pos, b = original[i].pos, c = original[i + 1].pos;
+            if ((b.x - a.x) * (c.y - a.y) !== (b.y - a.y) * (c.x - a.x))
+                corners.push(i);
+        }
+        corners.push(last);
         path.length = 0;
         path.push(original[0]);
-        for (let k = 0; k < original.length - 1;)
+        for (let k = 0; k < last;)
         {
-            let j = original.length - 1;
+            let j = k + 1;
             if (original[k].isClear()) // isLineClear needs both ends clear
-                while (j > k + 1 && !(original[j].isClear() && this.isLineClear(original[k].pos, original[j].pos)))
-                    --j;
-            else
-                j = k + 1;
+            {
+                const clear = (i)=> original[i].isClear() && this.isLineClear(original[k].pos, original[i].pos);
+                let c = corners.length - 1, next = last + 1; // next is the corner past the one found
+                while (c >= 0 && corners[c] > k + 1 && !clear(corners[c]))
+                    next = corners[c--];
+                j = c >= 0 && corners[c] > k + 1 ? corners[c] : k + 1;
+                for (let i = next - 1; i > j; --i)
+                    if (clear(i)) { j = i; break; }
+            }
             path.push(original[j]);
             k = j;
         }
@@ -578,20 +597,25 @@ class PathFinder
      *  @private */
     dropCollinearNodes(path)
     {
-        for (let i = path.length - 2; i >= 1; --i)
+        // one pass, a node kept only where the way turns from the last one kept
+        if (path.length < 3) return;
+        let kept = 1;
+        for (let i = 1; i < path.length - 1; ++i)
         {
-            const a = path[i - 1], b = path[i], c = path[i + 1];
-            if ((b.pos.x - a.pos.x) * (c.pos.y - a.pos.y) ===
+            const a = path[kept - 1], b = path[i], c = path[i + 1];
+            if ((b.pos.x - a.pos.x) * (c.pos.y - a.pos.y) !==
                 (b.pos.y - a.pos.y) * (c.pos.x - a.pos.x))
-                path.splice(i, 1);
+                path[kept++] = b;
         }
+        path[kept++] = path[path.length - 1];
+        path.length = kept;
     }
 
     /** Lookup helper: true when the node at tile coords (x, y) is in-bounds
      *  and clear (walkable, zero-cost). Used by isLineClear's hot path.
      *  @param {number} x
      *  @param {number} y
-     *  @returns {boolean}
+     *  @return {boolean}
      *  @private */
     isNodeClear(x, y)
     {
@@ -608,7 +632,7 @@ class PathFinder
      *  CheckLine() in pathFinding.cpp.
      *  @param {Vector2} startPos - Tile coords
      *  @param {Vector2} endPos - Tile coords
-     *  @returns {boolean}
+     *  @return {boolean}
      *  @private */
     isLineClear(startPos, endPos)
     {
@@ -731,7 +755,7 @@ class PathFinder
      *  @param {Vector2} startPos - World-space start
      *  @param {Vector2} endPos - World-space end
      *  @param {boolean} [rebuild] - Whether to call buildNodeData first
-     *  @returns {Vector2[]} */
+     *  @return {Vector2[]} */
     findPath(startPos, endPos, rebuild = true)
     {
         ASSERT(isVector2(startPos) && isVector2(endPos), 'findPath needs Vector2 endpoints');

package/plugins/pluginExport.js

@@ -37,6 +37,8 @@ export
     postProcessCurve,
     postProcessChromatic,
     postProcessOutline,
+    postProcessTiltShift,
+    postProcessDepthOfField,
     postProcessTV,
 
     // Light System