@vpmedia/phaser 1.124.0 → 1.126.0

package/src/phaser/display/text.ts

@@ -199,16 +199,16 @@ export class Text extends Image {
       tabs: source.tabs ?? 0,
     };
     const components = this.fontToComponents(resolved.font);
-    if (resolved.fontStyle) {
+    if (resolved.fontStyle !== undefined && resolved.fontStyle !== '') {
       components.fontStyle = resolved.fontStyle;
     }
-    if (resolved.fontVariant) {
+    if (resolved.fontVariant !== undefined && resolved.fontVariant !== '') {
       components.fontVariant = resolved.fontVariant;
     }
-    if (resolved.fontWeight) {
+    if (resolved.fontWeight !== undefined && resolved.fontWeight !== '') {
       components.fontWeight = String(resolved.fontWeight);
     }
-    if (resolved.fontSize) {
+    if (resolved.fontSize !== undefined && resolved.fontSize !== '') {
       const fontSize = typeof resolved.fontSize === 'number' ? `${resolved.fontSize}px` : resolved.fontSize;
       resolved.fontSize = fontSize;
       components.fontSize = fontSize;
@@ -302,7 +302,7 @@ export class Text extends Image {
     }
     this.canvas.height = height * this._res;
     this.context.scale(this._res, this._res);
-    if (this.style.backgroundColor) {
+    if (this.style.backgroundColor !== null && this.style.backgroundColor !== '') {
       this.context.fillStyle = this.style.backgroundColor;
       this.context.fillRect(0, 0, this.canvas.width, this.canvas.height);
     }
@@ -384,16 +384,17 @@ export class Text extends Image {
         }
       }
     } else {
+      let cursor = x;
       for (const part of text) {
         const section = Math.ceil(this.context.measureText(part).width);
         //  How far to the next tab?
-        snap = snapToCeil(x, tabs);
+        snap = snapToCeil(cursor, tabs);
         if (fill) {
           this.context.fillText(part, snap, y);
         } else {
           this.context.strokeText(part, snap, y);
         }
-        x = snap + section;
+        cursor = snap + section;
       }
     }
   }
@@ -441,24 +442,24 @@ export class Text extends Image {
         const components = this.fontToComponents(this.context.font);
         const charFontStyle = this.fontStyles[this._charCount];
         const charFontWeight = this.fontWeights[this._charCount];
-        if (charFontStyle) {
+        if (charFontStyle !== undefined && charFontStyle !== null && charFontStyle !== '') {
           components.fontStyle = charFontStyle;
         }
-        if (charFontWeight) {
+        if (charFontWeight !== undefined && charFontWeight !== null && charFontWeight !== '') {
           components.fontWeight = charFontWeight;
         }
         this.context.font = this.componentsToFont(components);
       }
       if (this.style.stroke && this.style.strokeThickness) {
         const charStrokeColor = this.strokeColors[this._charCount];
-        if (charStrokeColor) {
+        if (charStrokeColor !== undefined && charStrokeColor !== null && charStrokeColor !== '') {
           this.context.strokeStyle = charStrokeColor;
         }
         this.updateShadow(this.style.shadowStroke ?? false);
       }
       if (this.style.fill) {
         const charFillColor = this.colors[this._charCount];
-        if (charFillColor) {
+        if (charFillColor !== undefined && charFillColor !== null && charFillColor !== '') {
           this.context.fillStyle = charFillColor;
         }
         this.updateShadow(this.style.shadowFill ?? false);
@@ -476,36 +477,37 @@ export class Text extends Image {
    * @param {number} y - The y position to start updating from.
    */
   public updateLine(line: string, x: number, y: number): void {
+    let cursor = x;
     for (const letter of line) {
       if (this.fontWeights.length > 0 || this.fontStyles.length > 0) {
         const components = this.fontToComponents(this.context.font);
         const charFontStyle = this.fontStyles[this._charCount];
         const charFontWeight = this.fontWeights[this._charCount];
-        if (charFontStyle) {
+        if (charFontStyle !== undefined && charFontStyle !== null && charFontStyle !== '') {
           components.fontStyle = charFontStyle;
         }
-        if (charFontWeight) {
+        if (charFontWeight !== undefined && charFontWeight !== null && charFontWeight !== '') {
           components.fontWeight = charFontWeight;
         }
         this.context.font = this.componentsToFont(components);
       }
       if (this.style.stroke && this.style.strokeThickness) {
         const charStrokeColor = this.strokeColors[this._charCount];
-        if (charStrokeColor) {
+        if (charStrokeColor !== undefined && charStrokeColor !== null && charStrokeColor !== '') {
           this.context.strokeStyle = charStrokeColor;
         }
         this.updateShadow(this.style.shadowStroke ?? false);
-        this.context.strokeText(letter, x, y);
+        this.context.strokeText(letter, cursor, y);
       }
       if (this.style.fill) {
         const charFillColor = this.colors[this._charCount];
-        if (charFillColor) {
+        if (charFillColor !== undefined && charFillColor !== null && charFillColor !== '') {
           this.context.fillStyle = charFillColor;
         }
         this.updateShadow(this.style.shadowFill ?? false);
-        this.context.fillText(letter, x, y);
+        this.context.fillText(letter, cursor, y);
       }
-      x += this.context.measureText(letter).width;
+      cursor += this.context.measureText(letter).width;
       this._charCount += 1;
     }
   }
@@ -778,31 +780,20 @@ export class Text extends Image {
    * @returns {string} The font string.
    */
   public componentsToFont(components: FontComponents): string {
-    const parts = [];
-    let v;
-    v = components.fontStyle;
-    if (v && v !== 'normal') {
-      parts.push(v);
-    }
-    v = components.fontVariant;
-    if (v && v !== 'normal') {
-      parts.push(v);
-    }
-    v = components.fontWeight;
-    if (v && v !== 'normal') {
-      parts.push(v);
-    }
-    v = components.fontSize;
-    if (v && v !== 'medium') {
-      parts.push(v);
-    }
-    v = components.fontFamily;
-    if (v) {
-      parts.push(v);
-    }
+    const parts: string[] = [];
+    const push = (value: string | number | undefined, skip: string): void => {
+      if (value !== undefined && value !== '' && value !== skip) {
+        parts.push(String(value));
+      }
+    };
+    push(components.fontStyle, 'normal');
+    push(components.fontVariant, 'normal');
+    push(components.fontWeight, 'normal');
+    push(components.fontSize, 'medium');
+    push(components.fontFamily, '');
     if (parts.length === 0) {
       // Fallback to whatever value the 'font' was
-      parts.push(components.font);
+      parts.push(components.font ?? '');
     }
     return parts.join(' ');
   }
@@ -966,7 +957,7 @@ export class Text extends Image {
    * @returns {CanvasRenderingContext2D} The font properties canvas context.
    */
   public getFontPropertiesContext(): CanvasRenderingContext2D {
-    if (!globalThis.PhaserRegistry.fontPropertiesContext) {
+    if (globalThis.PhaserRegistry.fontPropertiesContext === undefined) {
       const canvas = this.getFontPropertiesCanvas();
       const context = canvas.getContext('2d', { willReadFrequently: true });
       if (!context) {
@@ -1026,7 +1017,7 @@ export class Text extends Image {
       context.textBaseline = 'alphabetic';
       context.fillStyle = '#000';
       context.fillText('|MÉq', 0, baseline);
-      if (!context.getImageData(0, 0, width, height)) {
+      if (context.getImageData(0, 0, width, height) === null) {
         const fallback: FontProperties = {
           ascent: baseline,
           descent: baseline + 6,
@@ -1169,7 +1160,7 @@ export class Text extends Image {
     if (typeof size === 'number') {
       return size;
     }
-    if (size && /(?:^0$|px$)/.exec(size)) {
+    if (size !== undefined && size !== '' && /(?:^0$|px$)/.exec(size)) {
       // Number() cannot read the value here: the string carries a px suffix.
       // eslint-disable-next-line unicorn/prefer-number-coercion
       return Number.parseInt(size, 10);

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

@@ -27,7 +27,7 @@ export class AbstractFilter {
     this.dirty = true;
     this.padding = 0;
     this.uniforms = uniforms ?? {};
-    this.fragmentSrc = fragmentSrc || [];
+    this.fragmentSrc = fragmentSrc;
   }
 
   /**

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

@@ -470,8 +470,8 @@ export const buildPoly = (graphicsData: DisplayGraphicsData, webGLData: Graphics
   const r = color[0] * alpha;
   const g = color[1] * alpha;
   const b = color[2] * alpha;
-  const triangles = triangulate(points, null, 2);
-  if (!triangles) {
+  const triangles: number[] | null = triangulate(points, null, 2);
+  if (!triangles?.length) {
     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. */