littlejsengine 1.24.3 → 1.26.0

package/plugins/medalSystem.js

@@ -4,8 +4,8 @@
  * - Medal class with name, description, icon, and unlock tracking
  * - Automatic saving to local storage, unless a service like Newgrounds holds the medal (see Medal.isLocal)
  * - Visual display queue with slide-in notifications
- * - The Newgrounds plugin extends it with NewgroundsMedal, held on the server while logged in
- * - Setting debugMedals = true in the game code before medalsInit skips the load and the save, and in the debug build logs the Newgrounds traffic; it is not exported, so only a script tag build can set it
+ * - The Newgrounds plugin extends it with NewgroundsMedal, held on the server while logged in, and the Wavedash plugin with WavedashMedal, saved here and sent to Wavedash
+ * - Setting debugMedals = true in the game code before medalsInit skips the load and the save, sends nothing to Wavedash, and in the debug build logs the Newgrounds traffic; it is not exported, so only a script tag build can set it
  * @namespace Medals
  */
 
@@ -54,13 +54,25 @@ let medalsDisplayQueue = [], medalsSaveName, medalsDisplayTimeLast, medalsRender
  *  - Call this after creating all medals
  *  - Loads which medals are unlocked from the save, and writes the catalog back
  *  - A medal a service like Newgrounds holds is left as it is, see Medal.isLocal
+ *  - A medal unlocked before the first call stays unlocked and is saved by it
  *  @param {string} saveName - The localStorage key the medals are kept under, a different one from the game's own
  *  readSaveData and writeSaveData, or each would overwrite the other
  *  @memberof Medals */
 function medalsInit(saveName)
 {
+    // unlocks from before the first call, which had nowhere to be saved, are kept: medals favour the player; a call
+    // after that, another player's save, starts from its own
+    const early = [];
+    medalsSaveName || medalsForEach((medal)=> medal.unlocked && medal.isLocal() && early.push(medal));
     medalsSaveName = saveName;
     medalsLoad();
+    if (early.length)
+    {
+        early.forEach((medal)=> medal.unlocked = true);
+        medalsSave();
+    }
+    // the saved unlocks of Wavedash medals go to Wavedash, when that plugin is in the build and started
+    typeof wavedash != 'undefined' && wavedash?.sendAchievements();
 
     // add the medal display once, however often this is called
     if (!medalsRenderAdded)
@@ -130,10 +142,11 @@ function medalsReset()
     medalsForEach(medal=> medal.isLocal() && (medal.unlocked = false));
     if (medalsSaveName && !debugMedals)
     {
-        // the saved unlocks of medals not made yet are cleared too, they are read when those medals are made
+        // the saved unlocks of the local medals and of medals not made yet are cleared too, since a save keeps an
+        // unlock another tab wrote, and those not made yet read theirs when they are made
         const saved = readSaveData(medalsSaveName);
         for (const id in saved)
-            if (!medals[id] && saved[id] && typeof saved[id] === 'object')
+            if ((!medals[id] || medals[id].isLocal()) && saved[id] && typeof saved[id] === 'object')
                 saved[id].unlocked = false;
         writeSaveData(medalsSaveName, saved);
     }
@@ -159,7 +172,7 @@ function medalsSave()
             name: medal.name,
             description: medal.description,
             icon: medal.icon,
-            unlocked: medal.unlocked,
+            unlocked: medal.unlocked || !!saved[medal.id]?.unlocked, // another tab may have unlocked it since
         };
         if (medal.image) entry.src = medal.image.src;
         data[medal.id] = entry;
@@ -229,8 +242,7 @@ class Medal
     {
         if (!medalsPreventUnlock && !this.unlocked)
         {
-            ASSERT(medalsSaveName, 'save name must be set');
-            this.unlocked = true;
+            this.unlocked = true; // saved now, or by medalsInit when it comes
             medalsSave();
             medalsDisplayQueue.push(this);
         }

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
@@ -157,9 +157,11 @@ class NewgroundsPlugin
         const hasLocation = typeof location != 'undefined';
         /** @property {string} - Hostname sent with the view the plugin logs when it starts */
         this.host = hasLocation ? location.hostname : '';
-        /** @property {Array} - Medals fetched from Newgrounds, empty until ready, with the unlocks only when logged in */
+        /** @property {Array<Object>} - Medals fetched from Newgrounds, empty until ready, with the unlocks only when logged in
+         *  @type {Array<Object>} */
         this.medals = [];
-        /** @property {Array} - Scoreboards fetched from Newgrounds, empty until ready */
+        /** @property {Array<Object>} - Scoreboards fetched from Newgrounds, empty until ready
+         *  @type {Array<Object>} */
         this.scoreboards = [];
         /** @property {{id: number, name: string, url: string, supporter: boolean}|null} - The logged in player once ready, null when not logged in
          *  @type {{id: number, name: string, url: string, supporter: boolean}|null} */
@@ -181,9 +183,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/parallax.js

@@ -47,6 +47,7 @@ class ParallaxLayer extends CanvasLayer
         ASSERT(isNumber(parallax) || isVector2(parallax), 'parallax must be a number or a Vector2');
         ASSERT(typeof drawFunction == 'function', 'drawFunction must be a function');
         super(pos, size, 0, renderOrder, canvasSize);
+        this.castShadow = false; // a backdrop, it would throw huge shadows in the light system, a sun's above all
 
         /** @property {Vector2} - How much of the camera's movement it follows on each axis, 0 stays with the world
          *  and 1 with the screen */

package/plugins/particleEffects.js

@@ -85,9 +85,9 @@ particleEffectAddSetting('randomColorLinear', 'checkbox', true, 0, 0, 0,
 
 particleEffectSettingGroup = 'Motion';
 particleEffectAddSetting('speed', 'number', .1, 0, .5, .005,
-    'Start speed, world units per frame', 0, 1e9);
+    'Start speed, world units per frame', -1e9, 1e9); // negative goes back against the cone, as the emitter takes it
 particleEffectAddSetting('angleSpeed', 'number', .05, 0, .5, .005,
-    'Spin speed, radians per frame', 0, 1e9);
+    'Spin speed, radians per frame', -1e9, 1e9);
 particleEffectAddSetting('damping', 'number', 1, .8, 1, .001,
     'Speed kept each frame, 1 keeps it all', 0, 1);
 particleEffectAddSetting('angleDamping', 'number', 1, .8, 1, .001,
@@ -107,7 +107,7 @@ particleEffectAddSetting('collideLevel', 'checkbox', false, 0, 0, 0,
 particleEffectAddSetting('restitution', 'number', 0, 0, 1, .01,
     'Bounce when hitting tiles');
 particleEffectAddSetting('friction', 'number', .8, 0, 1, .01,
-    'Speed kept sliding along tiles');
+    'Speed kept sliding along tiles, the larger of this and the friction of the layer, as for an object');
 
 particleEffectSettingGroup = 'Texture';
 particleEffectAddSetting('shape', 'shape', 'soft', 0, 0, 0,
@@ -160,9 +160,9 @@ function particleEffectSanitize(raw)
 {
     // one line of text, line breaks and control characters made spaces
     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
+    // whole characters, and no space left where it was cut
+    const name = text ? textGraphemes(text).slice(0, 60).join('').trim() : 'Effect';
     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 +212,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)
@@ -415,7 +415,7 @@ function particleEffectShapeTile(name)
  *  @param {string} name
  *  @param {function(Particle, number): void} update - Pushes a 2D particle, given the strength
  *  @param {function(Particle3D, number): void} [update3D] - The same for a 3D particle, none leaves 3D alone
- *  @param {number} [min] - Strength range the designer offers
+ *  @param {number} [min] - Strength range the designer offers, and the range a strength is clamped to
  *  @param {number} [max]
  *  @param {number} [value] - Strength when first added
  *  @param {string} [description]
@@ -479,17 +479,45 @@ function particleEffectSet(emitter, effect)
     emitter.particleUpdateCallback = particleEffectUpdateCallback(effect.behaviors);
 }
 
+// the options a play takes besides the settings
+const PARTICLE_EFFECT_OPTIONS = ['hue', 'saturation', 'scale', 'angle', 'tileInfo', 'flatten'];
+
+// whether an option is a value its setting takes, as particleEffectSanitize keeps one
+function particleEffectOptionValid(setting, value)
+{
+    return setting.kind === 'checkbox' ? typeof value === 'boolean' || value === 0 || value === 1 :
+        setting.kind === 'color' ? !!particleEffectColor(value) :
+        setting.kind === 'shape' ? value === '' || particleEffectShapes.includes(value) : isNumber(value);
+}
+
 // an effect from a name or an effect, recolored by the options
 function particleEffectResolve(nameOrEffect, options)
 {
     const found = typeof nameOrEffect == 'string' ? particleEffectsGet(nameOrEffect) : nameOrEffect;
     ASSERT(!!found, 'no particle effect named ' + nameOrEffect);
     if (!found) return;
-    // any setting in the options replaces the effect's own for this play, emitTime for a burst or a loop
+    // a vec2 emitSize is a rectangle, as ParticleEmitter takes one, unless emitRect is false, which makes a circle as
+    // wide as its x
+    if (isVector2(options.emitSize))
+        options = {...options, emitSize: options.emitSize.x, emitHeight: options.emitSize.y,
+            emitRect: options.emitRect ?? true};
+    if (debug)
+        for (const key in options)
+            ASSERT(PARTICLE_EFFECT_OPTIONS.includes(key) || particleEffectSettings.some((setting)=> setting.name === key),
+                'particleEffect: no option named ' + key);
+    // any setting in the options replaces the effect's own for this play, emitTime for a burst or a loop; one that is
+    // not a value of its kind keeps the effect's own, where the sanitizing would put the library's default
     const settings = {...found.settings};
     for (const setting of particleEffectSettings)
-        if (options[setting.name] !== undefined)
-            settings[setting.name] = options[setting.name];
+    {
+        const value = options[setting.name];
+        if (value === undefined) continue;
+        const valid = particleEffectOptionValid(setting, value);
+        ASSERT(valid, `particleEffect: ${setting.name} must be a ${setting.kind === 'checkbox' ? 'boolean' : setting.kind}`,
+            value);
+        if (valid)
+            settings[setting.name] = value;
+    }
     // sanitized each time, an effect may be written by hand or changed after it was added
     const effect = particleEffectSanitize({...found, settings}), {hue=0, saturation=1} = options;
     return hue || saturation != 1 ? particleEffectRecolor(effect, hue, saturation) : effect;
@@ -505,7 +533,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;
@@ -514,6 +542,7 @@ function particleEffectResolve(nameOrEffect, options)
  *  @memberof ParticleEffects */
 function particleEffect(nameOrEffect, pos=vec2(), options={})
 {
+    options ||= {}; // null is no options too
     const effect = particleEffectResolve(nameOrEffect, options);
     if (!effect) return;
     const emitter = new ParticleEmitter(pos.copy());
@@ -528,8 +557,9 @@ function particleEffect(nameOrEffect, pos=vec2(), options={})
 }
 
 /** An effect with a 2D emitter's settings, to save, build again, or build in 3D with particleEffect3D; its tile is
- *  left out, since a hand made emitter's tile is its own texture and not one an effect can name, and so is its
- *  scale, which an effect does not keep: pass it again with options.scale
+ *  left out, since a hand made emitter's tile is its own texture and not one an effect can name, and so are its
+ *  scale, which an effect does not keep: pass it again with options.scale, and its renderOrder, which an effect takes
+ *  from additive; a finished emitter's emit time is the time it emitted for
  *  @param {ParticleEmitter} emitter
  *  @param {string} [name]
  *  @return {Object}
@@ -540,6 +570,8 @@ function particleEffectFromEmitter(emitter, name='Effect')
     for (const setting of particleEffectSettings)
         if (!particleEffectIndirect.includes(setting.name) && emitter[setting.name] !== undefined)
             settings[setting.name] = emitter[setting.name]; // a Color is taken as its channels by the sanitizer
+    if (emitter.emitTime < 0) // destroyed, its last particles going: as long as it emitted, not 0, for ever
+        settings.emitTime = emitter.emitElapsed;
     settings.emitRect = !emitter.emitCircle;
     settings.emitSize = emitter.emitSize.x;
     settings.emitHeight = emitter.emitSize.y;
@@ -630,6 +662,7 @@ function particleEffectSet3D(emitter, effect)
  *  @memberof ParticleEffects */
 function particleEffect3D(nameOrEffect, pos3D=vec3(), options={})
 {
+    options ||= {}; // null is no options too
     const effect = particleEffectResolve(nameOrEffect, options);
     if (!effect) return;
     const e = new ParticleEmitter3D(pos3D.copy());

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)
     {
@@ -63,10 +64,11 @@ class PathFinderNode
         this.isOpen = this.isClosed = false;
     }
 
-    /** Reset per-search state and walkability (called by buildNodeData). */
+    /** 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;
@@ -75,7 +77,7 @@ class PathFinderNode
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/** Grid pathfinder using A* with two optional smoothing passes.
+/** Grid pathfinder using A* with two optional smoothing passes
  *  @memberof PathFinding
  *  @example
  *  // Tile-layer driven (most common):
@@ -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,25 +171,25 @@ 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;
     }
 
-    /** Get the node at tile coords, or null if out of bounds.
+    /** 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;
         return this.nodes[x + y * this.size.x];
     }
 
-    /** Convert a world-space position to integer tile coords (no clamping).
+    /** 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;
@@ -194,10 +197,10 @@ class PathFinder
         return vec2(floor(worldPos.x - ox), floor(worldPos.y - oy));
     }
 
-    /** Convert integer tile coords to the world-space center of that tile.
+    /** 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');
@@ -798,13 +822,11 @@ function pathFinderNearestNode(finder, worldPos, searchRange, test)
         const bound = max(0, offset - .5);
         if (nearest && bound * bound >= nearestDistSq) break;
 
+        // only the ring itself, the inside was searched already: its top and bottom rows whole, its two ends between,
+        // in the same row by row order a full walk of the square visits them in, so ties pick the same node
         for (let dy = -offset; dy <= offset; ++dy)
-        for (let dx = -offset; dx <= offset; ++dx)
+        for (let dx = -offset, step = abs(dy) === offset ? 1 : 2*offset; dx <= offset; dx += step)
         {
-            // only the ring itself, the inside was searched already
-            if (offset > 0 && abs(dx) !== offset && abs(dy) !== offset)
-                continue;
-
             const node = finder.getNode(centerX + dx, centerY + dy);
             if (!node || !test(node)) continue;
 

package/plugins/pluginExport.js

@@ -24,6 +24,11 @@ export
     NewgroundsPlugin,
     NewgroundsMedal,
 
+    // Wavedash
+    wavedash,
+    WavedashPlugin,
+    WavedashMedal,
+
     // Post Process
     postProcess,
     PostProcessPlugin,
@@ -37,12 +42,15 @@ export
     postProcessCurve,
     postProcessChromatic,
     postProcessOutline,
+    postProcessTiltShift,
+    postProcessDepthOfField,
     postProcessTV,
 
     // Light System
     lightSystem,
     LightSystemPlugin,
     Light,
+    DirectionalLight,
 
     // Audio Effects
     AudioEffect,
@@ -149,6 +157,9 @@ export
     // Render3D
     render3D,
     Render3DPlugin,
+    CubeMap,
+    makeCubeMap,
+    loadCubeMap,
     Camera3D,
     EngineObject3D,
     Mesh,