Archives/tobspr_shapez.io
1
0
Fork 0
mirror of https://github.com/tobspr/shapez.io.git synced 2025-12-13 18:21:51 +00:00
Code Issues Projects Releases Wiki Activity

Refactor building registry, make it easier for mods to add new buildings

Browse Source
This commit is contained in:
tobspr 2022-01-16 11:19:22 +01:00
parent e4b8071c2f
commit 2c8f11ff7f
35 changed files with 545 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
mod_examples/add_building_basic.js
View File

@ -4,11 +4,25 @@
* the advanced example
*/
registerMod(() => {
class MetaDemoModBuilding extends shapez.MetaBuilding {
class MetaDemoModBuilding extends shapez.ModMetaBuilding {
constructor() {
super("demoModBuilding");
}
static getAllVariantCombinations() {
return [
{
variant: shapez.defaultBuildingVariant,
name: "A test name",
description: "A test building",
regularImageBase64: RESOURCES["demoBuilding.png"],
blueprintImageBase64: RESOURCES["demoBuildingBlueprint.png"],
tutorialImageBase64: RESOURCES["demoBuildingBlueprint.png"],
},
];
}
getSilhouetteColor() {
return "red";
}
@ -41,18 +55,6 @@ registerMod(() => {
this.modInterface.registerNewBuilding({
metaClass: MetaDemoModBuilding,
buildingIconBase64: RESOURCES["demoBuilding.png"],
variantsAndRotations: [
{
name: "A test name",
description: "A test building",
variant: shapez.defaultBuildingVariant,
regularImageBase64: RESOURCES["demoBuilding.png"],
blueprintImageBase64: RESOURCES["demoBuildingBlueprint.png"],
tutorialImageBase64: RESOURCES["demoBuildingBlueprint.png"],
},
],
});
// Add it to the regular toolbar

28
mod_examples/add_building_flipper.js
View File

@ -35,11 +35,25 @@ registerMod(() => {
};
// Create the building
class MetaModFlipperBuilding extends shapez.MetaBuilding {
class MetaModFlipperBuilding extends shapez.ModMetaBuilding {
constructor() {
super("modFlipperBuilding");
}
static getAllVariantCombinations() {
return [
{
name: "Flipper",
description: "Flipps/Mirrors shapez from top to bottom",
variant: shapez.defaultBuildingVariant,
regularImageBase64: RESOURCES["flipper.png"],
blueprintImageBase64: RESOURCES["flipper.png"],
tutorialImageBase64: RESOURCES["flipper.png"],
},
];
}
getSilhouetteColor() {
return "red";
}
@ -106,18 +120,6 @@ registerMod(() => {
this.modInterface.registerNewBuilding({
metaClass: MetaModFlipperBuilding,
buildingIconBase64: RESOURCES["flipper.png"],
variantsAndRotations: [
{
name: "Flipper",
description: "Flipps/Mirrors shapez from top to bottom",
variant: shapez.defaultBuildingVariant,
regularImageBase64: RESOURCES["flipper.png"],
blueprintImageBase64: RESOURCES["flipper.png"],
tutorialImageBase64: RESOURCES["flipper.png"],
},
],
});
// Add it to the regular toolbar

3
src/js/game/building_codes.js
View File

@ -4,6 +4,8 @@ import { AtlasSprite } from "../core/sprites";
import { Vector } from "../core/vector";
/* typehints:end */
import { gMetaBuildingRegistry } from "../core/global_registries";
/**
* @typedef {{
* metaClass: typeof MetaBuilding,
@ -47,6 +49,7 @@ export function registerBuildingVariant(
assert(!gBuildingVariants[code], "Duplicate id: " + code);
gBuildingVariants[code] = {
metaClass: meta,
metaInstance: gMetaBuildingRegistry.findByClass(meta),
variant,
rotationVariant,
// @ts-ignore

11
src/js/game/buildings/analyzer.js
View File

@ -3,7 +3,7 @@ import { enumDirection, Vector } from "../../core/vector";
import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -14,6 +14,15 @@ export class MetaAnalyzerBuilding extends MetaBuilding {
super("analyzer");
}
static getAllVariantCombinations() {
return [
{
internalId: 43,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#3a52bc";
}

25
src/js/game/buildings/balancer.js
View File

@ -31,6 +31,31 @@ export class MetaBalancerBuilding extends MetaBuilding {
super("balancer");
}
static getAllVariantCombinations() {
return [
{
internalId: 4,
variant: defaultBuildingVariant,
},
{
internalId: 5,
variant: enumBalancerVariants.merger,
},
{
internalId: 6,
variant: enumBalancerVariants.mergerInverse,
},
{
internalId: 47,
variant: enumBalancerVariants.splitter,
},
{
internalId: 48,
variant: enumBalancerVariants.splitterInverse,
},
];
}
getDimensions(variant) {
switch (variant) {
case defaultBuildingVariant:

22
src/js/game/buildings/belt.js
View File

@ -5,7 +5,7 @@ import { SOUNDS } from "../../platform/sound";
import { T } from "../../translations";
import { BeltComponent } from "../components/belt";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { THEME } from "../theme";
@ -22,6 +22,26 @@ export class MetaBeltBuilding extends MetaBuilding {
super("belt");
}
static getAllVariantCombinations() {
return [
{
internalId: 1,
variant: defaultBuildingVariant,
rotationVariant: 0,
},
{
internalId: 2,
variant: defaultBuildingVariant,
rotationVariant: 1,
},
{
internalId: 3,
variant: defaultBuildingVariant,
rotationVariant: 2,
},
];
}
getSilhouetteColor() {
return THEME.map.chunkOverview.beltColor;
}

11
src/js/game/buildings/block.js
View File

@ -2,13 +2,22 @@
import { Entity } from "../entity";
/* typehints:end */
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
export class MetaBlockBuilding extends MetaBuilding {
constructor() {
super("block");
}
static getAllVariantCombinations() {
return [
{
internalId: 64,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#333";
}

11
src/js/game/buildings/comparator.js
View File

@ -2,7 +2,7 @@ import { enumDirection, Vector } from "../../core/vector";
import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -11,6 +11,15 @@ export class MetaComparatorBuilding extends MetaBuilding {
super("comparator");
}
static getAllVariantCombinations() {
return [
{
internalId: 46,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#823cab";
}

11
src/js/game/buildings/constant_producer.js
View File

@ -6,13 +6,22 @@ import { enumDirection, Vector } from "../../core/vector";
import { ConstantSignalComponent } from "../components/constant_signal";
import { ItemEjectorComponent } from "../components/item_ejector";
import { ItemProducerComponent } from "../components/item_producer";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
export class MetaConstantProducerBuilding extends MetaBuilding {
constructor() {
super("constant_producer");
}
static getAllVariantCombinations() {
return [
{
internalId: 62,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#bfd630";
}

11
src/js/game/buildings/constant_signal.js
View File

@ -1,7 +1,7 @@
import { enumDirection, Vector } from "../../core/vector";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { ConstantSignalComponent } from "../components/constant_signal";
import { generateMatrixRotations } from "../../core/utils";
@ -14,6 +14,15 @@ export class MetaConstantSignalBuilding extends MetaBuilding {
super("constant_signal");
}
static getAllVariantCombinations() {
return [
{
internalId: 31,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#2b84fd";
}

13
src/js/game/buildings/cutter.js
View File

@ -17,6 +17,19 @@ export class MetaCutterBuilding extends MetaBuilding {
super("cutter");
}
static getAllVariantCombinations() {
return [
{
internalId: 9,
variant: defaultBuildingVariant,
},
{
internalId: 10,
variant: enumCutterVariants.quad,
},
];
}
getSilhouetteColor() {
return "#7dcda2";
}

11
src/js/game/buildings/display.js
View File

@ -1,7 +1,7 @@
import { enumDirection, Vector } from "../../core/vector";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { DisplayComponent } from "../components/display";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -11,6 +11,15 @@ export class MetaDisplayBuilding extends MetaBuilding {
super("display");
}
static getAllVariantCombinations() {
return [
{
internalId: 40,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#aaaaaa";
}

11
src/js/game/buildings/filter.js
View File

@ -6,7 +6,7 @@ import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -15,6 +15,15 @@ export class MetaFilterBuilding extends MetaBuilding {
super("filter");
}
static getAllVariantCombinations() {
return [
{
internalId: 37,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#c45c2e";
}

11
src/js/game/buildings/goal_acceptor.js
View File

@ -6,13 +6,22 @@ import { enumDirection, Vector } from "../../core/vector";
import { GoalAcceptorComponent } from "../components/goal_acceptor";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
export class MetaGoalAcceptorBuilding extends MetaBuilding {
constructor() {
super("goal_acceptor");
}
static getAllVariantCombinations() {
return [
{
internalId: 63,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#ce418a";
}

11
src/js/game/buildings/hub.js
View File

@ -3,7 +3,7 @@ import { HubComponent } from "../components/hub";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { WiredPinsComponent, enumPinSlotType } from "../components/wired_pins";
export class MetaHubBuilding extends MetaBuilding {
@ -11,6 +11,15 @@ export class MetaHubBuilding extends MetaBuilding {
super("hub");
}
static getAllVariantCombinations() {
return [
{
internalId: 26,
variant: defaultBuildingVariant,
},
];
}
getDimensions() {
return new Vector(4, 4);
}

11
src/js/game/buildings/item_producer.js
View File

@ -3,13 +3,22 @@ import { ItemEjectorComponent } from "../components/item_ejector";
import { ItemProducerComponent } from "../components/item_producer";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
export class MetaItemProducerBuilding extends MetaBuilding {
constructor() {
super("item_producer");
}
static getAllVariantCombinations() {
return [
{
internalId: 61,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#b37dcd";
}

11
src/js/game/buildings/lever.js
View File

@ -1,7 +1,7 @@
import { enumDirection, Vector } from "../../core/vector";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { LeverComponent } from "../components/lever";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -11,6 +11,15 @@ export class MetaLeverBuilding extends MetaBuilding {
super("lever");
}
static getAllVariantCombinations() {
return [
{
internalId: 33,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
// @todo: Render differently based on if its activated or not
return "#1a678b";

21
src/js/game/buildings/logic_gate.js
View File

@ -41,6 +41,27 @@ export class MetaLogicGateBuilding extends MetaBuilding {
super("logic_gate");
}
static getAllVariantCombinations() {
return [
{
internalId: 32,
variant: defaultBuildingVariant,
},
{
internalId: 34,
variant: enumLogicGateVariants.not,
},
{
internalId: 35,
variant: enumLogicGateVariants.xor,
},
{
internalId: 36,
variant: enumLogicGateVariants.or,
},
];
}
getSilhouetteColor(variant) {
return colors[variant];
}

13
src/js/game/buildings/miner.js
View File

@ -21,6 +21,19 @@ export class MetaMinerBuilding extends MetaBuilding {
super("miner");
}
static getAllVariantCombinations() {
return [
{
internalId: 7,
variant: defaultBuildingVariant,
},
{
internalId: 8,
variant: enumMinerVariants.chainable,
},
];
}
getSilhouetteColor() {
return "#b37dcd";
}

11
src/js/game/buildings/mixer.js
View File

@ -5,7 +5,7 @@ import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -14,6 +14,15 @@ export class MetaMixerBuilding extends MetaBuilding {
super("mixer");
}
static getAllVariantCombinations() {
return [
{
internalId: 15,
variant: defaultBuildingVariant,
},
];
}
getDimensions() {
return new Vector(2, 1);
}

21
src/js/game/buildings/painter.js
View File

@ -22,6 +22,27 @@ export class MetaPainterBuilding extends MetaBuilding {
super("painter");
}
static getAllVariantCombinations() {
return [
{
internalId: 16,
variant: defaultBuildingVariant,
},
{
internalId: 17,
variant: enumPainterVariants.mirrored,
},
{
internalId: 18,
variant: enumPainterVariants.double,
},
{
internalId: 19,
variant: enumPainterVariants.quad,
},
];
}
getDimensions(variant) {
switch (variant) {
case defaultBuildingVariant:

11
src/js/game/buildings/reader.js
View File

@ -4,7 +4,7 @@ import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { BeltUnderlaysComponent } from "../components/belt_underlays";
import { BeltReaderComponent } from "../components/belt_reader";
@ -18,6 +18,15 @@ export class MetaReaderBuilding extends MetaBuilding {
super("reader");
}
static getAllVariantCombinations() {
return [
{
internalId: 49,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#25fff2";
}

17
src/js/game/buildings/rotater.js
View File

@ -23,6 +23,23 @@ export class MetaRotaterBuilding extends MetaBuilding {
super("rotater");
}
static getAllVariantCombinations() {
return [
{
internalId: 11,
variant: defaultBuildingVariant,
},
{
internalId: 12,
variant: enumRotaterVariants.ccw,
},
{
internalId: 13,
variant: enumRotaterVariants.rotate180,
},
];
}
getSilhouetteColor() {
return "#7dc6cd";
}

11
src/js/game/buildings/stacker.js
View File

@ -5,7 +5,7 @@ import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -14,6 +14,15 @@ export class MetaStackerBuilding extends MetaBuilding {
super("stacker");
}
static getAllVariantCombinations() {
return [
{
internalId: 14,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#9fcd7d";
}

11
src/js/game/buildings/storage.js
View File

@ -6,7 +6,7 @@ import { ItemEjectorComponent } from "../components/item_ejector";
import { StorageComponent } from "../components/storage";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -17,6 +17,15 @@ export class MetaStorageBuilding extends MetaBuilding {
super("storage");
}
static getAllVariantCombinations() {
return [
{
internalId: 21,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#bbdf6d";
}

13
src/js/game/buildings/transistor.js
View File

@ -22,6 +22,19 @@ export class MetaTransistorBuilding extends MetaBuilding {
super("transistor");
}
static getAllVariantCombinations() {
return [
{
internalId: 38,
variant: defaultBuildingVariant,
},
{
internalId: 60,
variant: enumTransistorVariants.mirrored,
},
];
}
getSilhouetteColor() {
return "#bc3a61";
}

11
src/js/game/buildings/trash.js
View File

@ -4,7 +4,7 @@ import { ACHIEVEMENTS } from "../../platform/achievement_provider";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -15,6 +15,15 @@ export class MetaTrashBuilding extends MetaBuilding {
super("trash");
}
static getAllVariantCombinations() {
return [
{
internalId: 20,
variant: defaultBuildingVariant,
},
];
}
getIsRotateable() {
return false;
}

25
src/js/game/buildings/underground_belt.js
View File

@ -40,6 +40,31 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
super("underground_belt");
}
static getAllVariantCombinations() {
return [
{
internalId: 22,
variant: defaultBuildingVariant,
rotationVariant: 0,
},
{
internalId: 23,
variant: defaultBuildingVariant,
rotationVariant: 1,
},
{
internalId: 24,
variant: enumUndergroundBeltVariants.tier2,
rotationVariant: 0,
},
{
internalId: 25,
variant: enumUndergroundBeltVariants.tier2,
rotationVariant: 1,
},
];
}
getSilhouetteColor(variant, rotationVariant) {
return colorsByRotationVariant[rotationVariant];
}

25
src/js/game/buildings/virtual_processor.js
View File

@ -40,6 +40,31 @@ export class MetaVirtualProcessorBuilding extends MetaBuilding {
super("virtual_processor");
}
static getAllVariantCombinations() {
return [
{
internalId: 42,
variant: defaultBuildingVariant,
},
{
internalId: 44,
variant: enumVirtualProcessorVariants.rotater,
},
{
internalId: 45,
variant: enumVirtualProcessorVariants.unstacker,
},
{
internalId: 50,
variant: enumVirtualProcessorVariants.stacker,
},
{
internalId: 51,
variant: enumVirtualProcessorVariants.painter,
},
];
}
getSilhouetteColor(variant) {
return colors[variant];
}

45
src/js/game/buildings/wire.js
View File

@ -37,6 +37,51 @@ export class MetaWireBuilding extends MetaBuilding {
super("wire");
}
static getAllVariantCombinations() {
return [
{
internalId: 27,
variant: defaultBuildingVariant,
rotationVariant: 0,
},
{
internalId: 28,
variant: defaultBuildingVariant,
rotationVariant: 1,
},
{
internalId: 29,
variant: defaultBuildingVariant,
rotationVariant: 2,
},
{
internalId: 30,
variant: defaultBuildingVariant,
rotationVariant: 3,
},
{
internalId: 52,
variant: enumWireVariant.second,
rotationVariant: 0,
},
{
internalId: 53,
variant: enumWireVariant.second,
rotationVariant: 1,
},
{
internalId: 54,
variant: enumWireVariant.second,
rotationVariant: 2,
},
{
internalId: 55,
variant: enumWireVariant.second,
rotationVariant: 3,
},
];
}
getHasDirectionLockAvailable() {
return true;
}

11
src/js/game/buildings/wire_tunnel.js
View File

@ -2,7 +2,7 @@ import { generateMatrixRotations } from "../../core/utils";
import { Vector } from "../../core/vector";
import { WireTunnelComponent } from "../components/wire_tunnel";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
@ -13,6 +13,15 @@ export class MetaWireTunnelBuilding extends MetaBuilding {
super("wire_tunnel");
}
static getAllVariantCombinations() {
return [
{
internalId: 39,
variant: defaultBuildingVariant,
},
];
}
getSilhouetteColor() {
return "#777a86";
}

10
src/js/game/meta_building.js
View File

@ -18,6 +18,16 @@ export class MetaBuilding {
this.id = id;
}
/**
* Should return all possible variants of this building, no matter
* if they are already available or will be unlocked later on
*
* @returns {Array<{ variant: string, rotationVariant?: number, internalId?: number|string }>}
*/
static getAllVariantCombinations() {
throw new Error("implement getAllVariantCombinations");
}
/**
* Returns the id of this building
*/

227
src/js/game/meta_building_registry.js
View File

@ -2,202 +2,89 @@ import { gMetaBuildingRegistry } from "../core/global_registries";
import { createLogger } from "../core/logging";
import { T } from "../translations";
import { MetaAnalyzerBuilding } from "./buildings/analyzer";
import { enumBalancerVariants, MetaBalancerBuilding } from "./buildings/balancer";
import { MetaBalancerBuilding } from "./buildings/balancer";
import { MetaBeltBuilding } from "./buildings/belt";
import { MetaBlockBuilding } from "./buildings/block";
import { MetaComparatorBuilding } from "./buildings/comparator";
import { MetaConstantProducerBuilding } from "./buildings/constant_producer";
import { MetaConstantSignalBuilding } from "./buildings/constant_signal";
import { enumCutterVariants, MetaCutterBuilding } from "./buildings/cutter";
import { MetaCutterBuilding } from "./buildings/cutter";
import { MetaDisplayBuilding } from "./buildings/display";
import { MetaFilterBuilding } from "./buildings/filter";
import { MetaGoalAcceptorBuilding } from "./buildings/goal_acceptor";
import { MetaHubBuilding } from "./buildings/hub";
import { MetaItemProducerBuilding } from "./buildings/item_producer";
import { MetaLeverBuilding } from "./buildings/lever";
import { enumLogicGateVariants, MetaLogicGateBuilding } from "./buildings/logic_gate";
import { enumMinerVariants, MetaMinerBuilding } from "./buildings/miner";
import { MetaLogicGateBuilding } from "./buildings/logic_gate";
import { MetaMinerBuilding } from "./buildings/miner";
import { MetaMixerBuilding } from "./buildings/mixer";
import { enumPainterVariants, MetaPainterBuilding } from "./buildings/painter";
import { MetaPainterBuilding } from "./buildings/painter";
import { MetaReaderBuilding } from "./buildings/reader";
import { enumRotaterVariants, MetaRotaterBuilding } from "./buildings/rotater";
import { MetaRotaterBuilding } from "./buildings/rotater";
import { MetaStackerBuilding } from "./buildings/stacker";
import { MetaStorageBuilding } from "./buildings/storage";
import { enumTransistorVariants, MetaTransistorBuilding } from "./buildings/transistor";
import { MetaTransistorBuilding } from "./buildings/transistor";
import { MetaTrashBuilding } from "./buildings/trash";
import { enumUndergroundBeltVariants, MetaUndergroundBeltBuilding } from "./buildings/underground_belt";
import { enumVirtualProcessorVariants, MetaVirtualProcessorBuilding } from "./buildings/virtual_processor";
import { MetaUndergroundBeltBuilding } from "./buildings/underground_belt";
import { MetaVirtualProcessorBuilding } from "./buildings/virtual_processor";
import { MetaWireBuilding } from "./buildings/wire";
import { MetaWireTunnelBuilding } from "./buildings/wire_tunnel";
import { buildBuildingCodeCache, gBuildingVariants, registerBuildingVariant } from "./building_codes";
import { enumWireVariant } from "./components/wire";
import { KEYMAPPINGS } from "./key_action_mapper";
import { defaultBuildingVariant } from "./meta_building";
import { defaultBuildingVariant, MetaBuilding } from "./meta_building";
const logger = createLogger("building_registry");
export function initMetaBuildingRegistry() {
gMetaBuildingRegistry.register(MetaBalancerBuilding);
gMetaBuildingRegistry.register(MetaMinerBuilding);
gMetaBuildingRegistry.register(MetaCutterBuilding);
gMetaBuildingRegistry.register(MetaRotaterBuilding);
gMetaBuildingRegistry.register(MetaStackerBuilding);
gMetaBuildingRegistry.register(MetaMixerBuilding);
gMetaBuildingRegistry.register(MetaPainterBuilding);
gMetaBuildingRegistry.register(MetaTrashBuilding);
gMetaBuildingRegistry.register(MetaStorageBuilding);
gMetaBuildingRegistry.register(MetaBeltBuilding);
gMetaBuildingRegistry.register(MetaUndergroundBeltBuilding);
gMetaBuildingRegistry.register(MetaGoalAcceptorBuilding);
gMetaBuildingRegistry.register(MetaHubBuilding);
gMetaBuildingRegistry.register(MetaWireBuilding);
gMetaBuildingRegistry.register(MetaConstantSignalBuilding);
gMetaBuildingRegistry.register(MetaLogicGateBuilding);
gMetaBuildingRegistry.register(MetaLeverBuilding);
gMetaBuildingRegistry.register(MetaFilterBuilding);
gMetaBuildingRegistry.register(MetaWireTunnelBuilding);
gMetaBuildingRegistry.register(MetaDisplayBuilding);
gMetaBuildingRegistry.register(MetaVirtualProcessorBuilding);
gMetaBuildingRegistry.register(MetaReaderBuilding);
gMetaBuildingRegistry.register(MetaTransistorBuilding);
gMetaBuildingRegistry.register(MetaAnalyzerBuilding);
gMetaBuildingRegistry.register(MetaComparatorBuilding);
gMetaBuildingRegistry.register(MetaItemProducerBuilding);
gMetaBuildingRegistry.register(MetaConstantProducerBuilding);
gMetaBuildingRegistry.register(MetaBlockBuilding);
// Belt
registerBuildingVariant(1, MetaBeltBuilding, defaultBuildingVariant, 0);
registerBuildingVariant(2, MetaBeltBuilding, defaultBuildingVariant, 1);
registerBuildingVariant(3, MetaBeltBuilding, defaultBuildingVariant, 2);
// Balancer
registerBuildingVariant(4, MetaBalancerBuilding);
registerBuildingVariant(5, MetaBalancerBuilding, enumBalancerVariants.merger);
registerBuildingVariant(6, MetaBalancerBuilding, enumBalancerVariants.mergerInverse);
registerBuildingVariant(47, MetaBalancerBuilding, enumBalancerVariants.splitter);
registerBuildingVariant(48, MetaBalancerBuilding, enumBalancerVariants.splitterInverse);
// 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.rotate180);
// 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);
// Storage
registerBuildingVariant(21, MetaStorageBuilding);
// 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);
// Wire
registerBuildingVariant(27, MetaWireBuilding, defaultBuildingVariant, 0);
registerBuildingVariant(28, MetaWireBuilding, defaultBuildingVariant, 1);
registerBuildingVariant(29, MetaWireBuilding, defaultBuildingVariant, 2);
registerBuildingVariant(30, MetaWireBuilding, defaultBuildingVariant, 3);
registerBuildingVariant(52, MetaWireBuilding, enumWireVariant.second, 0);
registerBuildingVariant(53, MetaWireBuilding, enumWireVariant.second, 1);
registerBuildingVariant(54, MetaWireBuilding, enumWireVariant.second, 2);
registerBuildingVariant(55, MetaWireBuilding, enumWireVariant.second, 3);
// Constant signal
registerBuildingVariant(31, MetaConstantSignalBuilding);
// Logic gate
registerBuildingVariant(32, MetaLogicGateBuilding);
registerBuildingVariant(34, MetaLogicGateBuilding, enumLogicGateVariants.not);
registerBuildingVariant(35, MetaLogicGateBuilding, enumLogicGateVariants.xor);
registerBuildingVariant(36, MetaLogicGateBuilding, enumLogicGateVariants.or);
// Transistor
registerBuildingVariant(38, MetaTransistorBuilding, defaultBuildingVariant);
registerBuildingVariant(60, MetaTransistorBuilding, enumTransistorVariants.mirrored);
// Lever
registerBuildingVariant(33, MetaLeverBuilding);
// Filter
registerBuildingVariant(37, MetaFilterBuilding);
// Wire tunnel
registerBuildingVariant(39, MetaWireTunnelBuilding);
// Display
registerBuildingVariant(40, MetaDisplayBuilding);
// Virtual Processor
registerBuildingVariant(42, MetaVirtualProcessorBuilding);
registerBuildingVariant(44, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.rotater);
registerBuildingVariant(45, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.unstacker);
registerBuildingVariant(50, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.stacker);
registerBuildingVariant(51, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.painter);
// Analyzer
registerBuildingVariant(46, MetaComparatorBuilding);
registerBuildingVariant(43, MetaAnalyzerBuilding);
// Reader
registerBuildingVariant(49, MetaReaderBuilding);
// Item producer
registerBuildingVariant(61, MetaItemProducerBuilding);
// Constant producer
registerBuildingVariant(62, MetaConstantProducerBuilding);
// Goal acceptor
registerBuildingVariant(63, MetaGoalAcceptorBuilding);
// Block
registerBuildingVariant(64, MetaBlockBuilding);
// Propagate instances
for (const key in gBuildingVariants) {
gBuildingVariants[key].metaInstance = gMetaBuildingRegistry.findByClass(
gBuildingVariants[key].metaClass
/**
*
* @param {typeof MetaBuilding} metaBuilding
*/
export function registerBuildingVariants(metaBuilding) {
gMetaBuildingRegistry.register(metaBuilding);
const combinations = metaBuilding.getAllVariantCombinations();
combinations.forEach(combination => {
registerBuildingVariant(
combination.internalId,
metaBuilding,
combination.variant || defaultBuildingVariant,
combination.rotationVariant || 0
);
}
});
}
for (const key in gBuildingVariants) {
const variant = gBuildingVariants[key];
assert(variant.metaClass, "Variant has no meta: " + key);
export function initMetaBuildingRegistry() {
const buildings = [
MetaBalancerBuilding,
MetaMinerBuilding,
MetaCutterBuilding,
MetaRotaterBuilding,
MetaStackerBuilding,
MetaMixerBuilding,
MetaPainterBuilding,
MetaTrashBuilding,
MetaStorageBuilding,
MetaBeltBuilding,
MetaUndergroundBeltBuilding,
MetaGoalAcceptorBuilding,
MetaHubBuilding,
MetaWireBuilding,
MetaConstantSignalBuilding,
MetaLogicGateBuilding,
MetaLeverBuilding,
MetaFilterBuilding,
MetaWireTunnelBuilding,
MetaDisplayBuilding,
MetaVirtualProcessorBuilding,
MetaReaderBuilding,
MetaTransistorBuilding,
MetaAnalyzerBuilding,
MetaComparatorBuilding,
MetaItemProducerBuilding,
MetaConstantProducerBuilding,
MetaBlockBuilding,
];
if (typeof variant.rotationVariant === "undefined") {
variant.rotationVariant = 0;
}
if (typeof variant.variant === "undefined") {
variant.variant = defaultBuildingVariant;
}
}
buildings.forEach(registerBuildingVariants);
// Check for valid keycodes
if (G_IS_DEV) {

42
src/js/mods/mod_interface.js
View File

@ -24,6 +24,7 @@ import { MOD_CHUNK_DRAW_HOOKS } from "../game/map_chunk_view";
import { KEYMAPPINGS } from "../game/key_action_mapper";
import { HUDModalDialogs } from "../game/hud/parts/modal_dialogs";
import { THEMES } from "../game/theme";
import { ModMetaBuilding } from "./mod_meta_building";
export class ModInterface {
/**
@ -190,54 +191,47 @@ export class ModInterface {
/**
*
* @param {object} param0
* @param {typeof MetaBuilding} param0.metaClass
* @param {typeof ModMetaBuilding} param0.metaClass
* @param {string=} param0.buildingIconBase64
* @param {({
* variant?: string;
* rotationVariant?: number;
* name: string;
* description: string;
* blueprintImageBase64?: string;
* regularImageBase64?: string;
* tutorialImageBase64?: string;
* }[])} param0.variantsAndRotations
*/
registerNewBuilding({ metaClass, variantsAndRotations, buildingIconBase64 }) {
const id = new /** @type {new () => MetaBuilding} */ (metaClass)().getId();
registerNewBuilding({ metaClass, buildingIconBase64 }) {
const id = new /** @type {new (...args) => ModMetaBuilding} */ (metaClass)().getId();
if (gMetaBuildingRegistry.hasId(id)) {
throw new Error("Tried to register building twice: " + id);
}
gMetaBuildingRegistry.register(metaClass);
const metaInstance = gMetaBuildingRegistry.findByClass(metaClass);
T.buildings[id] = {};
variantsAndRotations.forEach(payload => {
const actualVariant = payload.variant || defaultBuildingVariant;
registerBuildingVariant(id, metaClass, actualVariant, payload.rotationVariant || 0);
metaClass.getAllVariantCombinations().forEach(combination => {
const actualVariant = combination.variant || defaultBuildingVariant;
registerBuildingVariant(id, metaClass, actualVariant, combination.rotationVariant || 0);
gBuildingVariants[id].metaInstance = metaInstance;
T.buildings[id][actualVariant] = {
name: payload.name,
description: payload.description,
name: combination.name || "Name",
description: combination.description || "Description",
};
const buildingIdentifier =
id + (actualVariant === defaultBuildingVariant ? "" : "-" + actualVariant);
if (payload.regularImageBase64) {
if (combination.regularImageBase64) {
this.registerSprite(
"sprites/buildings/" + buildingIdentifier + ".png",
payload.regularImageBase64
combination.regularImageBase64
);
}
if (payload.blueprintImageBase64) {
if (combination.blueprintImageBase64) {
this.registerSprite(
"sprites/blueprints/" + buildingIdentifier + ".png",
payload.blueprintImageBase64
combination.blueprintImageBase64
);
}
if (payload.tutorialImageBase64) {
this.setBuildingTutorialImage(id, actualVariant, payload.tutorialImageBase64);
if (combination.tutorialImageBase64) {
this.setBuildingTutorialImage(id, actualVariant, combination.tutorialImageBase64);
}
});

18
src/js/mods/mod_meta_building.js Normal file
View File

@ -0,0 +1,18 @@
import { MetaBuilding } from "../game/meta_building";
export class ModMetaBuilding extends MetaBuilding {
/**
* @returns {({
* variant: string;
* rotationVariant?: number;
* name: string;
* description: string;
* blueprintImageBase64?: string;
* regularImageBase64?: string;
* tutorialImageBase64?: string;
* }[])}
*/
static getAllVariantCombinations() {
throw new Error("Implement getAllVariantCombinations");
}
}