fixed weird asset issues we had in our fork

src/js/core/config.local.js

@@ -9,7 +9,7 @@ export default {
     // noArtificialDelays: true,
     // -----------------------------------------------------------------------------------
     // Disables writing of savegames, useful for testing the same savegame over and over
-    // disableSavegameWrite: true,
+    disableSavegameWrite: true,
     // -----------------------------------------------------------------------------------
     // Shows bounds of all entities
     // showEntityBounds: true,
@@ -33,7 +33,7 @@ export default {
     // allBuildingsUnlocked: true,
     // -----------------------------------------------------------------------------------
     // Disables cost of blueprints
-    // blueprintsNoCost: true,
+    blueprintsNoCost: true,
     // -----------------------------------------------------------------------------------
     // Disables cost of upgrades
     // upgradesNoCost: true,
@@ -75,7 +75,7 @@ export default {
     // instantMiners: true,
     // -----------------------------------------------------------------------------------
     // When using fastGameEnter, controls whether a new game is started or the last one is resumed
-    // resumeGameOnFastEnter: true,
+    resumeGameOnFastEnter: true,
     // -----------------------------------------------------------------------------------
     // Special option used to render the trailer
     // renderForTrailer: true,

src/js/core/read_write_proxy.js

@@ -169,7 +169,7 @@ export class ReadWriteProxy {
                 // Check for errors during read
                 .catch(err => {
                     if (err === FILE_NOT_FOUND) {
-                        logger.log("File not found, using default data");
+                        logger.error("File not found, using default data");
 
                         // File not found or unreadable, assume default file
                         return Promise.resolve(null);

src/js/core/utils.js

@@ -671,6 +671,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

@@ -565,9 +565,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

@@ -57,6 +57,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

@@ -421,7 +421,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

@@ -13,6 +13,9 @@ const logger = createLogger("entity_manager");
 // NOTICE: We use arrayDeleteValue instead of fastArrayDeleteValue since that does not preserve the order
 // This is slower but we need it for the street path generation
 
+/** @typedef {number} EntityUid */
+/** @typedef {string} ComponentId */
+
 export class EntityManager extends BasicSerializableObject {
     constructor(root) {
         super();
@@ -20,8 +23,14 @@ 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
@@ -30,8 +39,8 @@ export class EntityManager extends BasicSerializableObject {
 
         // Store a map from componentid to entities - This is used by the game system
         // for faster processing
-        /** @type {Object.<string, Array<Entity>>} */
+        ///** @type {Object.<string, Array<Entity>>} */
-        this.componentToEntity = newEmptyMap();
+        //this.componentToEntity = newEmptyMap();
 
         // Store the next uid to use
         this.nextUid = 10000;
@@ -48,7 +57,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 +65,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 +85,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 +94,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 +126,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 +140,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,10 +151,8 @@ 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.uid === uid) {
             if (entity.queuedForDestroy || entity.destroyed) {
                 if (errorWhenNotFound) {
                     logger.warn("Entity with UID", uid, "not found (destroyed)");
@@ -148,7 +161,6 @@ export class EntityManager extends BasicSerializableObject {
             }
             return entity;
         }
-        }
         if (errorWhenNotFound) {
             logger.warn("Entity with UID", uid, "not found");
         }
@@ -162,15 +174,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 +183,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 +194,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 +236,8 @@ export class EntityManager extends BasicSerializableObject {
             return;
         }
 
-        if (this.destroyList.indexOf(entity) < 0) {
         this.destroyList.push(entity);
         entity.queuedForDestroy = true;
         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,7 @@ import { Entity } from "./entity";
 
 import { GameRoot } from "./root";
 import { GameSystem } from "./game_system";
-import { arrayDelete, arrayDeleteValue } from "../core/utils";
+import { arrayDelete, arrayDeleteValue, fastArrayDelete } from "../core/utils";
-import { globalConfig } from "../core/config";
 
 export class GameSystemWithFilter extends GameSystem {
     /**
@@ -22,9 +21,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 +37,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 +54,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 +63,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 +71,8 @@ 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);
+                //arrayDeleteValue(this.allEntities, entity);
+                this.allEntitiesArrayIsOutdated = this.allEntitiesSet.delete(entity);
             }
         }
     }
@@ -81,23 +87,24 @@ export class GameSystemWithFilter extends GameSystem {
                 return;
             }
         }
-        if (this.allEntities.indexOf(entity) >= 0) {
+        if (this.allEntitiesSet.has(entity)) {
             return;
         }
         this.internalRegisterEntity(entity);
     }
 
     refreshCaches() {
+        //this.allEntities.sort((a, b) => a.uid - b.uid);
         // 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 +119,13 @@ 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) {
+        // if (this.root.gameInitialized && !this.root.bulkOperationRunning) {
-            // Sort entities by uid so behaviour is predictable
+        //     // Sort entities by uid so behaviour is predictable
-            this.allEntities.sort((a, b) => a.uid - b.uid);
+        //     this.allEntities.sort((a, b) => a.uid - b.uid);
-        }
+        // }
     }
 
     /**
@@ -126,12 +134,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

@@ -44,6 +44,7 @@ import { HUDWireInfo } from "./parts/wire_info";
 import { HUDLeverToggle } from "./parts/lever_toggle";
 import { HUDLayerPreview } from "./parts/layer_preview";
 import { HUDMinerHighlight } from "./parts/miner_highlight";
+import { Entity } from "../entity";
 import { HUDBetaOverlay } from "./parts/beta_overlay";
 import { HUDStandaloneAdvantages } from "./parts/standalone_advantages";
 import { HUDCatMemes } from "./parts/cat_memes";

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

@@ -3,13 +3,14 @@ import { STOP_PROPAGATION } from "../../../core/signal";
 import { TrackedState } from "../../../core/tracked_state";
 import { makeDiv } from "../../../core/utils";
 import { Vector } from "../../../core/vector";
-import { SOUNDS } from "../../../platform/sound";
 import { T } from "../../../translations";
-import { Blueprint } from "../../blueprint";
 import { enumMouseButton } from "../../camera";
 import { KEYMAPPINGS } from "../../key_action_mapper";
 import { BaseHUDPart } from "../base_hud_part";
 import { DynamicDomAttach } from "../dynamic_dom_attach";
+import { Blueprint } from "../../blueprint";
+import { SOUNDS } from "../../../platform/sound";
+import { Entity } from "../../entity";
 
 export class HUDBlueprintPlacer extends BaseHUDPart {
     createElements(parent) {
@@ -141,13 +142,13 @@ export class HUDBlueprintPlacer extends BaseHUDPart {
 
     /**
      * Called when an array of bulidings was selected
-     * @param {Array<number>} uids
+     * @param {Array<Entity>} entities
      */
-    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/mass_selector.js

@@ -5,7 +5,7 @@ import { DrawParameters } from "../../../core/draw_parameters";
 import { Entity } from "../../entity";
 import { Loader } from "../../../core/loader";
 import { globalConfig } from "../../../core/config";
-import { makeDiv, formatBigNumber, formatBigNumberFull } from "../../../core/utils";
+import { makeDiv, formatBigNumber, formatBigNumberFull, dirInterval } from "../../../core/utils";
 import { DynamicDomAttach } from "../dynamic_dom_attach";
 import { createLogger } from "../../../core/logging";
 import { enumMouseButton } from "../../camera";
@@ -23,7 +23,12 @@ export class HUDMassSelector extends BaseHUDPart {
     initialize() {
         this.currentSelectionStartWorld = null;
         this.currentSelectionEnd = null;
-        this.selectedUids = new Set();
+
+        /** @type {Set<Entity>} */
+        this.selectedEntities = new Set();
+
+        /** @type {number} */
+        this.selectedUids = 42;
 
         this.root.signals.entityQueuedForDestroy.add(this.onEntityDestroyed, this);
         this.root.hud.signals.pasteBlueprintRequested.add(this.clearSelection, this);
@@ -43,6 +48,20 @@ export class HUDMassSelector extends BaseHUDPart {
         this.root.signals.editModeChanged.add(this.clearSelection, this);
     }
 
+    clear() {
+        this.selectedEntities.clear();
+    }
+
+    // getUidArray() {
+    //     if (this.selectedEntities.size <= 0) return [];
+    //     const uids = [];
+    //     const arr = [...this.selectedEntities.values()];
+    //     for (let i = arr.length - 1; i >= 0; --i) {
+    //         uids.push(arr[i].uid);
+    //     }
+    //     return uids;
+    // }
+
     /**
      * Handles the destroy callback and makes sure we clean our list
      * @param {Entity} entity
@@ -51,7 +70,7 @@ export class HUDMassSelector extends BaseHUDPart {
         if (this.root.bulkOperationRunning) {
             return;
         }
-        this.selectedUids.delete(entity.uid);
+        this.selectedEntities.delete(entity);
     }
 
     /**
@@ -59,8 +78,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;
         }
     }
@@ -69,19 +88,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"]
             );
@@ -92,35 +111,26 @@ 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();
+        //const mapUidToEntity = this.root.entityMgr.getFrozenUidSearchMap();
 
         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");
                 }
             }
         });
 
-        // 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,
@@ -128,8 +138,10 @@ export class HUDMassSelector extends BaseHUDPart {
                 );
                 return;
             }
-            this.root.hud.signals.buildingsSelectedForCopy.dispatch(Array.from(this.selectedUids));
+            const uids = [];
-            this.selectedUids = new Set();
+
+            this.root.hud.signals.buildingsSelectedForCopy.dispatch([...this.selectedEntities.values()]);
+            this.selectedEntities.clear();
             this.root.soundProxy.playUiClick();
         } else {
             this.root.soundProxy.playUiError();
@@ -144,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"]
             );
@@ -161,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,
@@ -212,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());
@@ -245,7 +257,7 @@ export class HUDMassSelector extends BaseHUDPart {
                 for (let y = realTileStart.y; y <= realTileEnd.y; ++y) {
                     const contents = this.root.map.getLayerContentXY(x, y, this.root.currentLayer);
                     if (contents && this.root.logic.canDeleteBuilding(contents)) {
-                        this.selectedUids.add(contents.uid);
+                        this.selectedEntities.add(contents);
                     }
                 }
             }
@@ -319,8 +331,11 @@ 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 arr = [...this.selectedEntities.values()];
+            for (let i = arr.length - 1; i >= 0; --i) {
+                const entity = arr[i];
                 const staticComp = entity.components.StaticMapEntity;
                 const bounds = staticComp.getTileSpaceBounds();
                 parameters.context.beginRoundedRect(
@@ -331,6 +346,7 @@ export class HUDMassSelector extends BaseHUDPart {
                     2
                 );
                 parameters.context.fill();
-        });
+            }
+        }
     }
 }

src/js/game/systems/belt.js

@@ -422,8 +422,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,9 +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_signal.js

@@ -22,8 +22,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 pinsComp = entity.components.WiredPins;
             const signalComp = entity.components.ConstantSignal;
             pinsComp.slots[0].value = signalComp.signal;

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/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]);
+            const entity = this.allEntitiesArray[i];
+            this.drawEntity(parameters, entity);
         }
     }
 
     update() {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-            // Set hub goal
+            const entity = this.allEntitiesArray[i];
-            const entity = this.allEntities[i];
             const pinsComp = entity.components.WiredPins;
             pinsComp.slots[0].value = this.root.shapeDefinitionMgr.getShapeItemFromDefinition(
                 this.root.hubGoals.currentGoal.definition
@@ -65,17 +65,6 @@ export class HubSystem extends GameSystemWithFilter {
 
         this.hubSprite.draw(context, 0, 0, w, h);
 
-        if (this.root.hubGoals.isEndOfDemoReached()) {
-            // End of demo
-            context.font = "bold 12px GameFont";
-            context.fillStyle = "#fd0752";
-            context.textAlign = "center";
-            context.fillText(T.buildings.hub.endOfDemo.toUpperCase(), w / 2, h / 2 + 6);
-            context.textAlign = "left";
-
-            return;
-        }
-
         const definition = this.root.hubGoals.currentGoal.definition;
         definition.drawCentered(45, 58, parameters, 36);
 
@@ -115,7 +104,6 @@ export class HubSystem extends GameSystemWithFilter {
             context.font = "13px GameFont";
             context.fillStyle = "#a4a6b0";
             context.fillText("/ " + formatBigNumber(goals.required), textOffsetX, textOffsetY + 13);
-        }
 
             // Reward
             const rewardText = T.storyRewards[goals.reward].title.toUpperCase();
@@ -156,6 +144,7 @@ export class HubSystem extends GameSystemWithFilter {
 
             context.textAlign = "left";
         }
+    }
 
     /**
      * @param {DrawParameters} parameters

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 { BaseItem } from "../base_item";
 import { BeltComponent } from "../components/belt";
@@ -60,8 +61,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);
         }
     }
@@ -146,8 +147,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

@@ -68,9 +68,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

@@ -7,8 +7,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 pinsComp = entity.components.WiredPins;
             const pin = pinsComp.slots[0];
             const network = pin.linkedNetwork;

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

@@ -223,9 +223,8 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
 
     update() {
         this.staleAreaWatcher.update();
-
+        for (let i = this.allEntitiesArray.length - 1; i >= 0; --i) {
-        for (let i = 0; i < this.allEntities.length; ++i) {
+            const entity = this.allEntitiesArray[i];
-            const entity = this.allEntities[i];
             const undergroundComp = entity.components.UndergroundBelt;
             if (undergroundComp.mode === enumUndergroundBeltMode.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";
@@ -168,7 +169,10 @@ 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;
+        return (
+            !!this.currentData.dump &&
+            (this.currentData.dump.entities.length > 0 || this.currentData.dump.entities.size > 0)
+        );
     }
 
     /**

src/js/savegame/savegame_serializer.js

@@ -67,9 +67,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 = 0; i < entities.length; ++i) {
             /** @type {Entity} */
-            const entity = savegame.entities[i];
+            const entity = entities[i];
 
             const uid = entity.uid;
             if (!Number.isInteger(uid)) {
@@ -133,7 +134,8 @@ export class SavegameSerializer {
         errorReason = errorReason || root.hubGoals.deserialize(savegame.hubGoals, root);
         errorReason = errorReason || root.hud.parts.pinnedShapes.deserialize(savegame.pinnedShapes);
         errorReason = errorReason || root.hud.parts.waypoints.deserialize(savegame.waypoints);
-        errorReason = errorReason || this.internal.deserializeEntityArray(root, savegame.entities);
+        errorReason =
+            errorReason || this.internal.deserializeEntityArray(root, [...savegame.entities.values()]);
         errorReason = errorReason || root.systemMgr.systems.belt.deserializePaths(savegame.beltPaths);
 
         // Check for errors

src/js/savegame/savegame_typedefs.js

@@ -11,7 +11,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
+        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());
             }