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

Merge branch 'remove-enum-layer' of github.com:bjornstar/shapez.io into enum-removal-super-branch

Browse Source
This commit is contained in:
Bjorn Stromberg 2020-08-05 15:56:37 +09:00
commit 688225ffbc
56 changed files with 318 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/js/game/base_item.js
View File

@ -1,35 +1,28 @@
import { DrawParameters } from "../core/draw_parameters";
import { BasicSerializableObject } from "../savegame/serialization";
import { enumLayer } from "./root";
/** @enum {string} */
export const enumItemType = {
shape: "shape",
color: "color",
positiveEnergy: "positiveEnergy",
negativeEnergy: "negativeEnergy",
/**
* @typedef {import("./root").Layer} Layer
*
* @typedef {"shape" | "color" | "positiveEnergy" | "negativeEnergy" | "genericEnergy"} ItemType
*/
// Can be used for filters
genericEnergy: "genericEnergy",
};
/** @type {ItemType[]} **/
export const itemTypes = ["shape", "color", "positiveEnergy", "negativeEnergy", "genericEnergy"];
/** @enum {enumLayer} */
export const enumItemTypeToLayer = {
[enumItemType.shape]: enumLayer.regular,
[enumItemType.color]: enumLayer.regular,
[enumItemType.positiveEnergy]: enumLayer.wires,
[enumItemType.negativeEnergy]: enumLayer.wires,
[enumItemType.genericEnergy]: enumLayer.wires,
/** @type {Record<ItemType, Layer>} **/
export const itemTypeLayerMap = {
shape: "regular",
color: "regular",
positiveEnergy: "wires",
negativeEnergy: "wires",
genericEnergy: "wires",
};
/**
* Class for items on belts etc. Not an entity for performance reasons
*/
export class BaseItem extends BasicSerializableObject {
constructor() {
super();
}
static getId() {
return "base_item";
}
@ -39,10 +32,10 @@ export class BaseItem extends BasicSerializableObject {
return {};
}
/** @returns {enumItemType} */
/** @abstract @returns {ItemType} **/
getItemType() {
abstract;
return "";
return "shape";
}
/**

8
src/js/game/belt_path.js
View File

@ -5,11 +5,15 @@ import { epsilonCompare, round4Digits } from "../core/utils";
import { Vector } from "../core/vector";
import { BaseItem } from "./base_item";
import { Entity } from "./entity";
import { GameRoot, enumLayer } from "./root";
import { Rectangle } from "../core/rectangle";
import { BasicSerializableObject, types } from "../savegame/serialization";
import { gItemRegistry } from "../core/global_registries";
/**
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
**/
const logger = createLogger("belt_path");
// Helpers for more semantic access into interleaved arrays
@ -127,7 +131,7 @@ export class BeltPath extends BasicSerializableObject {
/**
* Returns the layer of the this path
* @returns {enumLayer}
* @returns {Layer}
*/
getLayer() {
return this.entityPath[0].layer;

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

@ -3,11 +3,15 @@ import { Loader } from "../core/loader";
import { createLogger } from "../core/logging";
import { clockwiseAngleMap, counterClockwiseAngleMap, Vector } from "../core/vector";
import { Entity } from "./entity";
import { GameRoot, enumLayer } from "./root";
import { findNiceIntegerValue } from "../core/utils";
import { blueprintShape } from "./upgrades";
import { globalConfig } from "../core/config";
/**
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
**/
const logger = createLogger("blueprint");
export class Blueprint {
@ -20,11 +24,11 @@ export class Blueprint {
/**
* Returns the layer of this blueprint
* @returns {enumLayer}
* @returns {Layer}
*/
get layer() {
if (this.entities.length === 0) {
return enumLayer.regular;
return "regular";
}
return this.entities[0].layer;
}

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

@ -1,7 +1,6 @@
import { formatItemsPerSecond } from "../../core/utils";
import { Vector } from "../../core/vector";
import { T } from "../../translations";
import { enumItemType } from "../base_item";
import { EnergyConsumerComponent } from "../components/energy_consumer";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
@ -9,7 +8,11 @@ import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/it
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { enumLayer, GameRoot } from "../root";
/**
* @typedef {import("../root").GameRoot} GameRoot
* @typedef {import("../root").Layer} Layer
*/
export class MetaAdvancedProcessorBuilding extends MetaBuilding {
constructor() {
@ -58,7 +61,7 @@ export class MetaAdvancedProcessorBuilding extends MetaBuilding {
new ItemEjectorComponent({
slots: [
{ pos: new Vector(1, 0), direction: "right" },
{ pos: new Vector(1, 0), direction: "top", layer: enumLayer.wires },
{ pos: new Vector(1, 0), direction: "top", layer: "wires" },
],
})
);
@ -98,8 +101,8 @@ export class MetaAdvancedProcessorBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["top"],
filter: enumItemType.positiveEnergy,
layer: enumLayer.wires,
filter: "positiveEnergy",
layer: "wires",
},
],
})

9
src/js/game/buildings/belt_base.js
View File

@ -14,9 +14,10 @@ import { ItemEjectorComponent } from "../components/item_ejector";
import { ReplaceableMapEntityComponent } from "../components/replaceable_map_entity";
import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { GameRoot, enumLayer } from "../root";
/**
* @typedef {import("../root").GameRoot} GameRoot
* @typedef {import("../root").Layer} Layer
* @typedef {import("../../core/vector").Angle} Angle
* @typedef {import("../../core/vector").Direction} Direction
*/
@ -35,7 +36,7 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
* @returns {Array<[string, string]>}
*/
getAdditionalStatistics(root, variant) {
const beltSpeed = root.hubGoals.getBeltBaseSpeed(enumLayer.regular);
const beltSpeed = root.hubGoals.getBeltBaseSpeed("regular");
return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]];
}
@ -112,10 +113,10 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
* @param {Vector} param0.tile
* @param {Angle} param0.rotation
* @param {string} param0.variant
* @param {string} param0.layer
* @param {Layer} param0.layer
* @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, layer }) {
const topDirection = angleDirectionMap[rotation];
const rightDirection = angleDirectionMap[clockwiseAngleMap[rotation]];
const bottomDirection = angleDirectionMap[inverseAngleMap[rotation]];

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

@ -8,7 +8,6 @@ import { Entity } from "../entity";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
import { enumItemType } from "../base_item";
/** @enum {string} */
export const enumCutterVariants = { quad: "quad" };
@ -82,7 +81,7 @@ export class MetaCutterBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
],
})

16
src/js/game/buildings/energy_generator.js
View File

@ -1,14 +1,16 @@
import { Vector } from "../../core/vector";
import { enumItemType } from "../base_item";
import { EnergyGeneratorComponent } from "../components/energy_generator";
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 { enumLayer, GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
/**
* @typedef {import("../root").GameRoot} GameRoot
*/
export class MetaEnergyGenerator extends MetaBuilding {
constructor() {
super("energy_generator");
@ -51,18 +53,18 @@ export class MetaEnergyGenerator extends MetaBuilding {
{
pos: new Vector(0, 1),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 1),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 0),
directions: ["top"],
layer: enumLayer.wires,
filter: enumItemType.negativeEnergy,
layer: "wires",
filter: "negativeEnergy",
},
],
})
@ -74,7 +76,7 @@ export class MetaEnergyGenerator extends MetaBuilding {
{
pos: new Vector(0, 0),
direction: "top",
layer: enumLayer.wires,
layer: "wires",
},
],
instantEject: true,

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

@ -1,5 +1,4 @@
import { Vector } from "../../core/vector";
import { enumItemType } from "../base_item";
import { HubComponent } from "../components/hub";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
@ -53,72 +52,72 @@ export class MetaHubBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["top", "left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 0),
directions: ["top"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(2, 0),
directions: ["top"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(3, 0),
directions: ["top", "right"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(0, 3),
directions: ["bottom", "left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 3),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(2, 3),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(3, 3),
directions: ["bottom", "right"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(0, 1),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(0, 2),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(0, 3),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(3, 1),
directions: ["right"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(3, 2),
directions: ["right"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(3, 3),
directions: ["right"],
filter: enumItemType.shape,
filter: "shape",
},
],
})

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

@ -1,7 +1,6 @@
import { formatItemsPerSecond } from "../../core/utils";
import { Vector } from "../../core/vector";
import { T } from "../../translations";
import { enumItemType } from "../base_item";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
@ -63,12 +62,12 @@ export class MetaMixerBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["bottom"],
filter: enumItemType.color,
filter: "color",
},
{
pos: new Vector(1, 0),
directions: ["bottom"],
filter: enumItemType.color,
filter: "color",
},
],
})

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

@ -8,7 +8,6 @@ import { Entity } from "../entity";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
import { enumItemType } from "../base_item";
/** @enum {string} */
export const enumPainterVariants = { mirrored: "mirrored", double: "double", quad: "quad" };
@ -98,12 +97,12 @@ export class MetaPainterBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 0),
directions: ["top"],
filter: enumItemType.color,
filter: "color",
},
],
})
@ -124,12 +123,12 @@ export class MetaPainterBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 0),
directions: [variant === defaultBuildingVariant ? "top" : "bottom"],
filter: enumItemType.color,
filter: "color",
},
]);
@ -143,17 +142,17 @@ export class MetaPainterBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(0, 1),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 0),
directions: ["top"],
filter: enumItemType.color,
filter: "color",
},
]);
@ -167,27 +166,27 @@ export class MetaPainterBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["left"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(0, 0),
directions: ["bottom"],
filter: enumItemType.color,
filter: "color",
},
{
pos: new Vector(1, 0),
directions: ["bottom"],
filter: enumItemType.color,
filter: "color",
},
{
pos: new Vector(2, 0),
directions: ["bottom"],
filter: enumItemType.color,
filter: "color",
},
{
pos: new Vector(3, 0),
directions: ["bottom"],
filter: enumItemType.color,
filter: "color",
},
]);

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

@ -8,7 +8,6 @@ import { Entity } from "../entity";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
import { enumItemType } from "../base_item";
/** @enum {string} */
export const enumRotaterVariants = { ccw: "ccw", fl: "fl" };
@ -89,7 +88,7 @@ export class MetaRotaterBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
],
})

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

@ -5,11 +5,14 @@ import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
import { GameRoot, enumLayer } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
import { T } from "../../translations";
import { formatItemsPerSecond } from "../../core/utils";
/**
* @typedef {import("../root").GameRoot} GameRoot
*/
/** @enum {string} */
export const enumSplitterVariants = { compact: "compact", compactInverse: "compact-inverse" };
@ -116,8 +119,8 @@ export class MetaSplitterBuilding extends MetaBuilding {
]);
entity.components.ItemAcceptor.beltUnderlays = [
{ pos: new Vector(0, 0), direction: "top", layer: enumLayer.regular },
{ pos: new Vector(1, 0), direction: "top", layer: enumLayer.regular },
{ pos: new Vector(0, 0), direction: "top", layer: "regular" },
{ pos: new Vector(1, 0), direction: "top", layer: "regular" },
];
break;
@ -138,7 +141,7 @@ export class MetaSplitterBuilding extends MetaBuilding {
entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: "top" }]);
entity.components.ItemAcceptor.beltUnderlays = [
{ pos: new Vector(0, 0), direction: "top", layer: enumLayer.regular },
{ pos: new Vector(0, 0), direction: "top", layer: "regular" },
];
break;

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

@ -8,7 +8,6 @@ import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building";
import { GameRoot } from "../root";
import { enumHubGoalRewards } from "../tutorial_goals";
import { enumItemType } from "../base_item";
export class MetaStackerBuilding extends MetaBuilding {
constructor() {
@ -63,12 +62,12 @@ export class MetaStackerBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
{
pos: new Vector(1, 0),
directions: ["bottom"],
filter: enumItemType.shape,
filter: "shape",
},
],
})

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

@ -5,13 +5,16 @@ import { ItemEjectorComponent } from "../components/item_ejector";
import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
import { Entity } from "../entity";
import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
import { GameRoot, enumLayer } from "../root";
import { globalConfig } from "../../core/config";
import { enumHubGoalRewards } from "../tutorial_goals";
import { formatItemsPerSecond } from "../../core/utils";
import { T } from "../../translations";
/** @typedef {import("../../core/vector").Angle} Angle **/
/**
* @typedef {import("../../core/vector").Angle} Angle
* @typedef {import("../root").GameRoot} GameRoot
* @typedef {import("../root").Layer} Layer
*/
/** @enum {string} */
export const arrayUndergroundRotationVariantToMode = [
@ -155,10 +158,9 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
* @param {Vector} param0.tile
* @param {Angle} param0.rotation
* @param {string} param0.variant
* @param {string} param0.layer
* @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant }) {
const searchDirection = angleDirectionMap[rotation];
const searchVector = directionVectorMap[searchDirection];
const tier = enumUndergroundBeltVariantToTier[variant];
@ -174,7 +176,7 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
tile = tile.addScalars(searchVector.x, searchVector.y);
/* WIRES: FIXME */
const contents = root.map.getTileContent(tile, enumLayer.regular);
const contents = root.map.getTileContent(tile, "regular");
if (contents) {
const undergroundComp = contents.components.UndergroundBelt;
if (undergroundComp && undergroundComp.tier === tier) {

4
src/js/game/buildings/wire_base.js
View File

@ -1,5 +1,4 @@
import { Loader } from "../../core/loader";
import { enumLayer } from "../root";
import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "./belt_base";
export class MetaWireBaseBuilding extends MetaBeltBaseBuilding {
@ -11,8 +10,9 @@ export class MetaWireBaseBuilding extends MetaBeltBaseBuilding {
return "#c425d7";
}
/** @returns {"wires"} **/
getLayer() {
return enumLayer.wires;
return "wires";
}
getPreviewSprite(rotationVariant) {

18
src/js/game/buildings/wire_crossings.js
View File

@ -1,11 +1,10 @@
import { Vector } from "../../core/vector";
import { enumItemType } from "../base_item";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
import { enumLayer, GameRoot } from "../root";
import { GameRoot } from "../root";
/** @enum {string} */
export const enumWireCrossingVariants = {
@ -26,8 +25,9 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
return "#c425d7";
}
/** @returns {"wires"} **/
getLayer() {
return enumLayer.wires;
return "wires";
}
/**
@ -83,13 +83,13 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["bottom"],
layer: enumLayer.wires,
layer: "wires",
},
]);
entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: "top", layer: enumLayer.wires },
{ pos: new Vector(0, 0), direction: "right", layer: enumLayer.wires },
{ pos: new Vector(0, 0), direction: "top", layer: "wires" },
{ pos: new Vector(0, 0), direction: "right", layer: "wires" },
]);
break;
@ -99,17 +99,17 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
{
pos: new Vector(0, 0),
directions: ["top"],
layer: enumLayer.wires,
layer: "wires",
},
{
pos: new Vector(0, 0),
directions: ["right"],
layer: enumLayer.wires,
layer: "wires",
},
]);
entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: "bottom", layer: enumLayer.wires },
{ pos: new Vector(0, 0), direction: "bottom", layer: "wires" },
]);
break;
}

15
src/js/game/components/belt.js
View File

@ -3,7 +3,10 @@ import { types } from "../../savegame/serialization";
import { BeltPath } from "../belt_path";
import { Component } from "../component";
import { Entity } from "../entity";
import { enumLayer } from "../root";
/**
* @typedef {import("../root").Layer} Layer
**/
/** @typedef {import("../../core/vector").Direction} Direction **/
@ -47,12 +50,12 @@ export class BeltComponent extends Component {
/**
* Returns the effective length of this belt in tile space
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {number}
*/
getEffectiveLengthTiles(layer) {
assert(layer, "no layer given");
if (layer === enumLayer.wires) {
if (layer === "wires") {
return 1.0;
}
return this.direction === "top" ? 1.0 : curvedBeltLength;
@ -62,14 +65,14 @@ export class BeltComponent extends Component {
* Converts from belt space (0 = start of belt ... 1 = end of belt) to the local
* belt coordinates (-0.5|-0.5 to 0.5|0.5)
* @param {number} progress
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {Vector}
*/
transformBeltToLocalSpace(progress, layer) {
assert(progress >= 0.0, "Invalid progress ( < 0): " + progress);
switch (layer) {
case enumLayer.regular: {
case "regular": {
switch (this.direction) {
case "top":
assert(progress <= 1.02, "Invalid progress: " + progress);
@ -96,7 +99,7 @@ export class BeltComponent extends Component {
return new Vector(0, 0);
}
}
case enumLayer.wires: {
case "wires": {
const pow = 0.5;
switch (this.direction) {
case "top":

12
src/js/game/components/energy_consumer.js
View File

@ -1,7 +1,7 @@
import { Component } from "../component";
import { types } from "../../savegame/serialization";
import { Vector } from "../../core/vector";
import { BaseItem, enumItemTypeToLayer, enumItemType } from "../base_item";
import { BaseItem, itemTypes } from "../base_item";
export class EnergyConsumerComponent extends Component {
static getId() {
@ -13,8 +13,8 @@ export class EnergyConsumerComponent extends Component {
bufferSize: types.float,
perCharge: types.float,
batteryPosition: types.vector,
energyType: types.enum(enumItemType),
wasteType: types.enum(enumItemType),
energyType: types.enum(itemTypes),
wasteType: types.enum(itemTypes),
acceptorSlotIndex: types.uint,
ejectorSlotIndex: types.uint,
@ -54,8 +54,10 @@ export class EnergyConsumerComponent extends Component {
this.bufferSize = bufferSize;
this.perCharge = perCharge;
this.batteryPosition = batteryPosition;
this.energyType = enumItemType.positiveEnergy;
this.wasteType = enumItemType.negativeEnergy;
/** @type {"positiveEnergy"} **/
this.energyType = "positiveEnergy";
/** @type {"negativeEnergy"} **/
this.wasteType = "negativeEnergy";
this.acceptorSlotIndex = acceptorSlotIndex;
this.ejectorSlotIndex = ejectorSlotIndex;

4
src/js/game/components/energy_generator.js
View File

@ -1,5 +1,5 @@
import { types } from "../../savegame/serialization";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem } from "../base_item";
import { Component } from "../component";
import { ShapeItem } from "../items/shape_item";
@ -59,7 +59,7 @@ export class EnergyGeneratorComponent extends Component {
// just destroy it
return true;
} else {
if (item.getItemType() !== enumItemType.shape) {
if (item.getItemType() !== "shape") {
// This shouldn't happen since we have a filter - still, it doesn't hurt
// to check either
assertAlways(

36
src/js/game/components/item_acceptor.js
View File

@ -1,18 +1,20 @@
import { directions, invertedDirectionMap } from "../../core/vector";
import { types } from "../../savegame/serialization";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem, itemTypes } from "../base_item";
import { Component } from "../component";
import { enumLayer } from "../root";
import { layers } from "../root";
/**
* @typedef {import("../../core/vector").Direction} Direction
* @typedef {import("../../core/vector").Vector} Vector
* @typedef {import("../root").Layer} Layer
* @typedef {import ("../base_item").ItemType} ItemType
*
* @typedef {{
* pos: Vector,
* directions: Direction[],
* layer: enumLayer,
* filter?: enumItemType
* layer: Layer,
* filter?: ItemType
* }} ItemAcceptorSlot
*
* Contains information about a slot plus its location
@ -25,10 +27,10 @@ import { enumLayer } from "../root";
* @typedef {{
* pos: Vector,
* directions: Direction[],
* layer?: enumLayer,
* filter?: enumItemType
* layer?: Layer,
* filter?: ItemType
* }} ItemAcceptorSlotConfig
*/
**/
export class ItemAcceptorComponent extends Component {
static getId() {
@ -41,10 +43,10 @@ export class ItemAcceptorComponent extends Component {
types.structured({
pos: types.vector,
directions: types.array(types.enum(directions)),
filter: types.nullable(types.enum(enumItemType)),
filter: types.nullable(types.enum(itemTypes)),
// TODO: MIGRATE
layer: types.enum(enumLayer),
layer: types.enum(layers),
})
),
animated: types.bool,
@ -54,7 +56,7 @@ export class ItemAcceptorComponent extends Component {
direction: types.enum(directions),
// TODO: MIGRATE
layer: types.enum(enumLayer),
layer: types.enum(layers),
})
),
};
@ -94,7 +96,7 @@ export class ItemAcceptorComponent extends Component {
* @param {object} param0
* @param {Array<ItemAcceptorSlotConfig>} param0.slots The slots from which we accept items
* @param {boolean=} param0.animated Whether to animate item consumption
* @param {Array<{pos: Vector, direction: Direction, layer: enumLayer}>=} param0.beltUnderlays Where to render belt underlays
* @param {Array<{pos: Vector, direction: Direction, layer: Layer}>=} param0.beltUnderlays Where to render belt underlays
*/
constructor({ slots = [], beltUnderlays = [], animated = true }) {
super();
@ -125,9 +127,9 @@ export class ItemAcceptorComponent extends Component {
this.slots.push({
pos: slot.pos,
directions: slot.directions,
layer: slot.layer || enumLayer.regular,
layer: slot.layer || "regular",
// Which type of item to accept (shape | color | all) @see enumItemType
// Which type of item to accept (shape | color | all) @see ItemType
filter: slot.filter,
});
}
@ -145,7 +147,7 @@ export class ItemAcceptorComponent extends Component {
/**
* Returns if the given filter matches
* @param {enumItemType|null} filter
* @param {ItemType|null} filter
* @param {BaseItem} item
*/
filterMatches(filter, item) {
@ -154,8 +156,8 @@ export class ItemAcceptorComponent extends Component {
}
const itemType = item.getItemType();
if (filter === enumItemType.genericEnergy) {
return itemType === enumItemType.positiveEnergy || itemType === enumItemType.negativeEnergy;
if (filter === "genericEnergy") {
return itemType === "positiveEnergy" || itemType === "negativeEnergy";
}
return itemType === filter;
@ -182,7 +184,7 @@ export class ItemAcceptorComponent extends Component {
* Tries to find a slot which accepts the current item
* @param {Vector} targetLocalTile
* @param {Direction} fromLocalDirection
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {ItemAcceptorLocatedSlot|null}
*/
findMatchingSlot(targetLocalTile, fromLocalDirection, layer) {

18
src/js/game/components/item_ejector.js
View File

@ -4,16 +4,18 @@ import { Component } from "../component";
import { types } from "../../savegame/serialization";
import { gItemRegistry } from "../../core/global_registries";
import { Entity } from "../entity";
import { enumLayer } from "../root";
import { layers } from "../root";
/**
* @typedef {import("../root").Layer} Layer
* @typedef {import("../../core/vector").Direction} Direction
* @typedef {import("./item_acceptor").ItemAcceptorLocatedSlot} ItemAcceptorLocatedSlot
*
* @typedef {{
* pos: Vector,
* direction: Direction,
* item: BaseItem,
* layer: enumLayer,
* layer: Layer,
* progress: number?,
* cachedDestSlot?: ItemAcceptorLocatedSlot,
* cachedTargetEntity?: Entity
@ -38,7 +40,7 @@ export class ItemEjectorComponent extends Component {
progress: types.float,
// TODO: Migrate
layer: types.enum(enumLayer),
layer: types.enum(layers),
})
),
};
@ -64,7 +66,7 @@ export class ItemEjectorComponent extends Component {
/**
*
* @param {object} param0
* @param {Array<{pos: Vector, direction: Direction, layer?: enumLayer}>=} param0.slots The slots to eject on
* @param {Array<{pos: Vector, direction: Direction, layer?: Layer}>=} param0.slots The slots to eject on
* @param {boolean=} param0.instantEject If the ejection is instant
*/
constructor({ slots = [], instantEject = false }) {
@ -85,7 +87,7 @@ export class ItemEjectorComponent extends Component {
}
/**
* @param {Array<{pos: Vector, direction: Direction, layer?: enumLayer}>} slots The slots to eject on
* @param {Array<{pos: Vector, direction: Direction, layer?: Layer}>} slots The slots to eject on
*/
setSlots(slots) {
/** @type {Array<ItemEjectorSlot>} */
@ -97,7 +99,7 @@ export class ItemEjectorComponent extends Component {
direction: slot.direction,
item: null,
progress: 0,
layer: slot.layer || enumLayer.regular,
layer: slot.layer || "regular",
cachedDestSlot: null,
cachedTargetEntity: null,
});
@ -118,7 +120,7 @@ export class ItemEjectorComponent extends Component {
/**
* Returns whether any slot ejects to the given local tile
* @param {Vector} tile
* @param {enumLayer} layer
* @param {Layer} layer
*/
anySlotEjectsToLocalTile(tile, layer) {
for (let i = 0; i < this.slots.length; ++i) {
@ -141,7 +143,7 @@ export class ItemEjectorComponent extends Component {
/**
* Returns the first free slot on this ejector or null if there is none
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {number?}
*/
getFirstFreeSlot(layer) {

6
src/js/game/components/storage.js
View File

@ -1,7 +1,7 @@
import { Component } from "../component";
import { types } from "../../savegame/serialization";
import { gItemRegistry } from "../../core/global_registries";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem } from "../base_item";
import { ColorItem } from "../items/color_item";
import { ShapeItem } from "../items/shape_item";
@ -67,11 +67,11 @@ export class StorageComponent extends Component {
return false;
}
if (itemType === enumItemType.color) {
if (itemType === "color") {
return /** @type {ColorItem} */ (this.storedItem).color === /** @type {ColorItem} */ (item).color;
}
if (itemType === enumItemType.shape) {
if (itemType === "shape") {
return (
/** @type {ShapeItem} */ (this.storedItem).definition.getHash() ===
/** @type {ShapeItem} */ (item).definition.getHash()

6
src/js/game/components/underground_belt.js
View File

@ -4,7 +4,6 @@ import { globalConfig } from "../../core/config";
import { types } from "../../savegame/serialization";
import { gItemRegistry } from "../../core/global_registries";
import { Entity } from "../entity";
import { enumLayer } from "../root";
/** @enum {string} */
export const enumUndergroundBeltMode = {
@ -103,8 +102,7 @@ export class UndergroundBeltComponent extends Component {
}
// Notice: We assume that for all items the travel distance is the same
const maxItemsInTunnel =
(2 + travelDistance) / globalConfig.beltItemSpacingByLayer[enumLayer.regular];
const maxItemsInTunnel = (2 + travelDistance) / globalConfig.beltItemSpacingByLayer.regular;
if (this.pendingItems.length >= maxItemsInTunnel) {
// Simulate a real belt which gets full at some point
return false;
@ -115,7 +113,7 @@ export class UndergroundBeltComponent extends Component {
// So instead of adding 1 we add 0.5 only.
// Additionally it takes 1 tile for the acceptor which we just add on top.
const travelDuration =
(travelDistance + 1.5) / beltSpeed / globalConfig.beltItemSpacingByLayer[enumLayer.regular];
(travelDistance + 1.5) / beltSpeed / globalConfig.beltItemSpacingByLayer.regular;
this.pendingItems.push([item, travelDuration]);

22
src/js/game/core.js
View File

@ -23,7 +23,7 @@ import { GameHUD } from "./hud/hud";
import { KeyActionMapper } from "./key_action_mapper";
import { GameLogic } from "./logic";
import { MapView } from "./map_view";
import { GameRoot, enumLayer } from "./root";
import { GameRoot } from "./root";
import { ShapeDefinitionManager } from "./shape_definition_manager";
import { SoundProxy } from "./sound_proxy";
import { GameTime } from "./time/game_time";
@ -32,6 +32,10 @@ import { randomInt } from "../core/utils";
import { defaultBuildingVariant } from "./meta_building";
import { DynamicTickrate } from "./dynamic_tickrate";
/**
* @typedef {import("./root").Layer} Layer
**/
const logger = createLogger("ingame/core");
// Store the canvas so we can reuse it later
@ -398,14 +402,14 @@ export class GameCore {
if (!this.root.camera.getIsMapOverlayActive()) {
// Underlays for splitters / balancers
systems.itemAcceptor.drawUnderlays(params, enumLayer.regular);
systems.itemAcceptor.drawUnderlays(params, "regular");
// Belt items
systems.belt.drawLayerBeltItems(params, enumLayer.regular);
systems.belt.drawLayerBeltItems(params, "regular");
// Items being ejected / accepted currently (animations)
systems.itemEjector.drawLayer(params, enumLayer.regular);
systems.itemAcceptor.drawLayer(params, enumLayer.regular);
systems.itemEjector.drawLayer(params, "regular");
systems.itemAcceptor.drawLayer(params, "regular");
}
// Miner & Static map entities
@ -428,14 +432,14 @@ export class GameCore {
// Green wires overlay (not within the if because it can fade)
root.hud.parts.wiresOverlay.draw(params);
if (this.root.currentLayer === enumLayer.wires && !this.root.camera.getIsMapOverlayActive()) {
if (this.root.currentLayer === "wires" && !this.root.camera.getIsMapOverlayActive()) {
// Belt sprites & Static map entities
root.map.drawWiresLayer(params);
// Belt items as well as accepted / ejected items
systems.belt.drawLayerBeltItems(params, enumLayer.wires);
systems.itemEjector.drawLayer(params, enumLayer.wires);
systems.itemAcceptor.drawLayer(params, enumLayer.wires);
systems.belt.drawLayerBeltItems(params, "wires");
systems.itemEjector.drawLayer(params, "wires");
systems.itemAcceptor.drawLayer(params, "wires");
root.map.drawWiresForegroundLayer(params);

12
src/js/game/entity.js
View File

@ -3,15 +3,20 @@ import { DrawParameters } from "../core/draw_parameters";
import { Component } from "./component";
/* typehints:end */
import { GameRoot, enumLayer } from "./root";
import { globalConfig } from "../core/config";
import { directionAngleMap, directionVectorMap } from "../core/vector";
import { BasicSerializableObject, types } from "../savegame/serialization";
import { EntityComponentStorage } from "./entity_components";
import { layers } from "./root";
import { Loader } from "../core/loader";
import { drawRotatedSprite } from "../core/draw_utils";
import { gComponentRegistry } from "../core/global_registries";
/**
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
**/
export class Entity extends BasicSerializableObject {
/**
* @param {GameRoot} root
@ -36,8 +41,9 @@ export class Entity extends BasicSerializableObject {
/**
* On which layer this entity is
* @type {Layer}
*/
this.layer = enumLayer.regular;
this.layer = "regular";
/**
* Internal entity unique id, set by the @see EntityManager
@ -77,7 +83,7 @@ export class Entity extends BasicSerializableObject {
return {
uid: types.uint,
components: types.keyValueMap(types.objData(gComponentRegistry)),
layer: types.enum(enumLayer),
layer: types.enum(layers),
};
}

9
src/js/game/game_system_with_filter.js
View File

@ -3,11 +3,16 @@ import { Component } from "./component";
import { Entity } from "./entity";
/* typehints:end */
import { GameRoot, enumLayer } from "./root";
import { GameSystem } from "./game_system";
import { arrayDelete, arrayDeleteValue } from "../core/utils";
import { DrawParameters } from "../core/draw_parameters";
import { globalConfig } from "../core/config";
/**
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
**/
export class GameSystemWithFilter extends GameSystem {
/**
* Constructs a new game system with the given component filter. It will process
@ -39,7 +44,7 @@ export class GameSystemWithFilter extends GameSystem {
* Calls a function for each matching entity on the screen, useful for drawing them
* @param {DrawParameters} parameters
* @param {function} callback
* @param {enumLayer=} layerFilter Can be null for no filter
* @param {Layer=} layerFilter Can be null for no filter
*/
forEachMatchingEntityOnScreen(parameters, callback, layerFilter = null) {
const cullRange = parameters.visibleRect.toTileCullRectangle();

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

@ -4,11 +4,15 @@ import { clamp, findNiceIntegerValue, randomChoice, randomInt } from "../core/ut
import { BasicSerializableObject, types } from "../savegame/serialization";
import { colors } from "./colors";
import { enumItemProcessorTypes } from "./components/item_processor";
import { GameRoot, enumLayer } from "./root";
import { enumSubShape, ShapeDefinition } from "./shape_definition";
import { enumHubGoalRewards, tutorialGoals } from "./tutorial_goals";
import { UPGRADES, blueprintShape } from "./upgrades";
/**
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
**/
export class HubGoals extends BasicSerializableObject {
static getId() {
return "HubGoals";
@ -369,11 +373,11 @@ export class HubGoals extends BasicSerializableObject {
/**
* Belt speed
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {number} items / sec
*/
getBeltBaseSpeed(layer) {
if (layer === enumLayer.wires) {
if (layer === "wires") {
return globalConfig.wiresSpeedItemsPerSecond;
}
return globalConfig.beltSpeedItemsPerSecond * this.upgradeImprovements.belt;

7
src/js/game/hud/parts/blueprint_placer.js
View File

@ -11,7 +11,10 @@ import { BaseHUDPart } from "../base_hud_part";
import { DynamicDomAttach } from "../dynamic_dom_attach";
import { Blueprint } from "../../blueprint";
import { SOUNDS } from "../../../platform/sound";
import { enumLayer } from "../../root";
/**
* @typedef {import("../../root").Layer} Layer
**/
export class HUDBlueprintPlacer extends BaseHUDPart {
createElements(parent) {
@ -60,7 +63,7 @@ export class HUDBlueprintPlacer extends BaseHUDPart {
/**
* Called when the layer was changed
* @param {enumLayer} layer
* @param {Layer} layer
*/
onEditModeChanged(layer) {
// Check if the layer of the blueprint differs and thus we have to deselect it

14
src/js/game/hud/parts/building_placer.js
View File

@ -8,13 +8,17 @@ import { directionVectorMap, directionAngleMap, invertedDirectionMap, Vector } f
import { T } from "../../../translations";
import { KEYMAPPINGS } from "../../key_action_mapper";
import { defaultBuildingVariant } from "../../meta_building";
import { layers } from "../../root";
import { THEME } from "../../theme";
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";
/**
* @typedef {import("../../root").Layer} Layer
**/
export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
/**
* @param {HTMLElement} parent
@ -55,9 +59,9 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
this.currentInterpolatedCornerTile = new Vector();
this.lockIndicatorSprites = {};
for (const layerId in enumLayer) {
this.lockIndicatorSprites[layerId] = this.makeLockIndicatorSprite(layerId);
}
layers.forEach(layer => {
this.lockIndicatorSprites[layer] = this.makeLockIndicatorSprite(layer);
});
//
@ -70,7 +74,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
/**
* Makes the lock indicator sprite for the given layer
* @param {enumLayer} layer
* @param {Layer} layer
*/
makeLockIndicatorSprite(layer) {
const dims = 48;

11
src/js/game/hud/parts/building_placer_logic.js
View File

@ -18,11 +18,14 @@ import { BaseHUDPart } from "../base_hud_part";
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";
/** @typedef {import("../../../core/vector").Angle} Angle **/
/**
* @typedef {import("../../root").Layer} Layer
**/
/**
* Contains all logic for the building placer - this doesn't include the rendering
* of info boxes or drawing.
@ -140,12 +143,12 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/**
* Called when the edit mode got changed
* @param {enumLayer} editMode
* @param {Layer} layer
*/
onEditModeChanged(editMode) {
onEditModeChanged(layer) {
const metaBuilding = this.currentMetaBuilding.get();
if (metaBuilding) {
if (metaBuilding.getLayer() !== editMode) {
if (metaBuilding.getLayer() !== layer) {
// This layer doesn't fit the edit mode anymore
this.currentMetaBuilding.set(null);
}

3
src/js/game/hud/parts/buildings_toolbar.js
View File

@ -9,7 +9,6 @@ import { MetaSplitterBuilding } from "../../buildings/splitter";
import { MetaStackerBuilding } from "../../buildings/stacker";
import { MetaTrashBuilding } from "../../buildings/trash";
import { MetaUndergroundBeltBuilding } from "../../buildings/underground_belt";
import { enumLayer } from "../../root";
import { HUDBaseToolbar } from "./base_toolbar";
import { MetaAdvancedProcessorBuilding } from "../../buildings/advanced_processor";
@ -34,7 +33,7 @@ export class HUDBuildingsToolbar extends HUDBaseToolbar {
super(root, {
supportedBuildings,
visibilityCondition: () =>
!this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === enumLayer.regular,
!this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === "regular",
htmlElementId: "ingame_HUD_buildings_toolbar",
});
}

10
src/js/game/hud/parts/color_blind_helper.js
View File

@ -6,8 +6,6 @@ import { DrawParameters } from "../../../core/draw_parameters";
import { THEME } from "../../theme";
import { globalConfig } from "../../../core/config";
import { T } from "../../../translations";
import { enumItemType } from "../../base_item";
import { enumLayer } from "../../root";
/**
* @typedef {import("../../colors").Color} Color
@ -44,7 +42,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
return null;
}
if (this.root.currentLayer !== enumLayer.regular) {
if (this.root.currentLayer !== "regular") {
// Not in regular mode
return null;
}
@ -59,7 +57,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
// Check if the belt has a color item
if (beltComp) {
const item = beltComp.assignedPath.findItemAtTile(tile);
if (item && item.getItemType() === enumItemType.color) {
if (item && item.getItemType() === "color") {
return /** @type {ColorItem} */ (item).color;
}
}
@ -72,7 +70,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
if (slot.layer !== this.root.currentLayer) {
continue;
}
if (slot.item && slot.item.getItemType() === enumItemType.color) {
if (slot.item && slot.item.getItemType() === "color") {
return /** @type {ColorItem} */ (slot.item).color;
}
}
@ -80,7 +78,7 @@ export class HUDColorBlindHelper extends BaseHUDPart {
} else {
// We hovered a lower layer, show the color there
const lowerLayer = this.root.map.getLowerLayerContentXY(tile.x, tile.y);
if (lowerLayer && lowerLayer.getItemType() === enumItemType.color) {
if (lowerLayer && lowerLayer.getItemType() === "color") {
return /** @type {ColorItem} */ (lowerLayer).color;
}
}

9
src/js/game/hud/parts/wires_overlay.js
View File

@ -2,7 +2,6 @@ import { makeOffscreenBuffer } from "../../../core/buffer_utils";
import { globalConfig } from "../../../core/config";
import { DrawParameters } from "../../../core/draw_parameters";
import { KEYMAPPINGS } from "../../key_action_mapper";
import { enumLayer } from "../../root";
import { THEME } from "../../theme";
import { BaseHUDPart } from "../base_hud_part";
import { Loader } from "../../../core/loader";
@ -26,10 +25,10 @@ export class HUDWiresOverlay extends BaseHUDPart {
* Switches between layers
*/
switchLayers() {
if (this.root.currentLayer === enumLayer.regular) {
this.root.currentLayer = enumLayer.wires;
if (this.root.currentLayer === "regular") {
this.root.currentLayer = "wires";
} else {
this.root.currentLayer = enumLayer.regular;
this.root.currentLayer = "regular";
}
this.root.signals.editModeChanged.dispatch(this.root.currentLayer);
}
@ -50,7 +49,7 @@ export class HUDWiresOverlay extends BaseHUDPart {
}
update() {
const desiredAlpha = this.root.currentLayer === enumLayer.wires ? 1.0 : 0.0;
const desiredAlpha = this.root.currentLayer === "wires" ? 1.0 : 0.0;
this.currentAlpha = lerp(this.currentAlpha, desiredAlpha, 0.12);
}

3
src/js/game/hud/parts/wires_toolbar.js
View File

@ -1,5 +1,4 @@
import { MetaWireBaseBuilding } from "../../buildings/wire_base";
import { enumLayer } from "../../root";
import { HUDBaseToolbar } from "./base_toolbar";
import { MetaWireCrossingsBuilding } from "../../buildings/wire_crossings";
@ -10,7 +9,7 @@ export class HUDWiresToolbar extends HUDBaseToolbar {
super(root, {
supportedBuildings,
visibilityCondition: () =>
!this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === enumLayer.wires,
!this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === "wires",
htmlElementId: "ingame_HUD_wires_toolbar",
});
}

7
src/js/game/hud/trailer_maker.js
View File

@ -1,4 +1,3 @@
import { GameRoot, enumLayer } from "../root";
import { globalConfig } from "../../core/config";
import { Vector, mixVector } from "../../core/vector";
import { lerp } from "../../core/utils";
@ -9,6 +8,10 @@ import { gMetaBuildingRegistry } from "../../core/global_registries";
import { MetaBeltBaseBuilding } from "../buildings/belt_base";
import { MinerComponent } from "../components/miner";
/**
* @typedef {import("../root").GameRoot} GameRoot
**/
const tickrate = 1 / 165;
export class TrailerMaker {
@ -92,7 +95,7 @@ export class TrailerMaker {
const speed =
globalConfig.tileSize *
globalConfig.beltSpeedItemsPerSecond *
globalConfig.beltItemSpacingByLayer[enumLayer.regular];
globalConfig.beltItemSpacingByLayer.regular;
// let time =
// this.currentPlaybackOrigin.distance(Vector.fromSerializedObject(nextMarker.pos)) / speed;
const time = nextMarker.time;

5
src/js/game/items/color_item.js
View File

@ -2,7 +2,7 @@ import { globalConfig } from "../../core/config";
import { smoothenDpi } from "../../core/dpi_manager";
import { DrawParameters } from "../../core/draw_parameters";
import { types } from "../../savegame/serialization";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem } from "../base_item";
import { colors, colorHexColorMap } from "../colors";
import { THEME } from "../theme";
@ -28,8 +28,9 @@ export class ColorItem extends BaseItem {
this.color = data;
}
/** @returns {"color"} **/
getItemType() {
return enumItemType.color;
return "color";
}
/**

5
src/js/game/items/negative_energy_item.js
View File

@ -1,7 +1,7 @@
import { DrawParameters } from "../../core/draw_parameters";
import { Loader } from "../../core/loader";
import { types } from "../../savegame/serialization";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem } from "../base_item";
export class NegativeEnergyItem extends BaseItem {
static getId() {
@ -18,8 +18,9 @@ export class NegativeEnergyItem extends BaseItem {
deserialize(data) {}
/** @returns {"negativeEnergy"} **/
getItemType() {
return enumItemType.negativeEnergy;
return "negativeEnergy";
}
/**

5
src/js/game/items/positive_energy_item.js
View File

@ -1,7 +1,7 @@
import { DrawParameters } from "../../core/draw_parameters";
import { Loader } from "../../core/loader";
import { types } from "../../savegame/serialization";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem } from "../base_item";
export class PositiveEnergyItem extends BaseItem {
static getId() {
@ -18,8 +18,9 @@ export class PositiveEnergyItem extends BaseItem {
deserialize(data) {}
/** @returns {"positiveEnergy"} **/
getItemType() {
return enumItemType.positiveEnergy;
return "positiveEnergy";
}
/**

5
src/js/game/items/shape_item.js
View File

@ -1,6 +1,6 @@
import { DrawParameters } from "../../core/draw_parameters";
import { types } from "../../savegame/serialization";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem } from "../base_item";
import { ShapeDefinition } from "../shape_definition";
import { THEME } from "../theme";
@ -21,8 +21,9 @@ export class ShapeItem extends BaseItem {
this.definition = ShapeDefinition.fromShortKey(data);
}
/** @returns {"shape"} **/
getItemType() {
return enumItemType.shape;
return "shape";
}
/**

5
src/js/game/logic.js
View File

@ -3,7 +3,6 @@ import { round2Digits } from "../core/utils";
import { directionVectorMap, Vector } from "../core/vector";
import { Entity } from "./entity";
import { MetaBuilding } from "./meta_building";
import { enumLayer, GameRoot } from "./root";
import { STOP_PROPAGATION } from "../core/signal";
const logger = createLogger("ingame/logic");
@ -13,6 +12,8 @@ const logger = createLogger("ingame/logic");
* @typedef {import("./components/item_acceptor").ItemAcceptorSlot} ItemAcceptorSlot
* @typedef {import("../core/vector").Angle} Angle
* @typedef {import("../core/vector").Direction} Direction
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
*
* @typedef {Array<{
* entity: Entity,
@ -177,7 +178,7 @@ export class GameLogic {
/**
* Returns the acceptors and ejectors which affect the current tile
* @param {Vector} tile
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {AcceptorsAndEjectorsAffectingTile}
*/
getEjectorsAndAcceptorsAtTile(tile, layer) {

14
src/js/game/map.js
View File

@ -1,4 +1,3 @@
import { GameRoot, enumLayer } from "./root";
import { globalConfig } from "../core/config";
import { Vector } from "../core/vector";
import { Entity } from "./entity";
@ -8,6 +7,11 @@ import { MapChunkView } from "./map_chunk_view";
import { randomInt } from "../core/utils";
import { BasicSerializableObject, types } from "../savegame/serialization";
/**
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
*/
const logger = createLogger("map");
export class BaseMap extends BasicSerializableObject {
@ -98,7 +102,7 @@ export class BaseMap extends BasicSerializableObject {
/**
* Returns the tile content of a given tile
* @param {Vector} tile
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {Entity} Entity or null
*/
getTileContent(tile, layer) {
@ -123,7 +127,7 @@ export class BaseMap extends BasicSerializableObject {
* Returns the tile content of a given tile
* @param {number} x
* @param {number} y
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {Entity} Entity or null
*/
getLayerContentXY(x, y, layer) {
@ -148,7 +152,7 @@ export class BaseMap extends BasicSerializableObject {
/**
* Checks if the tile is used
* @param {Vector} tile
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {boolean}
*/
isTileUsed(tile, layer) {
@ -163,7 +167,7 @@ export class BaseMap extends BasicSerializableObject {
* Checks if the tile is used
* @param {number} x
* @param {number} y
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {boolean}
*/
isTileUsedXY(x, y, layer) {

16
src/js/game/map_chunk.js
View File

@ -1,4 +1,3 @@
import { GameRoot, enumLayer } from "./root";
import { globalConfig } from "../core/config";
import { createLogger } from "../core/logging";
import { clamp, fastArrayDeleteValueIfContained, make2DUndefinedArray } from "../core/utils";
@ -10,6 +9,11 @@ import { ShapeItem } from "./items/shape_item";
import { enumSubShape } from "./shape_definition";
import { RandomNumberGenerator } from "../core/rng";
/**
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
*/
const logger = createLogger("map_chunk");
/** @typedef {import("./colors").Color} Color **/
@ -334,7 +338,7 @@ export class MapChunk {
* Returns the contents of this chunk from the given world space coordinates
* @param {number} worldX
* @param {number} worldY
* @param {enumLayer} layer
* @param {Layer} layer
* @returns {Entity=}
*/
getLayerContentFromWorldCoords(worldX, worldY, layer) {
@ -344,7 +348,7 @@ export class MapChunk {
assert(localY >= 0, "Local Y is < 0");
assert(localX < globalConfig.mapChunkSize, "Local X is >= chunk size");
assert(localY < globalConfig.mapChunkSize, "Local Y is >= chunk size");
if (layer === enumLayer.regular) {
if (layer === "regular") {
return this.contents[localX][localY] || null;
} else {
return this.wireContents[localX][localY] || null;
@ -397,7 +401,7 @@ export class MapChunk {
* @param {number} tileX
* @param {number} tileY
* @param {Entity=} contents
* @param {enumLayer} layer
* @param {Layer} layer
*/
setLayerContentFromWorldCords(tileX, tileY, contents, layer) {
const localX = tileX - this.tileX;
@ -408,7 +412,7 @@ export class MapChunk {
assert(localY < globalConfig.mapChunkSize, "Local Y is >= chunk size");
let oldContents;
if (layer === enumLayer.regular) {
if (layer === "regular") {
oldContents = this.contents[localX][localY];
} else {
oldContents = this.wireContents[localX][localY];
@ -421,7 +425,7 @@ export class MapChunk {
fastArrayDeleteValueIfContained(this.containedEntities, oldContents);
}
if (layer === enumLayer.regular) {
if (layer === "regular") {
this.contents[localX][localY] = contents;
} else {
this.wireContents[localX][localY] = contents;

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

@ -4,10 +4,13 @@ import { Vector } from "../core/vector";
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";
/** @typedef {import("../core/vector").Angle} Angle **/
/**
* @typedef {import("../core/vector").Angle} Angle
* @typedef {import("./root").GameRoot} GameRoot
* @typedef {import("./root").Layer} Layer
*/
export const defaultBuildingVariant = "default";
@ -29,10 +32,10 @@ export class MetaBuilding {
/**
* Returns the edit layer of the building
* @returns {enumLayer}
* @returns {Layer}
*/
getLayer() {
return enumLayer.regular;
return "regular";
}
/**
@ -196,10 +199,10 @@ export class MetaBuilding {
* @param {Vector} param0.tile
* @param {Angle} param0.rotation
* @param {string} param0.variant
* @param {string} param0.layer
* @param {Layer} param0.layer
* @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
computeOptimalDirectionAndRotationVariantAtTile({ rotation, variant }) {
if (!this.isRotateable(variant)) {
return {
rotation: 0,

4
src/js/game/production_analytics.js
View File

@ -1,7 +1,7 @@
import { GameRoot } from "./root";
import { ShapeDefinition } from "./shape_definition";
import { globalConfig } from "../core/config";
import { BaseItem, enumItemType } from "./base_item";
import { BaseItem } from "./base_item";
import { ShapeItem } from "./items/shape_item";
import { BasicSerializableObject } from "../savegame/serialization";
@ -53,7 +53,7 @@ export class ProductionAnalytics extends BasicSerializableObject {
* @param {BaseItem} item
*/
onItemProduced(item) {
if (item.getItemType() === enumItemType.shape) {
if (item.getItemType() === "shape") {
const definition = /** @type {ShapeItem} */ (item).definition;
const key = definition.getHash();
const entry = this.history[enumAnalyticsDataSource.produced];

19
src/js/game/root.js
View File

@ -1,10 +1,7 @@
/* eslint-disable no-unused-vars */
import { Signal } from "../core/signal";
import { RandomNumberGenerator } from "../core/rng";
import { createLogger } from "../core/logging";
// Type hints
/* typehints:start */
import { GameTime } from "./time/game_time";
import { EntityManager } from "./entity_manager";
@ -32,14 +29,10 @@ import { Vector } from "../core/vector";
const logger = createLogger("game/root");
/** @enum {string} */
export const enumLayer = {
regular: "regular",
wires: "wires",
};
/** @typedef {"regular" | "wires"} Layer **/
/** @type {Array<enumLayer>} */
export const arrayLayers = [enumLayer.regular, enumLayer.wires];
/** @type {Array<Layer>} */
export const layers = ["regular", "wires"];
/**
* The game root is basically the whole game state at a given point,
@ -134,8 +127,8 @@ export class GameRoot {
/** @type {DynamicTickrate} */
this.dynamicTickrate = null;
/** @type {enumLayer} */
this.currentLayer = enumLayer.regular;
/** @type {Layer} */
this.currentLayer = "regular";
this.signals = {
// Entities
@ -170,7 +163,7 @@ export class GameRoot {
bulkOperationFinished: /** @type {TypedSignal<[]>} */ (new Signal()),
editModeChanged: /** @type {TypedSignal<[enumLayer]>} */ (new Signal()),
editModeChanged: /** @type {TypedSignal<[Layer]>} */ (new Signal()),
// Called to check if an entity can be placed, second parameter is an additional offset.
// Use to introduce additional placement checks

11
src/js/game/systems/belt.js
View File

@ -13,9 +13,8 @@ import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { MapChunkView } from "../map_chunk_view";
import { defaultBuildingVariant } from "../meta_building";
import { enumLayer } from "../root";
import { MetaWireBaseBuilding } from "../buildings/wire_base";
import { enumItemType } from "../base_item";
/** @typedef {import("../root").Layer} Layer **/
export const BELT_ANIM_COUNT = 28;
@ -310,7 +309,7 @@ export class BeltSystem extends GameSystemWithFilter {
/**
* Draws all belt paths
* @param {DrawParameters} parameters
* @param {enumLayer} layer
* @param {Layer} layer
*/
drawLayerBeltItems(parameters, layer) {
for (let i = 0; i < this.beltPaths.length; ++i) {
@ -510,13 +509,13 @@ export class BeltSystem extends GameSystemWithFilter {
}
// Limit speed to avoid belts going backwards
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(enumLayer.regular), 10);
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed("regular"), 10);
// SYNC with systems/item_acceptor.js:drawEntityUnderlays!
// 126 / 42 is the exact animation speed of the png animation
const animationIndex = Math.floor(
((this.root.time.realtimeNow() * speedMultiplier * BELT_ANIM_COUNT * 126) / 42) *
globalConfig.beltItemSpacingByLayer[enumLayer.regular]
globalConfig.beltItemSpacingByLayer.regular
);
const contents = chunk.contents;
for (let y = 0; y < globalConfig.mapChunkSize; ++y) {

9
src/js/game/systems/energy_consumer.js
View File

@ -1,13 +1,14 @@
import { DrawParameters } from "../../core/draw_parameters";
import { Loader } from "../../core/loader";
import { clamp } from "../../core/utils";
import { enumItemType } from "../base_item";
import { EnergyConsumerComponent } from "../components/energy_consumer";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { NEGATIVE_ENERGY_ITEM_SINGLETON } from "../items/negative_energy_item";
import { POSITIVE_ENERGY_ITEM_SINGLETON } from "../items/positive_energy_item";
/** @typedef {import("../base_item").ItemType} ItemType **/
export class EnergyConsumerSystem extends GameSystemWithFilter {
constructor(root) {
super(root, [EnergyConsumerComponent]);
@ -42,13 +43,13 @@ export class EnergyConsumerSystem extends GameSystemWithFilter {
/**
*
* @param {enumItemType} itemType
* @param {ItemType} itemType
*/
getItemSingletonByType(itemType) {
switch (itemType) {
case enumItemType.positiveEnergy:
case "positiveEnergy":
return POSITIVE_ENERGY_ITEM_SINGLETON;
case enumItemType.negativeEnergy:
case "negativeEnergy":
return NEGATIVE_ENERGY_ITEM_SINGLETON;
default:
assertAlways(false, "Bad item type: " + itemType);

13
src/js/game/systems/item_acceptor.js
View File

@ -8,7 +8,10 @@ import { Loader } from "../../core/loader";
import { drawRotatedSprite } from "../../core/draw_utils";
import { BELT_ANIM_COUNT } from "./belt";
import { fastArrayDelete } from "../../core/utils";
import { enumLayer } from "../root";
/**
* @typedef {import("../root").Layer} Layer
**/
export class ItemAcceptorSystem extends GameSystemWithFilter {
constructor(root) {
@ -53,7 +56,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
/**
* Draws the acceptor items
* @param {DrawParameters} parameters
* @param {enumLayer} layer
* @param {Layer} layer
*/
drawLayer(parameters, layer) {
this.forEachMatchingEntityOnScreen(parameters, this.drawEntityRegularLayer.bind(this, layer));
@ -62,14 +65,14 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
/**
* Draws the acceptor underlays
* @param {DrawParameters} parameters
* @param {enumLayer} layer
* @param {Layer} layer
*/
drawUnderlays(parameters, layer) {
this.forEachMatchingEntityOnScreen(parameters, this.drawEntityUnderlays.bind(this, layer));
}
/**
* @param {enumLayer} layer
* @param {Layer} layer
* @param {DrawParameters} parameters
* @param {Entity} entity
*/
@ -107,7 +110,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
}
/**
* @param {enumLayer} layer
* @param {Layer} layer
* @param {DrawParameters} parameters
* @param {Entity} entity
*/

11
src/js/game/systems/item_ejector.js
View File

@ -3,11 +3,12 @@ import { DrawParameters } from "../../core/draw_parameters";
import { createLogger } from "../../core/logging";
import { Rectangle } from "../../core/rectangle";
import { directionRotationMap, directionVectorMap } from "../../core/vector";
import { BaseItem, enumItemType, enumItemTypeToLayer } from "../base_item";
import { BaseItem, itemTypeLayerMap } from "../base_item";
import { ItemEjectorComponent } from "../components/item_ejector";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { enumLayer } from "../root";
/** @typedef {import("../root").Layer} Layer **/
const logger = createLogger("systems/ejector");
@ -257,7 +258,7 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
// TODO: Kinda hacky. How to solve this properly? Don't want to go through inheritance hell.
// Also its just a few cases (hope it stays like this .. :x).
const itemLayer = enumItemTypeToLayer[item.getItemType()];
const itemLayer = itemTypeLayerMap[item.getItemType()];
const beltComp = receiver.components.Belt;
if (beltComp) {
@ -338,14 +339,14 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
/**
* Draws the given layer
* @param {DrawParameters} parameters
* @param {enumLayer} layer
* @param {Layer} layer
*/
drawLayer(parameters, layer) {
this.forEachMatchingEntityOnScreen(parameters, this.drawSingleEntity.bind(this, layer));
}
/**
* @param {enumLayer} layer
* @param {Layer} layer
* @param {DrawParameters} parameters
* @param {Entity} entity
*/

6
src/js/game/systems/item_processor.js
View File

@ -1,5 +1,5 @@
import { globalConfig } from "../../core/config";
import { BaseItem, enumItemType } from "../base_item";
import { BaseItem } from "../base_item";
import { colorInvertedMap, colorMixingMap } from "../colors";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
@ -355,14 +355,14 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
case enumItemProcessorTypes.advancedProcessor: {
const item = items[0].item;
if (item.getItemType() === enumItemType.color) {
if (item.getItemType() === "color") {
const colorItem = /** @type {ColorItem} */ (items[0].item);
const newColor = colorInvertedMap[colorItem.color];
outItems.push({
item: new ColorItem(newColor),
requiredSlot: 0,
});
} else if (item.getItemType() === enumItemType.shape) {
} else if (item.getItemType() === "shape") {
const shapeItem = /** @type {ShapeItem} */ (items[0].item);
const newItem = this.root.shapeDefinitionMgr.shapeActionInvertColors(
shapeItem.definition

3
src/js/game/systems/miner.js
View File

@ -6,7 +6,6 @@ import { MinerComponent } from "../components/miner";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { MapChunkView } from "../map_chunk_view";
import { enumLayer } from "../root";
export class MinerSystem extends GameSystemWithFilter {
constructor(root) {
@ -75,7 +74,7 @@ export class MinerSystem extends GameSystemWithFilter {
const ejectingDirection = staticComp.localDirectionToWorld(ejectingSlot.direction);
const targetTile = ejectingPos.add(directionVectorMap[ejectingDirection]);
const targetContents = this.root.map.getTileContent(targetTile, enumLayer.regular);
const targetContents = this.root.map.getTileContent(targetTile, "regular");
// Check if we are connected to another miner and thus do not eject directly
if (targetContents) {

1
src/js/game/systems/static_map_entity.js
View File

@ -3,7 +3,6 @@ import { DrawParameters } from "../../core/draw_parameters";
import { globalConfig } from "../../core/config";
import { MapChunkView } from "../map_chunk_view";
import { Loader } from "../../core/loader";
import { enumLayer } from "../root";
export class StaticMapEntitySystem extends GameSystem {
constructor(root) {

3
src/js/game/systems/storage.js
View File

@ -4,7 +4,6 @@ import { Entity } from "../entity";
import { DrawParameters } from "../../core/draw_parameters";
import { formatBigNumber, lerp } from "../../core/utils";
import { Loader } from "../../core/loader";
import { enumLayer } from "../root";
export class StorageSystem extends GameSystemWithFilter {
constructor(root) {
@ -23,7 +22,7 @@ export class StorageSystem extends GameSystemWithFilter {
const ejectorComp = entity.components.ItemEjector;
/* FIXME: WIRES */
const nextSlot = ejectorComp.getFirstFreeSlot(enumLayer.regular);
const nextSlot = ejectorComp.getFirstFreeSlot("regular");
if (nextSlot !== null) {
if (ejectorComp.tryEject(nextSlot, storageComp.storedItem)) {
storageComp.storedCount--;

3
src/js/game/systems/underground_belt.js
View File

@ -12,7 +12,6 @@ import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { fastArrayDelete } from "../../core/utils";
import { enumLayer } from "../root";
const logger = createLogger("tunnels");
@ -297,7 +296,7 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
) {
currentTile = currentTile.add(searchVector);
const potentialReceiver = this.root.map.getTileContent(currentTile, enumLayer.regular);
const potentialReceiver = this.root.map.getTileContent(currentTile, "regular");
if (!potentialReceiver) {
// Empty tile
continue;

7
src/js/game/systems/wired_pins.js
View File

@ -5,7 +5,6 @@ import { Vector } from "../../core/vector";
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { enumLayer } from "../root";
import { STOP_PROPAGATION } from "../../core/signal";
import { drawRotatedSprite } from "../../core/draw_utils";
@ -43,7 +42,7 @@ export class WiredPinsSystem extends GameSystemWithFilter {
// If this entity is placed on the wires layer, make sure we don't
// place it above a pin
if (entity.layer === enumLayer.wires) {
if (entity.layer === "wires") {
for (let x = rect.x; x < rect.x + rect.w; ++x) {
for (let y = rect.y; y < rect.y + rect.h; ++y) {
// Find which entities are in same tiles of both layers
@ -108,7 +107,7 @@ export class WiredPinsSystem extends GameSystemWithFilter {
}
// Check if there is any entity on that tile (Wired pins are always on the wires layer)
const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, enumLayer.wires);
const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, "wires");
// If there's an entity, and it can't get removed -> That's a collision
if (collidingEntity && !collidingEntity.components.ReplaceableMapEntity) {
@ -133,7 +132,7 @@ export class WiredPinsSystem extends GameSystemWithFilter {
for (let i = 0; i < pinsComp.slots.length; ++i) {
const slot = pinsComp.slots[i];
const worldPos = entity.components.StaticMapEntity.localTileToWorld(slot.pos);
const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, enumLayer.wires);
const collidingEntity = this.root.map.getLayerContentXY(worldPos.x, worldPos.y, "wires");
if (collidingEntity) {
assertAlways(
collidingEntity.components.ReplaceableMapEntity,

4
src/js/savegame/serializer_internal.js
View File

@ -1,6 +1,6 @@
import { gComponentRegistry } from "../core/global_registries";
import { Entity } from "../game/entity";
import { enumLayer, GameRoot } from "../game/root";
import { GameRoot, layers } from "../game/root";
// Internal serializer methods
export class SerializerInternal {
@ -41,7 +41,7 @@ export class SerializerInternal {
this.deserializeComponents(entity, payload.components);
entity.layer = payload.layer;
if (!enumLayer[payload.layer]) {
if (!layers.includes(payload.layer)) {
assert(false, "Invalid layer: " + payload.layer);
}