Merge 10d3b53205 into a7a2aad2b6

.gitignore

@@ -56,3 +56,5 @@ config.local.js
 # Editor artifacts
 *.*.swp
 *.*.swo
+
+.history/

src/js/core/utils.js

@@ -682,6 +682,44 @@ export function smoothPulse(time) {
     return Math.sin(time * 4) * 0.5 + 0.5;
 }
 
+let logIntervals = {};
+const intervalStyle = "color: grey; font-style: inherit";
+const keyStyle = "color: purple; font-style: italic";
+const revertStyle = "color: inherit; font-style: inherit";
+
+export function logInterval(key, frames, message, ...args) {
+    let interval = logIntervals[key] || 0;
+    if (++interval > frames) {
+        console.log(
+            `%clogInterval [%c${key}%c]: \t%c` + message,
+            intervalStyle,
+            keyStyle,
+            intervalStyle,
+            revertStyle,
+            ...args
+        );
+        interval = 0;
+    }
+    logIntervals[key] = interval;
+}
+
+export function dirInterval(key, frames, object, premessage, ...args) {
+    let interval = logIntervals[key] || 0;
+    if (++interval > frames) {
+        console.log(
+            `%cdirInterval [%c${key}%c]: \t%c` + (premessage || ""),
+            intervalStyle,
+            keyStyle,
+            intervalStyle,
+            revertStyle,
+            ...args
+        );
+        console.dir(object);
+        interval = 0;
+    }
+    logIntervals[key] = interval;
+}
+
 /**
  * Fills in a <link> tag
  * @param {string} translation

src/js/game/belt_path.js

@@ -630,9 +630,10 @@ export class BeltPath extends BasicSerializableObject {
         beltComp.assignedPath = null;
 
         const entityLength = beltComp.getEffectiveLengthTiles();
-        assert(this.entityPath.indexOf(entity) >= 0, "Entity not contained for split");
+        const index = this.entityPath.indexOf(entity);
-        assert(this.entityPath.indexOf(entity) !== 0, "Entity is first");
+        assert(index >= 0, "Entity not contained for split");
-        assert(this.entityPath.indexOf(entity) !== this.entityPath.length - 1, "Entity is last");
+        assert(index !== 0, "Entity is first");
+        assert(index !== this.entityPath.length - 1, "Entity is last");
 
         let firstPathEntityCount = 0;
         let firstPathLength = 0;

src/js/game/blueprint.js

@@ -58,6 +58,37 @@ export class Blueprint {
         return new Blueprint(newEntities);
     }
 
+    /**
+     * Creates a new blueprint from the given entity uids
+     * @param {Array<Entity>} entities
+     */
+    static fromEntities(entities) {
+        const newEntities = [];
+
+        let averagePosition = new Vector();
+
+        // First, create a copy
+        for (let i = entities.length - 1; i >= 0; --i) {
+            const entity = entities[i];
+
+            const clone = entity.clone();
+            newEntities.push(clone);
+
+            const pos = entity.components.StaticMapEntity.getTileSpaceBounds().getCenter();
+            averagePosition.addInplace(pos);
+        }
+
+        averagePosition.divideScalarInplace(entities.length);
+        const blueprintOrigin = averagePosition.subScalars(0.5, 0.5).floor();
+
+        for (let i = newEntities.length - 1; i >= 0; --i) {
+            newEntities[i].components.StaticMapEntity.origin.subInplace(blueprintOrigin);
+        }
+
+        // Now, make sure the origin is 0,0
+        return new Blueprint(newEntities);
+    }
+
     /**
      * Returns the cost of this blueprint in shapes
      */

src/js/game/core.js

@@ -437,7 +437,7 @@ export class GameCore {
         this.overlayAlpha = lerp(this.overlayAlpha, desiredOverlayAlpha, 0.25);
 
         // On low performance, skip the fade
-        if (this.root.entityMgr.entities.length > 5000 || this.root.dynamicTickrate.averageFps < 50) {
+        if (this.root.entityMgr.entities.size > 5000 || this.root.dynamicTickrate.averageFps < 50) {
             this.overlayAlpha = desiredOverlayAlpha;
         }
 

src/js/game/entity_manager.js

@@ -1,4 +1,3 @@
-import { arrayDeleteValue, newEmptyMap, fastArrayDeleteValue } from "../core/utils";
 import { Component } from "./component";
 import { GameRoot } from "./root";
 import { Entity } from "./entity";
@@ -10,8 +9,8 @@ const logger = createLogger("entity_manager");
 
 // Manages all entities
 
-// NOTICE: We use arrayDeleteValue instead of fastArrayDeleteValue since that does not preserve the order
+/** @typedef {number} EntityUid */
-// This is slower but we need it for the street path generation
+/** @typedef {string} ComponentId */
 
 export class EntityManager extends BasicSerializableObject {
     constructor(root) {
@@ -20,19 +19,20 @@ export class EntityManager extends BasicSerializableObject {
         /** @type {GameRoot} */
         this.root = root;
 
-        /** @type {Array<Entity>} */
+        /** @type {Set<Entity>} */
-        this.entities = [];
+        this.entities = new Set();
+
+        /** @type {Map<EntityUid, Entity>} */
+        this.entitiesByUid = new Map();
+
+        /** @type {Map<ComponentId, Set<Entity>>} */
+        this.entitiesByComponent = new Map();
 
         // We store a separate list with entities to destroy, since we don't destroy
         // them instantly
         /** @type {Array<Entity>} */
         this.destroyList = [];
 
-        // Store a map from componentid to entities - This is used by the game system
-        // for faster processing
-        /** @type {Object.<string, Array<Entity>>} */
-        this.componentToEntity = newEmptyMap();
-
         // Store the next uid to use
         this.nextUid = 10000;
     }
@@ -48,7 +48,7 @@ export class EntityManager extends BasicSerializableObject {
     }
 
     getStatsText() {
-        return this.entities.length + " entities [" + this.destroyList.length + " to kill]";
+        return this.entities.size + " entities [" + this.destroyList.length + " to kill]";
     }
 
     // Main update
@@ -56,6 +56,19 @@ export class EntityManager extends BasicSerializableObject {
         this.processDestroyList();
     }
 
+    /**
+     * @param {Entity} entity
+     * @param {ComponentId} componentId
+     */
+    addToComponentMap(entity, componentId) {
+        let set;
+        if ((set = this.entitiesByComponent.get(componentId))) {
+            set.add(entity);
+        } else {
+            this.entitiesByComponent.set(componentId, new Set([entity]));
+        }
+    }
+
     /**
      * Registers a new entity
      * @param {Entity} entity
@@ -63,7 +76,7 @@ export class EntityManager extends BasicSerializableObject {
      */
     registerEntity(entity, uid = null) {
         if (G_IS_DEV && !globalConfig.debug.disableSlowAsserts) {
-            assert(this.entities.indexOf(entity) < 0, `RegisterEntity() called twice for entity ${entity}`);
+            assert(!this.entities.has(entity), `RegisterEntity() called twice for entity ${entity}`);
         }
         assert(!entity.destroyed, `Attempting to register destroyed entity ${entity}`);
 
@@ -72,21 +85,17 @@ export class EntityManager extends BasicSerializableObject {
             assert(uid >= 0 && uid < Number.MAX_SAFE_INTEGER, "Invalid uid passed: " + uid);
         }
 
-        this.entities.push(entity);
+        // Give each entity a unique id
+        entity.uid = uid || this.generateUid();
+
+        this.entities.add(entity);
+        this.entitiesByUid.set(uid, entity);
 
         // Register into the componentToEntity map
         for (const componentId in entity.components) {
-            if (entity.components[componentId]) {
+            this.addToComponentMap(entity, componentId);
-                if (this.componentToEntity[componentId]) {
-                    this.componentToEntity[componentId].push(entity);
-                } else {
-                    this.componentToEntity[componentId] = [entity];
-                }
-            }
         }
 
-        // Give each entity a unique id
-        entity.uid = uid ? uid : this.generateUid();
         entity.registered = true;
 
         this.root.signals.entityAdded.dispatch(entity);
@@ -108,11 +117,8 @@ export class EntityManager extends BasicSerializableObject {
     attachDynamicComponent(entity, component) {
         entity.addComponent(component, true);
         const componentId = /** @type {typeof Component} */ (component.constructor).getId();
-        if (this.componentToEntity[componentId]) {
+
-            this.componentToEntity[componentId].push(entity);
+        this.addToComponentMap(entity, componentId);
-        } else {
-            this.componentToEntity[componentId] = [entity];
-        }
         this.root.signals.entityGotNewComponent.dispatch(entity);
     }
 
@@ -125,7 +131,7 @@ export class EntityManager extends BasicSerializableObject {
         entity.removeComponent(component, true);
         const componentId = /** @type {typeof Component} */ (component.constructor).getId();
 
-        fastArrayDeleteValue(this.componentToEntity[componentId], entity);
+        this.entitiesByComponent.get(componentId).delete(entity);
         this.root.signals.entityComponentRemoved.dispatch(entity);
     }
 
@@ -136,18 +142,15 @@ export class EntityManager extends BasicSerializableObject {
      * @returns {Entity}
      */
     findByUid(uid, errorWhenNotFound = true) {
-        const arr = this.entities;
+        const entity = this.entitiesByUid.get(uid);
-        for (let i = 0, len = arr.length; i < len; ++i) {
+        if (entity) {
-            const entity = arr[i];
+            if (entity.queuedForDestroy || entity.destroyed) {
-            if (entity.uid === uid) {
+                if (errorWhenNotFound) {
-                if (entity.queuedForDestroy || entity.destroyed) {
+                    logger.warn("Entity with UID", uid, "not found (destroyed)");
-                    if (errorWhenNotFound) {
-                        logger.warn("Entity with UID", uid, "not found (destroyed)");
-                    }
-                    return null;
                 }
-                return entity;
+                return null;
             }
+            return entity;
         }
         if (errorWhenNotFound) {
             logger.warn("Entity with UID", uid, "not found");
@@ -162,15 +165,7 @@ export class EntityManager extends BasicSerializableObject {
      * @returns {Map<number, Entity>}
      */
     getFrozenUidSearchMap() {
-        const result = new Map();
+        return this.entitiesByUid;
-        const array = this.entities;
-        for (let i = 0, len = array.length; i < len; ++i) {
-            const entity = array[i];
-            if (!entity.queuedForDestroy && !entity.destroyed) {
-                result.set(entity.uid, entity);
-            }
-        }
-        return result;
     }
 
     /**
@@ -179,7 +174,9 @@ export class EntityManager extends BasicSerializableObject {
      * @returns {Array<Entity>} entities
      */
     getAllWithComponent(componentHandle) {
-        return this.componentToEntity[componentHandle.getId()] || [];
+        const set = this.entitiesByComponent.get(componentHandle.getId());
+        if (!set) return [];
+        else return [...set.values()];
     }
 
     /**
@@ -188,20 +185,20 @@ export class EntityManager extends BasicSerializableObject {
      */
     unregisterEntityComponents(entity) {
         for (const componentId in entity.components) {
-            if (entity.components[componentId]) {
+            const set = this.entitiesByComponent.get(componentId);
-                arrayDeleteValue(this.componentToEntity[componentId], entity);
+            if (set) set.delete(entity);
-            }
         }
     }
 
     // Processes the entities to destroy and actually destroys them
     /* eslint-disable max-statements */
     processDestroyList() {
-        for (let i = 0; i < this.destroyList.length; ++i) {
+        for (let i = this.destroyList.length - 1; i >= 0; --i) {
             const entity = this.destroyList[i];
 
             // Remove from entities list
-            arrayDeleteValue(this.entities, entity);
+            this.entities.delete(entity);
+            this.entitiesByUid.delete(entity.uid);
 
             // Remove from componentToEntity list
             this.unregisterEntityComponents(entity);
@@ -230,12 +227,8 @@ export class EntityManager extends BasicSerializableObject {
             return;
         }
 
-        if (this.destroyList.indexOf(entity) < 0) {
+        this.destroyList.push(entity);
-            this.destroyList.push(entity);
+        entity.queuedForDestroy = true;
-            entity.queuedForDestroy = true;
+        this.root.signals.entityQueuedForDestroy.dispatch(entity);
-            this.root.signals.entityQueuedForDestroy.dispatch(entity);
-        } else {
-            assert(false, "Trying to destroy entity twice");
-        }
     }
 }

src/js/game/game_system_with_filter.js

@@ -5,8 +5,6 @@ import { Entity } from "./entity";
 
 import { GameRoot } from "./root";
 import { GameSystem } from "./game_system";
-import { arrayDelete, arrayDeleteValue } from "../core/utils";
-import { globalConfig } from "../core/config";
 
 export class GameSystemWithFilter extends GameSystem {
     /**
@@ -22,9 +20,12 @@ export class GameSystemWithFilter extends GameSystem {
 
         /**
          * All entities which match the current components
-         * @type {Array<Entity>}
+         * @type {Set<Entity>}
          */
-        this.allEntities = [];
+        this.allEntitiesSet = new Set();
+        this.allEntitiesArray = [];
+        this.allEntitiesArrayIsOutdated = true;
+        this.entitiesQueuedToDelete = [];
 
         this.root.signals.entityAdded.add(this.internalPushEntityIfMatching, this);
         this.root.signals.entityGotNewComponent.add(this.internalReconsiderEntityToAdd, this);
@@ -35,6 +36,13 @@ export class GameSystemWithFilter extends GameSystem {
         this.root.signals.bulkOperationFinished.add(this.refreshCaches, this);
     }
 
+    tryUpdateEntitiesArray() {
+        if (this.allEntitiesArrayIsOutdated) {
+            this.allEntitiesArray = [...this.allEntitiesSet.values()];
+            this.allEntitiesArrayIsOutdated = false;
+        }
+    }
+
     /**
      * @param {Entity} entity
      */
@@ -45,11 +53,7 @@ export class GameSystemWithFilter extends GameSystem {
             }
         }
 
-        // This is slow!
+        assert(!this.allEntitiesSet.has(entity), "entity already in list: " + entity);
-        if (G_IS_DEV && !globalConfig.debug.disableSlowAsserts) {
-            assert(this.allEntities.indexOf(entity) < 0, "entity already in list: " + entity);
-        }
-
         this.internalRegisterEntity(entity);
     }
 
@@ -58,7 +62,7 @@ export class GameSystemWithFilter extends GameSystem {
      * @param {Entity} entity
      */
     internalCheckEntityAfterComponentRemoval(entity) {
-        if (this.allEntities.indexOf(entity) < 0) {
+        if (!this.allEntitiesSet.has(entity)) {
             // Entity wasn't interesting anyways
             return;
         }
@@ -66,7 +70,7 @@ export class GameSystemWithFilter extends GameSystem {
         for (let i = 0; i < this.requiredComponentIds.length; ++i) {
             if (!entity.components[this.requiredComponentIds[i]]) {
                 // Entity is not interesting anymore
-                arrayDeleteValue(this.allEntities, entity);
+                this.allEntitiesArrayIsOutdated = this.allEntitiesSet.delete(entity);
             }
         }
     }
@@ -81,7 +85,7 @@ export class GameSystemWithFilter extends GameSystem {
                 return;
             }
         }
-        if (this.allEntities.indexOf(entity) >= 0) {
+        if (this.allEntitiesSet.has(entity)) {
             return;
         }
         this.internalRegisterEntity(entity);
@@ -89,15 +93,15 @@ export class GameSystemWithFilter extends GameSystem {
 
     refreshCaches() {
         // Remove all entities which are queued for destroy
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        if (this.entitiesQueuedToDelete.length > 0) {
-            const entity = this.allEntities[i];
+            for (let i = this.entitiesQueuedToDelete.length - 1; i >= 0; --i) {
-            if (entity.queuedForDestroy || entity.destroyed) {
+                this.allEntitiesSet.delete(this.entitiesQueuedToDelete[i]);
-                this.allEntities.splice(i, 1);
-                i -= 1;
             }
+            this.entitiesQueuedToDelete = [];
         }
 
-        this.allEntities.sort((a, b) => a.uid - b.uid);
+        // called here in case a delete executed mid frame
+        this.tryUpdateEntitiesArray();
     }
 
     /**
@@ -112,12 +116,8 @@ export class GameSystemWithFilter extends GameSystem {
      * @param {Entity} entity
      */
     internalRegisterEntity(entity) {
-        this.allEntities.push(entity);
+        this.allEntitiesSet.add(entity);
-
+        this.allEntitiesArray.push(entity);
-        if (this.root.gameInitialized && !this.root.bulkOperationRunning) {
-            // Sort entities by uid so behaviour is predictable
-            this.allEntities.sort((a, b) => a.uid - b.uid);
-        }
     }
 
     /**
@@ -126,12 +126,9 @@ export class GameSystemWithFilter extends GameSystem {
      */
     internalPopEntityIfMatching(entity) {
         if (this.root.bulkOperationRunning) {
-            // We do this in refreshCaches afterwards
+            this.entitiesQueuedToDelete.push(entity);
             return;
         }
-        const index = this.allEntities.indexOf(entity);
+        this.allEntitiesArrayIsOutdated = this.allEntitiesSet.delete(entity);
-        if (index >= 0) {
-            arrayDelete(this.allEntities, index);
-        }
     }
 }

src/js/game/hud/hud.js

@@ -38,7 +38,7 @@ export class GameHUD {
             shapePinRequested: /** @type {TypedSignal<[ShapeDefinition]>} */ (new Signal()),
             shapeUnpinRequested: /** @type {TypedSignal<[string]>} */ (new Signal()),
             notification: /** @type {TypedSignal<[string, enumNotificationType]>} */ (new Signal()),
-            buildingsSelectedForCopy: /** @type {TypedSignal<[Array<number>]>} */ (new Signal()),
+            buildingsSelectedForCopy: /** @type {TypedSignal<[Array]>} */ (new Signal()),
             pasteBlueprintRequested: /** @type {TypedSignal<[]>} */ (new Signal()),
             viewShapeDetailsRequested: /** @type {TypedSignal<[ShapeDefinition]>} */ (new Signal()),
             unlockNotificationFinished: /** @type {TypedSignal<[]>} */ (new Signal()),

src/js/game/hud/parts/blueprint_placer.js

@@ -10,6 +10,7 @@ import { enumMouseButton } from "../../camera";
 import { KEYMAPPINGS } from "../../key_action_mapper";
 import { BaseHUDPart } from "../base_hud_part";
 import { DynamicDomAttach } from "../dynamic_dom_attach";
+import { Entity } from "../../entity";
 
 export class HUDBlueprintPlacer extends BaseHUDPart {
     createElements(parent) {
@@ -150,13 +151,13 @@ export class HUDBlueprintPlacer extends BaseHUDPart {
 
     /**
      * Called when an array of bulidings was selected
-     * @param {Array<number>} uids
+     * @param {Array<Entity>} uids
      */
-    createBlueprintFromBuildings(uids) {
+    createBlueprintFromBuildings(entities) {
-        if (uids.length === 0) {
+        if (entities.length === 0) {
             return;
         }
-        this.currentBlueprint.set(Blueprint.fromUids(this.root, uids));
+        this.currentBlueprint.set(Blueprint.fromEntities(entities));
     }
 
     /**

src/js/game/hud/parts/keybinding_overlay.js

@@ -101,7 +101,7 @@ export class HUDKeybindingOverlay extends BaseHUDPart {
      */
     get anythingSelectedOnMap() {
         const selector = this.root.hud.parts.massSelector;
-        return selector && selector.selectedUids.size > 0;
+        return selector && selector.selectedEntities.size > 0;
     }
 
     /**

src/js/game/hud/parts/mass_selector.js

@@ -1,6 +1,5 @@
 import { globalConfig } from "../../../core/config";
 import { DrawParameters } from "../../../core/draw_parameters";
-import { gMetaBuildingRegistry } from "../../../core/global_registries";
 import { createLogger } from "../../../core/logging";
 import { STOP_PROPAGATION } from "../../../core/signal";
 import { formatBigNumberFull } from "../../../core/utils";
@@ -8,15 +7,12 @@ import { Vector } from "../../../core/vector";
 import { ACHIEVEMENTS } from "../../../platform/achievement_provider";
 import { T } from "../../../translations";
 import { Blueprint } from "../../blueprint";
-import { MetaBlockBuilding } from "../../buildings/block";
-import { MetaConstantProducerBuilding } from "../../buildings/constant_producer";
-import { enumMouseButton } from "../../camera";
-import { Component } from "../../component";
 import { Entity } from "../../entity";
 import { KEYMAPPINGS } from "../../key_action_mapper";
 import { THEME } from "../../theme";
 import { enumHubGoalRewards } from "../../tutorial_goals";
 import { BaseHUDPart } from "../base_hud_part";
+import { enumMouseButton } from "../../camera";
 
 const logger = createLogger("hud/mass_selector");
 
@@ -26,7 +22,9 @@ export class HUDMassSelector extends BaseHUDPart {
     initialize() {
         this.currentSelectionStartWorld = null;
         this.currentSelectionEnd = null;
-        this.selectedUids = new Set();
+
+        /** @type {Set<Entity>} */
+        this.selectedEntities = new Set();
 
         this.root.signals.entityQueuedForDestroy.add(this.onEntityDestroyed, this);
         this.root.hud.signals.pasteBlueprintRequested.add(this.clearSelection, this);
@@ -47,6 +45,10 @@ export class HUDMassSelector extends BaseHUDPart {
         this.root.signals.editModeChanged.add(this.clearSelection, this);
     }
 
+    clear() {
+        this.selectedEntities.clear();
+    }
+
     /**
      * Handles the destroy callback and makes sure we clean our list
      * @param {Entity} entity
@@ -55,7 +57,7 @@ export class HUDMassSelector extends BaseHUDPart {
         if (this.root.bulkOperationRunning) {
             return;
         }
-        this.selectedUids.delete(entity.uid);
+        this.selectedEntities.delete(entity);
     }
 
     /**
@@ -63,8 +65,8 @@ export class HUDMassSelector extends BaseHUDPart {
      */
     onBack() {
         // Clear entities on escape
-        if (this.selectedUids.size > 0) {
+        if (this.selectedEntities.size > 0) {
-            this.selectedUids = new Set();
+            this.clear();
             return STOP_PROPAGATION;
         }
     }
@@ -73,19 +75,19 @@ export class HUDMassSelector extends BaseHUDPart {
      * Clears the entire selection
      */
     clearSelection() {
-        this.selectedUids = new Set();
+        this.clear();
     }
 
     confirmDelete() {
         if (
             !this.root.app.settings.getAllSettings().disableCutDeleteWarnings &&
-            this.selectedUids.size > 100
+            this.selectedEntities.size > 100
         ) {
             const { ok } = this.root.hud.parts.dialogs.showWarning(
                 T.dialogs.massDeleteConfirm.title,
                 T.dialogs.massDeleteConfirm.desc.replace(
                     "<count>",
-                    "" + formatBigNumberFull(this.selectedUids.size)
+                    "" + formatBigNumberFull(this.selectedEntities.size)
                 ),
                 ["cancel:good:escape", "ok:bad:enter"]
             );
@@ -96,25 +98,16 @@ export class HUDMassSelector extends BaseHUDPart {
     }
 
     doDelete() {
-        const entityUids = Array.from(this.selectedUids);
-
         // Build mapping from uid to entity
         /**
          * @type {Map<number, Entity>}
          */
-        const mapUidToEntity = this.root.entityMgr.getFrozenUidSearchMap();
 
         let count = 0;
         this.root.logic.performBulkOperation(() => {
-            for (let i = 0; i < entityUids.length; ++i) {
+            const arr = [...this.selectedEntities.values()];
-                const uid = entityUids[i];
+            for (let i = arr.length - 1; i >= 0; --i) {
-                const entity = mapUidToEntity.get(uid);
+                if (!this.root.logic.tryDeleteBuilding(arr[i])) {
-                if (!entity) {
-                    logger.error("Entity not found by uid:", uid);
-                    continue;
-                }
-
-                if (!this.root.logic.tryDeleteBuilding(entity)) {
                     logger.error("Error in mass delete, could not remove building");
                 } else {
                     count++;
@@ -124,12 +117,11 @@ export class HUDMassSelector extends BaseHUDPart {
             this.root.signals.achievementCheck.dispatch(ACHIEVEMENTS.destroy1000, count);
         });
 
-        // Clear uids later
+        this.clear();
-        this.selectedUids = new Set();
     }
 
     startCopy() {
-        if (this.selectedUids.size > 0) {
+        if (this.selectedEntities.size > 0) {
             if (!this.root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_blueprints)) {
                 this.root.hud.parts.dialogs.showInfo(
                     T.dialogs.blueprintsNotUnlocked.title,
@@ -137,8 +129,10 @@ export class HUDMassSelector extends BaseHUDPart {
                 );
                 return;
             }
-            this.root.hud.signals.buildingsSelectedForCopy.dispatch(Array.from(this.selectedUids));
+
-            this.selectedUids = new Set();
+            // @ts-ignore
+            this.root.hud.signals.buildingsSelectedForCopy.dispatch([...this.selectedEntities.values()]);
+            this.selectedEntities.clear();
             this.root.soundProxy.playUiClick();
         } else {
             this.root.soundProxy.playUiError();
@@ -146,13 +140,12 @@ export class HUDMassSelector extends BaseHUDPart {
     }
 
     clearBelts() {
-        for (const uid of this.selectedUids) {
+        for (const entity of this.selectedEntities) {
-            const entity = this.root.entityMgr.findByUid(uid);
             for (const component of Object.values(entity.components)) {
                 /** @type {Component} */ (component).clear();
             }
         }
-        this.selectedUids = new Set();
+        this.selectedEntities = new Set();
     }
 
     confirmCut() {
@@ -163,13 +156,13 @@ export class HUDMassSelector extends BaseHUDPart {
             );
         } else if (
             !this.root.app.settings.getAllSettings().disableCutDeleteWarnings &&
-            this.selectedUids.size > 100
+            this.selectedEntities.size > 100
         ) {
             const { ok } = this.root.hud.parts.dialogs.showWarning(
                 T.dialogs.massCutConfirm.title,
                 T.dialogs.massCutConfirm.desc.replace(
                     "<count>",
-                    "" + formatBigNumberFull(this.selectedUids.size)
+                    "" + formatBigNumberFull(this.selectedEntities.size)
                 ),
                 ["cancel:good:escape", "ok:bad:enter"]
             );
@@ -180,26 +173,26 @@ export class HUDMassSelector extends BaseHUDPart {
     }
 
     doCut() {
-        if (this.selectedUids.size > 0) {
+        if (this.selectedEntities.size > 0) {
-            const entityUids = Array.from(this.selectedUids);
+            const cutAction = argArray => {
-
+                const arr = argArray || [...this.selectedEntities.values()];
-            const cutAction = () => {
                 // copy code relies on entities still existing, so must copy before deleting.
-                this.root.hud.signals.buildingsSelectedForCopy.dispatch(entityUids);
 
-                for (let i = 0; i < entityUids.length; ++i) {
+                this.root.hud.signals.buildingsSelectedForCopy.dispatch(arr);
-                    const uid = entityUids[i];
+
-                    const entity = this.root.entityMgr.findByUid(uid);
+                for (let i = arr.length - 1; i >= 0; --i) {
+                    const entity = arr[i];
                     if (!this.root.logic.tryDeleteBuilding(entity)) {
                         logger.error("Error in mass cut, could not remove building");
-                        this.selectedUids.delete(uid);
+                        this.selectedEntities.delete(entity);
                     }
                 }
             };
 
-            const blueprint = Blueprint.fromUids(this.root, entityUids);
+            const arr = [...this.selectedEntities.values()];
+            const blueprint = Blueprint.fromEntities(arr);
             if (blueprint.canAfford(this.root)) {
-                cutAction();
+                cutAction(arr);
             } else {
                 const { cancel, ok } = this.root.hud.parts.dialogs.showWarning(
                     T.dialogs.massCutInsufficientConfirm.title,
@@ -231,7 +224,7 @@ export class HUDMassSelector extends BaseHUDPart {
 
         if (!this.root.keyMapper.getBinding(KEYMAPPINGS.massSelect.massSelectSelectMultiple).pressed) {
             // Start new selection
-            this.selectedUids = new Set();
+            this.clear();
         }
 
         this.currentSelectionStartWorld = this.root.camera.screenToWorld(pos.copy());
@@ -270,8 +263,7 @@ export class HUDMassSelector extends BaseHUDPart {
                         if (!staticComp.getMetaBuilding().getIsRemovable(this.root)) {
                             continue;
                         }
-
+                        this.selectedEntities.add(contents);
-                        this.selectedUids.add(contents.uid);
                     }
                 }
             }
@@ -350,18 +342,22 @@ export class HUDMassSelector extends BaseHUDPart {
         }
 
         parameters.context.fillStyle = THEME.map.selectionOverlay;
-        this.selectedUids.forEach(uid => {
+
-            const entity = this.root.entityMgr.findByUid(uid);
+        if (this.selectedEntities.size > 0) {
-            const staticComp = entity.components.StaticMapEntity;
+            const arr = [...this.selectedEntities.values()];
-            const bounds = staticComp.getTileSpaceBounds();
+            for (let i = arr.length - 1; i >= 0; --i) {
-            parameters.context.beginRoundedRect(
+                const entity = arr[i];
-                bounds.x * globalConfig.tileSize + boundsBorder,
+                const staticComp = entity.components.StaticMapEntity;
-                bounds.y * globalConfig.tileSize + boundsBorder,
+                const bounds = staticComp.getTileSpaceBounds();
-                bounds.w * globalConfig.tileSize - 2 * boundsBorder,
+                parameters.context.beginRoundedRect(
-                bounds.h * globalConfig.tileSize - 2 * boundsBorder,
+                    bounds.x * globalConfig.tileSize + boundsBorder,
-                2
+                    bounds.y * globalConfig.tileSize + boundsBorder,
-            );
+                    bounds.w * globalConfig.tileSize - 2 * boundsBorder,
-            parameters.context.fill();
+                    bounds.h * globalConfig.tileSize - 2 * boundsBorder,
-        });
+                    2
+                );
+                parameters.context.fill();
+            }
+        }
     }
 }

src/js/game/hud/parts/wires_overlay.js

@@ -8,6 +8,7 @@ import { KEYMAPPINGS } from "../../key_action_mapper";
 import { enumHubGoalRewards } from "../../tutorial_goals";
 import { BaseHUDPart } from "../base_hud_part";
 
+// @ts-ignore
 const copy = require("clipboard-copy");
 const wiresBackgroundDpi = 4;
 
@@ -64,7 +65,7 @@ export class HUDWiresOverlay extends BaseHUDPart {
         const desiredAlpha = this.root.currentLayer === "wires" ? 1.0 : 0.0;
 
         // On low performance, skip the fade
-        if (this.root.entityMgr.entities.length > 5000 || this.root.dynamicTickrate.averageFps < 50) {
+        if (this.root.entityMgr.entities.size > 5000 || this.root.dynamicTickrate.averageFps < 50) {
             this.currentAlpha = desiredAlpha;
         } else {
             this.currentAlpha = lerp(this.currentAlpha, desiredAlpha, 0.12);

src/js/game/systems/belt.js

@@ -425,8 +425,8 @@ export class BeltSystem extends GameSystemWithFilter {
 
         const result = [];
 
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             if (visitedUids.has(entity.uid)) {
                 continue;
             }

src/js/game/systems/belt_reader.js

@@ -12,8 +12,9 @@ export class BeltReaderSystem extends GameSystemWithFilter {
         const now = this.root.time.now();
         const minimumTime = now - globalConfig.readerAnalyzeIntervalSeconds;
         const minimumTimeForThroughput = now - 1;
-        for (let i = 0; i < this.allEntities.length; ++i) {
+
-            const entity = this.allEntities[i];
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
+            const entity = this.allEntitiesArray[i];
             const readerComp = entity.components.BeltReader;
             const pinsComp = entity.components.WiredPins;
 

src/js/game/systems/constant_producer.js

@@ -14,8 +14,8 @@ export class ConstantProducerSystem extends GameSystemWithFilter {
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const signalComp = entity.components.ConstantSignal;
             const ejectorComp = entity.components.ItemEjector;
             if (!ejectorComp) {

src/js/game/systems/constant_signal.js

@@ -24,8 +24,8 @@ export class ConstantSignalSystem extends GameSystemWithFilter {
 
     update() {
         // Set signals
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const signalComp = entity.components.ConstantSignal;
             const pinsComp = entity.components.WiredPins;
 

src/js/game/systems/filter.js

@@ -20,8 +20,8 @@ export class FilterSystem extends GameSystemWithFilter {
 
         const requiredProgress = 1 - progress;
 
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const filterComp = entity.components.Filter;
             const ejectorComp = entity.components.ItemEjector;
 

src/js/game/systems/goal_acceptor.js

@@ -20,8 +20,8 @@ export class GoalAcceptorSystem extends GameSystemWithFilter {
 
         let allAccepted = true;
 
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const goalComp = entity.components.GoalAcceptor;
 
             if (!goalComp.lastDelivery) {

src/js/game/systems/hub.js

@@ -25,15 +25,15 @@ export class HubSystem extends GameSystemWithFilter {
      * @param {DrawParameters} parameters
      */
     draw(parameters) {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            this.drawEntity(parameters, this.allEntities[i]);
+            this.drawEntity(parameters, this.allEntitiesArray[i]);
         }
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = 0; i < this.allEntitiesArray.length; ++i) {
             // Set hub goal
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const pinsComp = entity.components.WiredPins;
             pinsComp.slots[0].value = this.root.shapeDefinitionMgr.getShapeItemFromDefinition(
                 this.root.hubGoals.currentGoal.definition

src/js/game/systems/item_acceptor.js

@@ -39,8 +39,8 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
         // Reset accumulated ticks
         this.accumulatedTicksWhileInMapOverview = 0;
 
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const aceptorComp = entity.components.ItemAcceptor;
             const animations = aceptorComp.itemConsumptionAnimations;
 

src/js/game/systems/item_ejector.js

@@ -3,6 +3,7 @@ import { DrawParameters } from "../../core/draw_parameters";
 import { createLogger } from "../../core/logging";
 import { Rectangle } from "../../core/rectangle";
 import { StaleAreaDetector } from "../../core/stale_area_detector";
+import { dirInterval } from "../../core/utils";
 import { enumDirection, enumDirectionToVector } from "../../core/vector";
 import { ACHIEVEMENTS } from "../../platform/achievement_provider";
 import { BaseItem } from "../base_item";
@@ -61,8 +62,8 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
      */
     recomputeCacheFull() {
         logger.log("Full cache recompute in post load hook");
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             this.recomputeSingleEntityCache(entity);
         }
     }
@@ -147,8 +148,8 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
         }
 
         // Go over all cache entries
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const sourceEntity = this.allEntities[i];
+            const sourceEntity = this.allEntitiesArray[i];
             const sourceEjectorComp = sourceEntity.components.ItemEjector;
 
             const slots = sourceEjectorComp.slots;

src/js/game/systems/item_processor.js

@@ -70,9 +70,8 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
-
             const processorComp = entity.components.ItemProcessor;
             const ejectorComp = entity.components.ItemEjector;
 

src/js/game/systems/item_producer.js

@@ -13,9 +13,8 @@ export class ItemProducerSystem extends GameSystemWithFilter {
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
-            const ejectorComp = entity.components.ItemEjector;
             const pinsComp = entity.components.WiredPins;
             if (!pinsComp) {
                 continue;

src/js/game/systems/lever.js

@@ -14,9 +14,8 @@ export class LeverSystem extends GameSystemWithFilter {
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
-
             const leverComp = entity.components.Lever;
             const pinsComp = entity.components.WiredPins;
 

src/js/game/systems/logic_gate.js

@@ -30,8 +30,8 @@ export class LogicGateSystem extends GameSystemWithFilter {
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const logicComp = entity.components.LogicGate;
             const slotComp = entity.components.WiredPins;
 

src/js/game/systems/miner.js

@@ -36,8 +36,8 @@ export class MinerSystem extends GameSystemWithFilter {
             miningSpeed *= 100;
         }
 
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const minerComp = entity.components.Miner;
 
             // Reset everything on recompute

src/js/game/systems/storage.js

@@ -26,8 +26,8 @@ export class StorageSystem extends GameSystemWithFilter {
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const storageComp = entity.components.Storage;
             const pinsComp = entity.components.WiredPins;
 

src/js/game/systems/underground_belt.js

@@ -227,8 +227,8 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
         const sender = enumUndergroundBeltMode.sender;
         const now = this.root.time.now();
 
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            const entity = this.allEntities[i];
+            const entity = this.allEntitiesArray[i];
             const undergroundComp = entity.components.UndergroundBelt;
             if (undergroundComp.mode === sender) {
                 this.handleSender(entity);

src/js/savegame/savegame.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { ReadWriteProxy } from "../core/read_write_proxy";
 import { ExplainedResult } from "../core/explained_result";
 import { SavegameSerializer } from "./savegame_serializer";
@@ -208,7 +209,12 @@ export class Savegame extends ReadWriteProxy {
      * Returns if this game has a serialized game dump
      */
     hasGameDump() {
-        return !!this.currentData.dump && this.currentData.dump.entities.length > 0;
+        if (!this.currentData.dump) return false;
+        if (Array.isArray(this.currentData.dump.entities)) {
+            return this.currentData.dump.entities.length;
+        } else {
+            return this.currentData.dump.entities.size;
+        }
     }
 
     /**

src/js/savegame/savegame_serializer.js

@@ -70,9 +70,10 @@ export class SavegameSerializer {
         const seenUids = new Set();
 
         // Check for duplicate UIDS
-        for (let i = 0; i < savegame.entities.length; ++i) {
+        const entities = [...savegame.entities.values()];
+        for (let i = entities.length - 1; i >= 0; --i) {
             /** @type {Entity} */
-            const entity = savegame.entities[i];
+            const entity = entities[i];
 
             const uid = entity.uid;
             if (!Number.isInteger(uid)) {

src/js/savegame/savegame_typedefs.js

@@ -16,7 +16,7 @@
  *   hubGoals: any,
  *   pinnedShapes: any,
  *   waypoints: any,
- *   entities: Array<Entity>,
+ *   entities: Array<Entity>|Set<Entity>,
  *   beltPaths: Array<any>
  * }} SerializedGame
  *

src/js/savegame/schemas/1001.js

@@ -40,7 +40,7 @@ export class SavegameInterface_V1001 extends SavegameInterface_V1000 {
             ],
         };
 
-        const entities = dump.entities;
+        const entities = Array.isArray(dump.entities) ? dump.entities : [...dump.entities.values()];
         for (let i = 0; i < entities.length; ++i) {
             const entity = entities[i];
 

src/js/savegame/schemas/1002.js

@@ -24,7 +24,7 @@ export class SavegameInterface_V1002 extends SavegameInterface_V1001 {
             return true;
         }
 
-        const entities = dump.entities;
+        const entities = Array.isArray(dump.entities) ? dump.entities : [...dump.entities.values()];
         for (let i = 0; i < entities.length; ++i) {
             const entity = entities[i];
             const beltComp = entity.components.Belt;

src/js/savegame/schemas/1005.js

@@ -26,7 +26,7 @@ export class SavegameInterface_V1005 extends SavegameInterface_V1004 {
         // just reset belt paths for now
         dump.beltPaths = [];
 
-        const entities = dump.entities;
+        const entities = Array.isArray(dump.entities) ? dump.entities : [...dump.entities.values()];
 
         // clear ejector slots
         for (let i = 0; i < entities.length; ++i) {

src/js/savegame/schemas/1006.js

@@ -173,7 +173,8 @@ export class SavegameInterface_V1006 extends SavegameInterface_V1005 {
         dump.hubGoals.level = levelMapping[level] || level;
 
         // Update entities
-        const entities = dump.entities;
+        const entities = Array.isArray(dump.entities) ? dump.entities : [...dump.entities.values()];
+
         for (let i = 0; i < entities.length; ++i) {
             const entity = entities[i];
             const components = entity.components;
@@ -269,8 +270,17 @@ export class SavegameInterface_V1006 extends SavegameInterface_V1005 {
         newStaticComp.originalRotation = staticComp.originalRotation;
         newStaticComp.rotation = staticComp.rotation;
 
+        /**
+         * in one of our files:
+         * we dont seem to actually have a blueprintspritekey
+         *  but we do have this attribute called code
+         */
+
         // @ts-ignore
-        newStaticComp.code = spriteMapping[staticComp.blueprintSpriteKey];
+        if (staticComp.blueprintSpriteKey) {
+            // @ts-ignore
+            newStaticComp.code = spriteMapping[staticComp.blueprintSpriteKey];
+        } else newStaticComp.code = staticComp.code;
 
         // Hub special case
         if (entity.components.Hub) {
@@ -293,9 +303,11 @@ export class SavegameInterface_V1006 extends SavegameInterface_V1005 {
         }
 
         if (!newStaticComp.code) {
+            console.dir(entity);
+            console.dir(staticComp);
             throw new Error(
                 // @ts-ignore
-                "1006 Migration: Could not reconstruct code for " + staticComp.blueprintSpriteKey
+                "1006 Migration: Could not reconstruct code for " + code
             );
         }
 

src/js/savegame/serializer_internal.js

@@ -11,12 +11,15 @@ const logger = createLogger("serializer_internal");
 export class SerializerInternal {
     /**
      * Serializes an array of entities
-     * @param {Array<Entity>} array
+     * @param {Array<Entity>|Set<Entity>} array
      */
     serializeEntityArray(array) {
         const serialized = [];
-        for (let i = 0; i < array.length; ++i) {
+
-            const entity = array[i];
+        const arr = Array.isArray(array) ? array : [...array.values()];
+
+        for (let i = 0; i < arr.length; ++i) {
+            const entity = arr[i];
             if (!entity.queuedForDestroy && !entity.destroyed) {
                 serialized.push(entity.serialize());
             }

src/js/tslint.json

@@ -10,7 +10,8 @@
         "no-console": false,
         "forin": false,
         "no-empty": false,
-        "space-before-function-paren": ["always"]
+        "space-before-function-paren": ["always"],
+        "no-unused-declaration": true
     },
     "rulesDirectory": []
 }

src/js/webworkers/tsconfig.json

@@ -1,6 +1,6 @@
 {
     "compilerOptions": {
-        "lib": ["ES2018","WebWorker"]
+        "lib": ["ES2018", "WebWorker"]
     },
     "exclude": [],
     "extends": "../tsconfig",