Add storage building

src/js/game/systems/belt.js

@@ -258,8 +258,8 @@ export class BeltSystem extends GameSystemWithFilter {
                 if (progressAndItem[0] >= 1.0) {
                     if (followUp) {
                         const followUpBelt = followUp.components.Belt;
-                        if (followUpBelt.canAcceptNewItem()) {
-                            followUpBelt.takeNewItem(progressAndItem[1], progressAndItem[0] - 1.0);
+                        if (followUpBelt.canAcceptItem()) {
+                            followUpBelt.takeItem(progressAndItem[1], progressAndItem[0] - 1.0);
                             items.splice(itemIndex, 1);
                         } else {
                             // Well, we couldn't really take it to a follow up belt, keep it at

src/js/game/systems/item_ejector.js

@@ -99,8 +99,17 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
         const beltComp = receiver.components.Belt;
         if (beltComp) {
             // Ayy, its a belt!
-            if (beltComp.canAcceptNewItem()) {
-                beltComp.takeNewItem(item);
+            if (beltComp.canAcceptItem()) {
+                beltComp.takeItem(item);
+                return true;
+            }
+        }
+
+        const storageComp = receiver.components.Storage;
+        if (storageComp) {
+            // It's a storage
+            if (storageComp.canAcceptItem(item)) {
+                storageComp.takeItem(item);
                 return true;
             }
         }

src/js/game/systems/static_map_entity.js

@@ -28,12 +28,19 @@ export class StaticMapEntitySystem extends GameSystem {
 
         const drawOutlinesOnly = parameters.zoomLevel < globalConfig.mapChunkOverviewMinZoom;
 
+        const drawnUids = new Set();
+
         const contents = chunk.contents;
         for (let y = 0; y < globalConfig.mapChunkSize; ++y) {
             for (let x = 0; x < globalConfig.mapChunkSize; ++x) {
                 const entity = contents[x][y];
 
                 if (entity) {
+                    if (drawnUids.has(entity.uid)) {
+                        continue;
+                    }
+                    drawnUids.add(entity.uid);
+
                     const staticComp = entity.components.StaticMapEntity;
                     if (drawOutlinesOnly) {
                         const rect = staticComp.getTileSpaceBounds();

src/js/game/systems/storage.js

@@ -0,0 +1,75 @@
+import { GameSystemWithFilter } from "../game_system_with_filter";
+import { StorageComponent } from "../components/storage";
+import { Entity } from "../entity";
+import { DrawParameters } from "../../core/draw_parameters";
+import { formatBigNumber, lerp } from "../../core/utils";
+import { Loader } from "../../core/loader";
+
+export class StorageSystem extends GameSystemWithFilter {
+    constructor(root) {
+        super(root, [StorageComponent]);
+
+        this.storageOverlaySprite = Loader.getSprite("sprites/misc/storage_overlay.png");
+    }
+
+    update() {
+        for (let i = 0; i < this.allEntities.length; ++i) {
+            const entity = this.allEntities[i];
+            const storageComp = entity.components.Storage;
+
+            // Eject from storage
+            if (storageComp.storedItem && storageComp.storedCount > 0) {
+                const ejectorComp = entity.components.ItemEjector;
+                const nextSlot = ejectorComp.getFirstFreeSlot();
+                if (nextSlot !== null) {
+                    if (ejectorComp.tryEject(nextSlot, storageComp.storedItem)) {
+                        storageComp.storedCount--;
+
+                        if (storageComp.storedCount === 0) {
+                            storageComp.storedItem = null;
+                        }
+                    }
+                }
+            }
+
+            let targetAlpha = storageComp.storedCount > 0 ? 1 : 0;
+            storageComp.overlayOpacity = lerp(storageComp.overlayOpacity, targetAlpha, 0.05);
+        }
+    }
+
+    draw(parameters) {
+        this.forEachMatchingEntityOnScreen(parameters, this.drawEntity.bind(this));
+    }
+
+    /**
+     * @param {DrawParameters} parameters
+     * @param {Entity} entity
+     */
+    drawEntity(parameters, entity) {
+        const context = parameters.context;
+        const staticComp = entity.components.StaticMapEntity;
+
+        if (!staticComp.shouldBeDrawn(parameters)) {
+            return;
+        }
+
+        const storageComp = entity.components.Storage;
+
+        const storedItem = storageComp.storedItem;
+        if (storedItem !== null) {
+            context.globalAlpha = storageComp.overlayOpacity;
+            const center = staticComp.getTileSpaceBounds().getCenter().toWorldSpace();
+            storedItem.draw(center.x, center.y, parameters, 30);
+
+            this.storageOverlaySprite.drawCached(parameters, center.x - 15, center.y + 15, 30, 15);
+
+            context.font = "bold 10px GameFont";
+            context.textAlign = "center";
+            context.fillStyle = "#64666e";
+            context.fillText(formatBigNumber(storageComp.storedCount), center.x, center.y + 25.5);
+
+            context.textAlign = "left";
+            context.globalAlpha = 1;
+        }
+    }
+}