@woosh/meep-engine 3.20.0 → 3.21.0

package/src/view/minimap/dom/MinimapMarkerView.js

@@ -1,6 +1,8 @@
 import View from "../../View.js";
 import ImageView from "../../elements/image/ImageView.js";
 import domify from "../../DOM.js";
+import { assert } from "../../../core/assert.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../../../engine/ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 
 const MinimapMarkerDOMElementPrototype = domify('div').addClass('ui-minimap-marker-view').el;
 
@@ -11,14 +13,17 @@ export class MinimapMarkerView extends View {
      *
      * @param {Number} entity
      * @param {MinimapMarker} marker
-     * @param {Transform} transform
-     * @param worldScale
+     * @param {Transform64} transform
+     * @param {Vector2} worldScale
+     * @param {EntityComponentDataset} dataset the entity's own, asked for movement
      * @constructor
      */
-    constructor(entity, marker, transform, worldScale) {
-        // `this` is not available until super() returns; reading it here threw
-        // a ReferenceError on every construction
-        super(entity, marker, transform, worldScale);
+    constructor(entity, marker, transform, worldScale, dataset) {
+        super();
+
+        assert.defined(dataset, 'dataset');
+
+        this.entity = entity;
 
         /**
          *
@@ -27,55 +32,81 @@ export class MinimapMarkerView extends View {
         this.marker = marker;
         /**
          *
-         * @type {Transform}
+         * @type {Transform64}
          */
         this.transform = transform;
         this.worldScale = worldScale;
 
+        /**
+         * A {@link Transform64} carries no signals - that is the point of it - so the marker is
+         * told that it moved by the dataset that holds it, and cannot be built without one.
+         *
+         * @type {EntityComponentDataset}
+         */
+        this.dataset = dataset;
+
         const imageView = new ImageView(this.marker.iconURL);
 
         this.addChild(imageView);
 
-        const position = this.position;
-        const size = this.size;
-
-        function setPosition(x, y) {
-            position.set(x - size.x / 2, y - size.y / 2)
-        }
-
+        // Both of these change the same thing - the marker's size on the map is its own size scaled
+        // by the map's - so both are answered the same way. They are bound with a context, because
+        // a handler that reads the view it belongs to needs one.
         this
-            .bindSignal(this.transform.position.onChanged, this.__handleTransformPositionChange)
-            .bindSignal(this.worldScale.onChanged, this.__handleWorldScaleChange)
-            .bindSignal(this.marker.size.onChanged, this.__handleWorldSizeChange);
+            .bindSignal(this.worldScale.onChanged, this.__updateSize, this)
+            .bindSignal(this.marker.size.onChanged, this.__updateSize, this);
     }
 
-    __handleTransformPositionChange(x, y, z) {
-            setPosition(x * this.worldScale.x, z * this.worldScale.y);
-        }
+    /**
+     * The marker's size on the map, and - because the icon is centred on what it marks, so its
+     * placement depends on its size - where it sits.
+     *
+     * @private
+     */
+    __updateSize() {
+        const marker_size = this.marker.size;
+        const worldScale = this.worldScale;
+
+        this.size.set(marker_size.x * worldScale.x, marker_size.y * worldScale.y);
 
-    __handleWorldScaleChange(x, y) {
-            size.set(x * this.marker.size.x, y * this.marker.size.y);
+        this.__updatePosition();
+    }
 
-            setPosition(this.transform.translation_x * x, this.transform.translation_z * y);
-        }
+    /**
+     * Where the marker sits on the map, read off the transform it was linked with.
+     *
+     * It takes no arguments: {@link TRANSFORM64_EVENT_CHANGE} says only that the transform changed,
+     * and the instance it means is the one this view already holds.
+     *
+     * @private
+     */
+    __updatePosition() {
+        const transform = this.transform;
+        const worldScale = this.worldScale;
+        const size = this.size;
 
-    __handleWorldSizeChange(x, y) {
-            size.set(x * this.worldScale.x, y * this.worldScale.y);
-            setPosition(this.transform.translation_x * this.worldScale.x, this.transform.translation_z * this.worldScale.y)
-        }
+        this.position.set(
+            transform.translation_x * worldScale.x - size.x / 2,
+            transform.translation_z * worldScale.y - size.y / 2
+        );
+    }
 
     link() {
         super.link();
 
-        this.__handleWorldSizeChange(this.marker.size.x, this.marker.size.y);
-        this.__handleTransformPositionChange(this.transform.translation_x, this.transform.translation_y, this.transform.translation_z);
+        this.dataset.addEntityEventListener(
+            this.entity, TRANSFORM64_EVENT_CHANGE, this.__updatePosition, this
+        );
+
+        // places it as well as sizing it
+        this.__updateSize();
     }
 
     unlink() {
+        this.dataset.removeEntityEventListener(
+            this.entity, TRANSFORM64_EVENT_CHANGE, this.__updatePosition, this
+        );
+
         super.unlink();
     }
 }
-
-
-
-

package/src/view/minimap/gl/MarkerGL.d.ts

@@ -2,13 +2,14 @@ export class MarkerGL {
     /**
      *
      * @param {MinimapMarker} marker
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param entity
      * @param id
      * @param {MinimapMarkersGL} manager
+     * @param {EntityComponentDataset} dataset the entity's own, asked for movement
      * @constructor
      */
-    constructor(marker: MinimapMarker, transform: Transform, entity: any, id: any, manager: MinimapMarkersGL);
+    constructor(marker: MinimapMarker, transform: Transform64, entity: any, id: any, manager: MinimapMarkersGL, dataset: EntityComponentDataset);
     /**
      *
      * @type {Reference<AtlasPatch>}
@@ -20,11 +21,22 @@ export class MarkerGL {
      * @type {MinimapMarker}
      */
     marker: MinimapMarker;
-    transform: Transform;
+    /**
+     *
+     * @type {Transform64}
+     */
+    transform: Transform64;
     entity: any;
     id: any;
     manager: MinimapMarkersGL;
     particles: any;
+    /**
+     * A `Transform64` carries no signals - that is the point of it - so the marker is told
+     * that it moved by the dataset that holds it, and cannot be started without one.
+     *
+     * @type {EntityComponentDataset}
+     */
+    dataset: EntityComponentDataset;
     updatePosition(): void;
     updateIcon(newURL: any, oldURL: any): void;
     startup(): void;

package/src/view/minimap/gl/MarkerGL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkerGL.d.ts","sourceRoot":"","sources":["../../../../../src/view/minimap/gl/MarkerGL.js"],"names":[],"mappings":"AAOA;IASI;;;;;;;;OAQG;IACH,0GAaC;IA9BD;;;OAGG;IACH,OAFU,qBAAqB,CAER;IAEvB,gBAAe;IAYX;;;OAGG;IACH,sBAAoB;IACpB,qBAA0B;IAC1B,YAAoB;IAEpB,QAAY;IAEZ,0BAAsB;IACtB,eAAuC;IAG3C,uBAaC;IAED,2CA8BC;IAED,gBAkBC;IAED,iBASC;CACJ;0BArHyB,2CAA2C"}
+{"version":3,"file":"MarkerGL.d.ts","sourceRoot":"","sources":["../../../../../src/view/minimap/gl/MarkerGL.js"],"names":[],"mappings":"AASA;IASI;;;;;;;;;OASG;IACH,6IA2BC;IA7CD;;;OAGG;IACH,OAFU,qBAAqB,CAER;IAEvB,gBAAe;IAeX;;;OAGG;IACH,sBAAoB;IACpB;;;OAGG;IACH,uBAA0B;IAC1B,YAAoB;IAEpB,QAAY;IAEZ,0BAAsB;IACtB,eAAuC;IAEvC;;;;;OAKG;IACH,gCAAsB;IAG1B,uBAaC;IAED,2CA8BC;IAED,gBA0BC;IAED,iBAWC;CACJ;0BA9IyB,2CAA2C"}

package/src/view/minimap/gl/MarkerGL.js

@@ -1,3 +1,5 @@
+import { assert } from "../../../core/assert.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../../../engine/ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 import { Reference } from "../../../engine/reference/v2/Reference.js";
 import { MarkerGLAttributes } from "./MarkerGLAttributes.js";
 
@@ -17,18 +19,25 @@ export class MarkerGL {
     /**
      *
      * @param {MinimapMarker} marker
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param entity
      * @param id
      * @param {MinimapMarkersGL} manager
+     * @param {EntityComponentDataset} dataset the entity's own, asked for movement
      * @constructor
      */
-    constructor(marker, transform, entity, id, manager) {
+    constructor(marker, transform, entity, id, manager, dataset) {
+        assert.defined(dataset, 'dataset');
+
         /**
          *
          * @type {MinimapMarker}
          */
         this.marker = marker;
+        /**
+         *
+         * @type {Transform64}
+         */
         this.transform = transform;
         this.entity = entity;
 
@@ -36,6 +45,14 @@ export class MarkerGL {
 
         this.manager = manager;
         this.particles = this.manager.particles;
+
+        /**
+         * A `Transform64` carries no signals - that is the point of it - so the marker is told
+         * that it moved by the dataset that holds it, and cannot be started without one.
+         *
+         * @type {EntityComponentDataset}
+         */
+        this.dataset = dataset;
     }
 
     updatePosition() {
@@ -88,7 +105,15 @@ export class MarkerGL {
     startup() {
         this.active = true;
 
-        this.transform.position.process(this.updatePosition, this);
+        // One listener where there was a sub-object subscription, because the component announces
+        // itself whole rather than a channel at a time. `process` used to fold the first placement
+        // into the subscription; it is its own call now.
+        this.dataset.addEntityEventListener(
+            this.entity, TRANSFORM64_EVENT_CHANGE, this.updatePosition, this
+        );
+
+        this.updatePosition();
+
         this.marker.iconURL.onChanged.add(this.updateIcon, this);
         this.updateIcon(this.marker.iconURL.getValue(), null);
 
@@ -108,7 +133,9 @@ export class MarkerGL {
     shutdown() {
         this.active = false;
 
-        this.transform.position.onChanged.remove(this.updatePosition, this);
+        this.dataset.removeEntityEventListener(
+            this.entity, TRANSFORM64_EVENT_CHANGE, this.updatePosition, this
+        );
 
         this.marker.iconURL.onChanged.remove(this.updateIcon, this);