@vpmedia/phaser 1.124.0 → 1.125.0

package/src/phaser/display/webgl/earcut.ts

@@ -8,10 +8,11 @@ import { Node } from './earcut_node.js';
 export function sortLinked(list: Node | null): Node | null {
   let numMerges;
   let inSize = 1;
+  let sorted = list;
   do {
-    let p: Node | null = list;
+    let p: Node | null = sorted;
     let tail: Node | null = null;
-    list = null;
+    sorted = null;
     numMerges = 0;
     while (p) {
       numMerges += 1;
@@ -55,7 +56,7 @@ export function sortLinked(list: Node | null): Node | null {
         if (tail) {
           tail.nextZ = e;
         } else {
-          list = e;
+          sorted = e;
         }
         e.prevZ = tail;
         tail = e;
@@ -67,7 +68,7 @@ export function sortLinked(list: Node | null): Node | null {
     }
     inSize *= 2;
   } while (numMerges > 1);
-  return list;
+  return sorted;
 }
 
 /**
@@ -91,17 +92,17 @@ export function compareX(a: Node, b: Node): number {
  */
 export function zOrder(x: number, y: number, minX: number, minY: number, size: number): number {
   // coords are transformed into non-negative 15-bit integer range
-  x = (32_767 * (x - minX)) / size;
-  y = (32_767 * (y - minY)) / size;
-  x = (x | (x << 8)) & 0x00ff00ff;
-  x = (x | (x << 4)) & 0x0f0f0f0f;
-  x = (x | (x << 2)) & 0x33333333;
-  x = (x | (x << 1)) & 0x55555555;
-  y = (y | (y << 8)) & 0x00ff00ff;
-  y = (y | (y << 4)) & 0x0f0f0f0f;
-  y = (y | (y << 2)) & 0x33333333;
-  y = (y | (y << 1)) & 0x55555555;
-  return x | (y << 1);
+  let ix = (32_767 * (x - minX)) / size;
+  let iy = (32_767 * (y - minY)) / size;
+  ix = (ix | (ix << 8)) & 0x00ff00ff;
+  ix = (ix | (ix << 4)) & 0x0f0f0f0f;
+  ix = (ix | (ix << 2)) & 0x33333333;
+  ix = (ix | (ix << 1)) & 0x55555555;
+  iy = (iy | (iy << 8)) & 0x00ff00ff;
+  iy = (iy | (iy << 4)) & 0x0f0f0f0f;
+  iy = (iy | (iy << 2)) & 0x33333333;
+  iy = (iy | (iy << 1)) & 0x55555555;
+  return ix | (iy << 1);
 }
 
 /**
@@ -446,7 +447,7 @@ export function filterPoints(start: Node | null, end?: Node | null): Node | null
   if (!start) {
     return start;
   }
-  end ??= start;
+  let last = end ?? start;
   let p = start;
   let again;
   do {
@@ -454,7 +455,7 @@ export function filterPoints(start: Node | null, end?: Node | null): Node | null
     if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
       removeNode(p);
       p = p.prev;
-      end = p;
+      last = p;
       if (p === p.next) {
         return null;
       }
@@ -462,8 +463,8 @@ export function filterPoints(start: Node | null, end?: Node | null): Node | null
     } else {
       p = p.next;
     }
-  } while (again || p !== end);
-  return end;
+  } while (again || p !== last);
+  return last;
 }
 
 /**
@@ -567,14 +568,15 @@ export function eliminateHoles(
   }
   queue.sort(compareX);
   // process holes from left to right
+  let outer = outerNode;
   for (i = 0; i < queue.length; i += 1) {
-    if (!outerNode) {
-      return outerNode;
+    if (!outer) {
+      return outer;
     }
-    eliminateHole(queue[i]!, outerNode);
-    outerNode = filterPoints(outerNode, outerNode.next);
+    eliminateHole(queue[i]!, outer);
+    outer = filterPoints(outer, outer.next);
   }
-  return outerNode;
+  return outer;
 }
 
 /**
@@ -586,6 +588,7 @@ export function eliminateHoles(
  */
 export function cureLocalIntersections(start: Node, triangles: number[], dim: number): Node {
   let p = start;
+  let first = start;
   do {
     const a = p.prev;
     const b = p.next.next;
@@ -598,10 +601,10 @@ export function cureLocalIntersections(start: Node, triangles: number[], dim: nu
       removeNode(p);
       removeNode(p.next);
       p = b;
-      start = p;
+      first = p;
     }
     p = p.next;
-  } while (p !== start);
+  } while (p !== first);
   return p;
 }
 
@@ -659,40 +662,41 @@ export function earcutLinked(
   if (!ear) {
     return;
   }
+  let current = ear;
   // interlink polygon nodes in z-order
-  if (!pass && size) {
-    indexCurve(ear, minX, minY, size);
+  if (pass === undefined && size !== undefined) {
+    indexCurve(current, minX, minY, size);
   }
-  let stop = ear;
+  let stop = current;
   let prev;
   let next;
   // iterate through ears, slicing them one by one
-  while (ear.prev !== ear.next) {
-    ({ prev, next } = ear);
-    if (size ? isEarHashed(ear, minX, minY, size) : isEar(ear)) {
+  while (current.prev !== current.next) {
+    ({ prev, next } = current);
+    if (size === undefined ? isEar(current) : isEarHashed(current, minX, minY, size)) {
       // cut off the triangle
       triangles.push(prev.i / dim);
-      triangles.push(ear.i / dim);
+      triangles.push(current.i / dim);
       triangles.push(next.i / dim);
-      removeNode(ear);
+      removeNode(current);
       // skipping the next vertice leads to less sliver triangles
-      ear = next.next;
+      current = next.next;
       stop = next.next;
       continue;
     }
-    ear = next;
+    current = next;
     // if we looped through the whole remaining polygon and can't find any more ears
-    if (ear === stop) {
+    if (current === stop) {
       // try filtering points and slicing again
-      if (!pass) {
-        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, size, 1);
+      if (pass === undefined) {
+        earcutLinked(filterPoints(current), triangles, dim, minX, minY, size, 1);
         // if this didn't work, try curing all small self-intersections locally
       } else if (pass === 1) {
-        ear = cureLocalIntersections(ear, triangles, dim);
-        earcutLinked(ear, triangles, dim, minX, minY, size, 2);
+        current = cureLocalIntersections(current, triangles, dim);
+        earcutLinked(current, triangles, dim, minX, minY, size, 2);
         // as a last resort, try splitting the remaining polygon into two
       } else if (pass === 2) {
-        splitEarcut(ear, triangles, dim, minX, minY, size);
+        splitEarcut(current, triangles, dim, minX, minY, size);
       }
       break;
     }

package/src/phaser/display/webgl/graphics.ts

@@ -471,7 +471,7 @@ export const buildPoly = (graphicsData: DisplayGraphicsData, webGLData: Graphics
   const g = color[1] * alpha;
   const b = color[2] * alpha;
   const triangles = triangulate(points, null, 2);
-  if (!triangles) {
+  if (triangles.length === 0) {
     return false;
   }
   const vertPos = verts.length / 6;

package/src/phaser/display/webgl/renderer.ts

@@ -75,7 +75,7 @@ export class WebGLRenderer {
       alpha: Boolean(game.config.transparent),
       depth: false,
       antialias: game.config.antialias,
-      premultipliedAlpha: game.config.transparent && game.config.transparent !== 'notMultiplied',
+      premultipliedAlpha: game.config.transparent !== false && game.config.transparent !== 'notMultiplied',
       stencil: true,
       failIfMajorPerformanceCaveat: false,
       preserveDrawingBuffer: game.config.preserveDrawingBuffer,
@@ -111,7 +111,7 @@ export class WebGLRenderer {
     this.shaderManager.destroy();
     this.spriteBatch.destroy();
     this.filterManager.destroy();
-    if (this.gl) {
+    if (this.gl as IdentifiedWebGLRenderingContext | undefined) {
       this.gl.canvas.width = 1;
       this.gl.canvas.height = 1;
       const loseContextExt = this.gl.getExtension('WEBGL_lose_context');
@@ -289,7 +289,7 @@ export class WebGLRenderer {
    * Maps blend modes to WebGL rendering operations.
    */
   public mapBlendModes(): void {
-    if (globalThis.PhaserRegistry.blendModesWebGL) {
+    if (globalThis.PhaserRegistry.blendModesWebGL as number[][] | undefined) {
       return;
     }
     const { gl } = this;

package/src/phaser/display/webgl/shader/normal.ts

@@ -197,7 +197,7 @@ export class NormalShader {
    */
   public initSampler2D(uniform: SamplerUniform): void {
     const texture = uniform.value;
-    if (!texture?.baseTexture.hasLoaded) {
+    if (texture?.baseTexture.hasLoaded !== true) {
       return;
     }
     const { gl } = this;
@@ -218,13 +218,13 @@ export class NormalShader {
       const minFilter = data.minFilter ?? gl.LINEAR;
       let wrapS = data.wrapS ?? gl.CLAMP_TO_EDGE;
       let wrapT = data.wrapT ?? gl.CLAMP_TO_EDGE;
-      const format = data.luminance ? gl.LUMINANCE : gl.RGBA;
-      if (data.repeat) {
+      const format = data.luminance === true ? gl.LUMINANCE : gl.RGBA;
+      if (data.repeat === true) {
         wrapS = gl.REPEAT;
         wrapT = gl.REPEAT;
       }
       gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, Boolean(data.flipY));
-      if (data.width) {
+      if (data.width !== undefined) {
         const width = data.width ?? 512;
         const height = data.height ?? 2;
         const border = data.border ?? 0;
@@ -268,10 +268,10 @@ export class NormalShader {
       } else if (uniform.glValueLength === 4) {
         callUniformSetter(uniform.glFunc, gl, uniform.uniformLocation, vector.x, vector.y, vector.z, vector.w);
       } else if (uniform.type === 'sampler2D') {
-        if (uniform._init) {
+        if (uniform._init === true) {
           gl.activeTexture(glMember(gl, `TEXTURE${this.textureCount}`));
           const { baseTexture } = sampler.value!;
-          if (baseTexture._dirty[gl.id]) {
+          if (baseTexture._dirty[gl.id] === true) {
             globalThis.PhaserRegistry.INSTANCES[gl.id]?.updateTexture(baseTexture);
           } else {
             // bind the current texture

package/src/phaser/display/webgl/shader_manager.ts

@@ -71,7 +71,7 @@ export class WebGLShaderManager {
     for (i = 0; i < this.attribState.length; i += 1) {
       if (this.attribState[i] !== this.tempAttribState[i]) {
         this.attribState[i] = this.tempAttribState[i];
-        if (this.tempAttribState[i]) {
+        if (this.tempAttribState[i] === true) {
           gl.enableVertexAttribArray(i);
         } else {
           gl.disableVertexAttribArray(i);

package/src/phaser/display/webgl/sprite_batch.ts

@@ -266,7 +266,7 @@ export class WebGLSpriteBatch {
       nextBlendMode = sprite.blendMode;
       nextShader = sprite.shader ?? this.defaultShader;
       blendSwap = currentBlendMode !== nextBlendMode;
-      shaderSwap = !currentShader || !nextShader || currentShader._UID !== nextShader._UID;
+      shaderSwap = currentShader === null || currentShader._UID !== nextShader._UID;
       let skip = nextTexture.skipRender;
       if (skip && sprite.children.length > 0) {
         skip = false;
@@ -323,7 +323,7 @@ export class WebGLSpriteBatch {
     }
     const { gl } = this;
     // check if a texture is dirty..
-    if (texture._dirty[gl.id]) {
+    if (texture._dirty[gl.id] === true) {
       if (!this.renderSession.renderer.updateTexture(texture)) {
         //  If updateTexture returns false then we cannot render it, so bail out now
         return;

package/src/phaser/display/webgl/texture.ts

@@ -121,7 +121,8 @@ export class Texture {
       this.valid = false;
       return;
     }
-    this.valid = Boolean(frame && frame.width && frame.height && this.baseTexture.source && this.baseTexture.hasLoaded);
+    this.valid =
+      frame.width !== 0 && frame.height !== 0 && this.baseTexture.source !== null && this.baseTexture.hasLoaded;
     if (this.trim) {
       this.width = this.trim.width;
       this.height = this.trim.height;

package/src/phaser/display/webgl/util.ts

@@ -82,7 +82,7 @@ export const compileShader = (
   }
   gl.shaderSource(shader, src);
   gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+  if (gl.getShaderParameter(shader, gl.COMPILE_STATUS) !== true) {
     getRegistry();
     globalThis.PhaserRegistry.GL_SHADER_INFO_LOG = gl.getShaderInfoLog(shader);
     return null;
@@ -125,14 +125,14 @@ export const compileProgram = (
 
   const shaderProgram = gl.createProgram();
 
-  if (!shaderProgram || !vertexShader || !fragmentShader) {
+  if (shaderProgram === null || vertexShader === null || fragmentShader === null) {
     return null;
   }
   gl.attachShader(shaderProgram, vertexShader);
   gl.attachShader(shaderProgram, fragmentShader);
   gl.linkProgram(shaderProgram);
 
-  if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
+  if (gl.getProgramParameter(shaderProgram, gl.LINK_STATUS) !== true) {
     getRegistry();
     globalThis.PhaserRegistry.GL_PROGRAM_INFO_LOG = gl.getProgramInfoLog(shaderProgram);
   }

package/src/phaser/geom/polygon.ts

@@ -27,7 +27,7 @@ export class Polygon {
     this.flattened = false;
     /** @type {number} */
     this.type = GEOM_POLYGON;
-    if (points) {
+    if (points !== null) {
       this.setTo(points);
     }
   }
@@ -111,7 +111,7 @@ export class Polygon {
     this.area = 0;
     const vertices: Point[] = [];
     this._points = vertices;
-    if (points) {
+    if (points.length > 0) {
       //  If points isn't an array, use arguments as the array
       if (!Array.isArray(points)) {
         console.error('[Polygon] setTo() error, input parameter is not an array', points);

package/src/phaser/geom/rectangle.ts

@@ -95,9 +95,8 @@ export class Rectangle {
    * @returns {Rectangle} This rectangle instance for chaining.
    */
   public scale(x: number, y?: number): this {
-    y ??= x;
     this.width *= x;
-    this.height *= y;
+    this.height *= y ?? x;
     return this;
   }
 

package/src/phaser/geom/util/circle.ts

@@ -59,11 +59,9 @@ export const intersects = (a: Circle, b: Circle): boolean => distance(a.x, a.y,
  */
 export const circumferencePoint = (a: Circle, angle: number, asDegrees = false, output: Point | null = null): Point => {
   const result = output ?? new Point();
-  if (asDegrees) {
-    angle = degToRad(angle);
-  }
-  result.x = a.x + a.radius * Math.cos(angle);
-  result.y = a.y + a.radius * Math.sin(angle);
+  const radians = asDegrees ? degToRad(angle) : angle;
+  result.x = a.x + a.radius * Math.cos(radians);
+  result.y = a.y + a.radius * Math.sin(radians);
   return result;
 };
 
@@ -77,11 +75,9 @@ export const circumferencePoint = (a: Circle, angle: number, asDegrees = false,
  */
 export const intersectsPoint = (a: Circle, angle: number, asDegrees = false, output: Point | null = null): Point => {
   const result = output ?? new Point();
-  if (asDegrees) {
-    angle = degToRad(angle);
-  }
-  result.x = a.x + a.radius * Math.cos(angle);
-  result.y = a.y + a.radius * Math.sin(angle);
+  const radians = asDegrees ? degToRad(angle) : angle;
+  result.x = a.x + a.radius * Math.cos(radians);
+  result.y = a.y + a.radius * Math.sin(radians);
   return result;
 };
 

package/src/phaser/geom/util/point.ts

@@ -221,13 +221,11 @@ export const rotate = (
   asDegrees: boolean,
   dist: number | null | undefined
 ): Point => {
-  if (asDegrees) {
-    ang *= Math.PI / 180;
-  }
+  const radians = asDegrees ? ang * (Math.PI / 180) : ang;
   if (dist === undefined || dist === null) {
     a.subtract(x, y);
-    const s = Math.sin(ang);
-    const c = Math.cos(ang);
+    const s = Math.sin(radians);
+    const c = Math.cos(radians);
     const tx = c * a.x - s * a.y;
     const ty = s * a.x + c * a.y;
     a.x = tx + x;
@@ -273,10 +271,10 @@ export const centroid = (points: Point[], output: Point | null = null): Point =>
  */
 export const parse = (obj: Record<string, unknown>, xProp = 'x', yProp = 'y'): Point => {
   const point = new Point();
-  if (obj[xProp]) {
+  if (obj[xProp] !== undefined) {
     point.x = Math.trunc(Number(obj[xProp]));
   }
-  if (obj[yProp]) {
+  if (obj[yProp] !== undefined) {
     point.y = Math.trunc(Number(obj[yProp]));
   }
   return point;

package/src/phaser/util/math.ts

@@ -63,9 +63,8 @@ export const snapToCeil = (input: number, gap = 0, start = 0): number => {
   if (gap === 0) {
     return input;
   }
-  input -= start;
-  input = gap * Math.ceil(input / gap);
-  return start + input;
+  const offset = gap * Math.ceil((input - start) / gap);
+  return start + offset;
 };
 
 /** Wraps a value within a range. */