@m2c2kit/core 0.3.14 → 0.3.15

package/dist/index.js

@@ -175,7 +175,7 @@ class M2c2KitHelpers {
     entities.push(drawableEntity);
     const entityPointsArray = entities.map((entity) => {
       const boundingBox = M2c2KitHelpers.calculateEntityAbsoluteBoundingBox(entity);
-      return boundingBoxToPoints(boundingBox);
+      return M2c2KitHelpers.boundingBoxToPoints(boundingBox);
     });
     for (let i = 0; i < entityPointsArray.length; i++) {
       if (!entityNeedsRotation(entities[i])) {
@@ -183,7 +183,7 @@ class M2c2KitHelpers {
       }
       const entityPoints = entityPointsArray[i];
       const radians = entities[i].zRotation;
-      const center = findCentroid(entityPoints);
+      const center = M2c2KitHelpers.findCentroid(entityPoints);
       for (let j = i; j < entities.length; j++) {
         entityPointsArray[j] = rotateRectangle(
           entityPointsArray[j],
@@ -206,7 +206,7 @@ class M2c2KitHelpers {
    * @param drawableEntity - Entity to rotate the canvas for
    */
   static rotateCanvasForDrawableEntity(canvas, drawableEntity) {
-    const rotationTransforms = calculateRotationTransforms(drawableEntity);
+    const rotationTransforms = M2c2KitHelpers.calculateRotationTransforms(drawableEntity);
     if (rotationTransforms.length === 0) {
       return;
     }
@@ -269,24 +269,167 @@ class M2c2KitHelpers {
     }
     return normalized;
   }
+  /**
+   * Checks if two points are on the same side of a line.
+   *
+   * @remarks The line is defined by two points, a and b. The function uses
+   * the cross product to determine the relative position of the points.
+   *
+   * @param p1 - point to check
+   * @param p2 - point to check
+   * @param a - point that defines one end of the line
+   * @param b - point that defines the other end of the line
+   * @returns true if p1 and p2 are on the same side of the line, or false
+   * otherwise
+   */
+  static arePointsOnSameSideOfLine(p1, p2, a, b) {
+    const cp1 = (b.x - a.x) * (p1.y - a.y) - (b.y - a.y) * (p1.x - a.x);
+    const cp2 = (b.x - a.x) * (p2.y - a.y) - (b.y - a.y) * (p2.x - a.x);
+    return cp1 * cp2 >= 0;
+  }
   /**
    * Checks if a point is inside a rectangle.
    *
+   * @remarks The rectangle may have been rotated (sides might not be parallel
+   * to the axes).
+   *
    * @param point - The Point to check
    * @param rect - An array of four Points representing the vertices of the
    * rectangle in clockwise order
    * @returns true if the Point is inside the rectangle
    */
   static isPointInsideRectangle(point, rect) {
-    for (let i = 0; i < 4; i++) {
-      const p1 = rect[i];
-      const p2 = rect[(i + 1) % 4];
-      const cross = (p2.x - p1.x) * (point.y - p1.y) - (p2.y - p1.y) * (point.x - p1.x);
-      if (cross > 0) {
-        return false;
-      }
+    if (rect.length !== 4) {
+      throw new Error("Invalid input: expected an array of four points");
+    }
+    return M2c2KitHelpers.arePointsOnSameSideOfLine(
+      point,
+      rect[2],
+      rect[0],
+      rect[1]
+    ) && M2c2KitHelpers.arePointsOnSameSideOfLine(
+      point,
+      rect[3],
+      rect[1],
+      rect[2]
+    ) && M2c2KitHelpers.arePointsOnSameSideOfLine(
+      point,
+      rect[0],
+      rect[2],
+      rect[3]
+    ) && M2c2KitHelpers.arePointsOnSameSideOfLine(point, rect[1], rect[3], rect[0]);
+  }
+  /**
+   * Checks if the entity or any of its ancestors have been rotated.
+   *
+   * @param entity - entity to check
+   * @returns true if the entity or any of its ancestors have been rotated
+   */
+  static entityOrAncestorHasBeenRotated(entity) {
+    const entities = entity.ancestors;
+    entities.push(entity);
+    return entities.some((entity2) => entityNeedsRotation(entity2));
+  }
+  /**
+   * Converts a bounding box to an array of four points representing the
+   * vertices of the rectangle.
+   *
+   * @remarks In m2c2kit, the y-axis is inverted: origin is in the upper-left.
+   * Vertices are returned in clockwise order starting from the upper-left.
+   *
+   * @param boundingBox
+   * @returns An array of four points
+   */
+  static boundingBoxToPoints(boundingBox) {
+    const { xMin, xMax, yMin, yMax } = boundingBox;
+    const points = [
+      { x: xMin, y: yMin },
+      // Top left
+      { x: xMax, y: yMin },
+      // Top right
+      { x: xMax, y: yMax },
+      // Bottom right
+      { x: xMin, y: yMax }
+      // Bottom left
+    ];
+    return points;
+  }
+  /**
+   * Finds the centroid of a rectangle.
+   *
+   * @param points - An array of four points representing the vertices of the
+   * rectangle.
+   * @returns array of points representing the centroid of the rectangle.
+   */
+  static findCentroid(points) {
+    if (points.length !== 4) {
+      throw new Error("Invalid input: expected an array of four points");
     }
-    return true;
+    let xSum = 0;
+    let ySum = 0;
+    for (const point of points) {
+      xSum += point.x;
+      ySum += point.y;
+    }
+    const xAvg = xSum / 4;
+    const yAvg = ySum / 4;
+    return { x: xAvg, y: yAvg };
+  }
+  /**
+   * Rotates a point, counterclockwise, around another point by an angle in
+   * radians.
+   *
+   * @param point - Point to rotate
+   * @param radians - angle in radians
+   * @param center - Point to rotate around
+   * @returns rotated point
+   */
+  static rotatePoint(point, radians, center) {
+    const dx = point.x - center.x;
+    const dy = point.y - center.y;
+    const x = dx * Math.cos(-radians) - dy * Math.sin(-radians);
+    const y = dx * Math.sin(-radians) + dy * Math.cos(-radians);
+    return {
+      x: x + center.x,
+      y: y + center.y
+    };
+  }
+  /**
+   * Calculates the rotation transforms to apply to entity, respecting any
+   * ancestor rotations.
+   *
+   * @param drawableEntity - entity to calculate rotation transforms for
+   * @returns array of rotation transforms to apply
+   */
+  static calculateRotationTransforms(drawableEntity) {
+    const rotationTransforms = [];
+    const entities = drawableEntity.ancestors;
+    entities.reverse();
+    entities.push(drawableEntity);
+    entities.forEach((entity) => {
+      if (entityNeedsRotation(entity)) {
+        const drawable = entity;
+        if (drawable.type === EntityType.Scene) {
+          const center2 = {
+            x: drawable.absolutePosition.x + drawable.size.width * 0.5,
+            y: drawable.absolutePosition.y + drawable.size.height * 0.5
+          };
+          rotationTransforms.push({
+            radians: drawable.zRotation,
+            center: center2
+          });
+          return;
+        }
+        const boundingBox = M2c2KitHelpers.calculateEntityAbsoluteBoundingBox(drawable);
+        const points = M2c2KitHelpers.boundingBoxToPoints(boundingBox);
+        const center = M2c2KitHelpers.findCentroid(points);
+        rotationTransforms.push({
+          radians: drawable.zRotation,
+          center
+        });
+      }
+    });
+    return rotationTransforms;
   }
 }
 function applyRotationTransformsToCanvas(rotationTransforms, scale, canvas) {
@@ -298,84 +441,16 @@ function applyRotationTransformsToCanvas(rotationTransforms, scale, canvas) {
     );
   });
 }
-function calculateRotationTransforms(drawableEntity) {
-  const rotationTransforms = [];
-  const entities = drawableEntity.ancestors;
-  entities.reverse();
-  entities.push(drawableEntity);
-  entities.forEach((entity) => {
-    if (entityNeedsRotation(entity)) {
-      const drawable = entity;
-      if (drawable.type === EntityType.Scene) {
-        const center2 = {
-          x: drawable.absolutePosition.x + drawable.size.width * 0.5,
-          y: drawable.absolutePosition.y + drawable.size.height * 0.5
-        };
-        rotationTransforms.push({
-          radians: drawable.zRotation,
-          center: center2
-        });
-        return;
-      }
-      const boundingBox = M2c2KitHelpers.calculateEntityAbsoluteBoundingBox(drawable);
-      const points = boundingBoxToPoints(boundingBox);
-      const center = findCentroid(points);
-      rotationTransforms.push({
-        radians: drawable.zRotation,
-        center
-      });
-    }
-  });
-  return rotationTransforms;
-}
 function entityNeedsRotation(entity) {
   return M2c2KitHelpers.normalizeAngleRadians(entity.zRotation) !== 0 && entity.isDrawable;
 }
-function boundingBoxToPoints(boundingBox) {
-  const { xMin, xMax, yMin, yMax } = boundingBox;
-  const points = [
-    { x: xMin, y: yMin },
-    // Top left
-    { x: xMin, y: yMax },
-    // Bottom left
-    { x: xMax, y: yMax },
-    // Bottom right
-    { x: xMax, y: yMin }
-    // Top right
-  ];
-  return points;
-}
-function findCentroid(points) {
-  if (points.length !== 4) {
-    throw new Error("Invalid input: expected an array of four points");
-  }
-  let xSum = 0;
-  let ySum = 0;
-  for (const point of points) {
-    xSum += point.x;
-    ySum += point.y;
-  }
-  const xAvg = xSum / 4;
-  const yAvg = ySum / 4;
-  return { x: xAvg, y: yAvg };
-}
-function rotatePoint(point, radians, center) {
-  const dx = point.x - center.x;
-  const dy = point.y - center.y;
-  const x = dx * Math.cos(-radians) - dy * Math.sin(-radians);
-  const y = dx * Math.sin(-radians) + dy * Math.cos(-radians);
-  return {
-    x: x + center.x,
-    y: y + center.y
-  };
-}
 function rotateRectangle(rect, radians, center) {
   if (rect.length !== 4) {
     throw new Error("Invalid input: expected an array of four points");
   }
   const rotated = [];
   for (const p of rect) {
-    rotated.push(rotatePoint(p, radians, center));
+    rotated.push(M2c2KitHelpers.rotatePoint(p, radians, center));
   }
   return rotated;
 }
@@ -5748,9 +5823,24 @@ class Game {
       width = radius * 2;
       height = radius * 2;
     }
-    const x = domPointerEvent.offsetX;
-    const y = domPointerEvent.offsetY;
+    let x = domPointerEvent.offsetX;
+    let y = domPointerEvent.offsetY;
     const bb = M2c2KitHelpers.calculateEntityAbsoluteBoundingBox(entity);
+    if (M2c2KitHelpers.entityOrAncestorHasBeenRotated(entity)) {
+      const transforms = M2c2KitHelpers.calculateRotationTransforms(
+        entity
+      );
+      transforms.forEach((transform) => {
+        const rotatedPoint = M2c2KitHelpers.rotatePoint(
+          { x, y },
+          // take negative because we are applying the reverse rotation
+          -transform.radians,
+          transform.center
+        );
+        x = rotatedPoint.x;
+        y = rotatedPoint.y;
+      });
+    }
     const relativeX = (x - bb.xMin) / (bb.xMax - bb.xMin) * width;
     const relativeY = (y - bb.yMin) / (bb.yMax - bb.yMin) * height;
     return { x: relativeX, y: relativeY };
@@ -7332,7 +7422,7 @@ class Session {
     this.eventListeners = new Array();
     this.sessionDictionary = /* @__PURE__ */ new Map();
     this.initialized = false;
-    this.version = "0.3.14 (60325bea)";
+    this.version = "0.3.15 (38470c49)";
     this.options = options;
     for (const activity of this.options.activities) {
       if (this.options.activities.filter((a) => a === activity).length > 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m2c2kit/core",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "The m2c2kit core functionality",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -36,7 +36,7 @@
     "@rollup/plugin-commonjs": "25.0.7",
     "@rollup/plugin-node-resolve": "15.2.3",
     "@rollup/plugin-replace": "5.0.5",
-    "@types/jest": "29.5.10",
+    "@types/jest": "29.5.11",
     "@types/jsdom": "21.1.6",
     "@webgpu/types": "0.1.40",
     "canvas": "2.11.2",
@@ -48,14 +48,14 @@
     "jest-environment-jsdom": "29.7.0",
     "jsdom": "23.0.1",
     "rimraf": "5.0.5",
-    "rollup": "4.6.1",
+    "rollup": "4.8.0",
     "rollup-plugin-copy": "3.5.0",
     "rollup-plugin-dts": "6.1.0",
     "rollup-plugin-esbuild": "6.1.0",
     "rollup-plugin-polyfill-node": "0.13.0",
     "ts-jest": "29.1.1",
-    "ts-node": "10.9.1",
-    "typescript": "5.3.2"
+    "ts-node": "10.9.2",
+    "typescript": "5.3.3"
   },
   "engines": {
     "node": ">=18"