} uids
*/
- onBuildingsSelected(uids) {
+ createBlueprintFromBuildings(uids) {
if (uids.length === 0) {
return;
}
this.currentBlueprint.set(Blueprint.fromUids(this.root, uids));
}
+ /**
+ * Attempts to rotate the current blueprint
+ */
rotateBlueprint() {
if (this.currentBlueprint.get()) {
if (this.root.keyMapper.getBinding(KEYMAPPINGS.placement.rotateInverseModifier).pressed) {
@@ -139,8 +163,17 @@ export class HUDBlueprintPlacer extends BaseHUDPart {
}
}
+ /**
+ * Attempts to paste the last blueprint
+ */
pasteBlueprint() {
if (this.lastBlueprintUsed !== null) {
+ if (this.lastBlueprintUsed.layer !== this.root.currentLayer) {
+ // Not compatible
+ this.root.soundProxy.playUiError();
+ return;
+ }
+
this.root.hud.signals.pasteBlueprintRequested.dispatch();
this.currentBlueprint.set(this.lastBlueprintUsed);
} else {
diff --git a/src/js/game/hud/parts/building_placer.js b/src/js/game/hud/parts/building_placer.js
index 0e9752ef..d3a3c7ac 100644
--- a/src/js/game/hud/parts/building_placer.js
+++ b/src/js/game/hud/parts/building_placer.js
@@ -1,9 +1,9 @@
-import { Math_radians } from "../../../core/builtins";
-import { globalConfig } from "../../../core/config";
+import { ClickDetector } from "../../../core/click_detector";
+import { globalConfig, THIRDPARTY_URLS } from "../../../core/config";
import { DrawParameters } from "../../../core/draw_parameters";
-import { drawRotatedSprite } from "../../../core/draw_utils";
+import { drawRotatedSprite, rotateTrapezRightFaced } from "../../../core/draw_utils";
import { Loader } from "../../../core/loader";
-import { makeDiv, removeAllChildren, pulseAnimation, clamp } from "../../../core/utils";
+import { clamp, makeDiv, removeAllChildren } from "../../../core/utils";
import {
enumDirectionToAngle,
enumDirectionToVector,
@@ -16,7 +16,8 @@ import { defaultBuildingVariant } from "../../meta_building";
import { THEME } from "../../theme";
import { DynamicDomAttach } from "../dynamic_dom_attach";
import { HUDBuildingPlacerLogic } from "./building_placer_logic";
-import { ClickDetector } from "../../../core/click_detector";
+import { makeOffscreenBuffer } from "../../../core/buffer_utils";
+import { enumLayer } from "../../root";
export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
/**
@@ -50,13 +51,19 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
// Bind to signals
this.signals.variantChanged.add(this.rerenderVariants, this);
+ this.root.hud.signals.buildingSelectedForPlacement.add(this.startSelection, this);
this.domAttach = new DynamicDomAttach(this.root, this.element, {});
this.variantsAttach = new DynamicDomAttach(this.root, this.variantsElement, {});
this.currentInterpolatedCornerTile = new Vector();
- this.lockIndicatorSprite = Loader.getSprite("sprites/misc/lock_direction_indicator.png");
+ this.lockIndicatorSprites = {};
+ for (const layerId in enumLayer) {
+ this.lockIndicatorSprites[layerId] = this.makeLockIndicatorSprite(layerId);
+ }
+
+ //
/**
* Stores the click detectors for the variants so we can clean them up later
@@ -65,6 +72,37 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
this.variantClickDetectors = [];
}
+ /**
+ * Makes the lock indicator sprite for the given layer
+ * @param {enumLayer} layer
+ */
+ makeLockIndicatorSprite(layer) {
+ const dims = 48;
+ const [canvas, context] = makeOffscreenBuffer(dims, dims, {
+ smooth: true,
+ reusable: false,
+ label: "lock-direction-indicator",
+ });
+
+ // Loader.getSprite("sprites/misc/lock_direction_indicator.png").draw(context, 0, 0, 48, 48);
+ context.fillStyle = THEME.map.directionLock[enumLayer.wires].color;
+ context.strokeStyle = THEME.map.directionLock[enumLayer.wires].color;
+ context.lineWidth = 2;
+
+ const padding = 5;
+ const height = dims * 0.5;
+ const bottom = (dims + height) / 2;
+
+ context.moveTo(padding, bottom);
+ context.lineTo(dims / 2, bottom - height);
+ context.lineTo(dims - padding, bottom);
+ context.closePath();
+ context.stroke();
+ context.fill();
+
+ return canvas;
+ }
+
/**
* Rerenders the building info dialog
*/
@@ -178,7 +216,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
consumeEvents: true,
targetOnly: true,
});
- detector.click.add(() => this.currentVariant.set(variant));
+ detector.click.add(() => this.setVariant(variant));
}
}
@@ -230,12 +268,13 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
rotation,
rotationVariant,
connectedEntities,
- } = metaBuilding.computeOptimalDirectionAndRotationVariantAtTile(
- this.root,
- mouseTile,
- this.currentBaseRotation,
- this.currentVariant.get()
- );
+ } = metaBuilding.computeOptimalDirectionAndRotationVariantAtTile({
+ root: this.root,
+ tile: mouseTile,
+ rotation: this.currentBaseRotation,
+ variant: this.currentVariant.get(),
+ layer: metaBuilding.getLayer(),
+ });
// Check if there are connected entities
if (connectedEntities) {
@@ -275,14 +314,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
staticComp.tileSize = metaBuilding.getDimensions(this.currentVariant.get());
metaBuilding.updateVariants(this.fakeEntity, rotationVariant, this.currentVariant.get());
- // Check if we could place the buildnig
- const canBuild = this.root.logic.checkCanPlaceBuilding({
- origin: mouseTile,
- rotation,
- rotationVariant,
- building: metaBuilding,
- variant: this.currentVariant.get(),
- });
+ const canBuild = this.root.logic.checkCanPlaceEntity(this.fakeEntity);
// Fade in / out
parameters.context.lineWidth = 1;
@@ -334,8 +366,8 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const mouseWorld = this.root.camera.screenToWorld(mousePosition);
const mouseTile = mouseWorld.toTileSpace();
- parameters.context.fillStyle = THEME.map.directionLock;
- parameters.context.strokeStyle = THEME.map.directionLockTrack;
+ parameters.context.fillStyle = THEME.map.directionLock[this.root.currentLayer].color;
+ parameters.context.strokeStyle = THEME.map.directionLock[this.root.currentLayer].background;
parameters.context.lineWidth = 10;
parameters.context.beginCircle(mouseWorld.x, mouseWorld.y, 4);
@@ -358,23 +390,28 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
parameters.context.beginCircle(endLine.x, endLine.y, 5);
parameters.context.fill();
- // Draw arrows
+ // Draw arrow
+ const arrowSprite = this.lockIndicatorSprites[this.root.currentLayer];
const path = this.computeDirectionLockPath();
for (let i = 0; i < path.length - 1; i += 1) {
const { rotation, tile } = path[i];
const worldPos = tile.toWorldSpaceCenterOfTile();
- drawRotatedSprite({
- parameters,
- sprite: this.lockIndicatorSprite,
- x: worldPos.x,
- y: worldPos.y,
- angle: Math_radians(rotation),
- size: 12,
- offsetY:
- -globalConfig.halfTileSize -
+ const angle = Math.radians(rotation);
+
+ parameters.context.translate(worldPos.x, worldPos.y);
+ parameters.context.rotate(angle);
+ parameters.context.drawImage(
+ arrowSprite,
+ -6,
+ -globalConfig.halfTileSize -
clamp((this.root.time.realtimeNow() * 1.5) % 1.0, 0, 1) * 1 * globalConfig.tileSize +
- globalConfig.halfTileSize,
- });
+ globalConfig.halfTileSize -
+ 6,
+ 12,
+ 12
+ );
+ parameters.context.rotate(-angle);
+ parameters.context.translate(-worldPos.x, -worldPos.y);
}
}
}
@@ -390,7 +427,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const goodArrowSprite = Loader.getSprite("sprites/misc/slot_good_arrow.png");
const badArrowSprite = Loader.getSprite("sprites/misc/slot_bad_arrow.png");
- // Just ignore this code ...
+ // Just ignore the following code please ... thanks!
const offsetShift = 10;
@@ -398,9 +435,16 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const slots = acceptorComp.slots;
for (let acceptorSlotIndex = 0; acceptorSlotIndex < slots.length; ++acceptorSlotIndex) {
const slot = slots[acceptorSlotIndex];
+
+ // Only draw same layer slots
+ if (slot.layer !== this.root.currentLayer) {
+ continue;
+ }
+
const acceptorSlotWsTile = staticComp.localTileToWorld(slot.pos);
const acceptorSlotWsPos = acceptorSlotWsTile.toWorldSpaceCenterOfTile();
+ // Go over all slots
for (
let acceptorDirectionIndex = 0;
acceptorDirectionIndex < slot.directions.length;
@@ -409,30 +453,54 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const direction = slot.directions[acceptorDirectionIndex];
const worldDirection = staticComp.localDirectionToWorld(direction);
+ // Figure out which tile ejects to this slot
const sourceTile = acceptorSlotWsTile.add(enumDirectionToVector[worldDirection]);
- const sourceEntity = this.root.map.getTileContent(sourceTile);
- let sprite = goodArrowSprite;
- let alpha = 0.5;
+ let isBlocked = false;
+ let isConnected = false;
- if (sourceEntity) {
- sprite = badArrowSprite;
+ // Find all entities which are on that tile
+ const sourceEntities = this.root.map.getLayersContentsMultipleXY(
+ sourceTile.x,
+ sourceTile.y
+ );
+
+ // Check for every entity:
+ for (let i = 0; i < sourceEntities.length; ++i) {
+ const sourceEntity = sourceEntities[i];
const sourceEjector = sourceEntity.components.ItemEjector;
const sourceStaticComp = sourceEntity.components.StaticMapEntity;
const ejectorAcceptLocalTile = sourceStaticComp.worldToLocalTile(acceptorSlotWsTile);
- if (sourceEjector && sourceEjector.anySlotEjectsToLocalTile(ejectorAcceptLocalTile)) {
- sprite = goodArrowSprite;
+
+ // If this entity is on the same layer as the slot - if so, it can either be
+ // connected, or it can not be connected and thus block the input
+ if (sourceEntity.layer === slot.layer) {
+ if (
+ sourceEjector &&
+ sourceEjector.anySlotEjectsToLocalTile(
+ ejectorAcceptLocalTile,
+ this.root.currentLayer
+ )
+ ) {
+ // This one is connected, all good
+ isConnected = true;
+ } else {
+ // This one is blocked
+ isBlocked = true;
+ }
}
- alpha = 1.0;
}
+ const alpha = isConnected || isBlocked ? 1.0 : 0.3;
+ const sprite = isBlocked ? badArrowSprite : goodArrowSprite;
+
parameters.context.globalAlpha = alpha;
drawRotatedSprite({
parameters,
sprite,
x: acceptorSlotWsPos.x,
y: acceptorSlotWsPos.y,
- angle: Math_radians(enumDirectionToAngle[enumInvertedDirections[worldDirection]]),
+ angle: Math.radians(enumDirectionToAngle[enumInvertedDirections[worldDirection]]),
size: 13,
offsetY: offsetShift + 13,
});
@@ -443,8 +511,15 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
if (ejectorComp) {
const slots = ejectorComp.slots;
+
+ // Go over all slots
for (let ejectorSlotIndex = 0; ejectorSlotIndex < slots.length; ++ejectorSlotIndex) {
- const slot = ejectorComp.slots[ejectorSlotIndex];
+ const slot = slots[ejectorSlotIndex];
+
+ // Only draw same layer slots
+ if (slot.layer !== this.root.currentLayer) {
+ continue;
+ }
const ejectorSlotWsTile = staticComp.localTileToWorld(
ejectorComp.getSlotTargetLocalTile(ejectorSlotIndex)
@@ -452,33 +527,49 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const ejectorSLotWsPos = ejectorSlotWsTile.toWorldSpaceCenterOfTile();
const ejectorSlotWsDirection = staticComp.localDirectionToWorld(slot.direction);
- const destEntity = this.root.map.getTileContent(ejectorSlotWsTile);
+ let isBlocked = false;
+ let isConnected = false;
- let sprite = goodArrowSprite;
- let alpha = 0.5;
- if (destEntity) {
- alpha = 1;
+ // Find all entities which are on that tile
+ const destEntities = this.root.map.getLayersContentsMultipleXY(
+ ejectorSlotWsTile.x,
+ ejectorSlotWsTile.y
+ );
+
+ // Check for every entity:
+ for (let i = 0; i < destEntities.length; ++i) {
+ const destEntity = destEntities[i];
const destAcceptor = destEntity.components.ItemAcceptor;
const destStaticComp = destEntity.components.StaticMapEntity;
- if (destAcceptor) {
+ // If this entity is on the same layer as the slot - if so, it can either be
+ // connected, or it can not be connected and thus block the input
+ if (destEntity.layer === slot.layer) {
const destLocalTile = destStaticComp.worldToLocalTile(ejectorSlotWsTile);
const destLocalDir = destStaticComp.worldDirectionToLocal(ejectorSlotWsDirection);
- if (destAcceptor.findMatchingSlot(destLocalTile, destLocalDir)) {
- sprite = goodArrowSprite;
+ if (
+ destAcceptor &&
+ destAcceptor.findMatchingSlot(destLocalTile, destLocalDir, this.root.currentLayer)
+ ) {
+ // This one is connected, all good
+ isConnected = true;
} else {
- sprite = badArrowSprite;
+ // This one is blocked
+ isBlocked = true;
}
}
}
+ const alpha = isConnected || isBlocked ? 1.0 : 0.3;
+ const sprite = isBlocked ? badArrowSprite : goodArrowSprite;
+
parameters.context.globalAlpha = alpha;
drawRotatedSprite({
parameters,
sprite,
x: ejectorSLotWsPos.x,
y: ejectorSLotWsPos.y,
- angle: Math_radians(enumDirectionToAngle[ejectorSlotWsDirection]),
+ angle: Math.radians(enumDirectionToAngle[ejectorSlotWsDirection]),
size: 13,
offsetY: offsetShift,
});
diff --git a/src/js/game/hud/parts/building_placer_logic.js b/src/js/game/hud/parts/building_placer_logic.js
index 337e43f7..f0266b77 100644
--- a/src/js/game/hud/parts/building_placer_logic.js
+++ b/src/js/game/hud/parts/building_placer_logic.js
@@ -1,4 +1,3 @@
-import { Math_abs, Math_degrees, Math_round } from "../../../core/builtins";
import { globalConfig } from "../../../core/config";
import { gMetaBuildingRegistry } from "../../../core/global_registries";
import { Signal, STOP_PROPAGATION } from "../../../core/signal";
@@ -13,7 +12,7 @@ import { BaseHUDPart } from "../base_hud_part";
import { SOUNDS } from "../../../platform/sound";
import { MetaMinerBuilding, enumMinerVariants } from "../../buildings/miner";
import { enumHubGoalRewards } from "../../tutorial_goals";
-import { enumEditMode } from "../../root";
+import { enumLayer } from "../../root";
/**
* Contains all logic for the building placer - this doesn't include the rendering
@@ -93,6 +92,12 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
*/
this.currentDirectionLockSide = 0;
+ /**
+ * Whether the side for direction lock has not yet been determined.
+ * @type {boolean}
+ */
+ this.currentDirectionLockSideIndeterminate = true;
+
this.initializeBindings();
}
@@ -126,12 +131,12 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
/**
* Called when the edit mode got changed
- * @param {enumEditMode} editMode
+ * @param {enumLayer} editMode
*/
onEditModeChanged(editMode) {
const metaBuilding = this.currentMetaBuilding.get();
if (metaBuilding) {
- if (metaBuilding.getEditLayer() !== editMode) {
+ if (metaBuilding.getLayer() !== editMode) {
// This layer doesn't fit the edit mode anymore
this.currentMetaBuilding.set(null);
}
@@ -205,6 +210,17 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
const worldPos = this.root.camera.screenToWorld(mousePosition);
const mouseTile = worldPos.toTileSpace();
+ // Figure initial direction
+ const dx = Math.abs(this.lastDragTile.x - mouseTile.x);
+ const dy = Math.abs(this.lastDragTile.y - mouseTile.y);
+ if (dx === 0 && dy === 0) {
+ // Back at the start. Try a new direction.
+ this.currentDirectionLockSideIndeterminate = true;
+ } else if (this.currentDirectionLockSideIndeterminate) {
+ this.currentDirectionLockSideIndeterminate = false;
+ this.currentDirectionLockSide = dx <= dy ? 0 : 1;
+ }
+
if (this.currentDirectionLockSide === 0) {
return new Vector(this.lastDragTile.x, mouseTile.y);
} else {
@@ -277,7 +293,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
const worldPos = this.root.camera.screenToWorld(mousePosition);
const tile = worldPos.toTileSpace();
- const contents = this.root.map.getTileContent(tile);
+ const contents = this.root.map.getTileContent(tile, this.root.currentLayer);
if (contents) {
if (this.root.logic.tryDeleteBuilding(contents)) {
this.root.soundProxy.playUi(SOUNDS.destroyBuilding);
@@ -303,7 +319,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
const worldPos = this.root.camera.screenToWorld(mousePosition);
const tile = worldPos.toTileSpace();
- const contents = this.root.map.getTileContent(tile);
+ const contents = this.root.map.getTileContent(tile, this.root.currentLayer);
if (!contents) {
const tileBelow = this.root.map.getLowerLayerContentXY(tile.x, tile.y);
@@ -323,7 +339,13 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
// Try to extract the building
const extracted = this.hack_reconstructMetaBuildingAndVariantFromBuilding(contents);
- if (!extracted) {
+
+ // If the building we are picking is the same as the one we have, clear the cursor.
+ if (
+ !extracted ||
+ (extracted.metaBuilding === this.currentMetaBuilding.get() &&
+ extracted.variant === this.currentVariant.get())
+ ) {
this.currentMetaBuilding.set(null);
return;
}
@@ -331,11 +353,6 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
this.currentMetaBuilding.set(extracted.metaBuilding);
this.currentVariant.set(extracted.variant);
this.currentBaseRotation = contents.components.StaticMapEntity.rotation;
-
- // Make sure we selected something, and also make sure it's not a special entity
- // if (contents && !contents.components.Unremovable) {
-
- // }
}
/**
@@ -444,12 +461,13 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
}
const metaBuilding = this.currentMetaBuilding.get();
- const { rotation, rotationVariant } = metaBuilding.computeOptimalDirectionAndRotationVariantAtTile(
- this.root,
+ const { rotation, rotationVariant } = metaBuilding.computeOptimalDirectionAndRotationVariantAtTile({
+ root: this.root,
tile,
- this.currentBaseRotation,
- this.currentVariant.get()
- );
+ rotation: this.currentBaseRotation,
+ variant: this.currentVariant.get(),
+ layer: metaBuilding.getLayer(),
+ });
const entity = this.root.logic.tryPlaceBuilding({
origin: tile,
@@ -505,12 +523,21 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
);
const newIndex = (index + 1) % availableVariants.length;
const newVariant = availableVariants[newIndex];
- this.currentVariant.set(newVariant);
-
- this.preferredVariants[metaBuilding.getId()] = newVariant;
+ this.setVariant(newVariant);
}
}
+ /**
+ * Sets the current variant to the given variant
+ * @param {string} variant
+ */
+ setVariant(variant) {
+ const metaBuilding = this.currentMetaBuilding.get();
+ this.currentVariant.set(variant);
+
+ this.preferredVariants[metaBuilding.getId()] = variant;
+ }
+
/**
* Performs the direction locked placement between two points after
* releasing the mouse
@@ -559,16 +586,23 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
// Figure which points the line visits
const worldPos = this.root.camera.screenToWorld(mousePosition);
- const mouseTile = worldPos.toTileSpace();
- const startTile = this.lastDragTile;
+ let endTile = worldPos.toTileSpace();
+ let startTile = this.lastDragTile;
+
+ // if the alt key is pressed, reverse belt planner direction by switching start and end tile
+ if (this.root.keyMapper.getBinding(KEYMAPPINGS.placementModifiers.placeInverse).pressed) {
+ let tmp = startTile;
+ startTile = endTile;
+ endTile = tmp;
+ }
// Place from start to corner
const pathToCorner = this.currentDirectionLockCorner.sub(startTile);
const deltaToCorner = pathToCorner.normalize().round();
- const lengthToCorner = Math_round(pathToCorner.length());
+ const lengthToCorner = Math.round(pathToCorner.length());
let currentPos = startTile.copy();
- let rotation = (Math.round(Math_degrees(deltaToCorner.angle()) / 90) * 90 + 360) % 360;
+ let rotation = (Math.round(Math.degrees(deltaToCorner.angle()) / 90) * 90 + 360) % 360;
if (lengthToCorner > 0) {
for (let i = 0; i < lengthToCorner; ++i) {
@@ -581,12 +615,12 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
}
// Place from corner to end
- const pathFromCorner = mouseTile.sub(this.currentDirectionLockCorner);
+ const pathFromCorner = endTile.sub(this.currentDirectionLockCorner);
const deltaFromCorner = pathFromCorner.normalize().round();
- const lengthFromCorner = Math_round(pathFromCorner.length());
+ const lengthFromCorner = Math.round(pathFromCorner.length());
if (lengthFromCorner > 0) {
- rotation = (Math.round(Math_degrees(deltaFromCorner.angle()) / 90) * 90 + 360) % 360;
+ rotation = (Math.round(Math.degrees(deltaFromCorner.angle()) / 90) * 90 + 360) % 360;
for (let i = 0; i < lengthFromCorner + 1; ++i) {
result.push({
tile: currentPos.copy(),
@@ -722,7 +756,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
).pressed
) {
const delta = newPos.sub(oldPos);
- const angleDeg = Math_degrees(delta.angle());
+ const angleDeg = Math.degrees(delta.angle());
this.currentBaseRotation = (Math.round(angleDeg / 90) * 90 + 360) % 360;
// Holding alt inverts the placement
@@ -737,8 +771,8 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
let x1 = newPos.x;
let y1 = newPos.y;
- var dx = Math_abs(x1 - x0);
- var dy = Math_abs(y1 - y0);
+ var dx = Math.abs(x1 - x0);
+ var dy = Math.abs(y1 - y0);
var sx = x0 < x1 ? 1 : -1;
var sy = y0 < y1 ? 1 : -1;
var err = dx - dy;
@@ -749,7 +783,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
while (this.currentlyDeleting || this.currentMetaBuilding.get()) {
if (this.currentlyDeleting) {
// Deletion
- const contents = this.root.map.getTileContentXY(x0, y0);
+ const contents = this.root.map.getLayerContentXY(x0, y0, this.root.currentLayer);
if (contents && !contents.queuedForDestroy && !contents.destroyed) {
if (this.root.logic.tryDeleteBuilding(contents)) {
anythingDeleted = true;
diff --git a/src/js/game/hud/parts/buildings_toolbar.js b/src/js/game/hud/parts/buildings_toolbar.js
index d8b56943..c46a5c98 100644
--- a/src/js/game/hud/parts/buildings_toolbar.js
+++ b/src/js/game/hud/parts/buildings_toolbar.js
@@ -9,10 +9,11 @@ import { MetaSplitterBuilding } from "../../buildings/splitter";
import { MetaStackerBuilding } from "../../buildings/stacker";
import { MetaTrashBuilding } from "../../buildings/trash";
import { MetaUndergroundBeltBuilding } from "../../buildings/underground_belt";
-import { enumEditMode } from "../../root";
+import { enumLayer } from "../../root";
import { HUDBaseToolbar } from "./base_toolbar";
+import { MetaAdvancedProcessorBuilding } from "../../buildings/advanced_processor";
-const toolbarBuildings = [
+const supportedBuildings = [
MetaBeltBaseBuilding,
MetaSplitterBuilding,
MetaUndergroundBeltBuilding,
@@ -23,15 +24,18 @@ const toolbarBuildings = [
MetaMixerBuilding,
MetaPainterBuilding,
MetaTrashBuilding,
+
MetaEnergyGenerator,
+ MetaAdvancedProcessorBuilding,
];
export class HUDBuildingsToolbar extends HUDBaseToolbar {
constructor(root) {
- super(
- root,
- toolbarBuildings,
- () => !this.root.camera.getIsMapOverlayActive() && this.root.editMode === enumEditMode.regular
- );
+ super(root, {
+ supportedBuildings,
+ visibilityCondition: () =>
+ !this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === enumLayer.regular,
+ htmlElementId: "ingame_HUD_buildings_toolbar",
+ });
}
}
diff --git a/src/js/game/hud/parts/color_blind_helper.js b/src/js/game/hud/parts/color_blind_helper.js
index 4e6a0229..c7dd6288 100644
--- a/src/js/game/hud/parts/color_blind_helper.js
+++ b/src/js/game/hud/parts/color_blind_helper.js
@@ -7,6 +7,8 @@ import { DrawParameters } from "../../../core/draw_parameters";
import { THEME } from "../../theme";
import { globalConfig } from "../../../core/config";
import { T } from "../../../translations";
+import { enumItemType } from "../../base_item";
+import { enumLayer } from "../../root";
export class HUDColorBlindHelper extends BaseHUDPart {
createElements(parent) {
@@ -39,18 +41,23 @@ export class HUDColorBlindHelper extends BaseHUDPart {
return null;
}
+ if (this.root.currentLayer !== enumLayer.regular) {
+ // Not in regular mode
+ return null;
+ }
+
const worldPos = this.root.camera.screenToWorld(mousePosition);
const tile = worldPos.toTileSpace();
- const contents = this.root.map.getTileContent(tile);
+ const contents = this.root.map.getTileContent(tile, this.root.currentLayer);
if (contents && !contents.components.Miner) {
const beltComp = contents.components.Belt;
// Check if the belt has a color item
if (beltComp) {
- const firstItem = beltComp.sortedItems[0];
- if (firstItem && firstItem[1] instanceof ColorItem) {
- return firstItem[1].color;
+ const item = beltComp.assignedPath.findItemAtTile(tile);
+ if (item && item.getItemType() === enumItemType.color) {
+ return /** @type {ColorItem} */ (item).color;
}
}
@@ -59,16 +66,19 @@ export class HUDColorBlindHelper extends BaseHUDPart {
if (ejectorComp) {
for (let i = 0; i < ejectorComp.slots.length; ++i) {
const slot = ejectorComp.slots[i];
- if (slot.item && slot.item instanceof ColorItem) {
- return slot.item.color;
+ if (slot.layer !== this.root.currentLayer) {
+ continue;
+ }
+ if (slot.item && slot.item.getItemType() === enumItemType.color) {
+ return /** @type {ColorItem} */ (slot.item).color;
}
}
}
} else {
// We hovered a lower layer, show the color there
const lowerLayer = this.root.map.getLowerLayerContentXY(tile.x, tile.y);
- if (lowerLayer && lowerLayer instanceof ColorItem) {
- return lowerLayer.color;
+ if (lowerLayer && lowerLayer.getItemType() === enumItemType.color) {
+ return /** @type {ColorItem} */ (lowerLayer).color;
}
}
diff --git a/src/js/game/hud/parts/debug_changes.js b/src/js/game/hud/parts/debug_changes.js
index 46ad5234..1502afa2 100644
--- a/src/js/game/hud/parts/debug_changes.js
+++ b/src/js/game/hud/parts/debug_changes.js
@@ -27,7 +27,7 @@ export class HUDChangesDebugger extends BaseHUDPart {
* @param {string} fillColor Color to display (Hex)
* @param {number=} timeToDisplay How long to display the change
*/
- renderChange(label, area, fillColor, timeToDisplay = 2) {
+ renderChange(label, area, fillColor, timeToDisplay = 0.3) {
this.changes.push({
label,
area: area.clone(),
diff --git a/src/js/game/hud/parts/debug_info.js b/src/js/game/hud/parts/debug_info.js
index 4f4c052e..cdd00540 100644
--- a/src/js/game/hud/parts/debug_info.js
+++ b/src/js/game/hud/parts/debug_info.js
@@ -1,45 +1,122 @@
import { BaseHUDPart } from "../base_hud_part";
import { makeDiv, round3Digits, round2Digits } from "../../../core/utils";
-import { Math_round } from "../../../core/builtins";
import { DynamicDomAttach } from "../dynamic_dom_attach";
import { KEYMAPPINGS } from "../../key_action_mapper";
+import { Vector } from "../../../core/vector";
+import { TrackedState } from "../../../core/tracked_state";
+
+/** @enum {string} */
+const enumDebugOverlayMode = { disabled: "disabled", regular: "regular", detailed: "detailed" };
+
+/**
+ * Specifies which mode follows after which mode
+ * @enum {enumDebugOverlayMode}
+ */
+const enumDebugOverlayModeNext = {
+ [enumDebugOverlayMode.disabled]: enumDebugOverlayMode.regular,
+ [enumDebugOverlayMode.regular]: enumDebugOverlayMode.detailed,
+ [enumDebugOverlayMode.detailed]: enumDebugOverlayMode.disabled,
+};
+
+const UPDATE_INTERVAL_SECONDS = 0.25;
export class HUDDebugInfo extends BaseHUDPart {
createElements(parent) {
this.element = makeDiv(parent, "ingame_HUD_DebugInfo", []);
- this.tickRateElement = makeDiv(this.element, null, ["tickRate"], "Ticks /s: 120");
- this.fpsElement = makeDiv(this.element, null, ["fps"], "FPS: 60");
- this.tickDurationElement = makeDiv(this.element, null, ["tickDuration"], "Update time: 0.5ms");
+ const tickRateElement = makeDiv(this.element, null, ["tickRate"]);
+ this.trackedTickRate = new TrackedState(str => (tickRateElement.innerText = str));
+
+ const tickDurationElement = makeDiv(this.element, null, ["tickDuration"]);
+ this.trackedTickDuration = new TrackedState(str => (tickDurationElement.innerText = str));
+
+ const fpsElement = makeDiv(this.element, null, ["fps"]);
+ this.trackedFPS = new TrackedState(str => (fpsElement.innerText = str));
+
+ const mousePositionElement = makeDiv(this.element, null, ["mousePosition"]);
+ this.trackedMousePosition = new TrackedState(str => (mousePositionElement.innerHTML = str));
+
+ const cameraPositionElement = makeDiv(this.element, null, ["cameraPosition"]);
+ this.trackedCameraPosition = new TrackedState(str => (cameraPositionElement.innerHTML = str));
+
+ this.versionElement = makeDiv(this.element, null, ["version"], "version unknown");
}
initialize() {
this.lastTick = 0;
- this.visible = false;
+ this.trackedMode = new TrackedState(this.onModeChanged, this);
this.domAttach = new DynamicDomAttach(this.root, this.element);
- this.root.keyMapper.getBinding(KEYMAPPINGS.ingame.toggleFPSInfo).add(() => this.toggle());
+ this.root.keyMapper.getBinding(KEYMAPPINGS.ingame.toggleFPSInfo).add(() => this.cycleModes());
+
+ // Set initial mode
+ this.trackedMode.set(enumDebugOverlayMode.disabled);
}
- toggle() {
- this.visible = !this.visible;
- this.domAttach.update(this.visible);
+ /**
+ * Called when the mode changed
+ * @param {enumDebugOverlayMode} mode
+ */
+ onModeChanged(mode) {
+ this.element.setAttribute("data-mode", mode);
+ this.versionElement.innerText = `${G_BUILD_VERSION} @ ${G_APP_ENVIRONMENT} @ ${G_BUILD_COMMIT_HASH}`;
+ }
+
+ /**
+ * Updates the labels
+ */
+ updateLabels() {
+ this.trackedTickRate.set("Tickrate: " + this.root.dynamicTickrate.currentTickRate);
+ this.trackedFPS.set(
+ "FPS: " +
+ Math.round(this.root.dynamicTickrate.averageFps) +
+ " (" +
+ round2Digits(1000 / this.root.dynamicTickrate.averageFps) +
+ " ms)"
+ );
+ this.trackedTickDuration.set(
+ "Tick: " + round3Digits(this.root.dynamicTickrate.averageTickDuration) + "ms"
+ );
+ }
+
+ /**
+ * Updates the detailed information
+ */
+ updateDetailedInformation() {
+ const mousePos = this.root.app.mousePosition || new Vector(0, 0);
+ const mouseTile = this.root.camera.screenToWorld(mousePos).toTileSpace();
+ const cameraTile = this.root.camera.center.toTileSpace();
+
+ this.trackedMousePosition.set(`Pos: ${mouseTile.x} / ${mouseTile.y}`);
+ this.trackedCameraPosition.set(`Center: ${cameraTile.x} / ${cameraTile.y}`);
+ }
+
+ /**
+ * Cycles through the different modes
+ */
+ cycleModes() {
+ this.trackedMode.set(enumDebugOverlayModeNext[this.trackedMode.get()]);
}
update() {
+ const visible = this.trackedMode.get() !== enumDebugOverlayMode.disabled;
+ this.domAttach.update(visible);
+
+ if (!visible) {
+ return;
+ }
+
+ // Periodically update the text
const now = this.root.time.realtimeNow();
- if (now - this.lastTick > 0.25 && this.visible) {
+ if (now - this.lastTick > UPDATE_INTERVAL_SECONDS) {
this.lastTick = now;
- this.tickRateElement.innerText = "Tickrate: " + this.root.dynamicTickrate.currentTickRate;
- this.fpsElement.innerText =
- "FPS: " +
- Math_round(this.root.dynamicTickrate.averageFps) +
- " (" +
- round2Digits(1000 / this.root.dynamicTickrate.averageFps) +
- " ms)";
- this.tickDurationElement.innerText =
- "Tick Dur: " + round3Digits(this.root.dynamicTickrate.averageTickDuration) + "ms";
+ this.updateLabels();
+ }
+
+ // Also update detailed information if required
+ if (this.trackedMode.get() === enumDebugOverlayMode.detailed) {
+ this.updateDetailedInformation();
}
}
}
diff --git a/src/js/game/hud/parts/entity_debugger.js b/src/js/game/hud/parts/entity_debugger.js
index 1293d79b..9fe1bd7c 100644
--- a/src/js/game/hud/parts/entity_debugger.js
+++ b/src/js/game/hud/parts/entity_debugger.js
@@ -36,7 +36,7 @@ export class HUDEntityDebugger extends BaseHUDPart {
this.mousePosElem.innerText = worldTile.x + " / " + worldTile.y;
this.chunkPosElem.innerText = chunk.x + " / " + chunk.y;
- const entity = this.root.map.getTileContent(worldTile);
+ const entity = this.root.map.getTileContent(worldTile, this.root.currentLayer);
if (entity) {
removeAllChildren(this.entityInfoElem);
let html = "Entity";
diff --git a/src/js/game/hud/parts/mass_selector.js b/src/js/game/hud/parts/mass_selector.js
index a3505e2d..68d480e4 100644
--- a/src/js/game/hud/parts/mass_selector.js
+++ b/src/js/game/hud/parts/mass_selector.js
@@ -13,6 +13,7 @@ import { T } from "../../../translations";
import { KEYMAPPINGS } from "../../key_action_mapper";
import { THEME } from "../../theme";
import { enumHubGoalRewards } from "../../tutorial_goals";
+import { Blueprint } from "../../blueprint";
const logger = createLogger("hud/mass_selector");
@@ -41,6 +42,7 @@ export class HUDMassSelector extends BaseHUDPart {
this.root.keyMapper.getBinding(KEYMAPPINGS.massSelect.massSelectCopy).add(this.startCopy, this);
this.root.hud.signals.selectedPlacementBuildingChanged.add(this.clearSelection, this);
+ this.root.signals.editModeChanged.add(this.clearSelection, this);
}
/**
@@ -145,16 +147,30 @@ export class HUDMassSelector extends BaseHUDPart {
if (this.selectedUids.size > 0) {
const entityUids = Array.from(this.selectedUids);
- // copy code relies on entities still existing, so must copy before deleting.
- this.root.hud.signals.buildingsSelectedForCopy.dispatch(entityUids);
+ const cutAction = () => {
+ // copy code relies on entities still existing, so must copy before deleting.
+ this.root.hud.signals.buildingsSelectedForCopy.dispatch(entityUids);
- for (let i = 0; i < entityUids.length; ++i) {
- const uid = entityUids[i];
- const entity = this.root.entityMgr.findByUid(uid);
- if (!this.root.logic.tryDeleteBuilding(entity)) {
- logger.error("Error in mass cut, could not remove building");
- this.selectedUids.delete(uid);
+ for (let i = 0; i < entityUids.length; ++i) {
+ const uid = entityUids[i];
+ const entity = this.root.entityMgr.findByUid(uid);
+ if (!this.root.logic.tryDeleteBuilding(entity)) {
+ logger.error("Error in mass cut, could not remove building");
+ this.selectedUids.delete(uid);
+ }
}
+ };
+
+ const blueprint = Blueprint.fromUids(this.root, entityUids);
+ if (blueprint.canAfford(this.root)) {
+ cutAction();
+ } else {
+ const { cancel, ok } = this.root.hud.parts.dialogs.showWarning(
+ T.dialogs.massCutInsufficientConfirm.title,
+ T.dialogs.massCutInsufficientConfirm.desc,
+ ["cancel:good:escape", "ok:bad:enter"]
+ );
+ ok.add(cutAction);
}
this.root.soundProxy.playUiClick();
@@ -210,7 +226,7 @@ export class HUDMassSelector extends BaseHUDPart {
for (let x = realTileStart.x; x <= realTileEnd.x; ++x) {
for (let y = realTileStart.y; y <= realTileEnd.y; ++y) {
- const contents = this.root.map.getTileContentXY(x, y);
+ const contents = this.root.map.getLayerContentXY(x, y, this.root.currentLayer);
if (contents && this.root.logic.canDeleteBuilding(contents)) {
this.selectedUids.add(contents.uid);
}
@@ -259,7 +275,7 @@ export class HUDMassSelector extends BaseHUDPart {
for (let x = realTileStart.x; x <= realTileEnd.x; ++x) {
for (let y = realTileStart.y; y <= realTileEnd.y; ++y) {
- const contents = this.root.map.getTileContentXY(x, y);
+ const contents = this.root.map.getLayerContentXY(x, y, this.root.currentLayer);
if (contents && this.root.logic.canDeleteBuilding(contents)) {
const staticComp = contents.components.StaticMapEntity;
const bounds = staticComp.getTileSpaceBounds();
diff --git a/src/js/game/hud/parts/pinned_shapes.js b/src/js/game/hud/parts/pinned_shapes.js
index 3f935a0b..bda49f1e 100644
--- a/src/js/game/hud/parts/pinned_shapes.js
+++ b/src/js/game/hud/parts/pinned_shapes.js
@@ -1,4 +1,3 @@
-import { Math_max } from "../../../core/builtins";
import { ClickDetector } from "../../../core/click_detector";
import { formatBigNumber, makeDiv, arrayDelete, arrayDeleteValue } from "../../../core/utils";
import { ShapeDefinition } from "../../shape_definition";
diff --git a/src/js/game/hud/parts/processing_overlay.js b/src/js/game/hud/parts/processing_overlay.js
index 3354966a..95383dfd 100644
--- a/src/js/game/hud/parts/processing_overlay.js
+++ b/src/js/game/hud/parts/processing_overlay.js
@@ -1,6 +1,5 @@
import { DynamicDomAttach } from "../dynamic_dom_attach";
import { BaseHUDPart } from "../base_hud_part";
-import { performanceNow } from "../../../core/builtins";
import { makeDiv } from "../../../core/utils";
import { Signal } from "../../../core/signal";
import { InputReceiver } from "../../../core/input_receiver";
@@ -62,15 +61,15 @@ export class HUDProcessingOverlay extends BaseHUDPart {
}
processSync() {
- const now = performanceNow();
+ const now = performance.now();
while (this.tasks.length > 0) {
const workload = this.tasks[0];
workload.call();
this.tasks.shift();
}
- const duration = performanceNow() - now;
+ const duration = performance.now() - now;
if (duration > 100) {
- logger.log("Tasks done slow (SYNC!) within", (performanceNow() - now).toFixed(2), "ms");
+ logger.log("Tasks done slow (SYNC!) within", (performance.now() - now).toFixed(2), "ms");
}
}
@@ -89,15 +88,15 @@ export class HUDProcessingOverlay extends BaseHUDPart {
}
this.computeTimeout = setTimeout(() => {
- const now = performanceNow();
+ const now = performance.now();
while (this.tasks.length > 0) {
const workload = this.tasks[0];
workload.call();
this.tasks.shift();
}
- const duration = performanceNow() - now;
+ const duration = performance.now() - now;
if (duration > 100) {
- logger.log("Tasks done slow within", (performanceNow() - now).toFixed(2), "ms");
+ logger.log("Tasks done slow within", (performance.now() - now).toFixed(2), "ms");
}
this.domWatcher.update(false);
diff --git a/src/js/game/hud/parts/sandbox_controller.js b/src/js/game/hud/parts/sandbox_controller.js
new file mode 100644
index 00000000..6bf277bb
--- /dev/null
+++ b/src/js/game/hud/parts/sandbox_controller.js
@@ -0,0 +1,158 @@
+import { BaseHUDPart } from "../base_hud_part";
+import { makeDiv } from "../../../core/utils";
+import { DynamicDomAttach } from "../dynamic_dom_attach";
+import { blueprintShape, UPGRADES } from "../../upgrades";
+import { enumNotificationType } from "./notifications";
+import { tutorialGoals } from "../../tutorial_goals";
+
+export class HUDSandboxController extends BaseHUDPart {
+ createElements(parent) {
+ this.element = makeDiv(
+ parent,
+ "ingame_HUD_SandboxController",
+ [],
+ `
+
+ Use F6 to toggle this overlay
+
+
+ `
+ );
+
+ const bind = (selector, handler) => this.trackClicks(this.element.querySelector(selector), handler);
+
+ bind(".giveBlueprints", this.giveBlueprints);
+ bind(".maxOutAll", this.maxOutAll);
+ bind(".levelToggle .minus", () => this.modifyLevel(-1));
+ bind(".levelToggle .plus", () => this.modifyLevel(1));
+
+ bind(".upgradesBelt .minus", () => this.modifyUpgrade("belt", -1));
+ bind(".upgradesBelt .plus", () => this.modifyUpgrade("belt", 1));
+
+ bind(".upgradesExtraction .minus", () => this.modifyUpgrade("miner", -1));
+ bind(".upgradesExtraction .plus", () => this.modifyUpgrade("miner", 1));
+
+ bind(".upgradesProcessing .minus", () => this.modifyUpgrade("processors", -1));
+ bind(".upgradesProcessing .plus", () => this.modifyUpgrade("processors", 1));
+
+ bind(".upgradesPainting .minus", () => this.modifyUpgrade("painting", -1));
+ bind(".upgradesPainting .plus", () => this.modifyUpgrade("painting", 1));
+ }
+
+ giveBlueprints() {
+ if (!this.root.hubGoals.storedShapes[blueprintShape]) {
+ this.root.hubGoals.storedShapes[blueprintShape] = 0;
+ }
+ this.root.hubGoals.storedShapes[blueprintShape] += 1e4;
+ }
+
+ maxOutAll() {
+ this.modifyUpgrade("belt", 100);
+ this.modifyUpgrade("miner", 100);
+ this.modifyUpgrade("processors", 100);
+ this.modifyUpgrade("painting", 100);
+ }
+
+ modifyUpgrade(id, amount) {
+ const handle = UPGRADES[id];
+ const maxLevel = handle.tiers.length;
+
+ this.root.hubGoals.upgradeLevels[id] = Math.max(
+ 0,
+ Math.min(maxLevel, (this.root.hubGoals.upgradeLevels[id] || 0) + amount)
+ );
+
+ // Compute improvement
+ let improvement = 1;
+ for (let i = 0; i < this.root.hubGoals.upgradeLevels[id]; ++i) {
+ improvement += handle.tiers[i].improvement;
+ }
+ this.root.hubGoals.upgradeImprovements[id] = improvement;
+ this.root.signals.upgradePurchased.dispatch(id);
+ this.root.hud.signals.notification.dispatch(
+ "Upgrade '" + id + "' is now at level " + this.root.hubGoals.upgradeLevels[id],
+ enumNotificationType.upgrade
+ );
+ }
+
+ modifyLevel(amount) {
+ const hubGoals = this.root.hubGoals;
+ hubGoals.level = Math.max(1, hubGoals.level + amount);
+ hubGoals.createNextGoal();
+
+ // Clear all shapes of this level
+ hubGoals.storedShapes[hubGoals.currentGoal.definition.getHash()] = 0;
+
+ this.root.hud.parts.pinnedShapes.rerenderFull();
+
+ // Compute gained rewards
+ hubGoals.gainedRewards = {};
+ for (let i = 0; i < hubGoals.level - 1; ++i) {
+ if (i < tutorialGoals.length) {
+ const reward = tutorialGoals[i].reward;
+ hubGoals.gainedRewards[reward] = (hubGoals.gainedRewards[reward] || 0) + 1;
+ }
+ }
+
+ this.root.hud.signals.notification.dispatch(
+ "Changed level to " + hubGoals.level,
+ enumNotificationType.upgrade
+ );
+ }
+
+ initialize() {
+ // Allow toggling the controller overlay
+ this.root.gameState.inputReciever.keydown.add(key => {
+ if (key.keyCode === 117) {
+ // F6
+ this.toggle();
+ }
+ });
+
+ this.visible = !G_IS_DEV;
+ this.domAttach = new DynamicDomAttach(this.root, this.element);
+ }
+
+ toggle() {
+ this.visible = !this.visible;
+ }
+
+ update() {
+ this.domAttach.update(this.visible);
+ }
+}
diff --git a/src/js/game/hud/parts/screenshot_exporter.js b/src/js/game/hud/parts/screenshot_exporter.js
index 8623f902..19c644e9 100644
--- a/src/js/game/hud/parts/screenshot_exporter.js
+++ b/src/js/game/hud/parts/screenshot_exporter.js
@@ -5,7 +5,6 @@ import { T } from "../../../translations";
import { createLogger } from "../../../core/logging";
import { StaticMapEntityComponent } from "../../components/static_map_entity";
import { Vector } from "../../../core/vector";
-import { Math_max, Math_min, Math_floor } from "../../../core/builtins";
import { makeOffscreenBuffer } from "../../../core/buffer_utils";
import { DrawParameters } from "../../../core/draw_parameters";
import { Rectangle } from "../../../core/rectangle";
@@ -43,11 +42,11 @@ export class HUDScreenshotExporter extends BaseHUDPart {
const maxTile = new Vector(0, 0);
for (let i = 0; i < staticEntities.length; ++i) {
const bounds = staticEntities[i].components.StaticMapEntity.getTileSpaceBounds();
- minTile.x = Math_min(minTile.x, bounds.x);
- minTile.y = Math_min(minTile.y, bounds.y);
+ minTile.x = Math.min(minTile.x, bounds.x);
+ minTile.y = Math.min(minTile.y, bounds.y);
- maxTile.x = Math_max(maxTile.x, bounds.x + bounds.w);
- maxTile.y = Math_max(maxTile.y, bounds.y + bounds.h);
+ maxTile.x = Math.max(maxTile.x, bounds.x + bounds.w);
+ maxTile.y = Math.max(maxTile.y, bounds.y + bounds.h);
}
const minChunk = minTile.divideScalar(globalConfig.mapChunkSize).floor();
@@ -57,10 +56,10 @@ export class HUDScreenshotExporter extends BaseHUDPart {
logger.log("Dimensions:", dimensions);
let chunkSizePixels = 128;
- const maxDimensions = Math_max(dimensions.x, dimensions.y);
+ const maxDimensions = Math.max(dimensions.x, dimensions.y);
if (maxDimensions > 128) {
- chunkSizePixels = Math_max(1, Math_floor(128 * (128 / maxDimensions)));
+ chunkSizePixels = Math.max(1, Math.floor(128 * (128 / maxDimensions)));
}
logger.log("ChunkSizePixels:", chunkSizePixels);
diff --git a/src/js/game/hud/parts/shop.js b/src/js/game/hud/parts/shop.js
index f83cb89b..e2b8837b 100644
--- a/src/js/game/hud/parts/shop.js
+++ b/src/js/game/hud/parts/shop.js
@@ -1,4 +1,3 @@
-import { Math_min } from "../../../core/builtins";
import { ClickDetector } from "../../../core/click_detector";
import { InputReceiver } from "../../../core/input_receiver";
import { formatBigNumber, makeDiv } from "../../../core/utils";
@@ -178,7 +177,7 @@ export class HUDShop extends BaseHUDPart {
const { progressLabel, progressBar, definition, required } = handle.requireIndexToElement[i];
const haveAmount = this.root.hubGoals.getShapesStored(definition);
- const progress = Math_min(haveAmount / required, 1.0);
+ const progress = Math.min(haveAmount / required, 1.0);
progressLabel.innerText = formatBigNumber(haveAmount) + " / " + formatBigNumber(required);
progressBar.style.width = progress * 100.0 + "%";
@@ -198,6 +197,7 @@ export class HUDShop extends BaseHUDPart {
this.keyActionMapper = new KeyActionMapper(this.root, this.inputReciever);
this.keyActionMapper.getBinding(KEYMAPPINGS.general.back).add(this.close, this);
+ this.keyActionMapper.getBinding(KEYMAPPINGS.ingame.menuClose).add(this.close, this);
this.keyActionMapper.getBinding(KEYMAPPINGS.ingame.menuOpenShop).add(this.close, this);
this.close();
diff --git a/src/js/game/hud/parts/statistics.js b/src/js/game/hud/parts/statistics.js
index fc19b3fd..e1a747a2 100644
--- a/src/js/game/hud/parts/statistics.js
+++ b/src/js/game/hud/parts/statistics.js
@@ -1,4 +1,3 @@
-import { Math_min } from "../../../core/builtins";
import { InputReceiver } from "../../../core/input_receiver";
import { makeButton, makeDiv, removeAllChildren, capitalizeFirstLetter } from "../../../core/utils";
import { KeyActionMapper, KEYMAPPINGS } from "../../key_action_mapper";
@@ -82,6 +81,7 @@ export class HUDStatistics extends BaseHUDPart {
this.keyActionMapper = new KeyActionMapper(this.root, this.inputReciever);
this.keyActionMapper.getBinding(KEYMAPPINGS.general.back).add(this.close, this);
+ this.keyActionMapper.getBinding(KEYMAPPINGS.ingame.menuClose).add(this.close, this);
this.keyActionMapper.getBinding(KEYMAPPINGS.ingame.menuOpenStats).add(this.close, this);
/** @type {Object.} */
@@ -179,7 +179,7 @@ export class HUDStatistics extends BaseHUDPart {
let rendered = new Set();
- for (let i = 0; i < Math_min(entries.length, 200); ++i) {
+ for (let i = 0; i < Math.min(entries.length, 200); ++i) {
const entry = entries[i];
const shapeKey = entry[0];
diff --git a/src/js/game/hud/parts/statistics_handle.js b/src/js/game/hud/parts/statistics_handle.js
index d3612d92..d5c60d3b 100644
--- a/src/js/game/hud/parts/statistics_handle.js
+++ b/src/js/game/hud/parts/statistics_handle.js
@@ -1,10 +1,10 @@
+import { makeOffscreenBuffer } from "../../../core/buffer_utils";
+import { globalConfig } from "../../../core/config";
+import { clamp, formatBigNumber, round2Digits } from "../../../core/utils";
+import { T } from "../../../translations";
+import { enumAnalyticsDataSource } from "../../production_analytics";
import { GameRoot } from "../../root";
import { ShapeDefinition } from "../../shape_definition";
-import { enumAnalyticsDataSource } from "../../production_analytics";
-import { formatBigNumber, clamp } from "../../../core/utils";
-import { globalConfig } from "../../../core/config";
-import { makeOffscreenBuffer } from "../../../core/buffer_utils";
-import { T } from "../../../translations";
/** @enum {string} */
export const enumDisplayMode = {
@@ -91,6 +91,11 @@ export class HUDShapeStatisticsHandle {
"",
formatBigNumber(rate)
);
+
+ if (G_IS_DEV && globalConfig.debug.detailedStatistics) {
+ this.counter.innerText = "" + round2Digits(rate / 60) + " /s";
+ }
+
break;
}
}
diff --git a/src/js/game/hud/parts/waypoints.js b/src/js/game/hud/parts/waypoints.js
index 2472e57a..8cab85c5 100644
--- a/src/js/game/hud/parts/waypoints.js
+++ b/src/js/game/hud/parts/waypoints.js
@@ -1,5 +1,4 @@
import { makeOffscreenBuffer } from "../../../core/buffer_utils";
-import { Math_max, Math_PI, Math_radians } from "../../../core/builtins";
import { globalConfig, IS_DEMO } from "../../../core/config";
import { DrawParameters } from "../../../core/draw_parameters";
import { Loader } from "../../../core/loader";
@@ -112,7 +111,7 @@ export class HUDWaypoints extends BaseHUDPart {
this.root.camera.downPreHandler.add(this.onMouseDown, this);
this.root.keyMapper
.getBinding(KEYMAPPINGS.navigation.createMarker)
- .add(this.requestCreateMarker, this);
+ .add(() => this.requestSaveMarker({}));
/**
* Stores at how much opacity the markers should be rendered on the map.
@@ -153,15 +152,24 @@ export class HUDWaypoints extends BaseHUDPart {
if (ShapeDefinition.isValidShortKey(label)) {
const canvas = this.getWaypointCanvas(waypoint);
- element.appendChild(canvas);
+ /**
+ * Create a clone of the cached canvas, as calling appendElement when a canvas is
+ * already in the document will move the existing canvas to the new position.
+ */
+ const [newCanvas, context] = makeOffscreenBuffer(48, 48, {
+ smooth: true,
+ label: label + "-waypoint-" + i,
+ });
+ context.drawImage(canvas, 0, 0);
+ element.appendChild(newCanvas);
element.classList.add("shapeIcon");
} else {
element.innerText = label;
}
if (this.isWaypointDeletable(waypoint)) {
- const deleteButton = makeDiv(element, null, ["deleteButton"]);
- this.trackClicks(deleteButton, () => this.deleteWaypoint(waypoint));
+ const editButton = makeDiv(element, null, ["editButton"]);
+ this.trackClicks(editButton, () => this.requestSaveMarker({ waypoint }));
}
if (!waypoint.label) {
@@ -212,42 +220,61 @@ export class HUDWaypoints extends BaseHUDPart {
}
/**
- * Requests to create a marker at the current camera position. If worldPos is set,
+ * Requests to save a marker at the current camera position. If worldPos is set,
* uses that position instead.
- * @param {Vector=} worldPos Override the world pos, otherwise it is the camera position
+ * @param {object} param0
+ * @param {Vector=} param0.worldPos Override the world pos, otherwise it is the camera position
+ * @param {Waypoint=} param0.waypoint Waypoint to be edited. If omitted, create new
*/
- requestCreateMarker(worldPos = null) {
+ requestSaveMarker({ worldPos = null, waypoint = null }) {
// Construct dialog with input field
const markerNameInput = new FormElementInput({
id: "markerName",
label: null,
placeholder: "",
+ defaultValue: waypoint ? waypoint.label : "",
validator: val =>
val.length > 0 && (val.length < MAX_LABEL_LENGTH || ShapeDefinition.isValidShortKey(val)),
});
const dialog = new DialogWithForm({
app: this.root.app,
- title: T.dialogs.createMarker.title,
+ title: waypoint ? T.dialogs.createMarker.titleEdit : T.dialogs.createMarker.title,
desc: T.dialogs.createMarker.desc,
formElements: [markerNameInput],
+ buttons: waypoint ? ["delete:bad", "cancel", "ok:good"] : ["cancel", "ok:good"],
});
this.root.hud.parts.dialogs.internalShowDialog(dialog);
- // Compute where to create the marker
- const center = worldPos || this.root.camera.center;
+ // Edit marker
+ if (waypoint) {
+ dialog.buttonSignals.ok.add(() => {
+ // Actually rename the waypoint
+ this.renameWaypoint(waypoint, markerNameInput.getValue());
+ });
+ dialog.buttonSignals.delete.add(() => {
+ // Actually delete the waypoint
+ this.deleteWaypoint(waypoint);
+ });
+ } else {
+ // Compute where to create the marker
+ const center = worldPos || this.root.camera.center;
- dialog.buttonSignals.ok.add(() => {
- // Show info that you can have only N markers in the demo,
- // actually show this *after* entering the name so you want the
- // standalone even more (I'm evil :P)
- if (IS_DEMO && this.waypoints.length > 2) {
- this.root.hud.parts.dialogs.showFeatureRestrictionInfo("", T.dialogs.markerDemoLimit.desc);
- return;
- }
+ dialog.buttonSignals.ok.add(() => {
+ // Show info that you can have only N markers in the demo,
+ // actually show this *after* entering the name so you want the
+ // standalone even more (I'm evil :P)
+ if (IS_DEMO && this.waypoints.length > 2) {
+ this.root.hud.parts.dialogs.showFeatureRestrictionInfo(
+ "",
+ T.dialogs.markerDemoLimit.desc
+ );
+ return;
+ }
- // Actually create the waypoint
- this.addWaypoint(markerNameInput.getValue(), center);
- });
+ // Actually create the waypoint
+ this.addWaypoint(markerNameInput.getValue(), center);
+ });
+ }
}
/**
@@ -261,21 +288,10 @@ export class HUDWaypoints extends BaseHUDPart {
center: { x: position.x, y: position.y },
// Make sure the zoom is *just* a bit above the zoom level where the map overview
// starts, so you always see all buildings
- zoomLevel: Math_max(this.root.camera.zoomLevel, globalConfig.mapChunkOverviewMinZoom + 0.05),
+ zoomLevel: Math.max(this.root.camera.zoomLevel, globalConfig.mapChunkOverviewMinZoom + 0.05),
});
- // Sort waypoints by name
- this.waypoints.sort((a, b) => {
- if (!a.label) {
- return -1;
- }
- if (!b.label) {
- return 1;
- }
- return this.getWaypointLabel(a)
- .padEnd(MAX_LABEL_LENGTH, "0")
- .localeCompare(this.getWaypointLabel(b).padEnd(MAX_LABEL_LENGTH, "0"));
- });
+ this.sortWaypoints();
// Show notification about creation
this.root.hud.signals.notification.dispatch(
@@ -287,6 +303,26 @@ export class HUDWaypoints extends BaseHUDPart {
this.rerenderWaypointList();
}
+ /**
+ * Renames a waypoint with the given label
+ * @param {Waypoint} waypoint
+ * @param {string} label
+ */
+ renameWaypoint(waypoint, label) {
+ waypoint.label = label;
+
+ this.sortWaypoints();
+
+ // Show notification about renamed
+ this.root.hud.signals.notification.dispatch(
+ T.ingame.waypoints.creationSuccessNotification,
+ enumNotificationType.success
+ );
+
+ // Re-render the list and thus add it
+ this.rerenderWaypointList();
+ }
+
/**
* Called every frame to update stuff
*/
@@ -296,6 +332,23 @@ export class HUDWaypoints extends BaseHUDPart {
}
}
+ /**
+ * Sort waypoints by name
+ */
+ sortWaypoints() {
+ this.waypoints.sort((a, b) => {
+ if (!a.label) {
+ return -1;
+ }
+ if (!b.label) {
+ return 1;
+ }
+ return this.getWaypointLabel(a)
+ .padEnd(MAX_LABEL_LENGTH, "0")
+ .localeCompare(this.getWaypointLabel(b).padEnd(MAX_LABEL_LENGTH, "0"));
+ });
+ }
+
/**
* Returns the label for a given waypoint
* @param {Waypoint} waypoint
@@ -373,7 +426,7 @@ export class HUDWaypoints extends BaseHUDPart {
} else if (button === enumMouseButton.right) {
if (this.isWaypointDeletable(waypoint)) {
this.root.soundProxy.playUiClick();
- this.deleteWaypoint(waypoint);
+ this.requestSaveMarker({ waypoint });
} else {
this.root.soundProxy.playUiError();
}
@@ -385,7 +438,7 @@ export class HUDWaypoints extends BaseHUDPart {
if (button === enumMouseButton.right) {
if (this.root.camera.getIsMapOverlayActive()) {
const worldPos = this.root.camera.screenToWorld(pos);
- this.requestCreateMarker(worldPos);
+ this.requestSaveMarker({ worldPos });
return STOP_PROPAGATION;
}
}
@@ -410,7 +463,7 @@ export class HUDWaypoints extends BaseHUDPart {
if (this.currentCompassOpacity > 0.01) {
context.globalAlpha = this.currentCompassOpacity;
- const angle = cameraPos.angle() + Math_radians(45) + Math_PI / 2;
+ const angle = cameraPos.angle() + Math.radians(45) + Math.PI / 2;
context.translate(dims / 2, dims / 2);
context.rotate(angle);
this.directionIndicatorSprite.drawCentered(context, 0, 0, indicatorSize);
diff --git a/src/js/game/hud/parts/wires_overlay.js b/src/js/game/hud/parts/wires_overlay.js
index 0d228509..8bda5d0d 100644
--- a/src/js/game/hud/parts/wires_overlay.js
+++ b/src/js/game/hud/parts/wires_overlay.js
@@ -2,11 +2,13 @@ import { makeOffscreenBuffer } from "../../../core/buffer_utils";
import { globalConfig } from "../../../core/config";
import { DrawParameters } from "../../../core/draw_parameters";
import { KEYMAPPINGS } from "../../key_action_mapper";
-import { enumEditMode } from "../../root";
+import { enumLayer } from "../../root";
import { THEME } from "../../theme";
import { BaseHUDPart } from "../base_hud_part";
+import { Loader } from "../../../core/loader";
+import { lerp } from "../../../core/utils";
-const wiresBackgroundDpi = 3;
+const wiresBackgroundDpi = 4;
export class HUDWiresOverlay extends BaseHUDPart {
createElements(parent) {}
@@ -16,49 +18,52 @@ export class HUDWiresOverlay extends BaseHUDPart {
this.root.keyMapper.getBinding(KEYMAPPINGS.ingame.switchLayers).add(this.switchLayers, this);
this.generateTilePattern();
+
+ this.currentAlpha = 0.0;
}
/**
* Switches between layers
*/
switchLayers() {
- if (this.root.editMode === enumEditMode.regular) {
- this.root.editMode = enumEditMode.wires;
+ if (this.root.currentLayer === enumLayer.regular) {
+ this.root.currentLayer = enumLayer.wires;
} else {
- this.root.editMode = enumEditMode.regular;
+ this.root.currentLayer = enumLayer.regular;
}
- this.root.signals.editModeChanged.dispatch(this.root.editMode);
+ this.root.signals.editModeChanged.dispatch(this.root.currentLayer);
}
/**
* Generates the background pattern for the wires overlay
*/
generateTilePattern() {
+ const overlayTile = Loader.getSprite("sprites/misc/wires_overlay_tile.png");
const dims = globalConfig.tileSize * wiresBackgroundDpi;
const [canvas, context] = makeOffscreenBuffer(dims, dims, {
smooth: false,
reusable: false,
label: "wires-tile-pattern",
});
-
- context.scale(wiresBackgroundDpi, wiresBackgroundDpi);
- context.fillStyle = THEME.map.wires.overlay;
- context.fillRect(0, 0, globalConfig.tileSize, globalConfig.tileSize);
-
- const lineWidth = 1;
-
- context.fillRect(0, 0, globalConfig.tileSize, lineWidth);
- context.fillRect(0, lineWidth, lineWidth, globalConfig.tileSize);
-
+ overlayTile.draw(context, 0, 0, dims, dims);
this.tilePatternCanvas = canvas;
}
+ update() {
+ const desiredAlpha = this.root.currentLayer === enumLayer.wires ? 1.0 : 0.0;
+ this.currentAlpha = lerp(this.currentAlpha, desiredAlpha, 0.12);
+ }
+
/**
*
* @param {DrawParameters} parameters
*/
draw(parameters) {
- if (this.root.editMode !== enumEditMode.wires) {
+ if (this.currentAlpha < 0.02) {
+ return;
+ }
+
+ if (this.root.camera.getIsMapOverlayActive()) {
return;
}
@@ -70,6 +75,8 @@ export class HUDWiresOverlay extends BaseHUDPart {
const scaleFactor = 1 / wiresBackgroundDpi;
+ parameters.context.globalAlpha = 0.9 * this.currentAlpha;
+ parameters.context.globalCompositeOperation = "darken";
parameters.context.scale(scaleFactor, scaleFactor);
parameters.context.fillStyle = this.cachedPatternBackground;
parameters.context.fillRect(
@@ -79,5 +86,12 @@ export class HUDWiresOverlay extends BaseHUDPart {
bounds.h / scaleFactor
);
parameters.context.scale(1 / scaleFactor, 1 / scaleFactor);
+ parameters.context.globalCompositeOperation = "source-over";
+ parameters.context.globalAlpha = 1;
+
+ // parameters.context.fillStyle = "#3a85bf";
+ // parameters.context.globalAlpha = 0.0 * this.currentAlpha;
+ // parameters.context.fillRect(bounds.x, bounds.y, bounds.w, bounds.h);
+ // parameters.context.globalAlpha = 1;
}
}
diff --git a/src/js/game/hud/parts/wires_toolbar.js b/src/js/game/hud/parts/wires_toolbar.js
new file mode 100644
index 00000000..6ebc0a98
--- /dev/null
+++ b/src/js/game/hud/parts/wires_toolbar.js
@@ -0,0 +1,17 @@
+import { MetaWireBaseBuilding } from "../../buildings/wire_base";
+import { enumLayer } from "../../root";
+import { HUDBaseToolbar } from "./base_toolbar";
+import { MetaWireCrossingsBuilding } from "../../buildings/wire_crossings";
+
+const supportedBuildings = [MetaWireBaseBuilding, MetaWireCrossingsBuilding];
+
+export class HUDWiresToolbar extends HUDBaseToolbar {
+ constructor(root) {
+ super(root, {
+ supportedBuildings,
+ visibilityCondition: () =>
+ !this.root.camera.getIsMapOverlayActive() && this.root.currentLayer === enumLayer.wires,
+ htmlElementId: "ingame_HUD_wires_toolbar",
+ });
+ }
+}
diff --git a/src/js/game/hud/trailer_maker.js b/src/js/game/hud/trailer_maker.js
index 72509b93..2834b40d 100644
--- a/src/js/game/hud/trailer_maker.js
+++ b/src/js/game/hud/trailer_maker.js
@@ -1,7 +1,6 @@
-import { GameRoot } from "../root";
+import { GameRoot, enumLayer } from "../root";
import { globalConfig } from "../../core/config";
import { Vector, mixVector } from "../../core/vector";
-import { performanceNow } from "../../core/builtins";
import { lerp } from "../../core/utils";
/* dev:start */
@@ -87,18 +86,18 @@ export class TrailerMaker {
if (!nextMarker.startTime) {
console.log("Starting to approach", nextMarker.pos);
- nextMarker.startTime = performanceNow() / 1000.0;
+ nextMarker.startTime = performance.now() / 1000.0;
}
const speed =
globalConfig.tileSize *
globalConfig.beltSpeedItemsPerSecond *
- globalConfig.itemSpacingOnBelts;
+ globalConfig.beltItemSpacingByLayer[enumLayer.regular];
// let time =
// this.currentPlaybackOrigin.distance(Vector.fromSerializedObject(nextMarker.pos)) / speed;
const time = nextMarker.time;
- const progress = (performanceNow() / 1000.0 - nextMarker.startTime) / time;
+ const progress = (performance.now() / 1000.0 - nextMarker.startTime) / time;
if (progress > 1.0) {
if (nextMarker.wait > 0) {
diff --git a/src/js/game/item_registry.js b/src/js/game/item_registry.js
index b6a77836..d483119f 100644
--- a/src/js/game/item_registry.js
+++ b/src/js/game/item_registry.js
@@ -1,8 +1,12 @@
import { gItemRegistry } from "../core/global_registries";
import { ShapeItem } from "./items/shape_item";
import { ColorItem } from "./items/color_item";
+import { PositiveEnergyItem } from "./items/positive_energy_item";
+import { NegativeEnergyItem } from "./items/negative_energy_item";
export function initItemRegistry() {
gItemRegistry.register(ShapeItem);
gItemRegistry.register(ColorItem);
+ gItemRegistry.register(PositiveEnergyItem);
+ gItemRegistry.register(NegativeEnergyItem);
}
diff --git a/src/js/game/items/color_item.js b/src/js/game/items/color_item.js
index b2a3cd74..d1b9a217 100644
--- a/src/js/game/items/color_item.js
+++ b/src/js/game/items/color_item.js
@@ -2,7 +2,7 @@ import { globalConfig } from "../../core/config";
import { smoothenDpi } from "../../core/dpi_manager";
import { DrawParameters } from "../../core/draw_parameters";
import { types } from "../../savegame/serialization";
-import { BaseItem } from "../base_item";
+import { BaseItem, enumItemType } from "../base_item";
import { enumColors, enumColorsToHexCode } from "../colors";
import { THEME } from "../theme";
@@ -23,6 +23,10 @@ export class ColorItem extends BaseItem {
this.color = data;
}
+ getItemType() {
+ return enumItemType.color;
+ }
+
/**
* @param {enumColors} color
*/
diff --git a/src/js/game/items/negative_energy_item.js b/src/js/game/items/negative_energy_item.js
new file mode 100644
index 00000000..99e2cd06
--- /dev/null
+++ b/src/js/game/items/negative_energy_item.js
@@ -0,0 +1,37 @@
+import { DrawParameters } from "../../core/draw_parameters";
+import { Loader } from "../../core/loader";
+import { types } from "../../savegame/serialization";
+import { BaseItem, enumItemType } from "../base_item";
+
+export class NegativeEnergyItem extends BaseItem {
+ static getId() {
+ return "negative_energy";
+ }
+
+ static getSchema() {
+ return types.uint;
+ }
+
+ serialize() {
+ return 0;
+ }
+
+ deserialize(data) {}
+
+ getItemType() {
+ return enumItemType.negativeEnergy;
+ }
+
+ /**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} size
+ * @param {DrawParameters} parameters
+ */
+ draw(x, y, parameters, size = 12) {
+ const sprite = Loader.getSprite("sprites/wires/negative_energy.png");
+ sprite.drawCachedCentered(parameters, x, y, size * 1.5);
+ }
+}
+
+export const NEGATIVE_ENERGY_ITEM_SINGLETON = new NegativeEnergyItem();
diff --git a/src/js/game/items/positive_energy_item.js b/src/js/game/items/positive_energy_item.js
new file mode 100644
index 00000000..260ae149
--- /dev/null
+++ b/src/js/game/items/positive_energy_item.js
@@ -0,0 +1,37 @@
+import { DrawParameters } from "../../core/draw_parameters";
+import { Loader } from "../../core/loader";
+import { types } from "../../savegame/serialization";
+import { BaseItem, enumItemType } from "../base_item";
+
+export class PositiveEnergyItem extends BaseItem {
+ static getId() {
+ return "positive_energy";
+ }
+
+ static getSchema() {
+ return types.uint;
+ }
+
+ serialize() {
+ return 0;
+ }
+
+ deserialize(data) {}
+
+ getItemType() {
+ return enumItemType.positiveEnergy;
+ }
+
+ /**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} size
+ * @param {DrawParameters} parameters
+ */
+ draw(x, y, parameters, size = 12) {
+ const sprite = Loader.getSprite("sprites/wires/positive_energy.png");
+ sprite.drawCachedCentered(parameters, x, y, size * 1.5);
+ }
+}
+
+export const POSITIVE_ENERGY_ITEM_SINGLETON = new PositiveEnergyItem();
diff --git a/src/js/game/items/shape_item.js b/src/js/game/items/shape_item.js
index cfdb9830..2aca63f6 100644
--- a/src/js/game/items/shape_item.js
+++ b/src/js/game/items/shape_item.js
@@ -1,6 +1,6 @@
import { DrawParameters } from "../../core/draw_parameters";
import { types } from "../../savegame/serialization";
-import { BaseItem } from "../base_item";
+import { BaseItem, enumItemType } from "../base_item";
import { ShapeDefinition } from "../shape_definition";
import { THEME } from "../theme";
@@ -21,6 +21,10 @@ export class ShapeItem extends BaseItem {
this.definition = ShapeDefinition.fromShortKey(data);
}
+ getItemType() {
+ return enumItemType.shape;
+ }
+
/**
* @param {ShapeDefinition} definition
*/
diff --git a/src/js/game/key_action_mapper.js b/src/js/game/key_action_mapper.js
index 45949ae3..2dfc5bb1 100644
--- a/src/js/game/key_action_mapper.js
+++ b/src/js/game/key_action_mapper.js
@@ -7,8 +7,6 @@ import { Application } from "../application";
import { Signal, STOP_PROPAGATION } from "../core/signal";
import { IS_MOBILE } from "../core/config";
import { T } from "../translations";
-import { JSON_stringify } from "../core/builtins";
-
function key(str) {
return str.toUpperCase().charCodeAt(0);
}
@@ -22,6 +20,7 @@ export const KEYMAPPINGS = {
ingame: {
menuOpenShop: { keyCode: key("F") },
menuOpenStats: { keyCode: key("G") },
+ menuClose: { keyCode: key("Q") },
toggleHud: { keyCode: 113 }, // F2
exportScreenshot: { keyCode: 114 }, // F3PS
@@ -56,6 +55,11 @@ export const KEYMAPPINGS = {
painter: { keyCode: key("9") },
trash: { keyCode: key("0") },
energy_generator: { keyCode: key("O") },
+ advanced_processor: { keyCode: key("P") },
+
+ // Wires layer
+ wire: { keyCode: key("1") },
+ wire_crossings: { keyCode: key("2") },
},
placement: {
@@ -241,7 +245,6 @@ export function getStringForKeyCode(code) {
return "'";
}
- // TODO
return String.fromCharCode(code);
}
@@ -443,7 +446,7 @@ export class KeyActionMapper {
getBinding(binding) {
// @ts-ignore
const id = binding.id;
- assert(id, "Not a valid keybinding: " + JSON_stringify(binding));
+ assert(id, "Not a valid keybinding: " + JSON.stringify(binding));
assert(this.keybindings[id], "Keybinding " + id + " not known!");
return this.keybindings[id];
}
diff --git a/src/js/game/logic.js b/src/js/game/logic.js
index 5c1bbf66..403fa15b 100644
--- a/src/js/game/logic.js
+++ b/src/js/game/logic.js
@@ -1,13 +1,10 @@
-import { GameRoot } from "./root";
-import { Entity } from "./entity";
-import { Vector, enumDirectionToVector, enumDirection } from "../core/vector";
-import { MetaBuilding } from "./meta_building";
-import { StaticMapEntityComponent } from "./components/static_map_entity";
-import { Math_abs, performanceNow } from "../core/builtins";
import { createLogger } from "../core/logging";
-import { MetaBeltBaseBuilding, arrayBeltVariantToRotation } from "./buildings/belt_base";
-import { SOUNDS } from "../platform/sound";
import { round2Digits } from "../core/utils";
+import { enumDirection, enumDirectionToVector, Vector } from "../core/vector";
+import { Entity } from "./entity";
+import { MetaBuilding } from "./meta_building";
+import { enumLayer, GameRoot } from "./root";
+import { STOP_PROPAGATION } from "../core/signal";
const logger = createLogger("ingame/logic");
@@ -48,102 +45,41 @@ export class GameLogic {
}
/**
- * @param {object} param0
- * @param {Vector} param0.origin
- * @param {number} param0.rotation
- * @param {number} param0.rotationVariant
- * @param {string} param0.variant
- * @param {MetaBuilding} param0.building
- * @returns {boolean}
+ * Checks if the given entity can be placed
+ * @param {Entity} entity
+ * @param {Vector=} offset Optional, move the entity by the given offset first
+ * @returns {boolean} true if the entity could be placed there
*/
- isAreaFreeToBuild({ origin, rotation, rotationVariant, variant, building }) {
- const checker = new StaticMapEntityComponent({
- origin,
- tileSize: building.getDimensions(variant),
- rotation,
- blueprintSpriteKey: "",
- });
-
- const rect = checker.getTileSpaceBounds();
+ checkCanPlaceEntity(entity, offset = null) {
+ // Compute area of the building
+ const rect = entity.components.StaticMapEntity.getTileSpaceBounds();
+ if (offset) {
+ rect.x += offset.x;
+ rect.y += offset.y;
+ }
+ // Check the whole area of the building
for (let x = rect.x; x < rect.x + rect.w; ++x) {
for (let y = rect.y; y < rect.y + rect.h; ++y) {
- const contents = this.root.map.getTileContentXY(x, y);
- if (contents) {
- if (
- !this.checkCanReplaceBuilding({
- original: contents,
- origin,
- building,
- rotation,
- rotationVariant,
- })
- ) {
- // Content already has same rotation
- return false;
- }
+ // Check if there is any direct collision
+ const otherEntity = this.root.map.getLayerContentXY(x, y, entity.layer);
+ if (otherEntity && !otherEntity.components.ReplaceableMapEntity) {
+ // This one is a direct blocker
+ return false;
}
}
}
- return true;
- }
- /**
- * Checks if the given building can be replaced by another
- * @param {object} param0
- * @param {Entity} param0.original
- * @param {Vector} param0.origin
- * @param {number} param0.rotation
- * @param {number} param0.rotationVariant
- * @param {MetaBuilding} param0.building
- * @returns {boolean}
- */
- checkCanReplaceBuilding({ original, origin, building, rotation, rotationVariant }) {
- if (!original.components.ReplaceableMapEntity) {
- // Can not get replaced at all
+ // Perform additional placement checks
+ if (this.root.signals.prePlacementCheck.dispatch(entity, offset) === STOP_PROPAGATION) {
return false;
}
- const staticComp = original.components.StaticMapEntity;
- assert(staticComp, "Building is not static");
- const beltComp = original.components.Belt;
- if (beltComp && building instanceof MetaBeltBaseBuilding) {
- // Its a belt, check if it differs in either rotation or rotation variant
- if (staticComp.rotation !== rotation) {
- return true;
- }
- if (beltComp.direction !== arrayBeltVariantToRotation[rotationVariant]) {
- return true;
- }
- }
-
return true;
}
/**
- * @param {object} param0
- * @param {Vector} param0.origin
- * @param {number} param0.rotation
- * @param {number} param0.rotationVariant
- * @param {string} param0.variant
- * @param {MetaBuilding} param0.building
- */
- checkCanPlaceBuilding({ origin, rotation, rotationVariant, variant, building }) {
- if (!building.getIsUnlocked(this.root)) {
- return false;
- }
-
- return this.isAreaFreeToBuild({
- origin,
- rotation,
- rotationVariant,
- variant,
- building,
- });
- }
-
- /**
- *
+ * Attempts to place the given building
* @param {object} param0
* @param {Vector} param0.origin
* @param {number} param0.rotation
@@ -154,54 +90,62 @@ export class GameLogic {
* @returns {Entity}
*/
tryPlaceBuilding({ origin, rotation, rotationVariant, originalRotation, variant, building }) {
- if (this.checkCanPlaceBuilding({ origin, rotation, rotationVariant, variant, building })) {
- // Remove any removeable entities below
- const checker = new StaticMapEntityComponent({
- origin,
- tileSize: building.getDimensions(variant),
- rotation,
- blueprintSpriteKey: "",
- });
-
- const rect = checker.getTileSpaceBounds();
-
- for (let x = rect.x; x < rect.x + rect.w; ++x) {
- for (let y = rect.y; y < rect.y + rect.h; ++y) {
- const contents = this.root.map.getTileContentXY(x, y);
- if (contents) {
- if (!this.tryDeleteBuilding(contents)) {
- logger.error("Building has replaceable component but is also unremovable");
- return null;
- }
- }
- }
- }
-
- const entity = building.createAndPlaceEntity({
- root: this.root,
- origin,
- rotation,
- rotationVariant,
- originalRotation,
- variant,
- });
-
+ const entity = building.createEntity({
+ root: this.root,
+ origin,
+ rotation,
+ originalRotation,
+ rotationVariant,
+ variant,
+ });
+ if (this.checkCanPlaceEntity(entity)) {
+ this.freeEntityAreaBeforeBuild(entity);
+ this.root.map.placeStaticEntity(entity);
+ this.root.entityMgr.registerEntity(entity);
return entity;
}
return null;
}
+ /**
+ * Removes all entities with a RemovableMapEntityComponent which need to get
+ * removed before placing this entity
+ * @param {Entity} entity
+ */
+ freeEntityAreaBeforeBuild(entity) {
+ const staticComp = entity.components.StaticMapEntity;
+ const rect = staticComp.getTileSpaceBounds();
+ // Remove any removeable colliding entities on the same layer
+ for (let x = rect.x; x < rect.x + rect.w; ++x) {
+ for (let y = rect.y; y < rect.y + rect.h; ++y) {
+ const contents = this.root.map.getLayerContentXY(x, y, entity.layer);
+ if (contents) {
+ assertAlways(
+ contents.components.ReplaceableMapEntity,
+ "Tried to replace non-repleaceable entity"
+ );
+ if (!this.tryDeleteBuilding(contents)) {
+ assertAlways(false, "Tried to replace non-repleaceable entity #2");
+ }
+ }
+ }
+ }
+
+ // Perform other callbacks
+ this.root.signals.freeEntityAreaBeforeBuild.dispatch(entity);
+ }
+
/**
* Performs a bulk operation, not updating caches in the meantime
* @param {function} operation
*/
performBulkOperation(operation) {
- logger.log("Running bulk operation ...");
+ logger.warn("Running bulk operation ...");
assert(!this.root.bulkOperationRunning, "Can not run two bulk operations twice");
this.root.bulkOperationRunning = true;
- const now = performanceNow();
+ const now = performance.now();
const returnValue = operation();
- const duration = performanceNow() - now;
+ const duration = performance.now() - now;
logger.log("Done in", round2Digits(duration), "ms");
assert(this.root.bulkOperationRunning, "Bulk operation = false while bulk operation was running");
this.root.bulkOperationRunning = false;
@@ -227,33 +171,41 @@ export class GameLogic {
}
this.root.map.removeStaticEntity(building);
this.root.entityMgr.destroyEntity(building);
+ this.root.entityMgr.processDestroyList();
return true;
}
/**
* Returns the acceptors and ejectors which affect the current tile
* @param {Vector} tile
+ * @param {enumLayer} layer
* @returns {AcceptorsAndEjectorsAffectingTile}
*/
- getEjectorsAndAcceptorsAtTile(tile) {
+ getEjectorsAndAcceptorsAtTile(tile, layer) {
/** @type {EjectorsAffectingTile} */
let ejectors = [];
/** @type {AcceptorsAffectingTile} */
let acceptors = [];
+ // Well .. please ignore this code! :D
for (let dx = -1; dx <= 1; ++dx) {
for (let dy = -1; dy <= 1; ++dy) {
- if (Math_abs(dx) + Math_abs(dy) !== 1) {
+ if (Math.abs(dx) + Math.abs(dy) !== 1) {
continue;
}
- const entity = this.root.map.getTileContentXY(tile.x + dx, tile.y + dy);
- if (entity) {
+ const entities = this.root.map.getLayersContentsMultipleXY(tile.x + dx, tile.y + dy);
+ for (let i = 0; i < entities.length; ++i) {
+ const entity = entities[i];
+
const staticComp = entity.components.StaticMapEntity;
const itemEjector = entity.components.ItemEjector;
if (itemEjector) {
for (let ejectorSlot = 0; ejectorSlot < itemEjector.slots.length; ++ejectorSlot) {
const slot = itemEjector.slots[ejectorSlot];
+ if (slot.layer !== layer) {
+ continue;
+ }
const wsTile = staticComp.localTileToWorld(slot.pos);
const wsDirection = staticComp.localDirectionToWorld(slot.direction);
const targetTile = wsTile.add(enumDirectionToVector[wsDirection]);
@@ -272,6 +224,10 @@ export class GameLogic {
if (itemAcceptor) {
for (let acceptorSlot = 0; acceptorSlot < itemAcceptor.slots.length; ++acceptorSlot) {
const slot = itemAcceptor.slots[acceptorSlot];
+ if (slot.layer !== layer) {
+ continue;
+ }
+
const wsTile = staticComp.localTileToWorld(slot.pos);
for (let k = 0; k < slot.directions.length; ++k) {
const direction = slot.directions[k];
diff --git a/src/js/game/map.js b/src/js/game/map.js
index ef745c6d..3f8a16f8 100644
--- a/src/js/game/map.js
+++ b/src/js/game/map.js
@@ -1,11 +1,7 @@
-/* typehints:start */
-import { GameRoot } from "./root";
-/* typehints:end */
-
+import { GameRoot, enumLayer } from "./root";
import { globalConfig } from "../core/config";
import { Vector } from "../core/vector";
import { Entity } from "./entity";
-import { Math_floor } from "../core/builtins";
import { createLogger } from "../core/logging";
import { BaseItem } from "./base_item";
import { MapChunkView } from "./map_chunk_view";
@@ -47,7 +43,6 @@ export class BaseMap extends BasicSerializableObject {
* @param {number} chunkY
*/
getChunk(chunkX, chunkY, createIfNotExistent = false) {
- // TODO: Better generation
const chunkIdentifier = chunkX + "|" + chunkY;
let storedChunk;
@@ -71,8 +66,8 @@ export class BaseMap extends BasicSerializableObject {
* @returns {MapChunkView}
*/
getOrCreateChunkAtTile(tileX, tileY) {
- const chunkX = Math_floor(tileX / globalConfig.mapChunkSize);
- const chunkY = Math_floor(tileY / globalConfig.mapChunkSize);
+ const chunkX = Math.floor(tileX / globalConfig.mapChunkSize);
+ const chunkY = Math.floor(tileY / globalConfig.mapChunkSize);
return this.getChunk(chunkX, chunkY, true);
}
@@ -83,8 +78,8 @@ export class BaseMap extends BasicSerializableObject {
* @returns {MapChunkView?}
*/
getChunkAtTileOrNull(tileX, tileY) {
- const chunkX = Math_floor(tileX / globalConfig.mapChunkSize);
- const chunkY = Math_floor(tileY / globalConfig.mapChunkSize);
+ const chunkX = Math.floor(tileX / globalConfig.mapChunkSize);
+ const chunkY = Math.floor(tileY / globalConfig.mapChunkSize);
return this.getChunk(chunkX, chunkY, false);
}
@@ -103,14 +98,15 @@ export class BaseMap extends BasicSerializableObject {
/**
* Returns the tile content of a given tile
* @param {Vector} tile
+ * @param {enumLayer} layer
* @returns {Entity} Entity or null
*/
- getTileContent(tile) {
+ getTileContent(tile, layer) {
if (G_IS_DEV) {
this.internalCheckTile(tile);
}
const chunk = this.getChunkAtTileOrNull(tile.x, tile.y);
- return chunk && chunk.getTileContentFromWorldCoords(tile.x, tile.y);
+ return chunk && chunk.getLayerContentFromWorldCoords(tile.x, tile.y, layer);
}
/**
@@ -127,35 +123,52 @@ export class BaseMap extends BasicSerializableObject {
* Returns the tile content of a given tile
* @param {number} x
* @param {number} y
+ * @param {enumLayer} layer
* @returns {Entity} Entity or null
*/
- getTileContentXY(x, y) {
+ getLayerContentXY(x, y, layer) {
const chunk = this.getChunkAtTileOrNull(x, y);
- return chunk && chunk.getTileContentFromWorldCoords(x, y);
+ return chunk && chunk.getLayerContentFromWorldCoords(x, y, layer);
+ }
+
+ /**
+ * Returns the tile contents of a given tile
+ * @param {number} x
+ * @param {number} y
+ * @returns {Array} Entity or null
+ */
+ getLayersContentsMultipleXY(x, y) {
+ const chunk = this.getChunkAtTileOrNull(x, y);
+ if (!chunk) {
+ return [];
+ }
+ return chunk.getLayersContentsMultipleFromWorldCoords(x, y);
}
/**
* Checks if the tile is used
* @param {Vector} tile
+ * @param {enumLayer} layer
* @returns {boolean}
*/
- isTileUsed(tile) {
+ isTileUsed(tile, layer) {
if (G_IS_DEV) {
this.internalCheckTile(tile);
}
const chunk = this.getChunkAtTileOrNull(tile.x, tile.y);
- return chunk && chunk.getTileContentFromWorldCoords(tile.x, tile.y) != null;
+ return chunk && chunk.getLayerContentFromWorldCoords(tile.x, tile.y, layer) != null;
}
/**
* Checks if the tile is used
* @param {number} x
* @param {number} y
+ * @param {enumLayer} layer
* @returns {boolean}
*/
- isTileUsedXY(x, y) {
+ isTileUsedXY(x, y, layer) {
const chunk = this.getChunkAtTileOrNull(x, y);
- return chunk && chunk.getTileContentFromWorldCoords(x, y) != null;
+ return chunk && chunk.getLayerContentFromWorldCoords(x, y, layer) != null;
}
/**
@@ -168,7 +181,12 @@ export class BaseMap extends BasicSerializableObject {
this.internalCheckTile(tile);
}
- this.getOrCreateChunkAtTile(tile.x, tile.y).setTileContentFromWorldCords(tile.x, tile.y, entity);
+ this.getOrCreateChunkAtTile(tile.x, tile.y).setLayerContentFromWorldCords(
+ tile.x,
+ tile.y,
+ entity,
+ entity.layer
+ );
const staticComponent = entity.components.StaticMapEntity;
assert(staticComponent, "Can only place static map entities in tiles");
@@ -186,7 +204,7 @@ export class BaseMap extends BasicSerializableObject {
for (let dy = 0; dy < rect.h; ++dy) {
const x = rect.x + dx;
const y = rect.y + dy;
- this.getOrCreateChunkAtTile(x, y).setTileContentFromWorldCords(x, y, entity);
+ this.getOrCreateChunkAtTile(x, y).setLayerContentFromWorldCords(x, y, entity, entity.layer);
}
}
}
@@ -203,22 +221,11 @@ export class BaseMap extends BasicSerializableObject {
for (let dy = 0; dy < rect.h; ++dy) {
const x = rect.x + dx;
const y = rect.y + dy;
- this.getOrCreateChunkAtTile(x, y).setTileContentFromWorldCords(x, y, null);
+ this.getOrCreateChunkAtTile(x, y).setLayerContentFromWorldCords(x, y, null, entity.layer);
}
}
}
- /**
- * Resets the tiles content
- * @param {Vector} tile
- */
- clearTile(tile) {
- if (G_IS_DEV) {
- this.internalCheckTile(tile);
- }
- this.getOrCreateChunkAtTile(tile.x, tile.y).setTileContentFromWorldCords(tile.x, tile.y, null);
- }
-
// Internal
/**
diff --git a/src/js/game/map_chunk.js b/src/js/game/map_chunk.js
index bffaf9e8..dd9ba81d 100644
--- a/src/js/game/map_chunk.js
+++ b/src/js/game/map_chunk.js
@@ -1,8 +1,4 @@
-/* typehints:start */
-import { GameRoot } from "./root";
-/* typehints:end */
-
-import { Math_ceil, Math_max, Math_min, Math_round } from "../core/builtins";
+import { GameRoot, enumLayer } from "./root";
import { globalConfig } from "../core/config";
import { createLogger } from "../core/logging";
import { clamp, fastArrayDeleteValueIfContained, make2DUndefinedArray } from "../core/utils";
@@ -38,6 +34,13 @@ export class MapChunk {
"map-chunk@" + this.x + "|" + this.y
);
+ /** @type {Array>} */
+ this.wireContents = make2DUndefinedArray(
+ globalConfig.mapChunkSize,
+ globalConfig.mapChunkSize,
+ "map-chunk-wires@" + this.x + "|" + this.y
+ );
+
/** @type {Array>} */
this.lowerLayer = make2DUndefinedArray(
globalConfig.mapChunkSize,
@@ -66,7 +69,7 @@ export class MapChunk {
* @param {number=} overrideY Override the Y position of the patch
*/
internalGeneratePatch(rng, patchSize, item, overrideX = null, overrideY = null) {
- const border = Math_ceil(patchSize / 2 + 3);
+ const border = Math.ceil(patchSize / 2 + 3);
// Find a position within the chunk which is not blocked
let patchX = rng.nextIntRange(border, globalConfig.mapChunkSize - border - 1);
@@ -88,7 +91,7 @@ export class MapChunk {
for (let i = 0; i <= numCircles; ++i) {
// Determine circle parameters
- const circleRadius = Math_min(1 + i, patchSize);
+ const circleRadius = Math.min(1 + i, patchSize);
const circleRadiusSquare = circleRadius * circleRadius;
const circleOffsetRadius = (numCircles - i) / 2 + 2;
@@ -101,8 +104,8 @@ export class MapChunk {
for (let dx = -circleRadius * circleScaleX - 2; dx <= circleRadius * circleScaleX + 2; ++dx) {
for (let dy = -circleRadius * circleScaleY - 2; dy <= circleRadius * circleScaleY + 2; ++dy) {
- const x = Math_round(circleX + dx);
- const y = Math_round(circleY + dy);
+ const x = Math.round(circleX + dx);
+ const y = Math.round(circleY + dy);
if (x >= 0 && x < globalConfig.mapChunkSize && y >= 0 && y <= globalConfig.mapChunkSize) {
const originalDx = dx / circleScaleX;
const originalDy = dy / circleScaleY;
@@ -158,9 +161,9 @@ export class MapChunk {
// Later there is a mix of everything
weights = {
[enumSubShape.rect]: 100,
- [enumSubShape.circle]: Math_round(50 + clamp(distanceToOriginInChunks * 2, 0, 50)),
- [enumSubShape.star]: Math_round(20 + clamp(distanceToOriginInChunks, 0, 30)),
- [enumSubShape.windmill]: Math_round(6 + clamp(distanceToOriginInChunks / 2, 0, 20)),
+ [enumSubShape.circle]: Math.round(50 + clamp(distanceToOriginInChunks * 2, 0, 50)),
+ [enumSubShape.star]: Math.round(20 + clamp(distanceToOriginInChunks, 0, 30)),
+ [enumSubShape.windmill]: Math.round(6 + clamp(distanceToOriginInChunks / 2, 0, 20)),
};
if (distanceToOriginInChunks < 7) {
@@ -239,20 +242,20 @@ export class MapChunk {
}
const chunkCenter = new Vector(this.x, this.y).addScalar(0.5);
- const distanceToOriginInChunks = Math_round(chunkCenter.length());
+ const distanceToOriginInChunks = Math.round(chunkCenter.length());
// Determine how likely it is that there is a color patch
const colorPatchChance = 0.9 - clamp(distanceToOriginInChunks / 25, 0, 1) * 0.5;
if (rng.next() < colorPatchChance / 4) {
- const colorPatchSize = Math_max(2, Math_round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
+ const colorPatchSize = Math.max(2, Math.round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
this.internalGenerateColorPatch(rng, colorPatchSize, distanceToOriginInChunks);
}
// Determine how likely it is that there is a shape patch
const shapePatchChance = 0.9 - clamp(distanceToOriginInChunks / 25, 0, 1) * 0.5;
if (rng.next() < shapePatchChance / 4) {
- const shapePatchSize = Math_max(2, Math_round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
+ const shapePatchSize = Math.max(2, Math.round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
this.internalGenerateShapePatch(rng, shapePatchSize, distanceToOriginInChunks);
}
}
@@ -325,6 +328,53 @@ export class MapChunk {
return this.contents[localX][localY] || null;
}
+ /**
+ * Returns the contents of this chunk from the given world space coordinates
+ * @param {number} worldX
+ * @param {number} worldY
+ * @param {enumLayer} layer
+ * @returns {Entity=}
+ */
+ getLayerContentFromWorldCoords(worldX, worldY, layer) {
+ const localX = worldX - this.tileX;
+ const localY = worldY - this.tileY;
+ assert(localX >= 0, "Local X is < 0");
+ assert(localY >= 0, "Local Y is < 0");
+ assert(localX < globalConfig.mapChunkSize, "Local X is >= chunk size");
+ assert(localY < globalConfig.mapChunkSize, "Local Y is >= chunk size");
+ if (layer === enumLayer.regular) {
+ return this.contents[localX][localY] || null;
+ } else {
+ return this.wireContents[localX][localY] || null;
+ }
+ }
+ /**
+ * Returns the contents of this chunk from the given world space coordinates
+ * @param {number} worldX
+ * @param {number} worldY
+ * @returns {Array}
+ */
+ getLayersContentsMultipleFromWorldCoords(worldX, worldY) {
+ const localX = worldX - this.tileX;
+ const localY = worldY - this.tileY;
+ assert(localX >= 0, "Local X is < 0");
+ assert(localY >= 0, "Local Y is < 0");
+ assert(localX < globalConfig.mapChunkSize, "Local X is >= chunk size");
+ assert(localY < globalConfig.mapChunkSize, "Local Y is >= chunk size");
+
+ const regularContent = this.contents[localX][localY];
+ const wireContent = this.wireContents[localX][localY];
+
+ const result = [];
+ if (regularContent) {
+ result.push(regularContent);
+ }
+ if (wireContent) {
+ result.push(wireContent);
+ }
+ return result;
+ }
+
/**
* Returns the chunks contents from the given local coordinates
* @param {number} localX
@@ -345,22 +395,36 @@ export class MapChunk {
* @param {number} tileX
* @param {number} tileY
* @param {Entity=} contents
+ * @param {enumLayer} layer
*/
- setTileContentFromWorldCords(tileX, tileY, contents) {
+ setLayerContentFromWorldCords(tileX, tileY, contents, layer) {
const localX = tileX - this.tileX;
const localY = tileY - this.tileY;
assert(localX >= 0, "Local X is < 0");
assert(localY >= 0, "Local Y is < 0");
assert(localX < globalConfig.mapChunkSize, "Local X is >= chunk size");
assert(localY < globalConfig.mapChunkSize, "Local Y is >= chunk size");
- const oldContents = this.contents[localX][localY];
+
+ let oldContents;
+ if (layer === enumLayer.regular) {
+ oldContents = this.contents[localX][localY];
+ } else {
+ oldContents = this.wireContents[localX][localY];
+ }
+
assert(contents === null || !oldContents, "Tile already used: " + tileX + " / " + tileY);
if (oldContents) {
// Remove from list
fastArrayDeleteValueIfContained(this.containedEntities, oldContents);
}
- this.contents[localX][localY] = contents;
+
+ if (layer === enumLayer.regular) {
+ this.contents[localX][localY] = contents;
+ } else {
+ this.wireContents[localX][localY] = contents;
+ }
+
if (contents) {
if (this.containedEntities.indexOf(contents) < 0) {
this.containedEntities.push(contents);
diff --git a/src/js/game/map_chunk_view.js b/src/js/game/map_chunk_view.js
index cc0734d8..c3f09b39 100644
--- a/src/js/game/map_chunk_view.js
+++ b/src/js/game/map_chunk_view.js
@@ -3,7 +3,6 @@ import { GameRoot } from "./root";
import { globalConfig } from "../core/config";
import { DrawParameters } from "../core/draw_parameters";
import { round1Digit } from "../core/utils";
-import { Math_max, Math_round } from "../core/builtins";
import { Rectangle } from "../core/rectangle";
import { createLogger } from "../core/logging";
import { smoothenDpi } from "../core/dpi_manager";
@@ -22,9 +21,6 @@ export class MapChunkView extends MapChunk {
constructor(root, x, y) {
super(root, x, y);
- this.boundInternalDrawBackgroundToContext = this.internalDrawBackgroundToContext.bind(this);
- this.boundInternalDrawForegroundToContext = this.internalDrawForegroundToContext.bind(this);
-
/**
* Whenever something changes, we increase this number - so we know we need to redraw
*/
@@ -46,29 +42,9 @@ export class MapChunkView extends MapChunk {
* @param {DrawParameters} parameters
*/
drawBackgroundLayer(parameters) {
- if (parameters.zoomLevel > globalConfig.mapChunkPrerenderMinZoom) {
- this.internalDrawBackgroundSystems(parameters);
- return;
- }
-
- const dpi = smoothenDpi(parameters.zoomLevel);
- const buffer = this.root.buffers.getForKey(
- "" + dpi,
- this.renderKey + "@bg",
- chunkSizePixels,
- chunkSizePixels,
- dpi,
- this.boundInternalDrawBackgroundToContext,
- { zoomLevel: parameters.zoomLevel }
- );
-
- parameters.context.drawImage(
- buffer,
- this.tileX * globalConfig.tileSize,
- this.tileY * globalConfig.tileSize,
- chunkSizePixels,
- chunkSizePixels
- );
+ const systems = this.root.systemMgr.systems;
+ systems.mapResources.drawChunk(parameters, this);
+ systems.belt.drawChunk(parameters, this);
}
/**
@@ -76,127 +52,26 @@ export class MapChunkView extends MapChunk {
* @param {DrawParameters} parameters
*/
drawForegroundLayer(parameters) {
- if (parameters.zoomLevel > globalConfig.mapChunkPrerenderMinZoom) {
- this.internalDrawForegroundSystems(parameters);
- return;
- }
-
- const dpi = smoothenDpi(parameters.zoomLevel);
- const buffer = this.root.buffers.getForKey(
- "" + dpi,
- this.renderKey + "@fg",
- chunkSizePixels,
- chunkSizePixels,
- dpi,
- this.boundInternalDrawForegroundToContext,
- { zoomLevel: parameters.zoomLevel }
- );
- parameters.context.drawImage(
- buffer,
- this.tileX * globalConfig.tileSize,
- this.tileY * globalConfig.tileSize,
- chunkSizePixels,
- chunkSizePixels
- );
- }
-
- /**
- *
- * @param {HTMLCanvasElement} canvas
- * @param {CanvasRenderingContext2D} context
- * @param {number} w
- * @param {number} h
- * @param {number} dpi
- */
- internalDrawBackgroundToContext(canvas, context, w, h, dpi, { zoomLevel }) {
- const pattern = context.createPattern(this.root.map.cachedBackgroundCanvas, "repeat");
- context.scale(dpi, dpi);
-
- if (zoomLevel >= globalConfig.mapChunkOverviewMinZoom) {
- const bgDpi = this.root.map.backgroundCacheDPI;
- context.scale(1 / bgDpi, 1 / bgDpi);
- context.fillStyle = pattern;
- context.fillRect(0, 0, chunkSizePixels * bgDpi, chunkSizePixels * bgDpi);
- context.scale(bgDpi, bgDpi);
- } else {
- if (this.containedEntities.length > 0) {
- context.fillStyle = THEME.map.chunkOverview.filled;
- } else {
- context.fillStyle = THEME.map.chunkOverview.empty;
- }
- context.fillRect(0, 0, 10000, 10000);
- }
-
- if (G_IS_DEV && globalConfig.debug.showChunkBorders) {
- context.fillStyle = "rgba(0, 0, 255, 0.1)";
- context.fillRect(0, 0, 10000, 10000);
- }
-
- const parameters = new DrawParameters({
- context,
- visibleRect: new Rectangle(
- this.tileX * globalConfig.tileSize,
- this.tileY * globalConfig.tileSize,
- chunkSizePixels,
- chunkSizePixels
- ),
- desiredAtlasScale: "1",
- zoomLevel,
- root: this.root,
- });
-
- parameters.context.translate(
- -this.tileX * globalConfig.tileSize,
- -this.tileY * globalConfig.tileSize
- );
- this.internalDrawBackgroundSystems(parameters);
- }
-
- /**
- *
- * @param {HTMLCanvasElement} canvas
- * @param {CanvasRenderingContext2D} context
- * @param {number} w
- * @param {number} h
- * @param {number} dpi
- */
- internalDrawForegroundToContext(canvas, context, w, h, dpi, { zoomLevel }) {
- context.scale(dpi, dpi);
-
- const parameters = new DrawParameters({
- context,
- visibleRect: new Rectangle(
- this.tileX * globalConfig.tileSize,
- this.tileY * globalConfig.tileSize,
- chunkSizePixels,
- chunkSizePixels
- ),
- desiredAtlasScale: "1",
- zoomLevel,
- root: this.root,
- });
- parameters.context.translate(
- -this.tileX * globalConfig.tileSize,
- -this.tileY * globalConfig.tileSize
- );
- this.internalDrawForegroundSystems(parameters);
- }
-
- /**
- * @param {DrawParameters} parameters
- */
- internalDrawBackgroundSystems(parameters) {
- const systems = this.root.systemMgr.systems;
- systems.mapResources.drawChunk(parameters, this);
- systems.belt.drawChunk(parameters, this);
- }
-
- /**
- * @param {DrawParameters} parameters
- */
- internalDrawForegroundSystems(parameters) {
const systems = this.root.systemMgr.systems;
systems.miner.drawChunk(parameters, this);
systems.staticMapEntities.drawChunk(parameters, this);
}
+
+ /**
+ * Draws the wires layer
+ * @param {DrawParameters} parameters
+ */
+ drawWiresLayer(parameters) {
+ const systems = this.root.systemMgr.systems;
+ systems.belt.drawWiresChunk(parameters, this);
+ }
+
+ /**
+ * Draws the wires layer
+ * @param {DrawParameters} parameters
+ */
+ drawWiresForegroundLayer(parameters) {
+ const systems = this.root.systemMgr.systems;
+ systems.staticMapEntities.drawWiresChunk(parameters, this);
+ }
}
diff --git a/src/js/game/map_view.js b/src/js/game/map_view.js
index 5c4bf88a..bd10755c 100644
--- a/src/js/game/map_view.js
+++ b/src/js/game/map_view.js
@@ -1,10 +1,10 @@
-import { Math_max, Math_min, Math_floor, Math_ceil } from "../core/builtins";
import { globalConfig } from "../core/config";
import { DrawParameters } from "../core/draw_parameters";
import { BaseMap } from "./map";
import { freeCanvas, makeOffscreenBuffer } from "../core/buffer_utils";
import { Entity } from "./entity";
import { THEME } from "./theme";
+import { MapChunkView } from "./map_chunk_view";
/**
* This is the view of the map, it extends the map which is the raw model and allows
@@ -36,6 +36,7 @@ export class MapView extends BaseMap {
this.root.signals.entityAdded.add(this.onEntityChanged, this);
this.root.signals.entityDestroyed.add(this.onEntityChanged, this);
+ this.root.signals.entityChanged.add(this.onEntityChanged, this);
}
cleanup() {
@@ -45,7 +46,7 @@ export class MapView extends BaseMap {
}
/**
- * Called when an entity was added or removed
+ * Called when an entity was added, removed or changed
* @param {Entity} entity
*/
onEntityChanged(entity) {
@@ -130,6 +131,15 @@ export class MapView extends BaseMap {
* @param {DrawParameters} parameters
*/
drawForeground(parameters) {
+ this.drawVisibleChunks(parameters, MapChunkView.prototype.drawForegroundLayer);
+ }
+
+ /**
+ * Calls a given method on all given chunks
+ * @param {DrawParameters} parameters
+ * @param {function} method
+ */
+ drawVisibleChunks(parameters, method) {
const cullRange = parameters.visibleRect.toTileCullRectangle();
const top = cullRange.top();
const right = cullRange.right();
@@ -142,21 +152,37 @@ export class MapView extends BaseMap {
const minX = left - border;
const maxX = right + border - 1;
- const chunkStartX = Math_floor(minX / globalConfig.mapChunkSize);
- const chunkStartY = Math_floor(minY / globalConfig.mapChunkSize);
+ const chunkStartX = Math.floor(minX / globalConfig.mapChunkSize);
+ const chunkStartY = Math.floor(minY / globalConfig.mapChunkSize);
- const chunkEndX = Math_ceil(maxX / globalConfig.mapChunkSize);
- const chunkEndY = Math_ceil(maxY / globalConfig.mapChunkSize);
+ const chunkEndX = Math.ceil(maxX / globalConfig.mapChunkSize);
+ const chunkEndY = Math.ceil(maxY / globalConfig.mapChunkSize);
// Render y from top down for proper blending
for (let chunkX = chunkStartX; chunkX <= chunkEndX; ++chunkX) {
for (let chunkY = chunkStartY; chunkY <= chunkEndY; ++chunkY) {
const chunk = this.root.map.getChunk(chunkX, chunkY, true);
- chunk.drawForegroundLayer(parameters);
+ method.call(chunk, parameters);
}
}
}
+ /**
+ * Draws the wires background
+ * @param {DrawParameters} parameters
+ */
+ drawWiresLayer(parameters) {
+ this.drawVisibleChunks(parameters, MapChunkView.prototype.drawWiresLayer);
+ }
+
+ /**
+ * Draws the wires foreground
+ * @param {DrawParameters} parameters
+ */
+ drawWiresForegroundLayer(parameters) {
+ this.drawVisibleChunks(parameters, MapChunkView.prototype.drawWiresForegroundLayer);
+ }
+
/**
* Draws the map background
* @param {DrawParameters} parameters
@@ -184,31 +210,7 @@ export class MapView extends BaseMap {
parameters.context.scale(dpi, dpi);
}
- const cullRange = parameters.visibleRect.toTileCullRectangle();
- const top = cullRange.top();
- const right = cullRange.right();
- const bottom = cullRange.bottom();
- const left = cullRange.left();
-
- const border = 1;
- const minY = top - border;
- const maxY = bottom + border;
- const minX = left - border;
- const maxX = right + border - 1;
-
- const chunkStartX = Math_floor(minX / globalConfig.mapChunkSize);
- const chunkStartY = Math_floor(minY / globalConfig.mapChunkSize);
-
- const chunkEndX = Math_ceil(maxX / globalConfig.mapChunkSize);
- const chunkEndY = Math_ceil(maxY / globalConfig.mapChunkSize);
-
- // Render y from top down for proper blending
- for (let chunkX = chunkStartX; chunkX <= chunkEndX; ++chunkX) {
- for (let chunkY = chunkStartY; chunkY <= chunkEndY; ++chunkY) {
- const chunk = this.root.map.getChunk(chunkX, chunkY, true);
- chunk.drawBackgroundLayer(parameters);
- }
- }
+ this.drawVisibleChunks(parameters, MapChunkView.prototype.drawBackgroundLayer);
if (G_IS_DEV && globalConfig.debug.showChunkBorders) {
const cullRange = parameters.visibleRect.toTileCullRectangle();
@@ -223,11 +225,11 @@ export class MapView extends BaseMap {
const minX = left - border;
const maxX = right + border - 1;
- const chunkStartX = Math_floor(minX / globalConfig.mapChunkSize);
- const chunkStartY = Math_floor(minY / globalConfig.mapChunkSize);
+ const chunkStartX = Math.floor(minX / globalConfig.mapChunkSize);
+ const chunkStartY = Math.floor(minY / globalConfig.mapChunkSize);
- const chunkEndX = Math_ceil(maxX / globalConfig.mapChunkSize);
- const chunkEndY = Math_ceil(maxY / globalConfig.mapChunkSize);
+ const chunkEndX = Math.ceil(maxX / globalConfig.mapChunkSize);
+ const chunkEndY = Math.ceil(maxY / globalConfig.mapChunkSize);
// Render y from top down for proper blending
for (let chunkX = chunkStartX; chunkX <= chunkEndX; ++chunkX) {
diff --git a/src/js/game/meta_building.js b/src/js/game/meta_building.js
index 798e4d4c..514474c9 100644
--- a/src/js/game/meta_building.js
+++ b/src/js/game/meta_building.js
@@ -4,7 +4,7 @@ import { Vector } from "../core/vector";
import { SOUNDS } from "../platform/sound";
import { StaticMapEntityComponent } from "./components/static_map_entity";
import { Entity } from "./entity";
-import { enumEditMode, GameRoot } from "./root";
+import { enumLayer, GameRoot } from "./root";
export const defaultBuildingVariant = "default";
@@ -26,10 +26,10 @@ export class MetaBuilding {
/**
* Returns the edit layer of the building
- * @returns {enumEditMode}
+ * @returns {enumLayer}
*/
- getEditLayer() {
- return enumEditMode.regular;
+ getLayer() {
+ return enumLayer.regular;
}
/**
@@ -144,30 +144,6 @@ export class MetaBuilding {
return null;
}
- /**
- * Creates the entity at the given location
- * @param {object} param0
- * @param {GameRoot} param0.root
- * @param {Vector} param0.origin Origin tile
- * @param {number=} param0.rotation Rotation
- * @param {number} param0.originalRotation Original Rotation
- * @param {number} param0.rotationVariant Rotation variant
- * @param {string} param0.variant
- */
- createAndPlaceEntity({ root, origin, rotation, originalRotation, rotationVariant, variant }) {
- const entity = this.createEntity({
- root,
- origin,
- rotation,
- originalRotation,
- rotationVariant,
- variant,
- });
- root.map.placeStaticEntity(entity);
- root.entityMgr.registerEntity(entity);
- return entity;
- }
-
/**
* Creates the entity without placing it
* @param {object} param0
@@ -180,6 +156,7 @@ export class MetaBuilding {
*/
createEntity({ root, origin, rotation, originalRotation, rotationVariant, variant }) {
const entity = new Entity(root);
+ entity.layer = this.getLayer();
const blueprintSprite = this.getBlueprintSprite(rotationVariant, variant);
entity.addComponent(
new StaticMapEntityComponent({
@@ -203,13 +180,15 @@ export class MetaBuilding {
/**
* Should compute the optimal rotation variant on the given tile
- * @param {GameRoot} root
- * @param {Vector} tile
- * @param {number} rotation
- * @param {string} variant
+ * @param {object} param0
+ * @param {GameRoot} param0.root
+ * @param {Vector} param0.tile
+ * @param {number} param0.rotation
+ * @param {string} param0.variant
+ * @param {string} param0.layer
* @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array }}
*/
- computeOptimalDirectionAndRotationVariantAtTile(root, tile, rotation, variant) {
+ computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
if (!this.isRotateable(variant)) {
return {
rotation: 0,
diff --git a/src/js/game/meta_building_registry.js b/src/js/game/meta_building_registry.js
index 0f37762d..4e1fdd81 100644
--- a/src/js/game/meta_building_registry.js
+++ b/src/js/game/meta_building_registry.js
@@ -11,6 +11,10 @@ import { MetaTrashBuilding } from "./buildings/trash";
import { MetaUndergroundBeltBuilding } from "./buildings/underground_belt";
import { MetaHubBuilding } from "./buildings/hub";
import { MetaEnergyGenerator } from "./buildings/energy_generator";
+import { MetaWireBaseBuilding } from "./buildings/wire_base";
+import { MetaAdvancedProcessorBuilding } from "./buildings/advanced_processor";
+import { MetaBeltBuilding } from "./buildings/belt";
+import { MetaWireCrossingsBuilding } from "./buildings/wire_crossings";
export function initMetaBuildingRegistry() {
gMetaBuildingRegistry.register(MetaSplitterBuilding);
@@ -21,8 +25,11 @@ export function initMetaBuildingRegistry() {
gMetaBuildingRegistry.register(MetaMixerBuilding);
gMetaBuildingRegistry.register(MetaPainterBuilding);
gMetaBuildingRegistry.register(MetaTrashBuilding);
- gMetaBuildingRegistry.register(MetaBeltBaseBuilding);
+ gMetaBuildingRegistry.register(MetaBeltBuilding);
gMetaBuildingRegistry.register(MetaUndergroundBeltBuilding);
gMetaBuildingRegistry.register(MetaHubBuilding);
gMetaBuildingRegistry.register(MetaEnergyGenerator);
+ gMetaBuildingRegistry.register(MetaWireBaseBuilding);
+ gMetaBuildingRegistry.register(MetaAdvancedProcessorBuilding);
+ gMetaBuildingRegistry.register(MetaWireCrossingsBuilding);
}
diff --git a/src/js/game/production_analytics.js b/src/js/game/production_analytics.js
index 1abac940..41ec31ae 100644
--- a/src/js/game/production_analytics.js
+++ b/src/js/game/production_analytics.js
@@ -1,7 +1,7 @@
import { GameRoot } from "./root";
import { ShapeDefinition } from "./shape_definition";
import { globalConfig } from "../core/config";
-import { BaseItem } from "./base_item";
+import { BaseItem, enumItemType } from "./base_item";
import { ShapeItem } from "./items/shape_item";
import { BasicSerializableObject } from "../savegame/serialization";
@@ -53,8 +53,8 @@ export class ProductionAnalytics extends BasicSerializableObject {
* @param {BaseItem} item
*/
onItemProduced(item) {
- if (item instanceof ShapeItem) {
- const definition = item.definition;
+ if (item.getItemType() === enumItemType.shape) {
+ const definition = /** @type {ShapeItem} */ (item).definition;
const key = definition.getHash();
const entry = this.history[enumAnalyticsDataSource.produced];
entry[entry.length - 1][key] = (entry[entry.length - 1][key] || 0) + 1;
diff --git a/src/js/game/root.js b/src/js/game/root.js
index e8808317..df0db09e 100644
--- a/src/js/game/root.js
+++ b/src/js/game/root.js
@@ -27,16 +27,20 @@ import { ShapeDefinition } from "./shape_definition";
import { BaseItem } from "./base_item";
import { DynamicTickrate } from "./dynamic_tickrate";
import { KeyActionMapper } from "./key_action_mapper";
+import { Vector } from "../core/vector";
/* typehints:end */
const logger = createLogger("game/root");
/** @enum {string} */
-export const enumEditMode = {
+export const enumLayer = {
regular: "regular",
wires: "wires",
};
+/** @type {Array} */
+export const arrayLayers = [enumLayer.regular, enumLayer.wires];
+
/**
* The game root is basically the whole game state at a given point,
* combining all important classes. We don't have globals, but this
@@ -130,13 +134,14 @@ export class GameRoot {
/** @type {DynamicTickrate} */
this.dynamicTickrate = null;
- /** @type {enumEditMode} */
- this.editMode = enumEditMode.regular;
+ /** @type {enumLayer} */
+ this.currentLayer = enumLayer.regular;
this.signals = {
// Entities
entityManuallyPlaced: /** @type {TypedSignal<[Entity]>} */ (new Signal()),
entityAdded: /** @type {TypedSignal<[Entity]>} */ (new Signal()),
+ entityChanged: /** @type {TypedSignal<[Entity]>} */ (new Signal()),
entityGotNewComponent: /** @type {TypedSignal<[Entity]>} */ (new Signal()),
entityComponentRemoved: /** @type {TypedSignal<[Entity]>} */ (new Signal()),
entityQueuedForDestroy: /** @type {TypedSignal<[Entity]>} */ (new Signal()),
@@ -165,7 +170,15 @@ export class GameRoot {
bulkOperationFinished: /** @type {TypedSignal<[]>} */ (new Signal()),
- editModeChanged: /** @type {TypedSignal<[enumEditMode]>} */ (new Signal()),
+ editModeChanged: /** @type {TypedSignal<[enumLayer]>} */ (new Signal()),
+
+ // Called to check if an entity can be placed, second parameter is an additional offset.
+ // Use to introduce additional placement checks
+ prePlacementCheck: /** @type {TypedSignal<[Entity, Vector]>} */ (new Signal()),
+
+ // Called before actually placing an entity, use to perform additional logic
+ // for freeing space before actually placing.
+ freeEntityAreaBeforeBuild: /** @type {TypedSignal<[Entity]>} */ (new Signal()),
};
// RNG's
diff --git a/src/js/game/shape_definition.js b/src/js/game/shape_definition.js
index 8644e353..af2214e3 100644
--- a/src/js/game/shape_definition.js
+++ b/src/js/game/shape_definition.js
@@ -1,12 +1,17 @@
import { makeOffscreenBuffer } from "../core/buffer_utils";
-import { JSON_parse, JSON_stringify, Math_max, Math_PI, Math_radians } from "../core/builtins";
import { globalConfig } from "../core/config";
import { smoothenDpi } from "../core/dpi_manager";
import { DrawParameters } from "../core/draw_parameters";
import { createLogger } from "../core/logging";
import { Vector } from "../core/vector";
import { BasicSerializableObject, types } from "../savegame/serialization";
-import { enumColors, enumColorsToHexCode, enumColorToShortcode, enumShortcodeToColor } from "./colors";
+import {
+ enumColors,
+ enumColorsToHexCode,
+ enumColorToShortcode,
+ enumShortcodeToColor,
+ enumInvertedColors,
+} from "./colors";
import { THEME } from "./theme";
const rusha = require("rusha");
@@ -235,7 +240,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @returns {Array}
*/
internalCloneLayers() {
- return JSON_parse(JSON_stringify(this.layers));
+ return JSON.parse(JSON.stringify(this.layers));
}
/**
@@ -340,7 +345,7 @@ export class ShapeDefinition extends BasicSerializableObject {
for (let layerIndex = 0; layerIndex < this.layers.length; ++layerIndex) {
const quadrants = this.layers[layerIndex];
- const layerScale = Math_max(0.1, 0.9 - layerIndex * 0.22);
+ const layerScale = Math.max(0.1, 0.9 - layerIndex * 0.22);
for (let quadrantIndex = 0; quadrantIndex < 4; ++quadrantIndex) {
if (!quadrants[quadrantIndex]) {
@@ -352,7 +357,7 @@ export class ShapeDefinition extends BasicSerializableObject {
const centerQuadrantX = quadrantPos.x * quadrantHalfSize;
const centerQuadrantY = quadrantPos.y * quadrantHalfSize;
- const rotation = Math_radians(quadrantIndex * 90);
+ const rotation = Math.radians(quadrantIndex * 90);
context.translate(centerQuadrantX, centerQuadrantY);
context.rotate(rotation);
@@ -414,7 +419,7 @@ export class ShapeDefinition extends BasicSerializableObject {
insetPadding + -quadrantHalfSize,
-insetPadding + quadrantHalfSize,
quadrantSize * layerScale,
- -Math_PI * 0.5,
+ -Math.PI * 0.5,
0
);
context.closePath();
@@ -567,6 +572,23 @@ export class ShapeDefinition extends BasicSerializableObject {
return new ShapeDefinition({ layers: newLayers });
}
+ /**
+ * Clones the shape and inverts all colors
+ */
+ cloneAndInvertColors() {
+ const newLayers = this.internalCloneLayers();
+ for (let layerIndex = 0; layerIndex < newLayers.length; ++layerIndex) {
+ const quadrants = newLayers[layerIndex];
+ for (let quadrantIndex = 0; quadrantIndex < 4; ++quadrantIndex) {
+ const item = quadrants[quadrantIndex];
+ if (item) {
+ item.color = enumInvertedColors[item.color];
+ }
+ }
+ }
+ return new ShapeDefinition({ layers: newLayers });
+ }
+
/**
* Clones the shape and colors everything in the given colors
* @param {[enumColors, enumColors, enumColors, enumColors]} colors
diff --git a/src/js/game/shape_definition_manager.js b/src/js/game/shape_definition_manager.js
index ad682bf0..bebb4592 100644
--- a/src/js/game/shape_definition_manager.js
+++ b/src/js/game/shape_definition_manager.js
@@ -161,6 +161,22 @@ export class ShapeDefinitionManager extends BasicSerializableObject {
));
}
+ /**
+ * Generates a definition for inverting all colors on that shape
+ * @param {ShapeDefinition} definition
+ * @returns {ShapeDefinition}
+ */
+ shapeActionInvertColors(definition) {
+ const key = "invert:" + definition.getHash();
+ if (this.operationCache[key]) {
+ return /** @type {ShapeDefinition} */ (this.operationCache[key]);
+ }
+ const inverted = definition.cloneAndInvertColors();
+ return /** @type {ShapeDefinition} */ (this.operationCache[key] = this.registerOrReturnHandle(
+ inverted
+ ));
+ }
+
/**
* Generates a definition for painting it with the 4 colors
* @param {ShapeDefinition} definition
diff --git a/src/js/game/systems/belt.js b/src/js/game/systems/belt.js
index 5e4ac7f0..db538a56 100644
--- a/src/js/game/systems/belt.js
+++ b/src/js/game/systems/belt.js
@@ -1,24 +1,29 @@
-import { Math_sqrt, Math_max } from "../../core/builtins";
import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters";
import { gMetaBuildingRegistry } from "../../core/global_registries";
import { Loader } from "../../core/loader";
import { createLogger } from "../../core/logging";
-import { Rectangle } from "../../core/rectangle";
import { AtlasSprite } from "../../core/sprites";
+import { fastArrayDeleteValue } from "../../core/utils";
import { enumDirection, enumDirectionToVector, enumInvertedDirections, Vector } from "../../core/vector";
-import { MetaBeltBaseBuilding } from "../buildings/belt_base";
+import { BeltPath } from "../belt_path";
+import { arrayBeltVariantToRotation, MetaBeltBaseBuilding } from "../buildings/belt_base";
import { BeltComponent } from "../components/belt";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { MapChunkView } from "../map_chunk_view";
import { defaultBuildingVariant } from "../meta_building";
+import { enumLayer } from "../root";
+import { MetaWireBaseBuilding } from "../buildings/wire_base";
+import { enumItemType } from "../base_item";
export const BELT_ANIM_COUNT = 28;
-const SQRT_2 = Math_sqrt(2);
const logger = createLogger("belt");
+/**
+ * Manages all belts
+ */
export class BeltSystem extends GameSystemWithFilter {
constructor(root) {
super(root, [BeltComponent]);
@@ -31,6 +36,15 @@ export class BeltSystem extends GameSystemWithFilter {
[enumDirection.right]: Loader.getSprite("sprites/belt/right_0.png"),
};
+ /**
+ * @type {Object.>}
+ */
+ this.wireSprites = {
+ [enumDirection.top]: Loader.getSprite("sprites/buildings/wire_top.png"),
+ [enumDirection.left]: Loader.getSprite("sprites/buildings/wire_left.png"),
+ [enumDirection.right]: Loader.getSprite("sprites/buildings/wire_right.png"),
+ };
+
/**
* @type {Object.>}
*/
@@ -50,12 +64,58 @@ export class BeltSystem extends GameSystemWithFilter {
);
}
- this.root.signals.entityAdded.add(this.updateSurroundingBeltPlacement, this);
+ this.root.signals.entityDestroyed.add(this.onEntityDestroyed, this);
this.root.signals.entityDestroyed.add(this.updateSurroundingBeltPlacement, this);
- this.root.signals.postLoadHook.add(this.computeBeltCache, this);
- /** @type {Rectangle} */
- this.areaToRecompute = null;
+ // Notice: These must come *after* the entity destroyed signals
+ this.root.signals.entityAdded.add(this.onEntityAdded, this);
+ this.root.signals.entityAdded.add(this.updateSurroundingBeltPlacement, this);
+
+ /** @type {Array} */
+ this.beltPaths = [];
+ }
+
+ /**
+ * Serializes all belt paths
+ * @returns {Array