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

Replace enumDirection with string literal Direction

Browse Source
This commit is contained in:
Bjorn Stromberg 2020-08-03 18:01:16 +09:00
parent 235c380de1
commit 202f82629b
37 changed files with 456 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/js/core/draw_utils.js
View File

@ -9,6 +9,8 @@ import { createLogger } from "./logging";
const logger = createLogger("draw_utils"); const logger = createLogger("draw_utils");
/** @typedef {import("./vector").Angle} Angle **/
export function initDrawUtils() { export function initDrawUtils() {
CanvasRenderingContext2D.prototype.beginRoundedRect = function (x, y, w, h, r) { CanvasRenderingContext2D.prototype.beginRoundedRect = function (x, y, w, h, r) {
if (r < 0.05) { if (r < 0.05) {
@ -284,7 +286,7 @@ export function wrapText(context, text, x, y, maxWidth, lineHeight, stroke = fal
* @param {number} w * @param {number} w
* @param {number} h * @param {number} h
* @param {number} leftHeight * @param {number} leftHeight
* @param {number} angle * @param {Angle} angle
*/ */
export function rotateTrapezRightFaced(x, y, w, h, leftHeight, angle) { export function rotateTrapezRightFaced(x, y, w, h, leftHeight, angle) {
const halfY = y + h / 2; const halfY = y + h / 2;

4
src/js/core/rectangle.js
View File

@ -2,6 +2,8 @@ import { globalConfig } from "./config";
import { clamp, epsilonCompare, round2Digits } from "./utils"; import { clamp, epsilonCompare, round2Digits } from "./utils";
import { Vector } from "./vector"; import { Vector } from "./vector";
/** @typedef {import("./vector").Angle} Angle **/
export class Rectangle { export class Rectangle {
constructor(x = 0, y = 0, w = 0, h = 0) { constructor(x = 0, y = 0, w = 0, h = 0) {
this.x = x; this.x = x;
@ -56,7 +58,7 @@ export class Rectangle {
/** /**
* Returns a rectangle arround a rotated point * Returns a rectangle arround a rotated point
* @param {Array<Vector>} points * @param {Array<Vector>} points
* @param {number} angle * @param {Angle} angle
* @returns {Rectangle} * @returns {Rectangle}
*/ */
static getAroundPointsRotated(points, angle) { static getAroundPointsRotated(points, angle) {

229
src/js/core/vector.js
View File

@ -4,44 +4,117 @@ const tileSize = globalConfig.tileSize;
const halfTileSize = globalConfig.halfTileSize; const halfTileSize = globalConfig.halfTileSize;
/** /**
* @enum {string} * @typedef {"top" | "right" | "bottom" | "left"} Direction
* @typedef {0 | 90 | 180 | 270 | 360} Angle
*/ */
export const enumDirection = {
top: "top", /** @type {Angle[]} **/
right: "right", export const angles = [0, 90, 180, 270, 360];
bottom: "bottom",
left: "left", /** @type {Direction[]} **/
export const directions = ["top", "right", "bottom", "left"];
/** @type {Record<Direction, Direction>} **/
export const invertedDirectionMap = {
top: "bottom",
right: "left",
bottom: "top",
left: "right",
};
/** @type {Record<Direction, Exclude<Angle, 360>>} **/
export const directionAngleMap = {
top: 0,
right: 90,
bottom: 180,
left: 270,
};
/** @type {Record<Angle, Direction>} **/
export const angleDirectionMap = {
0: "top",
90: "right",
180: "bottom",
270: "left",
360: "top",
};
/** @type {Record<Angle, Exclude<Angle, 360>>} **/
export const inverseAngleMap = {
0: 0,
90: 270,
180: 180,
270: 90,
360: 0,
};
/** @type {Record<Angle, Exclude<Angle, 360>>} **/
export const clockwiseAngleMap = {
0: 90,
90: 180,
180: 270,
270: 0,
360: 90,
};
/** @type {Record<Angle, Exclude<Angle, 360>>} **/
export const counterClockwiseAngleMap = {
0: 270,
90: 0,
180: 90,
270: 180,
360: 270,
};
/** @type {Record<Direction, Record<Angle, Direction>>} **/
export const directionRotationMap = {
top: {
0: "top",
90: "right",
180: "bottom",
270: "left",
360: "top",
},
right: {
0: "right",
90: "bottom",
180: "left",
270: "top",
360: "right",
},
bottom: {
0: "bottom",
90: "left",
180: "top",
270: "right",
360: "bottom",
},
left: {
0: "left",
90: "top",
180: "right",
270: "bottom",
360: "left",
},
}; };
/** /**
* @enum {string} * @param {number} n
* @return {n is Angle}
*/ */
export const enumInvertedDirections = { function isAngle(n) {
[enumDirection.top]: enumDirection.bottom, return angles.includes(/** @type {Angle} **/ (n));
[enumDirection.right]: enumDirection.left, }
[enumDirection.bottom]: enumDirection.top,
[enumDirection.left]: enumDirection.right,
};
/** /**
* @enum {number} * @param {number} radians
* @return {Angle}
*/ */
export const enumDirectionToAngle = { export function snapToAngle(radians) {
[enumDirection.top]: 0, const angle = (Math.round(Math.degrees(radians) / 90) * 90 + 360) % 360;
[enumDirection.right]: 90, if (!isAngle(angle)) throw new Error("invalid Angle");
[enumDirection.bottom]: 180, return angle;
[enumDirection.left]: 270, }
};
/**
* @enum {enumDirection}
*/
export const enumAngleToDirection = {
0: enumDirection.top,
90: enumDirection.right,
180: enumDirection.bottom,
270: enumDirection.left,
};
export class Vector { export class Vector {
/** /**
@ -420,7 +493,7 @@ export class Vector {
/** /**
* Rotates this vector * Rotates this vector
* @param {number} angle * @param {Angle} angle
* @returns {Vector} new vector * @returns {Vector} new vector
*/ */
rotated(angle) { rotated(angle) {
@ -431,13 +504,10 @@ export class Vector {
/** /**
* Rotates this vector * Rotates this vector
* @param {number} angle * @param {Angle} angle
* @returns {Vector} this vector * @returns {Vector} this vector
*/ */
rotateInplaceFastMultipleOf90(angle) { rotateInplaceFastMultipleOf90(angle) {
// const sin = Math.sin(angle);
// const cos = Math.cos(angle);
// let sin = 0, cos = 1;
assert(angle >= 0 && angle <= 360, "Invalid angle, please clamp first: " + angle); assert(angle >= 0 && angle <= 360, "Invalid angle, please clamp first: " + angle);
switch (angle) { switch (angle) {
@ -446,24 +516,17 @@ export class Vector {
return this; return this;
} }
case 90: { case 90: {
// sin = 1;
// cos = 0;
const x = this.x; const x = this.x;
this.x = -this.y; this.x = -this.y;
this.y = x; this.y = x;
return this; return this;
} }
case 180: { case 180: {
// sin = 0
// cos = -1
this.x = -this.x; this.x = -this.x;
this.y = -this.y; this.y = -this.y;
return this; return this;
} }
case 270: { case 270: {
// sin = -1
// cos = 0
const x = this.x; const x = this.x;
this.x = this.y; this.x = this.y;
this.y = -x; this.y = -x;
@ -474,12 +537,11 @@ export class Vector {
return this; return this;
} }
} }
// return new Vector(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
} }
/** /**
* Rotates this vector * Rotates this vector
* @param {number} angle * @param {Angle} angle
* @returns {Vector} new vector * @returns {Vector} new vector
*/ */
rotateFastMultipleOf90(angle) { rotateFastMultipleOf90(angle) {
@ -506,79 +568,6 @@ export class Vector {
} }
} }
/**
* Helper method to rotate a direction
* @param {enumDirection} direction
* @param {number} angle
* @returns {enumDirection}
*/
static transformDirectionFromMultipleOf90(direction, angle) {
if (angle === 0 || angle === 360) {
return direction;
}
assert(angle >= 0 && angle <= 360, "Invalid angle: " + angle);
switch (direction) {
case enumDirection.top: {
switch (angle) {
case 90:
return enumDirection.right;
case 180:
return enumDirection.bottom;
case 270:
return enumDirection.left;
default:
assertAlways(false, "Invalid angle: " + angle);
return;
}
}
case enumDirection.right: {
switch (angle) {
case 90:
return enumDirection.bottom;
case 180:
return enumDirection.left;
case 270:
return enumDirection.top;
default:
assertAlways(false, "Invalid angle: " + angle);
return;
}
}
case enumDirection.bottom: {
switch (angle) {
case 90:
return enumDirection.left;
case 180:
return enumDirection.top;
case 270:
return enumDirection.right;
default:
assertAlways(false, "Invalid angle: " + angle);
return;
}
}
case enumDirection.left: {
switch (angle) {
case 90:
return enumDirection.top;
case 180:
return enumDirection.right;
case 270:
return enumDirection.bottom;
default:
assertAlways(false, "Invalid angle: " + angle);
return;
}
}
default:
assertAlways(false, "Invalid angle: " + angle);
return;
}
}
/** /**
* Compares both vectors for epsilon equality * Compares both vectors for epsilon equality
* @param {Vector} v * @param {Vector} v
@ -589,7 +578,7 @@ export class Vector {
} }
/** /**
* Returns the angle * Returns the angle in radians
* @returns {number} 0 .. 2 PI * @returns {number} 0 .. 2 PI
*/ */
angle() { angle() {
@ -662,9 +651,9 @@ export function mixVector(v1, v2, a) {
/** /**
* Mapping from string direction to actual vector * Mapping from string direction to actual vector
* @enum {Vector} * @type {Record<Direction, Vector>}
*/ */
export const enumDirectionToVector = { export const directionVectorMap = {
top: new Vector(0, -1), top: new Vector(0, -1),
right: new Vector(1, 0), right: new Vector(1, 0),
bottom: new Vector(0, 1), bottom: new Vector(0, 1),

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

@ -1,7 +1,7 @@
import { DrawParameters } from "../core/draw_parameters"; import { DrawParameters } from "../core/draw_parameters";
import { Loader } from "../core/loader"; import { Loader } from "../core/loader";
import { createLogger } from "../core/logging"; import { createLogger } from "../core/logging";
import { Vector } from "../core/vector"; import { clockwiseAngleMap, counterClockwiseAngleMap, Vector } from "../core/vector";
import { Entity } from "./entity"; import { Entity } from "./entity";
import { GameRoot, enumLayer } from "./root"; import { GameRoot, enumLayer } from "./root";
import { findNiceIntegerValue } from "../core/utils"; import { findNiceIntegerValue } from "../core/utils";
@ -111,19 +111,23 @@ export class Blueprint {
const entity = this.entities[i]; const entity = this.entities[i];
const staticComp = entity.components.StaticMapEntity; const staticComp = entity.components.StaticMapEntity;
staticComp.rotation = (staticComp.rotation + 90) % 360; staticComp.rotation = clockwiseAngleMap[staticComp.rotation];
staticComp.originalRotation = (staticComp.originalRotation + 90) % 360; staticComp.originalRotation = clockwiseAngleMap[staticComp.originalRotation];
staticComp.origin = staticComp.origin.rotateFastMultipleOf90(90); staticComp.origin = staticComp.origin.rotateFastMultipleOf90(90);
} }
} }
/** /**
* Rotates the blueprint counter clock wise * Rotates the blueprint counter-clockwise
*/ */
rotateCcw() { rotateCcw() {
// Well ... for (let i = 0; i < this.entities.length; ++i) {
for (let i = 0; i < 3; ++i) { const entity = this.entities[i];
this.rotateCw(); const staticComp = entity.components.StaticMapEntity;
staticComp.rotation = counterClockwiseAngleMap[staticComp.rotation];
staticComp.originalRotation = counterClockwiseAngleMap[staticComp.originalRotation];
staticComp.origin = staticComp.origin.rotateFastMultipleOf90(270);
} }
} }

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

@ -1,5 +1,5 @@
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { T } from "../../translations"; import { T } from "../../translations";
import { enumItemType } from "../base_item"; import { enumItemType } from "../base_item";
import { EnergyConsumerComponent } from "../components/energy_consumer"; import { EnergyConsumerComponent } from "../components/energy_consumer";
@ -57,8 +57,8 @@ export class MetaAdvancedProcessorBuilding extends MetaBuilding {
entity.addComponent( entity.addComponent(
new ItemEjectorComponent({ new ItemEjectorComponent({
slots: [ slots: [
{ pos: new Vector(1, 0), direction: enumDirection.right }, { pos: new Vector(1, 0), direction: "right" },
{ pos: new Vector(1, 0), direction: enumDirection.top, layer: enumLayer.wires }, { pos: new Vector(1, 0), direction: "top", layer: enumLayer.wires },
], ],
}) })
); );
@ -77,12 +77,12 @@ export class MetaAdvancedProcessorBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
direction: enumDirection.top, direction: "top",
type: enumPinSlotType.positiveEnergyAcceptor, type: enumPinSlotType.positiveEnergyAcceptor,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
direction: enumDirection.top, direction: "top",
type: enumPinSlotType.negativeEnergyEjector, type: enumPinSlotType.negativeEnergyEjector,
}, },
], ],
@ -93,11 +93,11 @@ export class MetaAdvancedProcessorBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 1), pos: new Vector(0, 1),
directions: [enumDirection.left], directions: ["left"],
}, },
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.top], directions: ["top"],
filter: enumItemType.positiveEnergy, filter: enumItemType.positiveEnergy,
layer: enumLayer.wires, layer: enumLayer.wires,
}, },

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

@ -1,5 +1,4 @@
import { Loader } from "../../core/loader"; import { Loader } from "../../core/loader";
import { enumDirection } from "../../core/vector";
import { SOUNDS } from "../../platform/sound"; import { SOUNDS } from "../../platform/sound";
import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "./belt_base"; import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "./belt_base";
@ -18,13 +17,13 @@ export class MetaBeltBuilding extends MetaBeltBaseBuilding {
getPreviewSprite(rotationVariant) { getPreviewSprite(rotationVariant) {
switch (arrayBeltVariantToRotation[rotationVariant]) { switch (arrayBeltVariantToRotation[rotationVariant]) {
case enumDirection.top: { case "top": {
return Loader.getSprite("sprites/buildings/belt_top.png"); return Loader.getSprite("sprites/buildings/belt_top.png");
} }
case enumDirection.left: { case "left": {
return Loader.getSprite("sprites/buildings/belt_left.png"); return Loader.getSprite("sprites/buildings/belt_left.png");
} }
case enumDirection.right: { case "right": {
return Loader.getSprite("sprites/buildings/belt_right.png"); return Loader.getSprite("sprites/buildings/belt_right.png");
} }
default: { default: {
@ -35,13 +34,13 @@ export class MetaBeltBuilding extends MetaBeltBaseBuilding {
getBlueprintSprite(rotationVariant) { getBlueprintSprite(rotationVariant) {
switch (arrayBeltVariantToRotation[rotationVariant]) { switch (arrayBeltVariantToRotation[rotationVariant]) {
case enumDirection.top: { case "top": {
return Loader.getSprite("sprites/blueprints/belt_top.png"); return Loader.getSprite("sprites/blueprints/belt_top.png");
} }
case enumDirection.left: { case "left": {
return Loader.getSprite("sprites/blueprints/belt_left.png"); return Loader.getSprite("sprites/blueprints/belt_left.png");
} }
case enumDirection.right: { case "right": {
return Loader.getSprite("sprites/blueprints/belt_right.png"); return Loader.getSprite("sprites/blueprints/belt_right.png");
} }
default: { default: {

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

@ -1,5 +1,11 @@
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { enumAngleToDirection, enumDirection, Vector } from "../../core/vector"; import {
angleDirectionMap,
clockwiseAngleMap,
counterClockwiseAngleMap,
inverseAngleMap,
Vector,
} from "../../core/vector";
import { SOUNDS } from "../../platform/sound"; import { SOUNDS } from "../../platform/sound";
import { T } from "../../translations"; import { T } from "../../translations";
import { BeltComponent } from "../components/belt"; import { BeltComponent } from "../components/belt";
@ -10,7 +16,13 @@ import { Entity } from "../entity";
import { MetaBuilding } from "../meta_building"; import { MetaBuilding } from "../meta_building";
import { GameRoot, enumLayer } from "../root"; import { GameRoot, enumLayer } from "../root";
export const arrayBeltVariantToRotation = [enumDirection.top, enumDirection.left, enumDirection.right]; /**
* @typedef {import("../../core/vector").Angle} Angle
* @typedef {import("../../core/vector").Direction} Direction
*/
/** @type {Direction[]} **/
export const arrayBeltVariantToRotation = ["top", "left", "right"];
export class MetaBeltBaseBuilding extends MetaBuilding { export class MetaBeltBaseBuilding extends MetaBuilding {
getHasDirectionLockAvailable() { getHasDirectionLockAvailable() {
@ -50,7 +62,7 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
setupEntityComponents(entity) { setupEntityComponents(entity) {
entity.addComponent( entity.addComponent(
new BeltComponent({ new BeltComponent({
direction: enumDirection.top, // updated later direction: "top", // updated later
}) })
); );
// Make this entity replaceabel // Make this entity replaceabel
@ -61,7 +73,7 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
layer: this.getLayer(), layer: this.getLayer(),
}, },
], ],
@ -74,7 +86,7 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
direction: enumDirection.top, // updated later direction: "top", // updated later
layer: this.getLayer(), layer: this.getLayer(),
}, },
], ],
@ -98,16 +110,16 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
* @param {object} param0 * @param {object} param0
* @param {GameRoot} param0.root * @param {GameRoot} param0.root
* @param {Vector} param0.tile * @param {Vector} param0.tile
* @param {number} param0.rotation * @param {Angle} param0.rotation
* @param {string} param0.variant * @param {string} param0.variant
* @param {string} param0.layer * @param {string} param0.layer
* @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array<Entity> }} * @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/ */
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) { computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
const topDirection = enumAngleToDirection[rotation]; const topDirection = angleDirectionMap[rotation];
const rightDirection = enumAngleToDirection[(rotation + 90) % 360]; const rightDirection = angleDirectionMap[clockwiseAngleMap[rotation]];
const bottomDirection = enumAngleToDirection[(rotation + 180) % 360]; const bottomDirection = angleDirectionMap[inverseAngleMap[rotation]];
const leftDirection = enumAngleToDirection[(rotation + 270) % 360]; const leftDirection = angleDirectionMap[counterClockwiseAngleMap[rotation]];
const { ejectors, acceptors } = root.logic.getEjectorsAndAcceptorsAtTile(tile, layer); const { ejectors, acceptors } = root.logic.getEjectorsAndAcceptorsAtTile(tile, layer);
@ -152,7 +164,7 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
if (hasRightEjector && !hasLeftEjector) { if (hasRightEjector && !hasLeftEjector) {
return { return {
rotation: (rotation + 270) % 360, rotation: counterClockwiseAngleMap[rotation],
rotationVariant: 2, rotationVariant: 2,
}; };
} }
@ -161,7 +173,7 @@ export class MetaBeltBaseBuilding extends MetaBuilding {
// do a curve from the right to the top // do a curve from the right to the top
if (hasLeftEjector && !hasRightEjector) { if (hasLeftEjector && !hasRightEjector) {
return { return {
rotation: (rotation + 90) % 360, rotation: clockwiseAngleMap[rotation],
rotationVariant: 1, rotationVariant: 1,
}; };
} }

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

@ -1,5 +1,5 @@
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { T } from "../../translations"; import { T } from "../../translations";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
@ -81,7 +81,7 @@ export class MetaCutterBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
], ],
@ -99,18 +99,18 @@ export class MetaCutterBuilding extends MetaBuilding {
switch (variant) { switch (variant) {
case defaultBuildingVariant: { case defaultBuildingVariant: {
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.top }, { pos: new Vector(0, 0), direction: "top" },
{ pos: new Vector(1, 0), direction: enumDirection.top }, { pos: new Vector(1, 0), direction: "top" },
]); ]);
entity.components.ItemProcessor.type = enumItemProcessorTypes.cutter; entity.components.ItemProcessor.type = enumItemProcessorTypes.cutter;
break; break;
} }
case enumCutterVariants.quad: { case enumCutterVariants.quad: {
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.top }, { pos: new Vector(0, 0), direction: "top" },
{ pos: new Vector(1, 0), direction: enumDirection.top }, { pos: new Vector(1, 0), direction: "top" },
{ pos: new Vector(2, 0), direction: enumDirection.top }, { pos: new Vector(2, 0), direction: "top" },
{ pos: new Vector(3, 0), direction: enumDirection.top }, { pos: new Vector(3, 0), direction: "top" },
]); ]);
entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad; entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad;
break; break;

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

@ -1,4 +1,4 @@
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { enumItemType } from "../base_item"; import { enumItemType } from "../base_item";
import { EnergyGeneratorComponent } from "../components/energy_generator"; import { EnergyGeneratorComponent } from "../components/energy_generator";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
@ -50,17 +50,17 @@ export class MetaEnergyGenerator extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 1), pos: new Vector(0, 1),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(1, 1), pos: new Vector(1, 1),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [enumDirection.top], directions: ["top"],
layer: enumLayer.wires, layer: enumLayer.wires,
filter: enumItemType.negativeEnergy, filter: enumItemType.negativeEnergy,
}, },
@ -73,7 +73,7 @@ export class MetaEnergyGenerator extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
direction: enumDirection.top, direction: "top",
layer: enumLayer.wires, layer: enumLayer.wires,
}, },
], ],
@ -95,12 +95,12 @@ export class MetaEnergyGenerator extends MetaBuilding {
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
type: enumPinSlotType.positiveEnergyEjector, type: enumPinSlotType.positiveEnergyEjector,
direction: enumDirection.top, direction: "top",
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
type: enumPinSlotType.negativeEnergyAcceptor, type: enumPinSlotType.negativeEnergyAcceptor,
direction: enumDirection.top, direction: "top",
}, },
], ],
}) })

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

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

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

@ -1,4 +1,4 @@
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
import { MinerComponent } from "../components/miner"; import { MinerComponent } from "../components/miner";
import { Entity } from "../entity"; import { Entity } from "../entity";
@ -49,7 +49,7 @@ export class MetaMinerBuilding extends MetaBuilding {
entity.addComponent(new MinerComponent({})); entity.addComponent(new MinerComponent({}));
entity.addComponent( entity.addComponent(
new ItemEjectorComponent({ new ItemEjectorComponent({
slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }], slots: [{ pos: new Vector(0, 0), direction: "top" }],
}) })
); );
} }

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

@ -1,5 +1,5 @@
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { T } from "../../translations"; import { T } from "../../translations";
import { enumItemType } from "../base_item"; import { enumItemType } from "../base_item";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
@ -54,7 +54,7 @@ export class MetaMixerBuilding extends MetaBuilding {
entity.addComponent( entity.addComponent(
new ItemEjectorComponent({ new ItemEjectorComponent({
slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }], slots: [{ pos: new Vector(0, 0), direction: "top" }],
}) })
); );
entity.addComponent( entity.addComponent(
@ -62,12 +62,12 @@ export class MetaMixerBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
], ],

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

@ -1,5 +1,5 @@
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { T } from "../../translations"; import { T } from "../../translations";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
@ -89,7 +89,7 @@ export class MetaPainterBuilding extends MetaBuilding {
entity.addComponent( entity.addComponent(
new ItemEjectorComponent({ new ItemEjectorComponent({
slots: [{ pos: new Vector(1, 0), direction: enumDirection.right }], slots: [{ pos: new Vector(1, 0), direction: "right" }],
}) })
); );
entity.addComponent( entity.addComponent(
@ -97,12 +97,12 @@ export class MetaPainterBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.left], directions: ["left"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [enumDirection.top], directions: ["top"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
], ],
@ -123,87 +123,77 @@ export class MetaPainterBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.left], directions: ["left"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [ directions: [variant === defaultBuildingVariant ? "top" : "bottom"],
variant === defaultBuildingVariant ? enumDirection.top : enumDirection.bottom,
],
filter: enumItemType.color, filter: enumItemType.color,
}, },
]); ]);
entity.components.ItemProcessor.type = enumItemProcessorTypes.painter; entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
entity.components.ItemProcessor.inputsPerCharge = 2; entity.components.ItemProcessor.inputsPerCharge = 2;
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: "right" }]);
{ pos: new Vector(1, 0), direction: enumDirection.right },
]);
break; break;
} }
case enumPainterVariants.double: { case enumPainterVariants.double: {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.left], directions: ["left"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(0, 1), pos: new Vector(0, 1),
directions: [enumDirection.left], directions: ["left"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [enumDirection.top], directions: ["top"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
]); ]);
entity.components.ItemProcessor.type = enumItemProcessorTypes.painterDouble; entity.components.ItemProcessor.type = enumItemProcessorTypes.painterDouble;
entity.components.ItemProcessor.inputsPerCharge = 3; entity.components.ItemProcessor.inputsPerCharge = 3;
entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: "right" }]);
entity.components.ItemEjector.setSlots([
{ pos: new Vector(1, 0), direction: enumDirection.right },
]);
break; break;
} }
case enumPainterVariants.quad: { case enumPainterVariants.quad: {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.left], directions: ["left"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
{ {
pos: new Vector(2, 0), pos: new Vector(2, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
{ {
pos: new Vector(3, 0), pos: new Vector(3, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.color, filter: enumItemType.color,
}, },
]); ]);
entity.components.ItemProcessor.type = enumItemProcessorTypes.painterQuad; entity.components.ItemProcessor.type = enumItemProcessorTypes.painterQuad;
entity.components.ItemProcessor.inputsPerCharge = 5; entity.components.ItemProcessor.inputsPerCharge = 5;
entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: "top" }]);
entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.top },
]);
break; break;
} }
default: default:

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

@ -1,5 +1,5 @@
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { T } from "../../translations"; import { T } from "../../translations";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
@ -80,7 +80,7 @@ export class MetaRotaterBuilding extends MetaBuilding {
entity.addComponent( entity.addComponent(
new ItemEjectorComponent({ new ItemEjectorComponent({
slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }], slots: [{ pos: new Vector(0, 0), direction: "top" }],
}) })
); );
entity.addComponent( entity.addComponent(
@ -88,7 +88,7 @@ export class MetaRotaterBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
], ],

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

@ -1,5 +1,5 @@
import { globalConfig } from "../../core/config"; import { globalConfig } from "../../core/config";
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor"; import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
@ -102,22 +102,22 @@ export class MetaSplitterBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
}, },
]); ]);
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.top }, { pos: new Vector(0, 0), direction: "top" },
{ pos: new Vector(1, 0), direction: enumDirection.top }, { pos: new Vector(1, 0), direction: "top" },
]); ]);
entity.components.ItemAcceptor.beltUnderlays = [ entity.components.ItemAcceptor.beltUnderlays = [
{ pos: new Vector(0, 0), direction: enumDirection.top, layer: enumLayer.regular }, { pos: new Vector(0, 0), direction: "top", layer: enumLayer.regular },
{ pos: new Vector(1, 0), direction: enumDirection.top, layer: enumLayer.regular }, { pos: new Vector(1, 0), direction: "top", layer: enumLayer.regular },
]; ];
break; break;
@ -127,24 +127,18 @@ export class MetaSplitterBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
}, },
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [ directions: [variant === enumSplitterVariants.compactInverse ? "left" : "right"],
variant === enumSplitterVariants.compactInverse
? enumDirection.left
: enumDirection.right,
],
}, },
]); ]);
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: "top" }]);
{ pos: new Vector(0, 0), direction: enumDirection.top },
]);
entity.components.ItemAcceptor.beltUnderlays = [ entity.components.ItemAcceptor.beltUnderlays = [
{ pos: new Vector(0, 0), direction: enumDirection.top, layer: enumLayer.regular }, { pos: new Vector(0, 0), direction: "top", layer: enumLayer.regular },
]; ];
break; break;

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

@ -1,5 +1,5 @@
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { T } from "../../translations"; import { T } from "../../translations";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
@ -54,7 +54,7 @@ export class MetaStackerBuilding extends MetaBuilding {
entity.addComponent( entity.addComponent(
new ItemEjectorComponent({ new ItemEjectorComponent({
slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }], slots: [{ pos: new Vector(0, 0), direction: "top" }],
}) })
); );
entity.addComponent( entity.addComponent(
@ -62,12 +62,12 @@ export class MetaStackerBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
filter: enumItemType.shape, filter: enumItemType.shape,
}, },
], ],

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

@ -1,4 +1,4 @@
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor"; import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
@ -85,12 +85,7 @@ export class MetaTrashBuilding extends MetaBuilding {
slots: [ slots: [
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [ directions: ["top", "right", "bottom", "left"],
enumDirection.top,
enumDirection.right,
enumDirection.bottom,
enumDirection.left,
],
}, },
], ],
}) })
@ -121,12 +116,7 @@ export class MetaTrashBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [ directions: ["top", "right", "bottom", "left"],
enumDirection.top,
enumDirection.right,
enumDirection.bottom,
enumDirection.left,
],
}, },
]); ]);
entity.components.ItemEjector.setSlots([]); entity.components.ItemEjector.setSlots([]);
@ -145,22 +135,22 @@ export class MetaTrashBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 1), pos: new Vector(0, 1),
directions: [enumDirection.bottom], directions: ["bottom"],
}, },
{ {
pos: new Vector(1, 1), pos: new Vector(1, 1),
directions: [enumDirection.bottom], directions: ["bottom"],
}, },
]); ]);
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
direction: enumDirection.top, direction: "top",
}, },
{ {
pos: new Vector(1, 0), pos: new Vector(1, 0),
direction: enumDirection.top, direction: "top",
}, },
]); ]);
break; break;

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

@ -1,5 +1,5 @@
import { Loader } from "../../core/loader"; import { Loader } from "../../core/loader";
import { enumDirection, Vector, enumAngleToDirection, enumDirectionToVector } from "../../core/vector"; import { Vector, angleDirectionMap, directionVectorMap, inverseAngleMap } from "../../core/vector";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt"; import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
@ -11,6 +11,8 @@ import { enumHubGoalRewards } from "../tutorial_goals";
import { formatItemsPerSecond } from "../../core/utils"; import { formatItemsPerSecond } from "../../core/utils";
import { T } from "../../translations"; import { T } from "../../translations";
/** @typedef {import("../../core/vector").Angle} Angle **/
/** @enum {string} */ /** @enum {string} */
export const arrayUndergroundRotationVariantToMode = [ export const arrayUndergroundRotationVariantToMode = [
enumUndergroundBeltMode.sender, enumUndergroundBeltMode.sender,
@ -151,17 +153,17 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
* @param {object} param0 * @param {object} param0
* @param {GameRoot} param0.root * @param {GameRoot} param0.root
* @param {Vector} param0.tile * @param {Vector} param0.tile
* @param {number} param0.rotation * @param {Angle} param0.rotation
* @param {string} param0.variant * @param {string} param0.variant
* @param {string} param0.layer * @param {string} param0.layer
* @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array<Entity> }} * @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/ */
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) { computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
const searchDirection = enumAngleToDirection[rotation]; const searchDirection = angleDirectionMap[rotation];
const searchVector = enumDirectionToVector[searchDirection]; const searchVector = directionVectorMap[searchDirection];
const tier = enumUndergroundBeltVariantToTier[variant]; const tier = enumUndergroundBeltVariantToTier[variant];
const targetRotation = (rotation + 180) % 360; const targetRotation = inverseAngleMap[rotation];
const targetSenderRotation = rotation; const targetSenderRotation = rotation;
for ( for (
@ -191,7 +193,7 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
// Draw connections to receivers // Draw connections to receivers
if (undergroundComp.mode === enumUndergroundBeltMode.receiver) { if (undergroundComp.mode === enumUndergroundBeltMode.receiver) {
return { return {
rotation: rotation, rotation,
rotationVariant: 0, rotationVariant: 0,
connectedEntities: [contents], connectedEntities: [contents],
}; };
@ -225,7 +227,7 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
}, },
]); ]);
return; return;
@ -236,7 +238,7 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
direction: enumDirection.top, direction: "top",
}, },
]); ]);
return; return;

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

@ -1,5 +1,4 @@
import { Loader } from "../../core/loader"; import { Loader } from "../../core/loader";
import { enumDirection } from "../../core/vector";
import { enumLayer } from "../root"; import { enumLayer } from "../root";
import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "./belt_base"; import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "./belt_base";
@ -18,13 +17,13 @@ export class MetaWireBaseBuilding extends MetaBeltBaseBuilding {
getPreviewSprite(rotationVariant) { getPreviewSprite(rotationVariant) {
switch (arrayBeltVariantToRotation[rotationVariant]) { switch (arrayBeltVariantToRotation[rotationVariant]) {
case enumDirection.top: { case "top": {
return Loader.getSprite("sprites/buildings/wire_top.png"); return Loader.getSprite("sprites/buildings/wire_top.png");
} }
case enumDirection.left: { case "left": {
return Loader.getSprite("sprites/buildings/wire_left.png"); return Loader.getSprite("sprites/buildings/wire_left.png");
} }
case enumDirection.right: { case "right": {
return Loader.getSprite("sprites/buildings/wire_right.png"); return Loader.getSprite("sprites/buildings/wire_right.png");
} }
default: { default: {
@ -35,13 +34,13 @@ export class MetaWireBaseBuilding extends MetaBeltBaseBuilding {
getBlueprintSprite(rotationVariant) { getBlueprintSprite(rotationVariant) {
switch (arrayBeltVariantToRotation[rotationVariant]) { switch (arrayBeltVariantToRotation[rotationVariant]) {
case enumDirection.top: { case "top": {
return Loader.getSprite("sprites/blueprints/wire_top.png"); return Loader.getSprite("sprites/blueprints/wire_top.png");
} }
case enumDirection.left: { case "left": {
return Loader.getSprite("sprites/blueprints/wire_left.png"); return Loader.getSprite("sprites/blueprints/wire_left.png");
} }
case enumDirection.right: { case "right": {
return Loader.getSprite("sprites/blueprints/wire_right.png"); return Loader.getSprite("sprites/blueprints/wire_right.png");
} }
default: { default: {

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

@ -1,4 +1,4 @@
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { enumItemType } from "../base_item"; import { enumItemType } from "../base_item";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
@ -82,14 +82,14 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.bottom], directions: ["bottom"],
layer: enumLayer.wires, layer: enumLayer.wires,
}, },
]); ]);
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.top, layer: enumLayer.wires }, { pos: new Vector(0, 0), direction: "top", layer: enumLayer.wires },
{ pos: new Vector(0, 0), direction: enumDirection.right, layer: enumLayer.wires }, { pos: new Vector(0, 0), direction: "right", layer: enumLayer.wires },
]); ]);
break; break;
@ -98,18 +98,18 @@ export class MetaWireCrossingsBuilding extends MetaBuilding {
entity.components.ItemAcceptor.setSlots([ entity.components.ItemAcceptor.setSlots([
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.top], directions: ["top"],
layer: enumLayer.wires, layer: enumLayer.wires,
}, },
{ {
pos: new Vector(0, 0), pos: new Vector(0, 0),
directions: [enumDirection.right], directions: ["right"],
layer: enumLayer.wires, layer: enumLayer.wires,
}, },
]); ]);
entity.components.ItemEjector.setSlots([ entity.components.ItemEjector.setSlots([
{ pos: new Vector(0, 0), direction: enumDirection.bottom, layer: enumLayer.wires }, { pos: new Vector(0, 0), direction: "bottom", layer: enumLayer.wires },
]); ]);
break; break;
} }

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

@ -1,10 +1,12 @@
import { enumDirection, Vector } from "../../core/vector"; import { Vector } from "../../core/vector";
import { types } from "../../savegame/serialization"; import { types } from "../../savegame/serialization";
import { BeltPath } from "../belt_path"; import { BeltPath } from "../belt_path";
import { Component } from "../component"; import { Component } from "../component";
import { Entity } from "../entity"; import { Entity } from "../entity";
import { enumLayer } from "../root"; import { enumLayer } from "../root";
/** @typedef {import("../../core/vector").Direction} Direction **/
export const curvedBeltLength = /* Math.PI / 4 */ 0.78; export const curvedBeltLength = /* Math.PI / 4 */ 0.78;
export class BeltComponent extends Component { export class BeltComponent extends Component {
@ -26,9 +28,9 @@ export class BeltComponent extends Component {
/** /**
* *
* @param {object} param0 * @param {object} param0
* @param {enumDirection=} param0.direction The direction of the belt * @param {Direction=} param0.direction The direction of the belt
*/ */
constructor({ direction = enumDirection.top }) { constructor({ direction = "top" }) {
super(); super();
this.direction = direction; this.direction = direction;
@ -53,7 +55,7 @@ export class BeltComponent extends Component {
if (layer === enumLayer.wires) { if (layer === enumLayer.wires) {
return 1.0; return 1.0;
} }
return this.direction === enumDirection.top ? 1.0 : curvedBeltLength; return this.direction === "top" ? 1.0 : curvedBeltLength;
} }
/** /**
@ -69,11 +71,11 @@ export class BeltComponent extends Component {
switch (layer) { switch (layer) {
case enumLayer.regular: { case enumLayer.regular: {
switch (this.direction) { switch (this.direction) {
case enumDirection.top: case "top":
assert(progress <= 1.02, "Invalid progress: " + progress); assert(progress <= 1.02, "Invalid progress: " + progress);
return new Vector(0, 0.5 - progress); return new Vector(0, 0.5 - progress);
case enumDirection.right: { case "right": {
assert(progress <= curvedBeltLength + 0.02, "Invalid progress 2: " + progress); assert(progress <= curvedBeltLength + 0.02, "Invalid progress 2: " + progress);
const arcProgress = (progress / curvedBeltLength) * 0.5 * Math.PI; const arcProgress = (progress / curvedBeltLength) * 0.5 * Math.PI;
return new Vector( return new Vector(
@ -81,7 +83,7 @@ export class BeltComponent extends Component {
0.5 - 0.5 * Math.sin(arcProgress) 0.5 - 0.5 * Math.sin(arcProgress)
); );
} }
case enumDirection.left: { case "left": {
assert(progress <= curvedBeltLength + 0.02, "Invalid progress 3: " + progress); assert(progress <= curvedBeltLength + 0.02, "Invalid progress 3: " + progress);
const arcProgress = (progress / curvedBeltLength) * 0.5 * Math.PI; const arcProgress = (progress / curvedBeltLength) * 0.5 * Math.PI;
return new Vector( return new Vector(
@ -97,15 +99,15 @@ export class BeltComponent extends Component {
case enumLayer.wires: { case enumLayer.wires: {
const pow = 0.5; const pow = 0.5;
switch (this.direction) { switch (this.direction) {
case enumDirection.top: case "top":
assert(progress <= 1.02, "Invalid progress: " + progress); assert(progress <= 1.02, "Invalid progress: " + progress);
return new Vector(0, 0.5 - progress); return new Vector(0, 0.5 - progress);
case enumDirection.right: { case "right": {
assert(progress <= 1.02, "Invalid progress 2: " + progress); assert(progress <= 1.02, "Invalid progress 2: " + progress);
return progress > 0.5 ? new Vector(progress - 0.5, 0) : new Vector(0, 0.5 - progress); return progress > 0.5 ? new Vector(progress - 0.5, 0) : new Vector(0, 0.5 - progress);
} }
case enumDirection.left: { case "left": {
assert(progress <= 1.02, "Invalid progress 3: " + progress); assert(progress <= 1.02, "Invalid progress 3: " + progress);
return progress > 0.5 return progress > 0.5
? new Vector(-progress + 0.5, 0) ? new Vector(-progress + 0.5, 0)

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

@ -1,30 +1,34 @@
import { enumDirection, enumInvertedDirections, Vector } from "../../core/vector"; import { directions, invertedDirectionMap } from "../../core/vector";
import { types } from "../../savegame/serialization"; import { types } from "../../savegame/serialization";
import { BaseItem, enumItemType } from "../base_item"; import { BaseItem, enumItemType } from "../base_item";
import { Component } from "../component"; import { Component } from "../component";
import { enumLayer } from "../root"; import { enumLayer } from "../root";
/** @typedef {{ /**
* @typedef {import("../../core/vector").Direction} Direction
* @typedef {import("../../core/vector").Vector} Vector
*
* @typedef {{
* pos: Vector, * pos: Vector,
* directions: enumDirection[], * directions: Direction[],
* layer: enumLayer, * layer: enumLayer,
* filter?: enumItemType * filter?: enumItemType
* }} ItemAcceptorSlot */ * }} ItemAcceptorSlot
*
/**
* Contains information about a slot plus its location * Contains information about a slot plus its location
* @typedef {{ * @typedef {{
* slot: ItemAcceptorSlot, * slot: ItemAcceptorSlot,
* index: number, * index: number,
* acceptedDirection: enumDirection * acceptedDirection: Direction
* }} ItemAcceptorLocatedSlot */ * }} ItemAcceptorLocatedSlot
*
/** @typedef {{ * @typedef {{
* pos: Vector, * pos: Vector,
* directions: enumDirection[], * directions: Direction[],
* layer?: enumLayer, * layer?: enumLayer,
* filter?: enumItemType * filter?: enumItemType
* }} ItemAcceptorSlotConfig */ * }} ItemAcceptorSlotConfig
*/
export class ItemAcceptorComponent extends Component { export class ItemAcceptorComponent extends Component {
static getId() { static getId() {
@ -36,7 +40,7 @@ export class ItemAcceptorComponent extends Component {
slots: types.array( slots: types.array(
types.structured({ types.structured({
pos: types.vector, pos: types.vector,
directions: types.array(types.enum(enumDirection)), directions: types.array(types.enum(directions)),
filter: types.nullable(types.enum(enumItemType)), filter: types.nullable(types.enum(enumItemType)),
// TODO: MIGRATE // TODO: MIGRATE
@ -47,7 +51,7 @@ export class ItemAcceptorComponent extends Component {
beltUnderlays: types.array( beltUnderlays: types.array(
types.structured({ types.structured({
pos: types.vector, pos: types.vector,
direction: types.enum(enumDirection), direction: types.enum(directions),
// TODO: MIGRATE // TODO: MIGRATE
layer: types.enum(enumLayer), layer: types.enum(enumLayer),
@ -90,7 +94,7 @@ export class ItemAcceptorComponent extends Component {
* @param {object} param0 * @param {object} param0
* @param {Array<ItemAcceptorSlotConfig>} param0.slots The slots from which we accept items * @param {Array<ItemAcceptorSlotConfig>} param0.slots The slots from which we accept items
* @param {boolean=} param0.animated Whether to animate item consumption * @param {boolean=} param0.animated Whether to animate item consumption
* @param {Array<{pos: Vector, direction: enumDirection, layer: enumLayer}>=} param0.beltUnderlays Where to render belt underlays * @param {Array<{pos: Vector, direction: Direction, layer: enumLayer}>=} param0.beltUnderlays Where to render belt underlays
*/ */
constructor({ slots = [], beltUnderlays = [], animated = true }) { constructor({ slots = [], beltUnderlays = [], animated = true }) {
super(); super();
@ -99,7 +103,7 @@ export class ItemAcceptorComponent extends Component {
/** /**
* Fixes belt animations * Fixes belt animations
* @type {Array<{ item: BaseItem, slotIndex: number, animProgress: number, direction: enumDirection }>} * @type {Array<{ item: BaseItem, slotIndex: number, animProgress: number, direction: Direction }>}
*/ */
this.itemConsumptionAnimations = []; this.itemConsumptionAnimations = [];
@ -160,7 +164,7 @@ export class ItemAcceptorComponent extends Component {
/** /**
* Called when an item has been accepted so that * Called when an item has been accepted so that
* @param {number} slotIndex * @param {number} slotIndex
* @param {enumDirection} direction * @param {Direction} direction
* @param {BaseItem} item * @param {BaseItem} item
*/ */
onItemAccepted(slotIndex, direction, item) { onItemAccepted(slotIndex, direction, item) {
@ -177,7 +181,7 @@ export class ItemAcceptorComponent extends Component {
/** /**
* Tries to find a slot which accepts the current item * Tries to find a slot which accepts the current item
* @param {Vector} targetLocalTile * @param {Vector} targetLocalTile
* @param {enumDirection} fromLocalDirection * @param {Direction} fromLocalDirection
* @param {enumLayer} layer * @param {enumLayer} layer
* @returns {ItemAcceptorLocatedSlot|null} * @returns {ItemAcceptorLocatedSlot|null}
*/ */
@ -185,7 +189,7 @@ export class ItemAcceptorComponent extends Component {
// We need to invert our direction since the acceptor specifies *from* which direction // We need to invert our direction since the acceptor specifies *from* which direction
// it accepts items, but the ejector specifies *into* which direction it ejects items. // it accepts items, but the ejector specifies *into* which direction it ejects items.
// E.g.: Ejector ejects into "right" direction but acceptor accepts from "left" direction. // E.g.: Ejector ejects into "right" direction but acceptor accepts from "left" direction.
const desiredDirection = enumInvertedDirections[fromLocalDirection]; const desiredDirection = invertedDirectionMap[fromLocalDirection];
// Go over all slots and try to find a target slot // Go over all slots and try to find a target slot
for (let slotIndex = 0; slotIndex < this.slots.length; ++slotIndex) { for (let slotIndex = 0; slotIndex < this.slots.length; ++slotIndex) {

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

@ -1,4 +1,4 @@
import { Vector, enumDirection, enumDirectionToVector } from "../../core/vector"; import { directions, directionVectorMap, Vector } from "../../core/vector";
import { BaseItem } from "../base_item"; import { BaseItem } from "../base_item";
import { Component } from "../component"; import { Component } from "../component";
import { types } from "../../savegame/serialization"; import { types } from "../../savegame/serialization";
@ -7,13 +7,15 @@ import { Entity } from "../entity";
import { enumLayer } from "../root"; import { enumLayer } from "../root";
/** /**
* @typedef {import("../../core/vector").Direction} Direction
* @typedef {import("./item_acceptor").ItemAcceptorLocatedSlot} ItemAcceptorLocatedSlot
* @typedef {{ * @typedef {{
* pos: Vector, * pos: Vector,
* direction: enumDirection, * direction: Direction,
* item: BaseItem, * item: BaseItem,
* layer: enumLayer, * layer: enumLayer,
* progress: number?, * progress: number?,
* cachedDestSlot?: import("./item_acceptor").ItemAcceptorLocatedSlot, * cachedDestSlot?: ItemAcceptorLocatedSlot,
* cachedTargetEntity?: Entity * cachedTargetEntity?: Entity
* }} ItemEjectorSlot * }} ItemEjectorSlot
*/ */
@ -31,7 +33,7 @@ export class ItemEjectorComponent extends Component {
slots: types.array( slots: types.array(
types.structured({ types.structured({
pos: types.vector, pos: types.vector,
direction: types.enum(enumDirection), direction: types.enum(directions),
item: types.nullable(types.obj(gItemRegistry)), item: types.nullable(types.obj(gItemRegistry)),
progress: types.float, progress: types.float,
@ -62,7 +64,7 @@ export class ItemEjectorComponent extends Component {
/** /**
* *
* @param {object} param0 * @param {object} param0
* @param {Array<{pos: Vector, direction: enumDirection, layer?: enumLayer}>=} param0.slots The slots to eject on * @param {Array<{pos: Vector, direction: Direction, layer?: enumLayer}>=} param0.slots The slots to eject on
* @param {boolean=} param0.instantEject If the ejection is instant * @param {boolean=} param0.instantEject If the ejection is instant
*/ */
constructor({ slots = [], instantEject = false }) { constructor({ slots = [], instantEject = false }) {
@ -83,7 +85,7 @@ export class ItemEjectorComponent extends Component {
} }
/** /**
* @param {Array<{pos: Vector, direction: enumDirection, layer?: enumLayer}>} slots The slots to eject on * @param {Array<{pos: Vector, direction: Direction, layer?: enumLayer}>} slots The slots to eject on
*/ */
setSlots(slots) { setSlots(slots) {
/** @type {Array<ItemEjectorSlot>} */ /** @type {Array<ItemEjectorSlot>} */
@ -109,7 +111,7 @@ export class ItemEjectorComponent extends Component {
*/ */
getSlotTargetLocalTile(index) { getSlotTargetLocalTile(index) {
const slot = this.slots[index]; const slot = this.slots[index];
const directionVector = enumDirectionToVector[slot.direction]; const directionVector = directionVectorMap[slot.direction];
return slot.pos.add(directionVector); return slot.pos.add(directionVector);
} }

25
src/js/game/components/static_map_entity.js
View File

@ -2,11 +2,16 @@ import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters"; import { DrawParameters } from "../../core/draw_parameters";
import { Rectangle } from "../../core/rectangle"; import { Rectangle } from "../../core/rectangle";
import { AtlasSprite } from "../../core/sprites"; import { AtlasSprite } from "../../core/sprites";
import { enumDirection, Vector } from "../../core/vector"; import { directionRotationMap, inverseAngleMap, Vector } from "../../core/vector";
import { types } from "../../savegame/serialization"; import { types } from "../../savegame/serialization";
import { Component } from "../component"; import { Component } from "../component";
import { getBuildingDataFromCode } from "../building_codes"; import { getBuildingDataFromCode } from "../building_codes";
/**
* @typedef {import("../../core/vector").Angle} Angle
* @typedef {import("../../core/vector").Direction} Direction
*/
export class StaticMapEntityComponent extends Component { export class StaticMapEntityComponent extends Component {
static getId() { static getId() {
return "StaticMapEntity"; return "StaticMapEntity";
@ -63,8 +68,8 @@ export class StaticMapEntityComponent extends Component {
* @param {object} param0 * @param {object} param0
* @param {Vector=} param0.origin Origin (Top Left corner) of the entity * @param {Vector=} param0.origin Origin (Top Left corner) of the entity
* @param {Vector=} param0.tileSize Size of the entity in tiles * @param {Vector=} param0.tileSize Size of the entity in tiles
* @param {number=} param0.rotation Rotation in degrees. Must be multiple of 90 * @param {Angle} param0.rotation Rotation in degrees. Must be multiple of 90
* @param {number=} param0.originalRotation Original Rotation in degrees. Must be multiple of 90 * @param {Angle=} param0.originalRotation Original Rotation in degrees. Must be multiple of 90
* @param {number=} param0.code Building code * @param {number=} param0.code Building code
*/ */
constructor({ constructor({
@ -136,25 +141,25 @@ export class StaticMapEntityComponent extends Component {
* @returns {Vector} * @returns {Vector}
*/ */
unapplyRotationToVector(vector) { unapplyRotationToVector(vector) {
return vector.rotateFastMultipleOf90(360 - this.rotation); return vector.rotateFastMultipleOf90(inverseAngleMap[this.rotation]);
} }
/** /**
* Transforms the given direction from local space * Transforms the given direction from local space
* @param {enumDirection} direction * @param {Direction} direction
* @returns {enumDirection} * @returns {Direction}
*/ */
localDirectionToWorld(direction) { localDirectionToWorld(direction) {
return Vector.transformDirectionFromMultipleOf90(direction, this.rotation); return directionRotationMap[direction][this.rotation];
} }
/** /**
* Transforms the given direction from world to local space * Transforms the given direction from world to local space
* @param {enumDirection} direction * @param {Direction} direction
* @returns {enumDirection} * @returns {Direction}
*/ */
worldDirectionToLocal(direction) { worldDirectionToLocal(direction) {
return Vector.transformDirectionFromMultipleOf90(direction, 360 - this.rotation); return directionRotationMap[direction][inverseAngleMap[this.rotation]];
} }
/** /**

29
src/js/game/components/wired_pins.js
View File

@ -1,7 +1,22 @@
import { Component } from "../component"; import { Component } from "../component";
import { Vector, enumDirection } from "../../core/vector"; import { Vector } from "../../core/vector";
import { types } from "../../savegame/serialization"; import { types } from "../../savegame/serialization";
/**
* @typedef {import("../../core/vector").Direction} Direction
*
* @typedef {{
* pos: Vector,
* type: enumPinSlotType,
* direction: Direction
* }} WirePinSlotDefinition
*
* @typedef {{
* pos: Vector,
* type: enumPinSlotType,
* direction: Direction
* }} WirePinSlot */
/** @enum {string} */ /** @enum {string} */
export const enumPinSlotType = { export const enumPinSlotType = {
positiveEnergyEjector: "positiveEnergyEjector", positiveEnergyEjector: "positiveEnergyEjector",
@ -10,18 +25,6 @@ export const enumPinSlotType = {
negativeEnergyAcceptor: "negativeEnergyAcceptor", negativeEnergyAcceptor: "negativeEnergyAcceptor",
}; };
/** @typedef {{
* pos: Vector,
* type: enumPinSlotType,
* direction: enumDirection
* }} WirePinSlotDefinition */
/** @typedef {{
* pos: Vector,
* type: enumPinSlotType,
* direction: enumDirection
* }} WirePinSlot */
export class WiredPinsComponent extends Component { export class WiredPinsComponent extends Component {
static getId() { static getId() {
return "WiredPins"; return "WiredPins";

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

@ -5,7 +5,7 @@ import { Component } from "./component";
import { GameRoot, enumLayer } from "./root"; import { GameRoot, enumLayer } from "./root";
import { globalConfig } from "../core/config"; import { globalConfig } from "../core/config";
import { enumDirectionToVector, enumDirectionToAngle } from "../core/vector"; import { directionAngleMap, directionVectorMap } from "../core/vector";
import { BasicSerializableObject, types } from "../savegame/serialization"; import { BasicSerializableObject, types } from "../savegame/serialization";
import { EntityComponentStorage } from "./entity_components"; import { EntityComponentStorage } from "./entity_components";
import { Loader } from "../core/loader"; import { Loader } from "../core/loader";
@ -174,8 +174,8 @@ export class Entity extends BasicSerializableObject {
} }
const slotTile = staticComp.localTileToWorld(slot.pos); const slotTile = staticComp.localTileToWorld(slot.pos);
const direction = staticComp.localDirectionToWorld(slot.direction); const direction = staticComp.localDirectionToWorld(slot.direction);
const directionVector = enumDirectionToVector[direction]; const directionVector = directionVectorMap[direction];
const angle = Math.radians(enumDirectionToAngle[direction]); const angle = Math.radians(directionAngleMap[direction]);
context.globalAlpha = slot.item ? 1 : 0.2; context.globalAlpha = slot.item ? 1 : 0.2;
drawRotatedSprite({ drawRotatedSprite({
@ -200,8 +200,8 @@ export class Entity extends BasicSerializableObject {
const slotTile = staticComp.localTileToWorld(slot.pos); const slotTile = staticComp.localTileToWorld(slot.pos);
for (let k = 0; k < slot.directions.length; ++k) { for (let k = 0; k < slot.directions.length; ++k) {
const direction = staticComp.localDirectionToWorld(slot.directions[k]); const direction = staticComp.localDirectionToWorld(slot.directions[k]);
const directionVector = enumDirectionToVector[direction]; const directionVector = directionVectorMap[direction];
const angle = Math.radians(enumDirectionToAngle[direction] + 180); const angle = Math.radians(directionAngleMap[direction] + 180);
context.globalAlpha = 0.4; context.globalAlpha = 0.4;
drawRotatedSprite({ drawRotatedSprite({
parameters, parameters,

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

@ -4,12 +4,7 @@ import { DrawParameters } from "../../../core/draw_parameters";
import { drawRotatedSprite, rotateTrapezRightFaced } from "../../../core/draw_utils"; import { drawRotatedSprite, rotateTrapezRightFaced } from "../../../core/draw_utils";
import { Loader } from "../../../core/loader"; import { Loader } from "../../../core/loader";
import { clamp, makeDiv, removeAllChildren } from "../../../core/utils"; import { clamp, makeDiv, removeAllChildren } from "../../../core/utils";
import { import { directionVectorMap, directionAngleMap, invertedDirectionMap, Vector } from "../../../core/vector";
enumDirectionToAngle,
enumDirectionToVector,
enumInvertedDirections,
Vector,
} from "../../../core/vector";
import { T } from "../../../translations"; import { T } from "../../../translations";
import { KEYMAPPINGS } from "../../key_action_mapper"; import { KEYMAPPINGS } from "../../key_action_mapper";
import { defaultBuildingVariant } from "../../meta_building"; import { defaultBuildingVariant } from "../../meta_building";
@ -459,7 +454,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const worldDirection = staticComp.localDirectionToWorld(direction); const worldDirection = staticComp.localDirectionToWorld(direction);
// Figure out which tile ejects to this slot // Figure out which tile ejects to this slot
const sourceTile = acceptorSlotWsTile.add(enumDirectionToVector[worldDirection]); const sourceTile = acceptorSlotWsTile.add(directionVectorMap[worldDirection]);
let isBlocked = false; let isBlocked = false;
let isConnected = false; let isConnected = false;
@ -505,7 +500,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
sprite, sprite,
x: acceptorSlotWsPos.x, x: acceptorSlotWsPos.x,
y: acceptorSlotWsPos.y, y: acceptorSlotWsPos.y,
angle: Math.radians(enumDirectionToAngle[enumInvertedDirections[worldDirection]]), angle: Math.radians(directionAngleMap[invertedDirectionMap[worldDirection]]),
size: 13, size: 13,
offsetY: offsetShift + 13, offsetY: offsetShift + 13,
}); });
@ -574,7 +569,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
sprite, sprite,
x: ejectorSLotWsPos.x, x: ejectorSLotWsPos.x,
y: ejectorSLotWsPos.y, y: ejectorSLotWsPos.y,
angle: Math.radians(enumDirectionToAngle[ejectorSlotWsDirection]), angle: Math.radians(directionAngleMap[ejectorSlotWsDirection]),
size: 13, size: 13,
offsetY: offsetShift, offsetY: offsetShift,
}); });

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

@ -2,7 +2,13 @@ import { globalConfig } from "../../../core/config";
import { gMetaBuildingRegistry } from "../../../core/global_registries"; import { gMetaBuildingRegistry } from "../../../core/global_registries";
import { Signal, STOP_PROPAGATION } from "../../../core/signal"; import { Signal, STOP_PROPAGATION } from "../../../core/signal";
import { TrackedState } from "../../../core/tracked_state"; import { TrackedState } from "../../../core/tracked_state";
import { Vector } from "../../../core/vector"; import {
clockwiseAngleMap,
counterClockwiseAngleMap,
inverseAngleMap,
snapToAngle,
Vector,
} from "../../../core/vector";
import { enumMouseButton } from "../../camera"; import { enumMouseButton } from "../../camera";
import { StaticMapEntityComponent } from "../../components/static_map_entity"; import { StaticMapEntityComponent } from "../../components/static_map_entity";
import { Entity } from "../../entity"; import { Entity } from "../../entity";
@ -15,6 +21,8 @@ import { enumHubGoalRewards } from "../../tutorial_goals";
import { enumLayer } from "../../root"; import { enumLayer } from "../../root";
import { getBuildingDataFromCode, getCodeFromBuildingData } from "../../building_codes"; import { getBuildingDataFromCode, getCodeFromBuildingData } from "../../building_codes";
/** @typedef {import("../../../core/vector").Angle} Angle **/
/** /**
* Contains all logic for the building placer - this doesn't include the rendering * Contains all logic for the building placer - this doesn't include the rendering
* of info boxes or drawing. * of info boxes or drawing.
@ -46,13 +54,13 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/** /**
* The current rotation * The current rotation
* @type {number} * @type {Angle}
*/ */
this.currentBaseRotationGeneral = 0; this.currentBaseRotationGeneral = 0;
/** /**
* The current rotation preference for each building. * The current rotation preference for each building.
* @type{Object.<string,number>} * @type{Object.<string,Angle>}
*/ */
this.preferredBaseRotations = {}; this.preferredBaseRotations = {};
@ -146,7 +154,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/** /**
* Returns the current base rotation for the current meta-building. * Returns the current base rotation for the current meta-building.
* @returns {number} * @returns {Angle}
*/ */
get currentBaseRotation() { get currentBaseRotation() {
if (!this.root.app.settings.getAllSettings().rotationByBuilding) { if (!this.root.app.settings.getAllSettings().rotationByBuilding) {
@ -162,7 +170,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/** /**
* Sets the base rotation for the current meta-building. * Sets the base rotation for the current meta-building.
* @param {number} rotation The new rotation/angle. * @param {Angle} rotation The new rotation/angle.
*/ */
set currentBaseRotation(rotation) { set currentBaseRotation(rotation) {
if (!this.root.app.settings.getAllSettings().rotationByBuilding) { if (!this.root.app.settings.getAllSettings().rotationByBuilding) {
@ -274,9 +282,9 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
const selectedBuilding = this.currentMetaBuilding.get(); const selectedBuilding = this.currentMetaBuilding.get();
if (selectedBuilding) { if (selectedBuilding) {
if (this.root.keyMapper.getBinding(KEYMAPPINGS.placement.rotateInverseModifier).pressed) { if (this.root.keyMapper.getBinding(KEYMAPPINGS.placement.rotateInverseModifier).pressed) {
this.currentBaseRotation = (this.currentBaseRotation + 270) % 360; this.currentBaseRotation = counterClockwiseAngleMap[this.currentBaseRotation];
} else { } else {
this.currentBaseRotation = (this.currentBaseRotation + 90) % 360; this.currentBaseRotation = clockwiseAngleMap[this.currentBaseRotation];
} }
const staticComp = this.fakeEntity.components.StaticMapEntity; const staticComp = this.fakeEntity.components.StaticMapEntity;
staticComp.rotation = this.currentBaseRotation; staticComp.rotation = this.currentBaseRotation;
@ -416,7 +424,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
KEYMAPPINGS.placementModifiers.placementDisableAutoOrientation KEYMAPPINGS.placementModifiers.placementDisableAutoOrientation
).pressed ).pressed
) { ) {
this.currentBaseRotation = (180 + this.currentBaseRotation) % 360; this.currentBaseRotation = inverseAngleMap[this.currentBaseRotation];
} }
// Check if we should stop placement // Check if we should stop placement
@ -500,7 +508,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/** /**
* Finds the path which the current direction lock will use * Finds the path which the current direction lock will use
* @returns {Array<{ tile: Vector, rotation: number }>} * @returns {Array<{ tile: Vector, rotation: Angle }>}
*/ */
computeDirectionLockPath() { computeDirectionLockPath() {
const mousePosition = this.root.app.mousePosition; const mousePosition = this.root.app.mousePosition;
@ -529,7 +537,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
const lengthToCorner = Math.round(pathToCorner.length()); const lengthToCorner = Math.round(pathToCorner.length());
let currentPos = startTile.copy(); let currentPos = startTile.copy();
let rotation = (Math.round(Math.degrees(deltaToCorner.angle()) / 90) * 90 + 360) % 360; let rotation = snapToAngle(deltaToCorner.angle());
if (lengthToCorner > 0) { if (lengthToCorner > 0) {
for (let i = 0; i < lengthToCorner; ++i) { for (let i = 0; i < lengthToCorner; ++i) {
@ -547,7 +555,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
const lengthFromCorner = Math.round(pathFromCorner.length()); const lengthFromCorner = Math.round(pathFromCorner.length());
if (lengthFromCorner > 0) { if (lengthFromCorner > 0) {
rotation = (Math.round(Math.degrees(deltaFromCorner.angle()) / 90) * 90 + 360) % 360; rotation = snapToAngle(deltaFromCorner.angle());
for (let i = 0; i < lengthFromCorner + 1; ++i) { for (let i = 0; i < lengthFromCorner + 1; ++i) {
result.push({ result.push({
tile: currentPos.copy(), tile: currentPos.copy(),
@ -683,12 +691,11 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
).pressed ).pressed
) { ) {
const delta = newPos.sub(oldPos); const delta = newPos.sub(oldPos);
const angleDeg = Math.degrees(delta.angle()); this.currentBaseRotation = snapToAngle(delta.angle());
this.currentBaseRotation = (Math.round(angleDeg / 90) * 90 + 360) % 360;
// Holding alt inverts the placement // Holding alt inverts the placement
if (this.root.keyMapper.getBinding(KEYMAPPINGS.placementModifiers.placeInverse).pressed) { if (this.root.keyMapper.getBinding(KEYMAPPINGS.placementModifiers.placeInverse).pressed) {
this.currentBaseRotation = (180 + this.currentBaseRotation) % 360; this.currentBaseRotation = inverseAngleMap[this.currentBaseRotation];
} }
} }

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

@ -1,6 +1,6 @@
import { createLogger } from "../core/logging"; import { createLogger } from "../core/logging";
import { round2Digits } from "../core/utils"; import { round2Digits } from "../core/utils";
import { enumDirection, enumDirectionToVector, Vector } from "../core/vector"; import { directionVectorMap, Vector } from "../core/vector";
import { Entity } from "./entity"; import { Entity } from "./entity";
import { MetaBuilding } from "./meta_building"; import { MetaBuilding } from "./meta_building";
import { enumLayer, GameRoot } from "./root"; import { enumLayer, GameRoot } from "./root";
@ -9,26 +9,25 @@ import { STOP_PROPAGATION } from "../core/signal";
const logger = createLogger("ingame/logic"); const logger = createLogger("ingame/logic");
/** /**
* Typing helper * @typedef {import("./components/item_ejector").ItemEjectorSlot} ItemEjectorSlot
* @typedef {import("./components/item_acceptor").ItemAcceptorSlot} ItemAcceptorSlot
* @typedef {import("../core/vector").Angle} Angle
* @typedef {import("../core/vector").Direction} Direction
*
* @typedef {Array<{ * @typedef {Array<{
* entity: Entity, * entity: Entity,
* slot: import("./components/item_ejector").ItemEjectorSlot, * slot: ItemEjectorSlot,
* fromTile: Vector, * fromTile: Vector,
* toDirection: enumDirection * toDirection: Direction
* }>} EjectorsAffectingTile * }>} EjectorsAffectingTile
*/ *
/**
* Typing helper
* @typedef {Array<{ * @typedef {Array<{
* entity: Entity, * entity: Entity,
* slot: import("./components/item_acceptor").ItemAcceptorSlot, * slot: ItemAcceptorSlot,
* toTile: Vector, * toTile: Vector,
* fromDirection: enumDirection * fromDirection: Direction
* }>} AcceptorsAffectingTile * }>} AcceptorsAffectingTile
*/ *
/**
* @typedef {{ * @typedef {{
* acceptors: AcceptorsAffectingTile, * acceptors: AcceptorsAffectingTile,
* ejectors: EjectorsAffectingTile * ejectors: EjectorsAffectingTile
@ -82,8 +81,8 @@ export class GameLogic {
* Attempts to place the given building * Attempts to place the given building
* @param {object} param0 * @param {object} param0
* @param {Vector} param0.origin * @param {Vector} param0.origin
* @param {number} param0.rotation * @param {Angle} param0.rotation
* @param {number} param0.originalRotation * @param {Angle} param0.originalRotation
* @param {number} param0.rotationVariant * @param {number} param0.rotationVariant
* @param {string} param0.variant * @param {string} param0.variant
* @param {MetaBuilding} param0.building * @param {MetaBuilding} param0.building
@ -183,9 +182,9 @@ export class GameLogic {
*/ */
getEjectorsAndAcceptorsAtTile(tile, layer) { getEjectorsAndAcceptorsAtTile(tile, layer) {
/** @type {EjectorsAffectingTile} */ /** @type {EjectorsAffectingTile} */
let ejectors = []; const ejectors = [];
/** @type {AcceptorsAffectingTile} */ /** @type {AcceptorsAffectingTile} */
let acceptors = []; const acceptors = [];
// Well .. please ignore this code! :D // Well .. please ignore this code! :D
for (let dx = -1; dx <= 1; ++dx) { for (let dx = -1; dx <= 1; ++dx) {
@ -208,7 +207,7 @@ export class GameLogic {
} }
const wsTile = staticComp.localTileToWorld(slot.pos); const wsTile = staticComp.localTileToWorld(slot.pos);
const wsDirection = staticComp.localDirectionToWorld(slot.direction); const wsDirection = staticComp.localDirectionToWorld(slot.direction);
const targetTile = wsTile.add(enumDirectionToVector[wsDirection]); const targetTile = wsTile.add(directionVectorMap[wsDirection]);
if (targetTile.equals(tile)) { if (targetTile.equals(tile)) {
ejectors.push({ ejectors.push({
entity, entity,
@ -233,7 +232,7 @@ export class GameLogic {
const direction = slot.directions[k]; const direction = slot.directions[k];
const wsDirection = staticComp.localDirectionToWorld(direction); const wsDirection = staticComp.localDirectionToWorld(direction);
const sourceTile = wsTile.add(enumDirectionToVector[wsDirection]); const sourceTile = wsTile.add(directionVectorMap[wsDirection]);
if (sourceTile.equals(tile)) { if (sourceTile.equals(tile)) {
acceptors.push({ acceptors.push({
entity, entity,

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

@ -7,6 +7,8 @@ import { Entity } from "./entity";
import { enumLayer, GameRoot } from "./root"; import { enumLayer, GameRoot } from "./root";
import { getCodeFromBuildingData } from "./building_codes"; import { getCodeFromBuildingData } from "./building_codes";
/** @typedef {import("../core/vector").Angle} Angle **/
export const defaultBuildingVariant = "default"; export const defaultBuildingVariant = "default";
export class MetaBuilding { export class MetaBuilding {
@ -150,8 +152,8 @@ export class MetaBuilding {
* @param {object} param0 * @param {object} param0
* @param {GameRoot} param0.root * @param {GameRoot} param0.root
* @param {Vector} param0.origin Origin tile * @param {Vector} param0.origin Origin tile
* @param {number=} param0.rotation Rotation * @param {Angle=} param0.rotation Rotation
* @param {number} param0.originalRotation Original Rotation * @param {Angle} param0.originalRotation Original Rotation
* @param {number} param0.rotationVariant Rotation variant * @param {number} param0.rotationVariant Rotation variant
* @param {string} param0.variant * @param {string} param0.variant
*/ */
@ -192,10 +194,10 @@ export class MetaBuilding {
* @param {object} param0 * @param {object} param0
* @param {GameRoot} param0.root * @param {GameRoot} param0.root
* @param {Vector} param0.tile * @param {Vector} param0.tile
* @param {number} param0.rotation * @param {Angle} param0.rotation
* @param {string} param0.variant * @param {string} param0.variant
* @param {string} param0.layer * @param {string} param0.layer
* @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array<Entity> }} * @return {{ rotation: Angle, rotationVariant: number, connectedEntities?: Array<Entity> }}
*/ */
computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) { computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
if (!this.isRotateable(variant)) { if (!this.isRotateable(variant)) {

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

@ -5,7 +5,7 @@ import { Loader } from "../../core/loader";
import { createLogger } from "../../core/logging"; import { createLogger } from "../../core/logging";
import { AtlasSprite } from "../../core/sprites"; import { AtlasSprite } from "../../core/sprites";
import { fastArrayDeleteValue } from "../../core/utils"; import { fastArrayDeleteValue } from "../../core/utils";
import { enumDirection, enumDirectionToVector, enumInvertedDirections, Vector } from "../../core/vector"; import { directionVectorMap, invertedDirectionMap, Vector } from "../../core/vector";
import { BeltPath } from "../belt_path"; import { BeltPath } from "../belt_path";
import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "../buildings/belt_base"; import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "../buildings/belt_base";
import { BeltComponent } from "../components/belt"; import { BeltComponent } from "../components/belt";
@ -21,6 +21,10 @@ export const BELT_ANIM_COUNT = 28;
const logger = createLogger("belt"); const logger = createLogger("belt");
/**
* @typedef {import("../../core/vector").Direction} Direction
*/
/** /**
* Manages all belts * Manages all belts
*/ */
@ -28,40 +32,36 @@ export class BeltSystem extends GameSystemWithFilter {
constructor(root) { constructor(root) {
super(root, [BeltComponent]); super(root, [BeltComponent]);
/** /**
* @type {Object.<enumDirection, Array<AtlasSprite>>} * @type {Object.<Direction, Array<AtlasSprite>>}
*/ */
this.beltSprites = { this.beltSprites = {
[enumDirection.top]: Loader.getSprite("sprites/belt/forward_0.png"), top: Loader.getSprite("sprites/belt/forward_0.png"),
[enumDirection.left]: Loader.getSprite("sprites/belt/left_0.png"), left: Loader.getSprite("sprites/belt/left_0.png"),
[enumDirection.right]: Loader.getSprite("sprites/belt/right_0.png"), right: Loader.getSprite("sprites/belt/right_0.png"),
}; };
/** /**
* @type {Object.<enumDirection, Array<AtlasSprite>>} * @type {Object.<Direction, Array<AtlasSprite>>}
*/ */
this.wireSprites = { this.wireSprites = {
[enumDirection.top]: Loader.getSprite("sprites/buildings/wire_top.png"), top: Loader.getSprite("sprites/buildings/wire_top.png"),
[enumDirection.left]: Loader.getSprite("sprites/buildings/wire_left.png"), left: Loader.getSprite("sprites/buildings/wire_left.png"),
[enumDirection.right]: Loader.getSprite("sprites/buildings/wire_right.png"), right: Loader.getSprite("sprites/buildings/wire_right.png"),
}; };
/** /**
* @type {Object.<enumDirection, Array<AtlasSprite>>} * @type {Object.<Direction, Array<AtlasSprite>>}
*/ */
this.beltAnimations = { this.beltAnimations = {
[enumDirection.top]: [], top: [],
[enumDirection.left]: [], left: [],
[enumDirection.right]: [], right: [],
}; };
for (let i = 0; i < BELT_ANIM_COUNT; ++i) { for (let i = 0; i < BELT_ANIM_COUNT; ++i) {
this.beltAnimations[enumDirection.top].push( this.beltAnimations.top.push(Loader.getSprite(`sprites/belt/forward_${i}.png`));
Loader.getSprite("sprites/belt/forward_" + i + ".png") this.beltAnimations.left.push(Loader.getSprite(`sprites/belt/left_${i}.png`));
); this.beltAnimations.right.push(Loader.getSprite(`sprites/belt/right_${i}.png`));
this.beltAnimations[enumDirection.left].push(Loader.getSprite("sprites/belt/left_" + i + ".png"));
this.beltAnimations[enumDirection.right].push(
Loader.getSprite("sprites/belt/right_" + i + ".png")
);
} }
this.root.signals.entityDestroyed.add(this.onEntityDestroyed, this); this.root.signals.entityDestroyed.add(this.onEntityDestroyed, this);
@ -351,7 +351,7 @@ export class BeltSystem extends GameSystemWithFilter {
const beltComp = entity.components.Belt; const beltComp = entity.components.Belt;
const followUpDirection = staticComp.localDirectionToWorld(beltComp.direction); const followUpDirection = staticComp.localDirectionToWorld(beltComp.direction);
const followUpVector = enumDirectionToVector[followUpDirection]; const followUpVector = directionVectorMap[followUpDirection];
const followUpTile = staticComp.origin.add(followUpVector); const followUpTile = staticComp.origin.add(followUpVector);
const followUpEntity = this.root.map.getLayerContentXY(followUpTile.x, followUpTile.y, entity.layer); const followUpEntity = this.root.map.getLayerContentXY(followUpTile.x, followUpTile.y, entity.layer);
@ -375,7 +375,7 @@ export class BeltSystem extends GameSystemWithFilter {
for (let k = 0; k < slot.directions.length; ++k) { for (let k = 0; k < slot.directions.length; ++k) {
const localDirection = followUpStatic.localDirectionToWorld(slot.directions[k]); const localDirection = followUpStatic.localDirectionToWorld(slot.directions[k]);
if (enumInvertedDirections[localDirection] === followUpDirection) { if (invertedDirectionMap[localDirection] === followUpDirection) {
return followUpEntity; return followUpEntity;
} }
} }
@ -394,8 +394,8 @@ export class BeltSystem extends GameSystemWithFilter {
findSupplyingEntity(entity) { findSupplyingEntity(entity) {
const staticComp = entity.components.StaticMapEntity; const staticComp = entity.components.StaticMapEntity;
const supplyDirection = staticComp.localDirectionToWorld(enumDirection.bottom); const supplyDirection = staticComp.localDirectionToWorld("bottom");
const supplyVector = enumDirectionToVector[supplyDirection]; const supplyVector = directionVectorMap[supplyDirection];
const supplyTile = staticComp.origin.add(supplyVector); const supplyTile = staticComp.origin.add(supplyVector);
const supplyEntity = this.root.map.getLayerContentXY(supplyTile.x, supplyTile.y, entity.layer); const supplyEntity = this.root.map.getLayerContentXY(supplyTile.x, supplyTile.y, entity.layer);
@ -417,7 +417,7 @@ export class BeltSystem extends GameSystemWithFilter {
continue; continue;
} }
const localDirection = supplyStatic.localDirectionToWorld(slot.direction); const localDirection = supplyStatic.localDirectionToWorld(slot.direction);
if (enumInvertedDirections[localDirection] === supplyDirection) { if (invertedDirectionMap[localDirection] === supplyDirection) {
return supplyEntity; return supplyEntity;
} }
} }

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

@ -2,7 +2,7 @@ import { GameSystemWithFilter } from "../game_system_with_filter";
import { globalConfig } from "../../core/config"; import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters"; import { DrawParameters } from "../../core/draw_parameters";
import { Entity } from "../entity"; import { Entity } from "../entity";
import { enumDirectionToVector, enumDirectionToAngle } from "../../core/vector"; import { directionAngleMap, directionVectorMap } from "../../core/vector";
import { ItemAcceptorComponent } from "../components/item_acceptor"; import { ItemAcceptorComponent } from "../components/item_acceptor";
import { Loader } from "../../core/loader"; import { Loader } from "../../core/loader";
import { drawRotatedSprite } from "../../core/draw_utils"; import { drawRotatedSprite } from "../../core/draw_utils";
@ -93,7 +93,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
} }
const slotWorldPos = staticComp.applyRotationToVector(slotData.pos).add(staticComp.origin); const slotWorldPos = staticComp.applyRotationToVector(slotData.pos).add(staticComp.origin);
const fadeOutDirection = enumDirectionToVector[staticComp.localDirectionToWorld(direction)]; const fadeOutDirection = directionVectorMap[staticComp.localDirectionToWorld(direction)];
const finalTile = slotWorldPos.subScalars( const finalTile = slotWorldPos.subScalars(
fadeOutDirection.x * (animProgress / 2 - 0.5), fadeOutDirection.x * (animProgress / 2 - 0.5),
fadeOutDirection.y * (animProgress / 2 - 0.5) fadeOutDirection.y * (animProgress / 2 - 0.5)
@ -131,7 +131,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
} }
const transformedPos = staticComp.localTileToWorld(pos); const transformedPos = staticComp.localTileToWorld(pos);
const angle = enumDirectionToAngle[staticComp.localDirectionToWorld(direction)]; const angle = directionAngleMap[staticComp.localDirectionToWorld(direction)];
// SYNC with systems/belt.js:drawSingleEntity! // SYNC with systems/belt.js:drawSingleEntity!
const animationIndex = Math.floor( const animationIndex = Math.floor(

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

@ -2,7 +2,7 @@ import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters"; import { DrawParameters } from "../../core/draw_parameters";
import { createLogger } from "../../core/logging"; import { createLogger } from "../../core/logging";
import { Rectangle } from "../../core/rectangle"; import { Rectangle } from "../../core/rectangle";
import { enumDirectionToVector, Vector } from "../../core/vector"; import { directionRotationMap, directionVectorMap } from "../../core/vector";
import { BaseItem, enumItemType, enumItemTypeToLayer } from "../base_item"; import { BaseItem, enumItemType, enumItemTypeToLayer } from "../base_item";
import { ItemEjectorComponent } from "../components/item_ejector"; import { ItemEjectorComponent } from "../components/item_ejector";
import { Entity } from "../entity"; import { Entity } from "../entity";
@ -133,7 +133,7 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
// Figure out where and into which direction we eject items // Figure out where and into which direction we eject items
const ejectSlotWsTile = staticComp.localTileToWorld(ejectorSlot.pos); const ejectSlotWsTile = staticComp.localTileToWorld(ejectorSlot.pos);
const ejectSlotWsDirection = staticComp.localDirectionToWorld(ejectorSlot.direction); const ejectSlotWsDirection = staticComp.localDirectionToWorld(ejectorSlot.direction);
const ejectSlotWsDirectionVector = enumDirectionToVector[ejectSlotWsDirection]; const ejectSlotWsDirectionVector = directionVectorMap[ejectSlotWsDirection];
const ejectSlotTargetWsTile = ejectSlotWsTile.add(ejectSlotWsDirectionVector); const ejectSlotTargetWsTile = ejectSlotWsTile.add(ejectSlotWsDirectionVector);
// Try to find the given acceptor component to take the item // Try to find the given acceptor component to take the item
@ -372,11 +372,8 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
} }
const realPosition = slot.pos.rotateFastMultipleOf90(staticComp.rotation); const realPosition = slot.pos.rotateFastMultipleOf90(staticComp.rotation);
const realDirection = Vector.transformDirectionFromMultipleOf90( const realDirection = directionRotationMap[slot.direction][staticComp.rotation];
slot.direction, const realDirectionVector = directionVectorMap[realDirection];
staticComp.rotation
);
const realDirectionVector = enumDirectionToVector[realDirection];
const tileX = const tileX =
staticComp.origin.x + realPosition.x + 0.5 + realDirectionVector.x * 0.5 * slot.progress; staticComp.origin.x + realPosition.x + 0.5 + realDirectionVector.x * 0.5 * slot.progress;

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

@ -1,6 +1,6 @@
import { globalConfig } from "../../core/config"; import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters"; import { DrawParameters } from "../../core/draw_parameters";
import { enumDirectionToVector } from "../../core/vector"; import { directionVectorMap } from "../../core/vector";
import { BaseItem } from "../base_item"; import { BaseItem } from "../base_item";
import { MinerComponent } from "../components/miner"; import { MinerComponent } from "../components/miner";
import { Entity } from "../entity"; import { Entity } from "../entity";
@ -74,7 +74,7 @@ export class MinerSystem extends GameSystemWithFilter {
const ejectingPos = staticComp.localTileToWorld(ejectingSlot.pos); const ejectingPos = staticComp.localTileToWorld(ejectingSlot.pos);
const ejectingDirection = staticComp.localDirectionToWorld(ejectingSlot.direction); const ejectingDirection = staticComp.localDirectionToWorld(ejectingSlot.direction);
const targetTile = ejectingPos.add(enumDirectionToVector[ejectingDirection]); const targetTile = ejectingPos.add(directionVectorMap[ejectingDirection]);
const targetContents = this.root.map.getTileContent(targetTile, enumLayer.regular); const targetContents = this.root.map.getTileContent(targetTile, enumLayer.regular);
// Check if we are connected to another miner and thus do not eject directly // Check if we are connected to another miner and thus do not eject directly

7
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 { globalConfig } from "../../core/config";
import { MapChunkView } from "../map_chunk_view"; import { MapChunkView } from "../map_chunk_view";
import { Loader } from "../../core/loader"; import { Loader } from "../../core/loader";
import { enumDirection } from "../../core/vector";
import { enumLayer } from "../root"; import { enumLayer } from "../root";
export class StaticMapEntitySystem extends GameSystem { export class StaticMapEntitySystem extends GameSystem {
@ -11,9 +10,9 @@ export class StaticMapEntitySystem extends GameSystem {
super(root); super(root);
this.beltOverviewSprites = { this.beltOverviewSprites = {
[enumDirection.top]: Loader.getSprite("sprites/map_overview/belt_forward.png"), top: Loader.getSprite("sprites/map_overview/belt_forward.png"),
[enumDirection.right]: Loader.getSprite("sprites/map_overview/belt_right.png"), right: Loader.getSprite("sprites/map_overview/belt_right.png"),
[enumDirection.left]: Loader.getSprite("sprites/map_overview/belt_left.png"), left: Loader.getSprite("sprites/map_overview/belt_left.png"),
}; };
} }

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

@ -3,11 +3,10 @@ import { Loader } from "../../core/loader";
import { createLogger } from "../../core/logging"; import { createLogger } from "../../core/logging";
import { Rectangle } from "../../core/rectangle"; import { Rectangle } from "../../core/rectangle";
import { import {
enumAngleToDirection, angleDirectionMap,
enumDirection, directionAngleMap,
enumDirectionToAngle, directionVectorMap,
enumDirectionToVector, invertedDirectionMap,
enumInvertedDirections,
} from "../../core/vector"; } from "../../core/vector";
import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt"; import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
import { Entity } from "../entity"; import { Entity } from "../entity";
@ -82,9 +81,9 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
const staticComp = entity.components.StaticMapEntity; const staticComp = entity.components.StaticMapEntity;
const tile = staticComp.origin; const tile = staticComp.origin;
const direction = enumAngleToDirection[staticComp.rotation]; const direction = angleDirectionMap[staticComp.rotation];
const inverseDirection = enumInvertedDirections[direction]; const inverseDirection = invertedDirectionMap[direction];
const offset = enumDirectionToVector[inverseDirection]; const offset = directionVectorMap[inverseDirection];
let currentPos = tile.copy(); let currentPos = tile.copy();
@ -107,7 +106,7 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
contentsUndergroundComp && contentsUndergroundComp &&
contentsUndergroundComp.tier === undergroundComp.tier && contentsUndergroundComp.tier === undergroundComp.tier &&
contentsUndergroundComp.mode === enumUndergroundBeltMode.sender && contentsUndergroundComp.mode === enumUndergroundBeltMode.sender &&
enumAngleToDirection[contentsStaticComp.rotation] === direction angleDirectionMap[contentsStaticComp.rotation] === direction
) { ) {
matchingEntrance = { matchingEntrance = {
entity: contents, entity: contents,
@ -144,8 +143,8 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
// It's a belt // It's a belt
if ( if (
contentsBeltComp.direction !== enumDirection.top || contentsBeltComp.direction !== "top" ||
enumAngleToDirection[contentsStaticComp.rotation] !== direction angleDirectionMap[contentsStaticComp.rotation] !== direction
) { ) {
allBeltsMatch = false; allBeltsMatch = false;
break; break;
@ -208,8 +207,8 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
const staticAfter = entityAfter.components.StaticMapEntity; const staticAfter = entityAfter.components.StaticMapEntity;
if ( if (
enumAngleToDirection[staticBefore.rotation] !== direction || angleDirectionMap[staticBefore.rotation] !== direction ||
enumAngleToDirection[staticAfter.rotation] !== direction angleDirectionMap[staticAfter.rotation] !== direction
) { ) {
// Wrong rotation // Wrong rotation
continue; continue;
@ -285,9 +284,9 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
findRecieverForSender(entity) { findRecieverForSender(entity) {
const staticComp = entity.components.StaticMapEntity; const staticComp = entity.components.StaticMapEntity;
const undergroundComp = entity.components.UndergroundBelt; const undergroundComp = entity.components.UndergroundBelt;
const searchDirection = staticComp.localDirectionToWorld(enumDirection.top); const searchDirection = staticComp.localDirectionToWorld("top");
const searchVector = enumDirectionToVector[searchDirection]; const searchVector = directionVectorMap[searchDirection];
const targetRotation = enumDirectionToAngle[searchDirection]; const targetRotation = directionAngleMap[searchDirection];
let currentTile = staticComp.origin; let currentTile = staticComp.origin;
// Search in the direction of the tunnel // Search in the direction of the tunnel

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

@ -460,7 +460,7 @@ export class TypeEnum extends BaseDataType {
*/ */
constructor(enumeration = {}) { constructor(enumeration = {}) {
super(); super();
this.availableValues = Object.keys(enumeration); this.availableValues = Object.values(enumeration);
} }
serialize(value) { serialize(value) {
@ -488,7 +488,7 @@ export class TypeEnum extends BaseDataType {
} }
verifySerializedValue(value) { verifySerializedValue(value) {
if (this.availableValues.indexOf(value) < 0) { if (!this.availableValues.includes(value)) {
return "Unknown enum value: " + value; return "Unknown enum value: " + value;
} }
} }