From bf2eee908fedb84dbbabd359a200c446020a340e Mon Sep 17 00:00:00 2001 From: tobspr Date: Mon, 27 Jul 2020 17:14:29 +0200 Subject: [PATCH] Refactor static map entity component to store building metaclass --- .../sprites/misc/lock_direction_indicator.png | Bin 2048 -> 0 bytes src/css/ingame_hud/buildings_toolbar.scss | 3 +- src/css/states/main_menu.scss | 2 +- src/js/core/background_resources_loader.js | 2 + src/js/game/blueprint.js | 6 +- src/js/game/building_codes.js | 72 ++++++++++ src/js/game/buildings/belt_base.js | 6 +- src/js/game/buildings/hub.js | 8 +- src/js/game/buildings/underground_belt.js | 20 ++- src/js/game/components/static_map_entity.js | 47 ++++-- src/js/game/hud/parts/building_placer.js | 11 +- .../game/hud/parts/building_placer_logic.js | 98 ++----------- src/js/game/hud/parts/debug_info.js | 4 +- src/js/game/meta_building.js | 25 ++-- src/js/game/meta_building_registry.js | 135 ++++++++++++++++-- src/js/game/systems/static_map_entity.js | 12 +- src/js/savegame/savegame_compressor.js | 22 +-- 17 files changed, 307 insertions(+), 166 deletions(-) delete mode 100644 res_raw/sprites/misc/lock_direction_indicator.png create mode 100644 src/js/game/building_codes.js diff --git a/res_raw/sprites/misc/lock_direction_indicator.png b/res_raw/sprites/misc/lock_direction_indicator.png deleted file mode 100644 index fe693ba2f1147ed841c4c82ab35cb4fb29cd07c9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2048 zcmbVN3v3f*952P{Is~T#iBk1;1hWON_vrHu>K^T29d^_*+?YhU-hFM)wRgweZEZ=A zA}>K+;SuDa2#5>=xC9a%m^hinAR&N(AZT!aU{G)-fDsh&yRIw4FeF}bci(;A@B96K z|Ht>gg~8hKgA1Q5G#Ctn{nfq@d=vUz@F0BF8?P^bFSA@dMKu_P1oV5rxZ^Ri!C<-} z)HP@gffpD~N?2K53Il5@Aw#smFt#iuvs@Fy| zh5{zdsIB8>G;uVKmOYP*O)-!l0W=m#CE}vWq&#Srmw{t_8b^^VL~HV(6}myBArM5o zk^&Hi)roPW-GR7hE9tb^Y5F;YB1kt*xN*{kkxs@=FcgL4E)-f*_y`m7jmz1BUmi53 zX)=T3$z;-+v{@x3ijy==;{=6M6b2EPnie%Sg^B9OUIrgfIYp2)K@t(2kqt}Dng@kS zdt6A!d0J7;g$V`>Pq8viS_$2yERg5&IJsGgXN~h54&opIL`{WQGLMyGk|wD!sUPb6 z@*M_XXaj+~jk{_|B=ROyt*QmOkqgLO(P~{<26zalQnSK=sun17r0$K(coo2El2Rv0 z@!muQdnF@YubvnhDXAAkUP`K^ef9t!s{s#65fp(DPK4s7MhZ z4j0tW_)5fI<#m#@(}_`5GAlO_VEm%0u_6cjJ`W1xV-*CRadJFCbF>``^EQCFc)JS= zyCY5vP;P>7x*ZXo>~R#7vdlB@zMqA+&%Q;2wf`c<~&-srJUA zHTb`?mR;-9zmB{H^w>DnoEg?;e5s?bVZi8Vd&;{HZXR)X zXNIu9mFyUGsq-DP@k-Hz>7qHJJ>D?;z^q*-=Rf+CDZ&;XYFa(hJlWXUw)%``XxoQ# z${(>r)7{9W>!n8u7g`>AZ(!}sqSm=1N`i#xmouj(%tk+15UMK6xC%bsJ=|D9H#!!b z`)cH|{rkQ%Mvwd&ipZvbSZL|U9K3kQthE=n4dI?X9~)EjVrkJzdg+?P6CX@2@UflS z;^~?T^-~62?c8*@be6An`(o3nuBj{cZXJ4dZNXfA)u9uuf4r9A8RM7opi%24FGCwo z9LTH*Aths8-71*>df<53mTS`NL9wHsE}i)G#jE4H3T`}na`Br7=iS8G%v} + */ +export const gBuildingVariants = { + // Set later +}; + +/** + * + * @param {*} id + * @param {*} meta + * @param {*} variant + * @param {*} rotationVariant + */ +export function registerBuildingVariant(id, meta, variant = defaultBuildingVariant, rotationVariant = 0) { + assert(!gBuildingVariants[id], "Duplicate id: " + id); + gBuildingVariants[id] = { + metaClass: meta, + variant, + rotationVariant, + }; +} + +/** + * + * @param {number} code + * @returns {BuildingVariantIdentifier} + */ +export function getBuildingDataFromCode(code) { + assert(gBuildingVariants[code], "Invalid building code: " + code); + return gBuildingVariants[code]; +} + +/** + * Finds the code for a given variant + * @param {MetaBuilding} metaBuilding + * @param {string} variant + * @param {number} rotationVariant + */ +export function getCodeFromBuildingData(metaBuilding, variant, rotationVariant) { + for (const key in gBuildingVariants) { + const data = gBuildingVariants[key]; + if ( + data.metaInstance.getId() === metaBuilding.getId() && + data.variant === variant && + data.rotationVariant === rotationVariant + ) { + return +key; + } + } + assertAlways( + false, + "Building not found by data: " + metaBuilding.getId() + " / " + variant + " / " + rotationVariant + ); + return 0; +} diff --git a/src/js/game/buildings/belt_base.js b/src/js/game/buildings/belt_base.js index b8e92150..a87589a3 100644 --- a/src/js/game/buildings/belt_base.js +++ b/src/js/game/buildings/belt_base.js @@ -1,4 +1,3 @@ -import { Loader } from "../../core/loader"; import { formatItemsPerSecond } from "../../core/utils"; import { enumAngleToDirection, enumDirection, Vector } from "../../core/vector"; import { SOUNDS } from "../../platform/sound"; @@ -40,6 +39,10 @@ export class MetaBeltBaseBuilding extends MetaBuilding { return SOUNDS.placeBelt; } + getSprite() { + return null; + } + /** * Creates the entity at the given location * @param {Entity} entity @@ -88,7 +91,6 @@ export class MetaBeltBaseBuilding extends MetaBuilding { updateVariants(entity, rotationVariant) { entity.components.Belt.direction = arrayBeltVariantToRotation[rotationVariant]; entity.components.ItemEjector.slots[0].direction = arrayBeltVariantToRotation[rotationVariant]; - entity.components.StaticMapEntity.spriteKey = null; } /** diff --git a/src/js/game/buildings/hub.js b/src/js/game/buildings/hub.js index 61a61f27..4f0e0d80 100644 --- a/src/js/game/buildings/hub.js +++ b/src/js/game/buildings/hub.js @@ -28,6 +28,11 @@ export class MetaHubBuilding extends MetaBuilding { return null; } + getSprite() { + // We render it ourself + return null; + } + /** * Creates the entity at the given location * @param {Entity} entity @@ -41,9 +46,6 @@ export class MetaHubBuilding extends MetaBuilding { }) ); - // We render the sprite ourself - entity.components.StaticMapEntity.spriteKey = null; - entity.addComponent(new UnremovableComponent()); entity.addComponent( new ItemAcceptorComponent({ diff --git a/src/js/game/buildings/underground_belt.js b/src/js/game/buildings/underground_belt.js index 99004b99..2c4f6a1d 100644 --- a/src/js/game/buildings/underground_belt.js +++ b/src/js/game/buildings/underground_belt.js @@ -71,6 +71,10 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding { return super.getAvailableVariants(root); } + /** + * @param {number} rotationVariant + * @param {string} variant + */ getPreviewSprite(rotationVariant, variant) { let suffix = ""; if (variant !== defaultBuildingVariant) { @@ -87,6 +91,10 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding { } } + /** + * @param {number} rotationVariant + * @param {string} variant + */ getBlueprintSprite(rotationVariant, variant) { let suffix = ""; if (variant !== defaultBuildingVariant) { @@ -103,6 +111,14 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding { } } + /** + * @param {number} rotationVariant + * @param {string} variant + */ + getSprite(rotationVariant, variant) { + return this.getPreviewSprite(rotationVariant, variant); + } + /** * @param {GameRoot} root */ @@ -201,10 +217,6 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding { */ updateVariants(entity, rotationVariant, variant) { entity.components.UndergroundBelt.tier = enumUndergroundBeltVariantToTier[variant]; - entity.components.StaticMapEntity.spriteKey = this.getPreviewSprite( - rotationVariant, - variant - ).spriteName; switch (arrayUndergroundRotationVariantToMode[rotationVariant]) { case enumUndergroundBeltMode.sender: { diff --git a/src/js/game/components/static_map_entity.js b/src/js/game/components/static_map_entity.js index 3f0794a4..6494aba1 100644 --- a/src/js/game/components/static_map_entity.js +++ b/src/js/game/components/static_map_entity.js @@ -5,6 +5,7 @@ import { AtlasSprite } from "../../core/sprites"; import { enumDirection, Vector } from "../../core/vector"; import { types } from "../../savegame/serialization"; import { Component } from "../component"; +import { getBuildingDataFromCode } from "../building_codes"; export class StaticMapEntityComponent extends Component { static getId() { @@ -17,21 +18,43 @@ export class StaticMapEntityComponent extends Component { tileSize: types.tileVector, rotation: types.float, originalRotation: types.float, - spriteKey: types.nullable(types.string), - blueprintSpriteKey: types.string, - silhouetteColor: types.nullable(types.string), + + // See building_codes.js + code: types.uint, }; } + /** + * Returns the sprite + * @returns {AtlasSprite} + */ + getSprite() { + return getBuildingDataFromCode(this.code).sprite; + } + + /** + * Returns the blueprint sprite + * @returns {AtlasSprite} + */ + getBlueprintSprite() { + return getBuildingDataFromCode(this.code).blueprintSprite; + } + + /** + * Returns the silhouette color + * @returns {string} + */ + getSilhouetteColor() { + return getBuildingDataFromCode(this.code).silhouetteColor; + } + duplicateWithoutContents() { return new StaticMapEntityComponent({ origin: this.origin.copy(), tileSize: this.tileSize.copy(), rotation: this.rotation, originalRotation: this.originalRotation, - spriteKey: this.spriteKey, - silhouetteColor: this.silhouetteColor, - blueprintSpriteKey: this.blueprintSpriteKey, + code: this.code, }); } @@ -42,18 +65,14 @@ export class StaticMapEntityComponent extends Component { * @param {Vector=} param0.tileSize Size of the entity in tiles * @param {number=} param0.rotation Rotation in degrees. Must be multiple of 90 * @param {number=} param0.originalRotation Original Rotation in degrees. Must be multiple of 90 - * @param {string=} param0.spriteKey Optional sprite - * @param {string} param0.blueprintSpriteKey Blueprint sprite, required - * @param {string=} param0.silhouetteColor Optional silhouette color override + * @param {number=} param0.code Building code */ constructor({ origin = new Vector(), tileSize = new Vector(1, 1), rotation = 0, originalRotation = 0, - spriteKey = null, - silhouetteColor = null, - blueprintSpriteKey = null, + code = 0, }) { super(); assert( @@ -63,11 +82,9 @@ export class StaticMapEntityComponent extends Component { this.origin = origin; this.tileSize = tileSize; - this.spriteKey = spriteKey; this.rotation = rotation; + this.code = code; this.originalRotation = originalRotation; - this.silhouetteColor = silhouetteColor; - this.blueprintSpriteKey = blueprintSpriteKey; } /** diff --git a/src/js/game/hud/parts/building_placer.js b/src/js/game/hud/parts/building_placer.js index d3a3c7ac..d5770d0a 100644 --- a/src/js/game/hud/parts/building_placer.js +++ b/src/js/game/hud/parts/building_placer.js @@ -18,6 +18,7 @@ import { DynamicDomAttach } from "../dynamic_dom_attach"; import { HUDBuildingPlacerLogic } from "./building_placer_logic"; import { makeOffscreenBuffer } from "../../../core/buffer_utils"; import { enumLayer } from "../../root"; +import { getCodeFromBuildingData } from "../../building_codes"; export class HUDBuildingPlacer extends HUDBuildingPlacerLogic { /** @@ -84,9 +85,8 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic { label: "lock-direction-indicator", }); - // Loader.getSprite("sprites/misc/lock_direction_indicator.png").draw(context, 0, 0, 48, 48); - context.fillStyle = THEME.map.directionLock[enumLayer.wires].color; - context.strokeStyle = THEME.map.directionLock[enumLayer.wires].color; + context.fillStyle = THEME.map.directionLock[layer].color; + context.strokeStyle = THEME.map.directionLock[layer].color; context.lineWidth = 2; const padding = 5; @@ -313,6 +313,11 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic { staticComp.rotation = rotation; staticComp.tileSize = metaBuilding.getDimensions(this.currentVariant.get()); metaBuilding.updateVariants(this.fakeEntity, rotationVariant, this.currentVariant.get()); + staticComp.code = getCodeFromBuildingData( + this.currentMetaBuilding.get(), + this.currentVariant.get(), + rotationVariant + ); const canBuild = this.root.logic.checkCanPlaceEntity(this.fakeEntity); diff --git a/src/js/game/hud/parts/building_placer_logic.js b/src/js/game/hud/parts/building_placer_logic.js index 563ce144..32b12796 100644 --- a/src/js/game/hud/parts/building_placer_logic.js +++ b/src/js/game/hud/parts/building_placer_logic.js @@ -13,6 +13,7 @@ import { SOUNDS } from "../../../platform/sound"; import { MetaMinerBuilding, enumMinerVariants } from "../../buildings/miner"; import { enumHubGoalRewards } from "../../tutorial_goals"; import { enumLayer } from "../../root"; +import { getBuildingDataFromCode, getCodeFromBuildingData } from "../../building_codes"; /** * Contains all logic for the building placer - this doesn't include the rendering @@ -338,109 +339,26 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart { } // Try to extract the building - const extracted = this.hack_reconstructMetaBuildingAndVariantFromBuilding(contents); + const buildingCode = contents.components.StaticMapEntity.code; + const extracted = getBuildingDataFromCode(buildingCode); // If the building we are picking is the same as the one we have, clear the cursor. if ( - !extracted || - (extracted.metaBuilding === this.currentMetaBuilding.get() && - extracted.variant === this.currentVariant.get()) + extracted.metaInstance.getId() === this.currentMetaBuilding.get().getId() && + extracted.variant === this.currentVariant.get() ) { this.currentMetaBuilding.set(null); return; } - this.currentMetaBuilding.set(extracted.metaBuilding); + this.currentMetaBuilding.set(extracted.metaInstance); this.currentVariant.set(extracted.variant); this.currentBaseRotation = contents.components.StaticMapEntity.rotation; } /** - * HACK! - * - * This attempts to reconstruct the meta building and its variant from a given entity - * @param {Entity} entity - * @returns {{ metaBuilding: MetaBuilding, variant: string }} + * Switches the side for the direction lock manually */ - hack_reconstructMetaBuildingAndVariantFromBuilding(entity) { - if (entity.components.Hub) { - // Hub is not copyable - return null; - } - - const matches = []; - const metaBuildings = gMetaBuildingRegistry.entries; - for (let i = 0; i < metaBuildings.length; ++i) { - const metaBuilding = metaBuildings[i]; - const availableVariants = metaBuilding.getAvailableVariants(this.root); - checkVariant: for (let k = 0; k < availableVariants.length; ++k) { - const variant = availableVariants[k]; - let unplaced = metaBuilding.createEntity({ - root: this.root, - variant, - origin: new Vector(0, 0), - rotation: 0, - originalRotation: 0, - rotationVariant: 0, - }); - - // Compare if both entities share the same components - for (let component in entity.components) { - if ((entity.components[component] == null) !== (unplaced.components[component] == null)) { - continue checkVariant; - } - } - - // Check for same item processor - if ( - entity.components.ItemProcessor && - entity.components.ItemProcessor.type != unplaced.components.ItemProcessor.type - ) { - continue checkVariant; - } - - // Check for underground belt - if ( - entity.components.UndergroundBelt && - entity.components.UndergroundBelt.tier != unplaced.components.UndergroundBelt.tier - ) { - continue checkVariant; - } - - // Check for same sprite key - except for underground belts - // since the sprite may vary here - if ( - !entity.components.UndergroundBelt && - entity.components.StaticMapEntity.spriteKey != - unplaced.components.StaticMapEntity.spriteKey - ) { - continue checkVariant; - } - - if (metaBuilding.id === "wire" && entity.layer !== enumLayer.wires) { - continue checkVariant; - } - - if (metaBuilding.id === "belt" && entity.layer !== enumLayer.regular) { - continue checkVariant; - } - matches.push({ metaBuilding, variant }); - } - } - - if (matches.length == 1) { - const staticEntity = entity.components.StaticMapEntity; - const key = staticEntity.spriteKey || staticEntity.blueprintSpriteKey; - assert( - key && - key.includes(matches[0].metaBuilding.id) && - (matches[0].variant === defaultBuildingVariant || key.includes(matches[0].variant)) - ); - return matches[0]; - } - return null; - } - switchDirectionLockSide() { this.currentDirectionLockSide = 1 - this.currentDirectionLockSide; } @@ -673,7 +591,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart { origin: new Vector(0, 0), rotation: 0, tileSize: metaBuilding.getDimensions(this.currentVariant.get()).copy(), - blueprintSpriteKey: "", + code: getCodeFromBuildingData(metaBuilding, variant, 0), }) ); metaBuilding.updateVariants(this.fakeEntity, 0, this.currentVariant.get()); diff --git a/src/js/game/hud/parts/debug_info.js b/src/js/game/hud/parts/debug_info.js index cdd00540..100a19ef 100644 --- a/src/js/game/hud/parts/debug_info.js +++ b/src/js/game/hud/parts/debug_info.js @@ -88,8 +88,8 @@ export class HUDDebugInfo extends BaseHUDPart { const mouseTile = this.root.camera.screenToWorld(mousePos).toTileSpace(); const cameraTile = this.root.camera.center.toTileSpace(); - this.trackedMousePosition.set(`Pos: ${mouseTile.x} / ${mouseTile.y}`); - this.trackedCameraPosition.set(`Center: ${cameraTile.x} / ${cameraTile.y}`); + this.trackedMousePosition.set(`Mouse: ${mouseTile.x} / ${mouseTile.y}`); + this.trackedCameraPosition.set(`Camera: ${cameraTile.x} / ${cameraTile.y}`); } /** diff --git a/src/js/game/meta_building.js b/src/js/game/meta_building.js index 514474c9..722dca13 100644 --- a/src/js/game/meta_building.js +++ b/src/js/game/meta_building.js @@ -5,6 +5,7 @@ import { SOUNDS } from "../platform/sound"; import { StaticMapEntityComponent } from "./components/static_map_entity"; import { Entity } from "./entity"; import { enumLayer, GameRoot } from "./root"; +import { getCodeFromBuildingData } from "./building_codes"; export const defaultBuildingVariant = "default"; @@ -157,20 +158,13 @@ export class MetaBuilding { createEntity({ root, origin, rotation, originalRotation, rotationVariant, variant }) { const entity = new Entity(root); entity.layer = this.getLayer(); - const blueprintSprite = this.getBlueprintSprite(rotationVariant, variant); entity.addComponent( new StaticMapEntityComponent({ - spriteKey: - "sprites/buildings/" + - this.id + - (variant === defaultBuildingVariant ? "" : "-" + variant) + - ".png", origin: new Vector(origin.x, origin.y), rotation, originalRotation, tileSize: this.getDimensions(variant).copy(), - silhouetteColor: this.getSilhouetteColor(), - blueprintSpriteKey: blueprintSprite ? blueprintSprite.spriteName : "", + code: getCodeFromBuildingData(this, variant, rotationVariant), }) ); this.setupEntityComponents(entity, root); @@ -178,6 +172,21 @@ export class MetaBuilding { return entity; } + /** + * Returns the sprite for a given variant + * @param {number} rotationVariant + * @param {string} variant + * @returns {AtlasSprite} + */ + getSprite(rotationVariant, variant) { + return Loader.getSprite( + "sprites/buildings/" + + this.id + + (variant === defaultBuildingVariant ? "" : "-" + variant) + + ".png" + ); + } + /** * Should compute the optimal rotation variant on the given tile * @param {object} param0 diff --git a/src/js/game/meta_building_registry.js b/src/js/game/meta_building_registry.js index 4e1fdd81..20ca6f41 100644 --- a/src/js/game/meta_building_registry.js +++ b/src/js/game/meta_building_registry.js @@ -1,20 +1,25 @@ import { gMetaBuildingRegistry } from "../core/global_registries"; -import { MetaBeltBaseBuilding } from "./buildings/belt_base"; -import { MetaCutterBuilding } from "./buildings/cutter"; -import { MetaMinerBuilding } from "./buildings/miner"; -import { MetaMixerBuilding } from "./buildings/mixer"; -import { MetaPainterBuilding } from "./buildings/painter"; -import { MetaRotaterBuilding } from "./buildings/rotater"; -import { MetaSplitterBuilding } from "./buildings/splitter"; -import { MetaStackerBuilding } from "./buildings/stacker"; -import { MetaTrashBuilding } from "./buildings/trash"; -import { MetaUndergroundBeltBuilding } from "./buildings/underground_belt"; -import { MetaHubBuilding } from "./buildings/hub"; -import { MetaEnergyGenerator } from "./buildings/energy_generator"; -import { MetaWireBaseBuilding } from "./buildings/wire_base"; +import { createLogger } from "../core/logging"; import { MetaAdvancedProcessorBuilding } from "./buildings/advanced_processor"; import { MetaBeltBuilding } from "./buildings/belt"; -import { MetaWireCrossingsBuilding } from "./buildings/wire_crossings"; +import { MetaBeltBaseBuilding } from "./buildings/belt_base"; +import { enumCutterVariants, MetaCutterBuilding } from "./buildings/cutter"; +import { MetaEnergyGenerator } from "./buildings/energy_generator"; +import { MetaHubBuilding } from "./buildings/hub"; +import { enumMinerVariants, MetaMinerBuilding } from "./buildings/miner"; +import { MetaMixerBuilding } from "./buildings/mixer"; +import { enumPainterVariants, MetaPainterBuilding } from "./buildings/painter"; +import { enumRotaterVariants, MetaRotaterBuilding } from "./buildings/rotater"; +import { enumSplitterVariants, MetaSplitterBuilding } from "./buildings/splitter"; +import { MetaStackerBuilding } from "./buildings/stacker"; +import { enumTrashVariants, MetaTrashBuilding } from "./buildings/trash"; +import { enumUndergroundBeltVariants, MetaUndergroundBeltBuilding } from "./buildings/underground_belt"; +import { MetaWireBaseBuilding } from "./buildings/wire_base"; +import { enumWireCrossingVariants, MetaWireCrossingsBuilding } from "./buildings/wire_crossings"; +import { gBuildingVariants, registerBuildingVariant } from "./building_codes"; +import { defaultBuildingVariant } from "./meta_building"; + +const logger = createLogger("building_registry"); export function initMetaBuildingRegistry() { gMetaBuildingRegistry.register(MetaSplitterBuilding); @@ -32,4 +37,106 @@ export function initMetaBuildingRegistry() { gMetaBuildingRegistry.register(MetaWireBaseBuilding); gMetaBuildingRegistry.register(MetaAdvancedProcessorBuilding); gMetaBuildingRegistry.register(MetaWireCrossingsBuilding); + + // Belt + registerBuildingVariant(1, MetaBeltBaseBuilding, defaultBuildingVariant, 0); + registerBuildingVariant(2, MetaBeltBaseBuilding, defaultBuildingVariant, 1); + registerBuildingVariant(3, MetaBeltBaseBuilding, defaultBuildingVariant, 2); + + // Splitter + registerBuildingVariant(4, MetaSplitterBuilding); + registerBuildingVariant(5, MetaSplitterBuilding, enumSplitterVariants.compact); + registerBuildingVariant(6, MetaSplitterBuilding, enumSplitterVariants.compactInverse); + + // Miner + registerBuildingVariant(7, MetaMinerBuilding); + registerBuildingVariant(8, MetaMinerBuilding, enumMinerVariants.chainable); + + // Cutter + registerBuildingVariant(9, MetaCutterBuilding); + registerBuildingVariant(10, MetaCutterBuilding, enumCutterVariants.quad); + + // Rotater + registerBuildingVariant(11, MetaRotaterBuilding); + registerBuildingVariant(12, MetaRotaterBuilding, enumRotaterVariants.ccw); + registerBuildingVariant(13, MetaRotaterBuilding, enumRotaterVariants.fl); + + // Stacker + registerBuildingVariant(14, MetaStackerBuilding); + + // Mixer + registerBuildingVariant(15, MetaMixerBuilding); + + // Painter + registerBuildingVariant(16, MetaPainterBuilding); + registerBuildingVariant(17, MetaPainterBuilding, enumPainterVariants.mirrored); + registerBuildingVariant(18, MetaPainterBuilding, enumPainterVariants.double); + registerBuildingVariant(19, MetaPainterBuilding, enumPainterVariants.quad); + + // Trash + registerBuildingVariant(20, MetaTrashBuilding); + registerBuildingVariant(21, MetaTrashBuilding, enumTrashVariants.storage); + + // Underground belt + registerBuildingVariant(22, MetaUndergroundBeltBuilding, defaultBuildingVariant, 0); + registerBuildingVariant(23, MetaUndergroundBeltBuilding, defaultBuildingVariant, 1); + registerBuildingVariant(24, MetaUndergroundBeltBuilding, enumUndergroundBeltVariants.tier2, 0); + registerBuildingVariant(25, MetaUndergroundBeltBuilding, enumUndergroundBeltVariants.tier2, 1); + + // Hub + registerBuildingVariant(26, MetaHubBuilding); + + // Energy generator + registerBuildingVariant(27, MetaEnergyGenerator); + + // Wire + registerBuildingVariant(28, MetaWireBaseBuilding, defaultBuildingVariant, 0); + registerBuildingVariant(29, MetaWireBaseBuilding, defaultBuildingVariant, 1); + registerBuildingVariant(30, MetaWireBaseBuilding, defaultBuildingVariant, 2); + + // Advanced processor + registerBuildingVariant(31, MetaAdvancedProcessorBuilding); + + // Wire crossing + registerBuildingVariant(32, MetaWireCrossingsBuilding); + registerBuildingVariant(33, MetaWireCrossingsBuilding, enumWireCrossingVariants.merger); + + // Propagate instances + for (const key in gBuildingVariants) { + gBuildingVariants[key].metaInstance = gMetaBuildingRegistry.findByClass( + gBuildingVariants[key].metaClass + ); + } + + for (const key in gBuildingVariants) { + const variant = gBuildingVariants[key]; + assert(variant.metaClass, "Variant has no meta: " + key); + + if (typeof variant.rotationVariant === "undefined") { + variant.rotationVariant = 0; + } + if (typeof variant.variant === "undefined") { + variant.variant = defaultBuildingVariant; + } + } + + logger.log("Registered", gMetaBuildingRegistry.getNumEntries(), "buildings"); + logger.log("Registered", Object.keys(gBuildingVariants).length, "building codes"); +} + +/** + * Once all sprites are loaded, propagates the cache + */ +export function initBuildingCodesAfterResourcesLoaded() { + logger.log("Propagating sprite cache"); + for (const key in gBuildingVariants) { + const variant = gBuildingVariants[key]; + + variant.sprite = variant.metaInstance.getSprite(variant.rotationVariant, variant.variant); + variant.blueprintSprite = variant.metaInstance.getBlueprintSprite( + variant.rotationVariant, + variant.variant + ); + variant.silhouetteColor = variant.metaInstance.getSilhouetteColor(); + } } diff --git a/src/js/game/systems/static_map_entity.js b/src/js/game/systems/static_map_entity.js index a212dcf6..886291a6 100644 --- a/src/js/game/systems/static_map_entity.js +++ b/src/js/game/systems/static_map_entity.js @@ -44,7 +44,7 @@ export class StaticMapEntitySystem extends GameSystem { const staticComp = entity.components.StaticMapEntity; if (drawOutlinesOnly) { const rect = staticComp.getTileSpaceBounds(); - parameters.context.fillStyle = staticComp.silhouetteColor || "#aaa"; + parameters.context.fillStyle = staticComp.getSilhouetteColor() || "#aaa"; const beltComp = entity.components.Belt; if (beltComp) { const sprite = this.beltOverviewSprites[beltComp.direction]; @@ -58,9 +58,8 @@ export class StaticMapEntitySystem extends GameSystem { ); } } else { - const spriteKey = staticComp.spriteKey; - if (spriteKey) { - const sprite = Loader.getSprite(spriteKey); + const sprite = staticComp.getSprite(); + if (sprite) { staticComp.drawSpriteOnFullEntityBounds(parameters, sprite, 2, false); } } @@ -91,9 +90,8 @@ export class StaticMapEntitySystem extends GameSystem { drawnUids.add(entity.uid); const staticComp = entity.components.StaticMapEntity; - const spriteKey = staticComp.spriteKey; - if (spriteKey) { - const sprite = Loader.getSprite(spriteKey); + const sprite = staticComp.getSprite(); + if (sprite) { staticComp.drawSpriteOnFullEntityBounds(parameters, sprite, 2, false); } } diff --git a/src/js/savegame/savegame_compressor.js b/src/js/savegame/savegame_compressor.js index 4962171e..30c28879 100644 --- a/src/js/savegame/savegame_compressor.js +++ b/src/js/savegame/savegame_compressor.js @@ -44,16 +44,18 @@ function decompressInt(s) { } // Sanity -for (let i = 0; i < 10000; ++i) { - if (decompressInt(compressInt(i)) !== i) { - throw new Error( - "Bad compression for: " + - i + - " compressed: " + - compressInt(i) + - " decompressed: " + - decompressInt(compressInt(i)) - ); +if (G_IS_DEV) { + for (let i = 0; i < 10000; ++i) { + if (decompressInt(compressInt(i)) !== i) { + throw new Error( + "Bad compression for: " + + i + + " compressed: " + + compressInt(i) + + " decompressed: " + + decompressInt(compressInt(i)) + ); + } } }