+ ${formatBigNumberFull(puzzle.meta.downloads)}
+ ${formatBigNumberFull(puzzle.meta.likes)}
+
+
+
+
+
+ ${puzzle.meta.shortKey}
+
+
+
+
+
+ `;
+
+ this.trackClicks(this.element.querySelector("button.share"), this.share);
+ this.trackClicks(this.element.querySelector("button.report"), this.report);
+
+ /** @type {HTMLElement} */ (this.element.querySelector(".author span")).innerText =
+ puzzle.meta.author;
+ }
+
+ initialize() {}
+
+ share() {
+ const mode = /** @type {PuzzlePlayGameMode} */ (this.root.gameMode);
+ mode.sharePuzzle();
+ }
+
+ report() {
+ const mode = /** @type {PuzzlePlayGameMode} */ (this.root.gameMode);
+ mode.reportPuzzle();
+ }
+}
diff --git a/src/js/game/hud/parts/puzzle_play_settings.js b/src/js/game/hud/parts/puzzle_play_settings.js
new file mode 100644
index 00000000..168c3de2
--- /dev/null
+++ b/src/js/game/hud/parts/puzzle_play_settings.js
@@ -0,0 +1,36 @@
+import { createLogger } from "../../../core/logging";
+import { makeDiv } from "../../../core/utils";
+import { T } from "../../../translations";
+import { BaseHUDPart } from "../base_hud_part";
+
+const logger = createLogger("puzzle-play");
+
+export class HUDPuzzlePlaySettings extends BaseHUDPart {
+ createElements(parent) {
+ this.element = makeDiv(parent, "ingame_HUD_PuzzlePlaySettings");
+
+ if (this.root.gameMode.getBuildableZones()) {
+ const bind = (selector, handler) =>
+ this.trackClicks(this.element.querySelector(selector), handler);
+ makeDiv(
+ this.element,
+ null,
+ ["section"],
+ `
+
+
+ `
+ );
+
+ bind("button.clear", this.clear);
+ }
+ }
+
+ clear() {
+ this.root.logic.clearAllBeltsAndItems();
+ }
+
+ initialize() {
+ this.visible = true;
+ }
+}
diff --git a/src/js/game/hud/parts/sandbox_controller.js b/src/js/game/hud/parts/sandbox_controller.js
index 592487ee..3689fa36 100644
--- a/src/js/game/hud/parts/sandbox_controller.js
+++ b/src/js/game/hud/parts/sandbox_controller.js
@@ -1,3 +1,4 @@
+import { queryParamOptions } from "../../../core/query_parameters";
import { makeDiv } from "../../../core/utils";
import { BaseHUDPart } from "../base_hud_part";
import { DynamicDomAttach } from "../dynamic_dom_attach";
@@ -19,25 +20,25 @@ export class HUDSandboxController extends BaseHUDPart {
-
+
@@ -117,7 +118,9 @@ export class HUDSandboxController extends BaseHUDPart {
// Clear all shapes of this level
hubGoals.storedShapes[hubGoals.currentGoal.definition.getHash()] = 0;
- this.root.hud.parts.pinnedShapes.rerenderFull();
+ if (this.root.hud.parts.pinnedShapes) {
+ this.root.hud.parts.pinnedShapes.rerenderFull();
+ }
// Compute gained rewards
hubGoals.gainedRewards = {};
@@ -144,7 +147,7 @@ export class HUDSandboxController extends BaseHUDPart {
}
});
- this.visible = !G_IS_DEV;
+ this.visible = false;
this.domAttach = new DynamicDomAttach(this.root, this.element);
}
diff --git a/src/js/game/hud/parts/settings_menu.js b/src/js/game/hud/parts/settings_menu.js
index eb902934..16da0440 100644
--- a/src/js/game/hud/parts/settings_menu.js
+++ b/src/js/game/hud/parts/settings_menu.js
@@ -13,17 +13,19 @@ export class HUDSettingsMenu extends BaseHUDPart {
this.menuElement = makeDiv(this.background, null, ["menuElement"]);
- this.statsElement = makeDiv(
- this.background,
- null,
- ["statsElement"],
- `
+ if (this.root.gameMode.hasHub()) {
+ this.statsElement = makeDiv(
+ this.background,
+ null,
+ ["statsElement"],
+ `
${T.ingame.settingsMenu.beltsPlaced}
${T.ingame.settingsMenu.buildingsPlaced}
${T.ingame.settingsMenu.playtime}
`
- );
+ );
+ }
this.buttonContainer = makeDiv(this.menuElement, null, ["buttons"]);
@@ -94,23 +96,25 @@ export class HUDSettingsMenu extends BaseHUDPart {
const totalMinutesPlayed = Math.ceil(this.root.time.now() / 60);
- /** @type {HTMLElement} */
- const playtimeElement = this.statsElement.querySelector(".playtime");
- /** @type {HTMLElement} */
- const buildingsPlacedElement = this.statsElement.querySelector(".buildingsPlaced");
- /** @type {HTMLElement} */
- const beltsPlacedElement = this.statsElement.querySelector(".beltsPlaced");
+ if (this.root.gameMode.hasHub()) {
+ /** @type {HTMLElement} */
+ const playtimeElement = this.statsElement.querySelector(".playtime");
+ /** @type {HTMLElement} */
+ const buildingsPlacedElement = this.statsElement.querySelector(".buildingsPlaced");
+ /** @type {HTMLElement} */
+ const beltsPlacedElement = this.statsElement.querySelector(".beltsPlaced");
- playtimeElement.innerText = T.global.time.xMinutes.replace("", `${totalMinutesPlayed}`);
+ playtimeElement.innerText = T.global.time.xMinutes.replace("", `${totalMinutesPlayed}`);
- buildingsPlacedElement.innerText = formatBigNumberFull(
- this.root.entityMgr.getAllWithComponent(StaticMapEntityComponent).length -
- this.root.entityMgr.getAllWithComponent(BeltComponent).length
- );
+ buildingsPlacedElement.innerText = formatBigNumberFull(
+ this.root.entityMgr.getAllWithComponent(StaticMapEntityComponent).length -
+ this.root.entityMgr.getAllWithComponent(BeltComponent).length
+ );
- beltsPlacedElement.innerText = formatBigNumberFull(
- this.root.entityMgr.getAllWithComponent(BeltComponent).length
- );
+ beltsPlacedElement.innerText = formatBigNumberFull(
+ this.root.entityMgr.getAllWithComponent(BeltComponent).length
+ );
+ }
}
close() {
diff --git a/src/js/game/hud/parts/waypoints.js b/src/js/game/hud/parts/waypoints.js
index 1a0e3739..2e0bc159 100644
--- a/src/js/game/hud/parts/waypoints.js
+++ b/src/js/game/hud/parts/waypoints.js
@@ -100,16 +100,14 @@ export class HUDWaypoints extends BaseHUDPart {
this.directionIndicatorSprite = Loader.getSprite("sprites/misc/hub_direction_indicator.png");
- /** @type {Array}
- */
- this.waypoints = [
- {
- label: null,
- center: { x: 0, y: 0 },
- zoomLevel: 3,
- layer: gMetaBuildingRegistry.findByClass(MetaHubBuilding).getLayer(),
- },
- ];
+ /** @type {Array} */
+ this.waypoints = [];
+ this.waypoints.push({
+ label: null,
+ center: { x: 0, y: 0 },
+ zoomLevel: 3,
+ layer: gMetaBuildingRegistry.findByClass(MetaHubBuilding).getLayer(),
+ });
// Create a buffer we can use to measure text
this.dummyBuffer = makeOffscreenBuffer(1, 1, {
diff --git a/src/js/game/hud/parts/wires_overlay.js b/src/js/game/hud/parts/wires_overlay.js
index 2fd3092c..328d6689 100644
--- a/src/js/game/hud/parts/wires_overlay.js
+++ b/src/js/game/hud/parts/wires_overlay.js
@@ -28,6 +28,9 @@ export class HUDWiresOverlay extends BaseHUDPart {
* Switches between layers
*/
switchLayers() {
+ if (!this.root.gameMode.getSupportsWires()) {
+ return;
+ }
if (this.root.currentLayer === "regular") {
if (
this.root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers) ||
diff --git a/src/js/game/key_action_mapper.js b/src/js/game/key_action_mapper.js
index 13f33d66..41208d13 100644
--- a/src/js/game/key_action_mapper.js
+++ b/src/js/game/key_action_mapper.js
@@ -49,6 +49,11 @@ export const KEYMAPPINGS = {
},
buildings: {
+ // Puzzle buildings
+ constant_producer: { keyCode: key("H") },
+ goal_acceptor: { keyCode: key("N") },
+ block: { keyCode: key("4") },
+
// Primary Toolbar
belt: { keyCode: key("1") },
balancer: { keyCode: key("2") },
@@ -102,6 +107,7 @@ export const KEYMAPPINGS = {
massSelectSelectMultiple: { keyCode: 16 }, // SHIFT
massSelectCopy: { keyCode: key("C") },
massSelectCut: { keyCode: key("X") },
+ massSelectClear: { keyCode: key("B") },
confirmMassDelete: { keyCode: 46 }, // DEL
pasteLastBlueprint: { keyCode: key("V") },
},
@@ -262,6 +268,8 @@ export function getStringForKeyCode(code) {
return ".";
case 191:
return "/";
+ case 192:
+ return "`";
case 219:
return "[";
case 220:
@@ -322,6 +330,15 @@ export class Keybinding {
this.signal.add(receiver, scope);
}
+ /**
+ * Adds an event listener
+ * @param {function() : void} receiver
+ * @param {object=} scope
+ */
+ addToTop(receiver, scope = null) {
+ this.signal.addToTop(receiver, scope);
+ }
+
/**
* @param {Element} elem
* @returns {HTMLElement} the created element, or null if the keybindings are not shown
diff --git a/src/js/game/logic.js b/src/js/game/logic.js
index 7ec7b8ab..20caca31 100644
--- a/src/js/game/logic.js
+++ b/src/js/game/logic.js
@@ -4,6 +4,7 @@ import { STOP_PROPAGATION } from "../core/signal";
import { round2Digits } from "../core/utils";
import { enumDirection, enumDirectionToVector, enumInvertedDirections, Vector } from "../core/vector";
import { getBuildingDataFromCode } from "./building_codes";
+import { Component } from "./component";
import { enumWireVariant } from "./components/wire";
import { Entity } from "./entity";
import { CHUNK_OVERLAY_RES } from "./map_chunk_view";
@@ -161,13 +162,34 @@ export class GameLogic {
return returnValue;
}
+ /**
+ * Performs a immutable operation, causing no recalculations
+ * @param {function} operation
+ */
+ performImmutableOperation(operation) {
+ logger.warn("Running immutable operation ...");
+ assert(!this.root.immutableOperationRunning, "Can not run two immutalbe operations twice");
+ this.root.immutableOperationRunning = true;
+ const now = performance.now();
+ const returnValue = operation();
+ const duration = performance.now() - now;
+ logger.log("Done in", round2Digits(duration), "ms");
+ assert(
+ this.root.immutableOperationRunning,
+ "Immutable operation = false while immutable operation was running"
+ );
+ this.root.immutableOperationRunning = false;
+ this.root.signals.immutableOperationFinished.dispatch();
+ return returnValue;
+ }
+
/**
* Returns whether the given building can get removed
* @param {Entity} building
*/
canDeleteBuilding(building) {
const staticComp = building.components.StaticMapEntity;
- return staticComp.getMetaBuilding().getIsRemovable();
+ return staticComp.getMetaBuilding().getIsRemovable(this.root);
}
/**
@@ -342,8 +364,6 @@ export class GameLogic {
return !!overlayMatrix[localPosition.x + localPosition.y * 3];
}
- g(tile, edge) {}
-
/**
* Returns the acceptors and ejectors which affect the current tile
* @param {Vector} tile
@@ -425,4 +445,15 @@ export class GameLogic {
}
return { ejectors, acceptors };
}
+
+ /**
+ * Clears all belts and items
+ */
+ clearAllBeltsAndItems() {
+ for (const entity of this.root.entityMgr.entities) {
+ for (const component of Object.values(entity.components)) {
+ /** @type {Component} */ (component).clear();
+ }
+ }
+ }
}
diff --git a/src/js/game/map_chunk_view.js b/src/js/game/map_chunk_view.js
index 848afbab..131ce37b 100644
--- a/src/js/game/map_chunk_view.js
+++ b/src/js/game/map_chunk_view.js
@@ -41,7 +41,14 @@ export class MapChunkView extends MapChunk {
*/
drawBackgroundLayer(parameters) {
const systems = this.root.systemMgr.systems;
- systems.mapResources.drawChunk(parameters, this);
+ if (systems.zone) {
+ systems.zone.drawChunk(parameters, this);
+ }
+
+ if (this.root.gameMode.hasResources()) {
+ systems.mapResources.drawChunk(parameters, this);
+ }
+
systems.beltUnderlays.drawChunk(parameters, this);
systems.belt.drawChunk(parameters, this);
}
@@ -69,6 +76,8 @@ export class MapChunkView extends MapChunk {
systems.lever.drawChunk(parameters, this);
systems.display.drawChunk(parameters, this);
systems.storage.drawChunk(parameters, this);
+ systems.constantProducer.drawChunk(parameters, this);
+ systems.goalAcceptor.drawChunk(parameters, this);
systems.itemProcessorOverlays.drawChunk(parameters, this);
}
diff --git a/src/js/game/meta_building.js b/src/js/game/meta_building.js
index 9deee272..f3df0b62 100644
--- a/src/js/game/meta_building.js
+++ b/src/js/game/meta_building.js
@@ -108,9 +108,10 @@ export class MetaBuilding {
/**
* Returns whether this building is removable
+ * @param {GameRoot} root
* @returns {boolean}
*/
- getIsRemovable() {
+ getIsRemovable(root) {
return true;
}
diff --git a/src/js/game/meta_building_registry.js b/src/js/game/meta_building_registry.js
index 0613103e..0c93153d 100644
--- a/src/js/game/meta_building_registry.js
+++ b/src/js/game/meta_building_registry.js
@@ -4,11 +4,14 @@ import { T } from "../translations";
import { MetaAnalyzerBuilding } from "./buildings/analyzer";
import { enumBalancerVariants, MetaBalancerBuilding } from "./buildings/balancer";
import { MetaBeltBuilding } from "./buildings/belt";
+import { MetaBlockBuilding } from "./buildings/block";
import { MetaComparatorBuilding } from "./buildings/comparator";
+import { MetaConstantProducerBuilding } from "./buildings/constant_producer";
import { MetaConstantSignalBuilding } from "./buildings/constant_signal";
import { enumCutterVariants, MetaCutterBuilding } from "./buildings/cutter";
import { MetaDisplayBuilding } from "./buildings/display";
import { MetaFilterBuilding } from "./buildings/filter";
+import { MetaGoalAcceptorBuilding } from "./buildings/goal_acceptor";
import { MetaHubBuilding } from "./buildings/hub";
import { MetaItemProducerBuilding } from "./buildings/item_producer";
import { MetaLeverBuilding } from "./buildings/lever";
@@ -45,6 +48,7 @@ export function initMetaBuildingRegistry() {
gMetaBuildingRegistry.register(MetaStorageBuilding);
gMetaBuildingRegistry.register(MetaBeltBuilding);
gMetaBuildingRegistry.register(MetaUndergroundBeltBuilding);
+ gMetaBuildingRegistry.register(MetaGoalAcceptorBuilding);
gMetaBuildingRegistry.register(MetaHubBuilding);
gMetaBuildingRegistry.register(MetaWireBuilding);
gMetaBuildingRegistry.register(MetaConstantSignalBuilding);
@@ -59,6 +63,8 @@ export function initMetaBuildingRegistry() {
gMetaBuildingRegistry.register(MetaAnalyzerBuilding);
gMetaBuildingRegistry.register(MetaComparatorBuilding);
gMetaBuildingRegistry.register(MetaItemProducerBuilding);
+ gMetaBuildingRegistry.register(MetaConstantProducerBuilding);
+ gMetaBuildingRegistry.register(MetaBlockBuilding);
// Belt
registerBuildingVariant(1, MetaBeltBuilding, defaultBuildingVariant, 0);
@@ -165,6 +171,15 @@ export function initMetaBuildingRegistry() {
// Item producer
registerBuildingVariant(61, MetaItemProducerBuilding);
+ // Constant producer
+ registerBuildingVariant(62, MetaConstantProducerBuilding);
+
+ // Goal acceptor
+ registerBuildingVariant(63, MetaGoalAcceptorBuilding);
+
+ // Block
+ registerBuildingVariant(64, MetaBlockBuilding);
+
// Propagate instances
for (const key in gBuildingVariants) {
gBuildingVariants[key].metaInstance = gMetaBuildingRegistry.findByClass(
diff --git a/src/js/game/modes/puzzle.js b/src/js/game/modes/puzzle.js
new file mode 100644
index 00000000..4bf3b1e6
--- /dev/null
+++ b/src/js/game/modes/puzzle.js
@@ -0,0 +1,106 @@
+/* typehints:start */
+import { GameRoot } from "../root";
+/* typehints:end */
+
+import { Rectangle } from "../../core/rectangle";
+import { types } from "../../savegame/serialization";
+import { enumGameModeTypes, GameMode } from "../game_mode";
+import { HUDPuzzleBackToMenu } from "../hud/parts/puzzle_back_to_menu";
+import { HUDPuzzleDLCLogo } from "../hud/parts/puzzle_dlc_logo";
+
+export class PuzzleGameMode extends GameMode {
+ static getType() {
+ return enumGameModeTypes.puzzle;
+ }
+
+ /** @returns {object} */
+ static getSchema() {
+ return {
+ zoneHeight: types.uint,
+ zoneWidth: types.uint,
+ };
+ }
+
+ /** @param {GameRoot} root */
+ constructor(root) {
+ super(root);
+
+ const data = this.getSaveData();
+
+ this.additionalHudParts = {
+ puzzleBackToMenu: HUDPuzzleBackToMenu,
+ puzzleDlcLogo: HUDPuzzleDLCLogo,
+ };
+
+ this.zoneWidth = data.zoneWidth || 8;
+ this.zoneHeight = data.zoneHeight || 6;
+ }
+
+ /**
+ * @param {typeof import("../meta_building").MetaBuilding} building
+ */
+ isBuildingExcluded(building) {
+ return this.hiddenBuildings.indexOf(building) >= 0;
+ }
+
+ getSaveData() {
+ const save = this.root.savegame.getCurrentDump();
+ if (!save) {
+ return {};
+ }
+ return save.gameMode.data;
+ }
+
+ getCameraBounds() {
+ return Rectangle.centered(this.zoneWidth + 20, this.zoneHeight + 20);
+ }
+
+ getBuildableZones() {
+ return [Rectangle.centered(this.zoneWidth, this.zoneHeight)];
+ }
+
+ hasHub() {
+ return false;
+ }
+
+ hasResources() {
+ return false;
+ }
+
+ getMinimumZoom() {
+ return 1;
+ }
+
+ getMaximumZoom() {
+ return 4;
+ }
+
+ getIsSaveable() {
+ return false;
+ }
+
+ getSupportsCopyPaste() {
+ return false;
+ }
+
+ throughputDoesNotMatter() {
+ return true;
+ }
+
+ getSupportsWires() {
+ return false;
+ }
+
+ getFixedTickrate() {
+ return 300;
+ }
+
+ getIsDeterministic() {
+ return true;
+ }
+
+ /** @returns {boolean} */
+ getIsFreeplayAvailable() {
+ return true;
+ }
+}
diff --git a/src/js/game/modes/puzzle_edit.js b/src/js/game/modes/puzzle_edit.js
new file mode 100644
index 00000000..e3d2e40d
--- /dev/null
+++ b/src/js/game/modes/puzzle_edit.js
@@ -0,0 +1,66 @@
+/* typehints:start */
+import { GameRoot } from "../root";
+/* typehints:end */
+
+import { enumGameModeIds } from "../game_mode";
+import { PuzzleGameMode } from "./puzzle";
+import { MetaStorageBuilding } from "../buildings/storage";
+import { MetaReaderBuilding } from "../buildings/reader";
+import { MetaFilterBuilding } from "../buildings/filter";
+import { MetaDisplayBuilding } from "../buildings/display";
+import { MetaLeverBuilding } from "../buildings/lever";
+import { MetaItemProducerBuilding } from "../buildings/item_producer";
+import { MetaMinerBuilding } from "../buildings/miner";
+import { MetaWireBuilding } from "../buildings/wire";
+import { MetaWireTunnelBuilding } from "../buildings/wire_tunnel";
+import { MetaConstantSignalBuilding } from "../buildings/constant_signal";
+import { MetaLogicGateBuilding } from "../buildings/logic_gate";
+import { MetaVirtualProcessorBuilding } from "../buildings/virtual_processor";
+import { MetaAnalyzerBuilding } from "../buildings/analyzer";
+import { MetaComparatorBuilding } from "../buildings/comparator";
+import { MetaTransistorBuilding } from "../buildings/transistor";
+import { HUDPuzzleEditorControls } from "../hud/parts/puzzle_editor_controls";
+import { HUDPuzzleEditorReview } from "../hud/parts/puzzle_editor_review";
+import { HUDPuzzleEditorSettings } from "../hud/parts/puzzle_editor_settings";
+
+export class PuzzleEditGameMode extends PuzzleGameMode {
+ static getId() {
+ return enumGameModeIds.puzzleEdit;
+ }
+
+ static getSchema() {
+ return {};
+ }
+
+ /** @param {GameRoot} root */
+ constructor(root) {
+ super(root);
+
+ this.hiddenBuildings = [
+ MetaStorageBuilding,
+ MetaReaderBuilding,
+ MetaFilterBuilding,
+ MetaDisplayBuilding,
+ MetaLeverBuilding,
+ MetaItemProducerBuilding,
+ MetaMinerBuilding,
+
+ MetaWireBuilding,
+ MetaWireTunnelBuilding,
+ MetaConstantSignalBuilding,
+ MetaLogicGateBuilding,
+ MetaVirtualProcessorBuilding,
+ MetaAnalyzerBuilding,
+ MetaComparatorBuilding,
+ MetaTransistorBuilding,
+ ];
+
+ this.additionalHudParts.puzzleEditorControls = HUDPuzzleEditorControls;
+ this.additionalHudParts.puzzleEditorReview = HUDPuzzleEditorReview;
+ this.additionalHudParts.puzzleEditorSettings = HUDPuzzleEditorSettings;
+ }
+
+ getIsEditor() {
+ return true;
+ }
+}
diff --git a/src/js/game/modes/puzzle_play.js b/src/js/game/modes/puzzle_play.js
new file mode 100644
index 00000000..46480c51
--- /dev/null
+++ b/src/js/game/modes/puzzle_play.js
@@ -0,0 +1,193 @@
+/* typehints:start */
+import { GameRoot } from "../root";
+/* typehints:end */
+
+import { enumGameModeIds } from "../game_mode";
+import { PuzzleGameMode } from "./puzzle";
+import { MetaStorageBuilding } from "../buildings/storage";
+import { MetaReaderBuilding } from "../buildings/reader";
+import { MetaFilterBuilding } from "../buildings/filter";
+import { MetaDisplayBuilding } from "../buildings/display";
+import { MetaLeverBuilding } from "../buildings/lever";
+import { MetaItemProducerBuilding } from "../buildings/item_producer";
+import { MetaMinerBuilding } from "../buildings/miner";
+import { MetaWireBuilding } from "../buildings/wire";
+import { MetaWireTunnelBuilding } from "../buildings/wire_tunnel";
+import { MetaConstantSignalBuilding } from "../buildings/constant_signal";
+import { MetaLogicGateBuilding } from "../buildings/logic_gate";
+import { MetaVirtualProcessorBuilding } from "../buildings/virtual_processor";
+import { MetaAnalyzerBuilding } from "../buildings/analyzer";
+import { MetaComparatorBuilding } from "../buildings/comparator";
+import { MetaTransistorBuilding } from "../buildings/transistor";
+import { MetaConstantProducerBuilding } from "../buildings/constant_producer";
+import { MetaGoalAcceptorBuilding } from "../buildings/goal_acceptor";
+import { PuzzleSerializer } from "../../savegame/puzzle_serializer";
+import { T } from "../../translations";
+import { HUDPuzzlePlayMetadata } from "../hud/parts/puzzle_play_metadata";
+import { createLogger } from "../../core/logging";
+import { HUDPuzzleCompleteNotification } from "../hud/parts/puzzle_complete_notification";
+import { HUDPuzzlePlaySettings } from "../hud/parts/puzzle_play_settings";
+import { MetaBlockBuilding } from "../buildings/block";
+import { MetaBuilding } from "../meta_building";
+import { gMetaBuildingRegistry } from "../../core/global_registries";
+
+const logger = createLogger("puzzle-play");
+const copy = require("clipboard-copy");
+
+export class PuzzlePlayGameMode extends PuzzleGameMode {
+ static getId() {
+ return enumGameModeIds.puzzlePlay;
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {object} payload
+ * @param {import("../../savegame/savegame_typedefs").PuzzleFullData} payload.puzzle
+ */
+ constructor(root, { puzzle }) {
+ super(root);
+
+ /** @type {Array} */
+ let excludedBuildings = [
+ MetaConstantProducerBuilding,
+ MetaGoalAcceptorBuilding,
+ MetaBlockBuilding,
+
+ MetaStorageBuilding,
+ MetaReaderBuilding,
+ MetaFilterBuilding,
+ MetaDisplayBuilding,
+ MetaLeverBuilding,
+ MetaItemProducerBuilding,
+ MetaMinerBuilding,
+
+ MetaWireBuilding,
+ MetaWireTunnelBuilding,
+ MetaConstantSignalBuilding,
+ MetaLogicGateBuilding,
+ MetaVirtualProcessorBuilding,
+ MetaAnalyzerBuilding,
+ MetaComparatorBuilding,
+ MetaTransistorBuilding,
+ ];
+
+ if (puzzle.game.excludedBuildings) {
+ /**
+ * @type {any}
+ */
+ const puzzleHidden = puzzle.game.excludedBuildings
+ .map(id => {
+ if (!gMetaBuildingRegistry.hasId(id)) {
+ return;
+ }
+ return gMetaBuildingRegistry.findById(id).constructor;
+ })
+ .filter(x => !!x);
+ excludedBuildings = excludedBuildings.concat(puzzleHidden);
+ }
+
+ this.hiddenBuildings = excludedBuildings;
+
+ this.additionalHudParts.puzzlePlayMetadata = HUDPuzzlePlayMetadata;
+ this.additionalHudParts.puzzlePlaySettings = HUDPuzzlePlaySettings;
+ this.additionalHudParts.puzzleCompleteNotification = HUDPuzzleCompleteNotification;
+
+ root.signals.postLoadHook.add(this.loadPuzzle, this);
+
+ this.puzzle = puzzle;
+ }
+
+ loadPuzzle() {
+ let errorText;
+ logger.log("Loading puzzle", this.puzzle);
+
+ try {
+ this.zoneWidth = this.puzzle.game.bounds.w;
+ this.zoneHeight = this.puzzle.game.bounds.h;
+ errorText = new PuzzleSerializer().deserializePuzzle(this.root, this.puzzle.game);
+ } catch (ex) {
+ errorText = ex.message || ex;
+ }
+
+ if (errorText) {
+ this.root.gameState.moveToState("PuzzleMenuState", {
+ error: {
+ title: T.dialogs.puzzleLoadError.title,
+ desc: T.dialogs.puzzleLoadError.desc + " " + errorText,
+ },
+ });
+ // const signals = this.root.hud.parts.dialogs.showWarning(
+ // T.dialogs.puzzleLoadError.title,
+ // T.dialogs.puzzleLoadError.desc + " " + errorText
+ // );
+ // signals.ok.add(() => this.root.gameState.moveToState("PuzzleMenuState"));
+ }
+ }
+
+ /**
+ *
+ * @param {boolean} liked
+ * @param {number} time
+ */
+ trackCompleted(liked, time) {
+ const closeLoading = this.root.hud.parts.dialogs.showLoadingDialog();
+
+ return this.root.app.clientApi
+ .apiCompletePuzzle(this.puzzle.meta.id, {
+ time,
+ liked,
+ })
+ .catch(err => {
+ logger.warn("Failed to complete puzzle:", err);
+ })
+ .then(() => {
+ closeLoading();
+ });
+ }
+
+ sharePuzzle() {
+ copy(this.puzzle.meta.shortKey);
+
+ this.root.hud.parts.dialogs.showInfo(
+ T.dialogs.puzzleShare.title,
+ T.dialogs.puzzleShare.desc.replace("", this.puzzle.meta.shortKey)
+ );
+ }
+
+ reportPuzzle() {
+ const { optionSelected } = this.root.hud.parts.dialogs.showOptionChooser(
+ T.dialogs.puzzleReport.title,
+ {
+ options: [
+ { value: "profane", text: T.dialogs.puzzleReport.options.profane },
+ { value: "unsolvable", text: T.dialogs.puzzleReport.options.unsolvable },
+ { value: "trolling", text: T.dialogs.puzzleReport.options.trolling },
+ ],
+ }
+ );
+
+ return new Promise(resolve => {
+ optionSelected.add(option => {
+ const closeLoading = this.root.hud.parts.dialogs.showLoadingDialog();
+
+ this.root.app.clientApi.apiReportPuzzle(this.puzzle.meta.id, option).then(
+ () => {
+ closeLoading();
+ const { ok } = this.root.hud.parts.dialogs.showInfo(
+ T.dialogs.puzzleReportComplete.title,
+ T.dialogs.puzzleReportComplete.desc
+ );
+ ok.add(resolve);
+ },
+ err => {
+ closeLoading();
+ const { ok } = this.root.hud.parts.dialogs.showInfo(
+ T.dialogs.puzzleReportError.title,
+ T.dialogs.puzzleReportError.desc + " " + err
+ );
+ }
+ );
+ });
+ });
+ }
+}
diff --git a/src/js/game/modes/regular.js b/src/js/game/modes/regular.js
index e99f4a7c..0b71ff39 100644
--- a/src/js/game/modes/regular.js
+++ b/src/js/game/modes/regular.js
@@ -1,19 +1,74 @@
+/* typehints:start */
+import { GameRoot } from "../root";
+import { MetaBuilding } from "../meta_building";
+/* typehints:end */
+
import { findNiceIntegerValue } from "../../core/utils";
-import { GameMode } from "../game_mode";
+import { MetaConstantProducerBuilding } from "../buildings/constant_producer";
+import { MetaGoalAcceptorBuilding } from "../buildings/goal_acceptor";
+import { enumGameModeIds, enumGameModeTypes, GameMode } from "../game_mode";
import { ShapeDefinition } from "../shape_definition";
import { enumHubGoalRewards } from "../tutorial_goals";
-
-const rocketShape = "CbCuCbCu:Sr------:--CrSrCr:CwCwCwCw";
-const finalGameShape = "RuCw--Cw:----Ru--";
+import { HUDWiresToolbar } from "../hud/parts/wires_toolbar";
+import { HUDBlueprintPlacer } from "../hud/parts/blueprint_placer";
+import { HUDUnlockNotification } from "../hud/parts/unlock_notification";
+import { HUDMassSelector } from "../hud/parts/mass_selector";
+import { HUDShop } from "../hud/parts/shop";
+import { HUDWaypoints } from "../hud/parts/waypoints";
+import { HUDStatistics } from "../hud/parts/statistics";
+import { HUDWireInfo } from "../hud/parts/wire_info";
+import { HUDLeverToggle } from "../hud/parts/lever_toggle";
+import { HUDPinnedShapes } from "../hud/parts/pinned_shapes";
+import { HUDNotifications } from "../hud/parts/notifications";
+import { HUDScreenshotExporter } from "../hud/parts/screenshot_exporter";
+import { HUDWiresOverlay } from "../hud/parts/wires_overlay";
+import { HUDShapeViewer } from "../hud/parts/shape_viewer";
+import { HUDLayerPreview } from "../hud/parts/layer_preview";
+import { HUDTutorialVideoOffer } from "../hud/parts/tutorial_video_offer";
+import { HUDMinerHighlight } from "../hud/parts/miner_highlight";
+import { HUDGameMenu } from "../hud/parts/game_menu";
+import { HUDConstantSignalEdit } from "../hud/parts/constant_signal_edit";
+import { IS_MOBILE } from "../../core/config";
+import { HUDKeybindingOverlay } from "../hud/parts/keybinding_overlay";
+import { HUDWatermark } from "../hud/parts/watermark";
+import { HUDStandaloneAdvantages } from "../hud/parts/standalone_advantages";
+import { HUDCatMemes } from "../hud/parts/cat_memes";
+import { HUDPartTutorialHints } from "../hud/parts/tutorial_hints";
+import { HUDInteractiveTutorial } from "../hud/parts/interactive_tutorial";
+import { HUDSandboxController } from "../hud/parts/sandbox_controller";
+import { queryParamOptions } from "../../core/query_parameters";
+import { MetaBlockBuilding } from "../buildings/block";
+
+/** @typedef {{
+ * shape: string,
+ * amount: number
+ * }} UpgradeRequirement */
+
+/** @typedef {{
+ * required: Array
+ * improvement?: number,
+ * excludePrevious?: boolean
+ * }} TierRequirement */
+
+/** @typedef {Array} UpgradeTiers */
+
+/** @typedef {{
+ * shape: string,
+ * required: number,
+ * reward: enumHubGoalRewards,
+ * throughputOnly?: boolean
+ * }} LevelDefinition */
+
+export const rocketShape = "CbCuCbCu:Sr------:--CrSrCr:CwCwCwCw";
+export const finalGameShape = "RuCw--Cw:----Ru--";
const preparementShape = "CpRpCp--:SwSwSwSw";
-const blueprintShape = "CbCbCbRb:CwCwCwCw";
// Tiers need % of the previous tier as requirement too
const tierGrowth = 2.5;
/**
* Generates all upgrades
- * @returns {Object} */
+ * @returns {Object} */
function generateUpgrades(limitedVersion = false) {
const fixedImprovements = [0.5, 0.5, 1, 1, 2, 1, 1];
const numEndgameUpgrades = limitedVersion ? 0 : 1000 - fixedImprovements.length - 1;
@@ -87,7 +142,14 @@ function generateUpgrades(limitedVersion = false) {
required: [{ shape: "CwCwCwCw:WbWbWbWb", amount: 23000 }],
},
{
- required: [{ shape: "CbRbRbCb:CwCwCwCw:WbWbWbWb", amount: 50000 }],
+ required: [
+ {
+ shape: G_CHINA_VERSION
+ ? "CyCyCyCy:CyCyCyCy:RyRyRyRy:RuRuRuRu"
+ : "CbRbRbCb:CwCwCwCw:WbWbWbWb",
+ amount: 50000,
+ },
+ ],
},
{
required: [{ shape: preparementShape, amount: 25000 }],
@@ -141,7 +203,12 @@ function generateUpgrades(limitedVersion = false) {
required: [{ shape: "WrWrWrWr", amount: 3800 }],
},
{
- required: [{ shape: "RpRpRpRp:CwCwCwCw", amount: 6500 }],
+ required: [
+ {
+ shape: G_CHINA_VERSION ? "CuCuCuCu:CwCwCwCw:Sb--Sr--" : "RpRpRpRp:CwCwCwCw",
+ amount: 6500,
+ },
+ ],
},
{
required: [{ shape: "WpWpWpWp:CwCwCwCw:WpWpWpWp", amount: 25000 }],
@@ -315,7 +382,7 @@ export function generateLevelDefinitions(limitedVersion = false) {
// 13
// Tunnel Tier 2
{
- shape: "RpRpRpRp:CwCwCwCw", // painting t3
+ shape: G_CHINA_VERSION ? "CuCuCuCu:CwCwCwCw:Sb--Sr--" : "RpRpRpRp:CwCwCwCw", // painting t3
required: 3800,
reward: enumHubGoalRewards.reward_underground_belt_tier_2,
},
@@ -324,7 +391,7 @@ export function generateLevelDefinitions(limitedVersion = false) {
...(limitedVersion
? [
{
- shape: "RpRpRpRp:CwCwCwCw",
+ shape: G_CHINA_VERSION ? "CuCuCuCu:CwCwCwCw:Sb--Sr--" : "RpRpRpRp:CwCwCwCw",
required: 0,
reward: enumHubGoalRewards.reward_demo_end,
},
@@ -358,7 +425,9 @@ export function generateLevelDefinitions(limitedVersion = false) {
// 17
// Double painter
{
- shape: "CbRbRbCb:CwCwCwCw:WbWbWbWb", // miner t4 (two variants)
+ shape: G_CHINA_VERSION
+ ? "CyCyCyCy:CyCyCyCy:RyRyRyRy:RuRuRuRu"
+ : "CbRbRbCb:CwCwCwCw:WbWbWbWb", // miner t4 (two variants)
required: 20000,
reward: enumHubGoalRewards.reward_painter_double,
},
@@ -398,7 +467,9 @@ export function generateLevelDefinitions(limitedVersion = false) {
// 22
// Constant signal
{
- shape: "Cg----Cr:Cw----Cw:Sy------:Cy----Cy",
+ shape: G_CHINA_VERSION
+ ? "RrSySrSy:RyCrCwCr:CyCyRyCy"
+ : "Cg----Cr:Cw----Cw:Sy------:Cy----Cy",
required: 25000,
reward: enumHubGoalRewards.reward_constant_signal,
},
@@ -406,14 +477,18 @@ export function generateLevelDefinitions(limitedVersion = false) {
// 23
// Display
{
- shape: "CcSyCcSy:SyCcSyCc:CcSyCcSy",
+ shape: G_CHINA_VERSION
+ ? "CrCrCrCr:CwCwCwCw:WwWwWwWw:CrCrCrCr"
+ : "CcSyCcSy:SyCcSyCc:CcSyCcSy",
required: 25000,
reward: enumHubGoalRewards.reward_display,
},
// 24 Logic gates
{
- shape: "CcRcCcRc:RwCwRwCw:Sr--Sw--:CyCyCyCy",
+ shape: G_CHINA_VERSION
+ ? "Su----Su:RwRwRwRw:Cu----Cu:CwCwCwCw"
+ : "CcRcCcRc:RwCwRwCw:Sr--Sw--:CyCyCyCy",
required: 25000,
reward: enumHubGoalRewards.reward_logic_gates,
},
@@ -454,27 +529,90 @@ const fullVersionLevels = generateLevelDefinitions(false);
const demoVersionLevels = generateLevelDefinitions(true);
export class RegularGameMode extends GameMode {
+ static getId() {
+ return enumGameModeIds.regular;
+ }
+
+ static getType() {
+ return enumGameModeTypes.default;
+ }
+
+ /** @param {GameRoot} root */
constructor(root) {
super(root);
+
+ this.additionalHudParts = {
+ wiresToolbar: HUDWiresToolbar,
+ blueprintPlacer: HUDBlueprintPlacer,
+ unlockNotification: HUDUnlockNotification,
+ massSelector: HUDMassSelector,
+ shop: HUDShop,
+ statistics: HUDStatistics,
+ waypoints: HUDWaypoints,
+ wireInfo: HUDWireInfo,
+ leverToggle: HUDLeverToggle,
+ pinnedShapes: HUDPinnedShapes,
+ notifications: HUDNotifications,
+ screenshotExporter: HUDScreenshotExporter,
+ wiresOverlay: HUDWiresOverlay,
+ shapeViewer: HUDShapeViewer,
+ layerPreview: HUDLayerPreview,
+ minerHighlight: HUDMinerHighlight,
+ tutorialVideoOffer: HUDTutorialVideoOffer,
+ gameMenu: HUDGameMenu,
+ constantSignalEdit: HUDConstantSignalEdit,
+ };
+
+ if (!IS_MOBILE) {
+ this.additionalHudParts.keybindingOverlay = HUDKeybindingOverlay;
+ }
+
+ if (this.root.app.restrictionMgr.getIsStandaloneMarketingActive()) {
+ this.additionalHudParts.watermark = HUDWatermark;
+ this.additionalHudParts.standaloneAdvantages = HUDStandaloneAdvantages;
+ this.additionalHudParts.catMemes = HUDCatMemes;
+ }
+
+ if (this.root.app.settings.getAllSettings().offerHints) {
+ this.additionalHudParts.tutorialHints = HUDPartTutorialHints;
+ this.additionalHudParts.interactiveTutorial = HUDInteractiveTutorial;
+ }
+
+ // @ts-ignore
+ if (queryParamOptions.sandboxMode || window.sandboxMode || G_IS_DEV) {
+ this.additionalHudParts.sandboxController = HUDSandboxController;
+ }
+
+ /** @type {(typeof MetaBuilding)[]} */
+ this.hiddenBuildings = [MetaConstantProducerBuilding, MetaGoalAcceptorBuilding, MetaBlockBuilding];
}
+ /**
+ * Should return all available upgrades
+ * @returns {Object}
+ */
getUpgrades() {
return this.root.app.restrictionMgr.getHasExtendedUpgrades()
? fullVersionUpgrades
: demoVersionUpgrades;
}
- getIsFreeplayAvailable() {
- return this.root.app.restrictionMgr.getHasExtendedLevelsAndFreeplay();
- }
-
- getBlueprintShapeKey() {
- return blueprintShape;
- }
-
+ /**
+ * Returns the goals for all levels including their reward
+ * @returns {Array}
+ */
getLevelDefinitions() {
return this.root.app.restrictionMgr.getHasExtendedLevelsAndFreeplay()
? fullVersionLevels
: demoVersionLevels;
}
+
+ /**
+ * Should return whether free play is available or if the game stops
+ * after the predefined levels
+ * @returns {boolean}
+ */
+ getIsFreeplayAvailable() {
+ return this.root.app.restrictionMgr.getHasExtendedLevelsAndFreeplay();
+ }
}
diff --git a/src/js/game/root.js b/src/js/game/root.js
index 82d1e49f..64004e9d 100644
--- a/src/js/game/root.js
+++ b/src/js/game/root.js
@@ -79,6 +79,11 @@ export class GameRoot {
*/
this.bulkOperationRunning = false;
+ /**
+ * Whether a immutable operation is running
+ */
+ this.immutableOperationRunning = false;
+
//////// Other properties ///////
/** @type {Camera} */
@@ -169,6 +174,7 @@ export class GameRoot {
itemProduced: /** @type {TypedSignal<[BaseItem]>} */ (new Signal()),
bulkOperationFinished: /** @type {TypedSignal<[]>} */ (new Signal()),
+ immutableOperationFinished: /** @type {TypedSignal<[]>} */ (new Signal()),
editModeChanged: /** @type {TypedSignal<[Layer]>} */ (new Signal()),
@@ -183,6 +189,9 @@ export class GameRoot {
// Called with an achievement key and necessary args to validate it can be unlocked.
achievementCheck: /** @type {TypedSignal<[string, any]>} */ (new Signal()),
bulkAchievementCheck: /** @type {TypedSignal<(string|any)[]>} */ (new Signal()),
+
+ // Puzzle mode
+ puzzleComplete: /** @type {TypedSignal<[]>} */ (new Signal()),
};
// RNG's
diff --git a/src/js/game/systems/belt.js b/src/js/game/systems/belt.js
index 10543e6c..00491eff 100644
--- a/src/js/game/systems/belt.js
+++ b/src/js/game/systems/belt.js
@@ -164,7 +164,10 @@ export class BeltSystem extends GameSystemWithFilter {
// Compute delta to see if anything changed
const newDirection = arrayBeltVariantToRotation[rotationVariant];
- if (targetStaticComp.rotation !== rotation || newDirection !== targetBeltComp.direction) {
+ if (
+ !this.root.immutableOperationRunning &&
+ (targetStaticComp.rotation !== rotation || newDirection !== targetBeltComp.direction)
+ ) {
const originalPath = targetBeltComp.assignedPath;
// Ok, first remove it from its current path
diff --git a/src/js/game/systems/belt_reader.js b/src/js/game/systems/belt_reader.js
index fbd00b6c..f6080aa9 100644
--- a/src/js/game/systems/belt_reader.js
+++ b/src/js/game/systems/belt_reader.js
@@ -14,7 +14,6 @@ export class BeltReaderSystem extends GameSystemWithFilter {
const minimumTimeForThroughput = now - 1;
for (let i = 0; i < this.allEntities.length; ++i) {
const entity = this.allEntities[i];
-
const readerComp = entity.components.BeltReader;
const pinsComp = entity.components.WiredPins;
@@ -23,12 +22,14 @@ export class BeltReaderSystem extends GameSystemWithFilter {
readerComp.lastItemTimes.shift();
}
- pinsComp.slots[1].value = readerComp.lastItem;
- pinsComp.slots[0].value =
- (readerComp.lastItemTimes[readerComp.lastItemTimes.length - 1] || 0) >
- minimumTimeForThroughput
- ? BOOL_TRUE_SINGLETON
- : BOOL_FALSE_SINGLETON;
+ if (!entity.components.BeltReader.isWireless()) {
+ pinsComp.slots[1].value = readerComp.lastItem;
+ pinsComp.slots[0].value =
+ (readerComp.lastItemTimes[readerComp.lastItemTimes.length - 1] || 0) >
+ minimumTimeForThroughput
+ ? BOOL_TRUE_SINGLETON
+ : BOOL_FALSE_SINGLETON;
+ }
if (now - readerComp.lastThroughputComputation > 0.5) {
// Compute throughput
diff --git a/src/js/game/systems/constant_producer.js b/src/js/game/systems/constant_producer.js
new file mode 100644
index 00000000..fa9f9e52
--- /dev/null
+++ b/src/js/game/systems/constant_producer.js
@@ -0,0 +1,66 @@
+import { globalConfig } from "../../core/config";
+import { DrawParameters } from "../../core/draw_parameters";
+import { Vector } from "../../core/vector";
+import { ConstantSignalComponent } from "../components/constant_signal";
+import { ItemProducerComponent } from "../components/item_producer";
+import { GameSystemWithFilter } from "../game_system_with_filter";
+import { MapChunk } from "../map_chunk";
+import { GameRoot } from "../root";
+
+export class ConstantProducerSystem extends GameSystemWithFilter {
+ /** @param {GameRoot} root */
+ constructor(root) {
+ super(root, [ConstantSignalComponent, ItemProducerComponent]);
+ }
+
+ update() {
+ for (let i = 0; i < this.allEntities.length; ++i) {
+ const entity = this.allEntities[i];
+ const producerComp = entity.components.ItemProducer;
+ const signalComp = entity.components.ConstantSignal;
+
+ if (!producerComp.isWireless() || !signalComp.isWireless()) {
+ continue;
+ }
+
+ const ejectorComp = entity.components.ItemEjector;
+
+ ejectorComp.tryEject(0, signalComp.signal);
+ }
+ }
+
+ /**
+ *
+ * @param {DrawParameters} parameters
+ * @param {MapChunk} chunk
+ * @returns
+ */
+ drawChunk(parameters, chunk) {
+ const contents = chunk.containedEntitiesByLayer.regular;
+ for (let i = 0; i < contents.length; ++i) {
+ const producerComp = contents[i].components.ItemProducer;
+ const signalComp = contents[i].components.ConstantSignal;
+
+ if (!producerComp || !producerComp.isWireless() || !signalComp || !signalComp.isWireless()) {
+ continue;
+ }
+
+ const staticComp = contents[i].components.StaticMapEntity;
+ const item = signalComp.signal;
+
+ if (!item) {
+ continue;
+ }
+
+ const center = staticComp.getTileSpaceBounds().getCenter().toWorldSpace();
+
+ const localOffset = new Vector(0, 1).rotateFastMultipleOf90(staticComp.rotation);
+ item.drawItemCenteredClipped(
+ center.x + localOffset.x,
+ center.y + localOffset.y,
+ parameters,
+ globalConfig.tileSize * 0.65
+ );
+ }
+ }
+}
diff --git a/src/js/game/systems/constant_signal.js b/src/js/game/systems/constant_signal.js
index d698c1d5..bcaa0583 100644
--- a/src/js/game/systems/constant_signal.js
+++ b/src/js/game/systems/constant_signal.js
@@ -6,7 +6,7 @@ import { fillInLinkIntoTranslation } from "../../core/utils";
import { T } from "../../translations";
import { BaseItem } from "../base_item";
import { enumColors } from "../colors";
-import { ConstantSignalComponent } from "../components/constant_signal";
+import { ConstantSignalComponent, enumConstantSignalType } from "../components/constant_signal";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { BOOL_FALSE_SINGLETON, BOOL_TRUE_SINGLETON } from "../items/boolean_item";
@@ -26,8 +26,13 @@ export class ConstantSignalSystem extends GameSystemWithFilter {
// Set signals
for (let i = 0; i < this.allEntities.length; ++i) {
const entity = this.allEntities[i];
- const pinsComp = entity.components.WiredPins;
const signalComp = entity.components.ConstantSignal;
+
+ if (signalComp.isWireless()) {
+ continue;
+ }
+
+ const pinsComp = entity.components.WiredPins;
pinsComp.slots[0].value = signalComp.signal;
}
}
@@ -51,31 +56,50 @@ export class ConstantSignalSystem extends GameSystemWithFilter {
label: fillInLinkIntoTranslation(T.dialogs.editSignal.descShortKey, THIRDPARTY_URLS.shapeViewer),
placeholder: "",
defaultValue: "",
- validator: val => this.parseSignalCode(val),
+ validator: val => this.parseSignalCode(entity.components.ConstantSignal.type, val),
});
- const itemInput = new FormElementItemChooser({
- id: "signalItem",
- label: null,
- items: [
- BOOL_FALSE_SINGLETON,
- BOOL_TRUE_SINGLETON,
- ...Object.values(COLOR_ITEM_SINGLETONS),
- this.root.shapeDefinitionMgr.getShapeItemFromDefinition(
- this.root.hubGoals.currentGoal.definition
- ),
+ const items = [...Object.values(COLOR_ITEM_SINGLETONS)];
+
+ if (entity.components.ConstantSignal.type === enumConstantSignalType.wired) {
+ items.unshift(BOOL_FALSE_SINGLETON, BOOL_TRUE_SINGLETON);
+ items.push(
this.root.shapeDefinitionMgr.getShapeItemFromShortKey(
this.root.gameMode.getBlueprintShapeKey()
- ),
+ )
+ );
+ } else if (entity.components.ConstantSignal.type === enumConstantSignalType.wireless) {
+ const shapes = ["CuCuCuCu", "RuRuRuRu", "WuWuWuWu", "SuSuSuSu"];
+ items.unshift(
+ ...shapes.reverse().map(key => this.root.shapeDefinitionMgr.getShapeItemFromShortKey(key))
+ );
+ }
+
+ if (this.root.gameMode.hasHub()) {
+ items.push(
+ this.root.shapeDefinitionMgr.getShapeItemFromDefinition(
+ this.root.hubGoals.currentGoal.definition
+ )
+ );
+ }
+
+ if (this.root.hud.parts.pinnedShapes) {
+ items.push(
...this.root.hud.parts.pinnedShapes.pinnedShapes.map(key =>
this.root.shapeDefinitionMgr.getShapeItemFromShortKey(key)
- ),
- ],
+ )
+ );
+ }
+
+ const itemInput = new FormElementItemChooser({
+ id: "signalItem",
+ label: null,
+ items,
});
const dialog = new DialogWithForm({
app: this.root.app,
- title: T.dialogs.editSignal.title,
+ title: T.dialogs.editConstantProducer.title,
desc: T.dialogs.editSignal.descItems,
formElements: [itemInput, signalValueInput],
buttons: ["cancel:bad:escape", "ok:good:enter"],
@@ -103,15 +127,22 @@ export class ConstantSignalSystem extends GameSystemWithFilter {
}
if (itemInput.chosenItem) {
- console.log(itemInput.chosenItem);
constantComp.signal = itemInput.chosenItem;
} else {
- constantComp.signal = this.parseSignalCode(signalValueInput.getValue());
+ constantComp.signal = this.parseSignalCode(
+ entity.components.ConstantSignal.type,
+ signalValueInput.getValue()
+ );
}
};
- dialog.buttonSignals.ok.add(closeHandler);
- dialog.valueChosen.add(closeHandler);
+ dialog.buttonSignals.ok.add(() => {
+ closeHandler();
+ });
+ dialog.valueChosen.add(() => {
+ dialog.closeRequested.dispatch();
+ closeHandler();
+ });
// When cancelled, destroy the entity again
if (deleteOnCancel) {
@@ -140,10 +171,11 @@ export class ConstantSignalSystem extends GameSystemWithFilter {
/**
* Tries to parse a signal code
+ * @param {string} type
* @param {string} code
* @returns {BaseItem}
*/
- parseSignalCode(code) {
+ parseSignalCode(type, code) {
if (!this.root || !this.root.shapeDefinitionMgr) {
// Stale reference
return null;
@@ -155,12 +187,15 @@ export class ConstantSignalSystem extends GameSystemWithFilter {
if (enumColors[codeLower]) {
return COLOR_ITEM_SINGLETONS[codeLower];
}
- if (code === "1" || codeLower === "true") {
- return BOOL_TRUE_SINGLETON;
- }
- if (code === "0" || codeLower === "false") {
- return BOOL_FALSE_SINGLETON;
+ if (type === enumConstantSignalType.wired) {
+ if (code === "1" || codeLower === "true") {
+ return BOOL_TRUE_SINGLETON;
+ }
+
+ if (code === "0" || codeLower === "false") {
+ return BOOL_FALSE_SINGLETON;
+ }
}
if (ShapeDefinition.isValidShortKey(code)) {
diff --git a/src/js/game/systems/goal_acceptor.js b/src/js/game/systems/goal_acceptor.js
new file mode 100644
index 00000000..75b286d3
--- /dev/null
+++ b/src/js/game/systems/goal_acceptor.js
@@ -0,0 +1,132 @@
+import { globalConfig } from "../../core/config";
+import { DrawParameters } from "../../core/draw_parameters";
+import { clamp, lerp } from "../../core/utils";
+import { Vector } from "../../core/vector";
+import { GoalAcceptorComponent } from "../components/goal_acceptor";
+import { GameSystemWithFilter } from "../game_system_with_filter";
+import { MapChunk } from "../map_chunk";
+import { GameRoot } from "../root";
+
+export class GoalAcceptorSystem extends GameSystemWithFilter {
+ /** @param {GameRoot} root */
+ constructor(root) {
+ super(root, [GoalAcceptorComponent]);
+
+ this.puzzleCompleted = false;
+ }
+
+ update() {
+ const now = this.root.time.now();
+
+ let allAccepted = true;
+
+ for (let i = 0; i < this.allEntities.length; ++i) {
+ const entity = this.allEntities[i];
+ const goalComp = entity.components.GoalAcceptor;
+
+ // filter the ones which are no longer active, or which are not the same
+ goalComp.deliveryHistory = goalComp.deliveryHistory.filter(
+ d =>
+ now - d.time < globalConfig.goalAcceptorMinimumDurationSeconds && d.item === goalComp.item
+ );
+
+ if (goalComp.deliveryHistory.length < goalComp.getRequiredDeliveryHistorySize()) {
+ allAccepted = false;
+ }
+ }
+
+ if (
+ !this.puzzleCompleted &&
+ this.root.gameInitialized &&
+ allAccepted &&
+ !this.root.gameMode.getIsEditor()
+ ) {
+ this.root.signals.puzzleComplete.dispatch();
+ this.puzzleCompleted = true;
+ }
+ }
+
+ /**
+ *
+ * @param {DrawParameters} parameters
+ * @param {MapChunk} chunk
+ * @returns
+ */
+ drawChunk(parameters, chunk) {
+ const contents = chunk.containedEntitiesByLayer.regular;
+ for (let i = 0; i < contents.length; ++i) {
+ const goalComp = contents[i].components.GoalAcceptor;
+
+ if (!goalComp) {
+ continue;
+ }
+
+ const staticComp = contents[i].components.StaticMapEntity;
+ const item = goalComp.item;
+
+ const requiredItemsForSuccess = goalComp.getRequiredDeliveryHistorySize();
+ const percentage = clamp(goalComp.deliveryHistory.length / requiredItemsForSuccess, 0, 1);
+
+ const center = staticComp.getTileSpaceBounds().getCenter().toWorldSpace();
+ if (item) {
+ const localOffset = new Vector(0, -1.8).rotateFastMultipleOf90(staticComp.rotation);
+ item.drawItemCenteredClipped(
+ center.x + localOffset.x,
+ center.y + localOffset.y,
+ parameters,
+ globalConfig.tileSize * 0.65
+ );
+ }
+
+ const isValid = item && goalComp.deliveryHistory.length >= requiredItemsForSuccess;
+
+ parameters.context.translate(center.x, center.y);
+ parameters.context.rotate((staticComp.rotation / 180) * Math.PI);
+
+ parameters.context.lineWidth = 1;
+ parameters.context.fillStyle = "#8de255";
+ parameters.context.strokeStyle = "#64666e";
+ parameters.context.lineCap = "round";
+
+ // progress arc
+
+ goalComp.displayPercentage = lerp(goalComp.displayPercentage, percentage, 0.3);
+
+ const startAngle = Math.PI * 0.595;
+ const maxAngle = Math.PI * 1.82;
+ parameters.context.beginPath();
+ parameters.context.arc(
+ 0.25,
+ -1.5,
+ 11.6,
+ startAngle,
+ startAngle + goalComp.displayPercentage * maxAngle,
+ false
+ );
+ parameters.context.arc(
+ 0.25,
+ -1.5,
+ 15.5,
+ startAngle + goalComp.displayPercentage * maxAngle,
+ startAngle,
+ true
+ );
+ parameters.context.closePath();
+ parameters.context.fill();
+ parameters.context.stroke();
+ parameters.context.lineCap = "butt";
+
+ // LED indicator
+
+ parameters.context.lineWidth = 1;
+ parameters.context.strokeStyle = "#64666e";
+ parameters.context.fillStyle = isValid ? "#8de255" : "#ff666a";
+ parameters.context.beginCircle(10, 11.8, 3);
+ parameters.context.fill();
+ parameters.context.stroke();
+
+ parameters.context.rotate((-staticComp.rotation / 180) * Math.PI);
+ parameters.context.translate(-center.x, -center.y);
+ }
+ }
+}
diff --git a/src/js/game/systems/item_ejector.js b/src/js/game/systems/item_ejector.js
index 1daaad6b..db37455a 100644
--- a/src/js/game/systems/item_ejector.js
+++ b/src/js/game/systems/item_ejector.js
@@ -239,6 +239,14 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
return false;
}
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ //
+ // NOTICE ! THIS CODE IS DUPLICATED IN THE BELT PATH FOR PERFORMANCE REASONS
+ //
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+
const itemProcessorComp = receiver.components.ItemProcessor;
if (itemProcessorComp) {
// Check for potential filters
diff --git a/src/js/game/systems/item_processor.js b/src/js/game/systems/item_processor.js
index 9775afde..e06d4a21 100644
--- a/src/js/game/systems/item_processor.js
+++ b/src/js/game/systems/item_processor.js
@@ -59,6 +59,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
[enumItemProcessorTypes.painterQuad]: this.process_PAINTER_QUAD,
[enumItemProcessorTypes.hub]: this.process_HUB,
[enumItemProcessorTypes.reader]: this.process_READER,
+ [enumItemProcessorTypes.goal]: this.process_GOAL,
};
// Bind all handlers
@@ -562,4 +563,32 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
this.root.hubGoals.handleDefinitionDelivered(item.definition);
}
}
+
+ /**
+ * @param {ProcessorImplementationPayload} payload
+ */
+ process_GOAL(payload) {
+ const goalComp = payload.entity.components.GoalAcceptor;
+ const item = payload.items[0].item;
+ const now = this.root.time.now();
+
+ if (this.root.gameMode.getIsEditor()) {
+ // while playing in editor, assign the item
+ goalComp.item = payload.items[0].item;
+ goalComp.deliveryHistory.push({
+ item,
+ time: now,
+ });
+ } else {
+ // otherwise, make sure it is the same, otherwise reset
+ if (item.equals(goalComp.item)) {
+ goalComp.deliveryHistory.push({
+ item,
+ time: now,
+ });
+ } else {
+ goalComp.deliveryHistory = [];
+ }
+ }
+ }
}
diff --git a/src/js/game/systems/item_producer.js b/src/js/game/systems/item_producer.js
index 52edf5d1..be78e4e8 100644
--- a/src/js/game/systems/item_producer.js
+++ b/src/js/game/systems/item_producer.js
@@ -1,14 +1,27 @@
+/* typehints:start */
+import { GameRoot } from "../root";
+/* typehints:end */
+
import { ItemProducerComponent } from "../components/item_producer";
import { GameSystemWithFilter } from "../game_system_with_filter";
export class ItemProducerSystem extends GameSystemWithFilter {
+ /** @param {GameRoot} root */
constructor(root) {
super(root, [ItemProducerComponent]);
+ this.item = null;
}
update() {
for (let i = 0; i < this.allEntities.length; ++i) {
const entity = this.allEntities[i];
+ const producerComp = entity.components.ItemProducer;
+ const ejectorComp = entity.components.ItemEjector;
+
+ if (producerComp.isWireless()) {
+ continue;
+ }
+
const pinsComp = entity.components.WiredPins;
const pin = pinsComp.slots[0];
const network = pin.linkedNetwork;
@@ -17,8 +30,8 @@ export class ItemProducerSystem extends GameSystemWithFilter {
continue;
}
- const ejectorComp = entity.components.ItemEjector;
- ejectorComp.tryEject(0, network.currentValue);
+ this.item = network.currentValue;
+ ejectorComp.tryEject(0, this.item);
}
}
}
diff --git a/src/js/game/systems/underground_belt.js b/src/js/game/systems/underground_belt.js
index 7a7609f8..9b31eec1 100644
--- a/src/js/game/systems/underground_belt.js
+++ b/src/js/game/systems/underground_belt.js
@@ -224,13 +224,16 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
update() {
this.staleAreaWatcher.update();
+ const sender = enumUndergroundBeltMode.sender;
+ const now = this.root.time.now();
+
for (let i = 0; i < this.allEntities.length; ++i) {
const entity = this.allEntities[i];
const undergroundComp = entity.components.UndergroundBelt;
- if (undergroundComp.mode === enumUndergroundBeltMode.sender) {
+ if (undergroundComp.mode === sender) {
this.handleSender(entity);
} else {
- this.handleReceiver(entity);
+ this.handleReceiver(entity, now);
}
}
}
@@ -327,14 +330,15 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
/**
*
* @param {Entity} entity
+ * @param {number} now
*/
- handleReceiver(entity) {
+ handleReceiver(entity, now) {
const undergroundComp = entity.components.UndergroundBelt;
// Try to eject items, we only check the first one because it is sorted by remaining time
const nextItemAndDuration = undergroundComp.pendingItems[0];
if (nextItemAndDuration) {
- if (this.root.time.now() > nextItemAndDuration[1]) {
+ if (now > nextItemAndDuration[1]) {
const ejectorComp = entity.components.ItemEjector;
const nextSlotIndex = ejectorComp.getFirstFreeSlot();
diff --git a/src/js/game/systems/zone.js b/src/js/game/systems/zone.js
new file mode 100644
index 00000000..109f5166
--- /dev/null
+++ b/src/js/game/systems/zone.js
@@ -0,0 +1,105 @@
+/* typehints:start */
+import { DrawParameters } from "../../core/draw_parameters";
+import { MapChunkView } from "../map_chunk_view";
+import { GameRoot } from "../root";
+/* typehints:end */
+
+import { globalConfig } from "../../core/config";
+import { STOP_PROPAGATION } from "../../core/signal";
+import { GameSystem } from "../game_system";
+import { THEME } from "../theme";
+import { Entity } from "../entity";
+import { Vector } from "../../core/vector";
+
+export class ZoneSystem extends GameSystem {
+ /** @param {GameRoot} root */
+ constructor(root) {
+ super(root);
+ this.drawn = false;
+ this.root.signals.prePlacementCheck.add(this.prePlacementCheck, this);
+
+ this.root.signals.gameFrameStarted.add(() => {
+ this.drawn = false;
+ });
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {Vector | undefined} tile
+ * @returns
+ */
+ prePlacementCheck(entity, tile = null) {
+ const staticComp = entity.components.StaticMapEntity;
+
+ if (!staticComp) {
+ return;
+ }
+
+ const mode = this.root.gameMode;
+
+ const zones = mode.getBuildableZones();
+ if (!zones) {
+ return;
+ }
+
+ const transformed = staticComp.getTileSpaceBounds();
+ if (tile) {
+ transformed.x += tile.x;
+ transformed.y += tile.y;
+ }
+
+ if (!zones.some(zone => zone.intersectsFully(transformed))) {
+ return STOP_PROPAGATION;
+ }
+ }
+
+ /**
+ * Draws the zone
+ * @param {DrawParameters} parameters
+ * @param {MapChunkView} chunk
+ */
+ drawChunk(parameters, chunk) {
+ if (this.drawn) {
+ // oof
+ return;
+ }
+ this.drawn = true;
+
+ const mode = this.root.gameMode;
+
+ const zones = mode.getBuildableZones();
+ if (!zones) {
+ return;
+ }
+
+ const zone = zones[0].allScaled(globalConfig.tileSize);
+ const context = parameters.context;
+
+ context.lineWidth = 2;
+ context.strokeStyle = THEME.map.zone.borderSolid;
+ context.beginPath();
+ context.rect(zone.x - 1, zone.y - 1, zone.w + 2, zone.h + 2);
+ context.stroke();
+
+ const outer = zone;
+ const padding = 40 * globalConfig.tileSize;
+ context.fillStyle = THEME.map.zone.outerColor;
+ context.fillRect(outer.x + outer.w, outer.y, padding, outer.h);
+ context.fillRect(outer.x - padding, outer.y, padding, outer.h);
+ context.fillRect(
+ outer.x - padding - globalConfig.tileSize,
+ outer.y - padding,
+ 2 * padding + zone.w + 2 * globalConfig.tileSize,
+ padding
+ );
+ context.fillRect(
+ outer.x - padding - globalConfig.tileSize,
+ outer.y + outer.h,
+ 2 * padding + zone.w + 2 * globalConfig.tileSize,
+ padding
+ );
+
+ context.globalAlpha = 1;
+ }
+}
diff --git a/src/js/game/themes/dark.json b/src/js/game/themes/dark.json
index 733b7682..cb111430 100644
--- a/src/js/game/themes/dark.json
+++ b/src/js/game/themes/dark.json
@@ -47,6 +47,11 @@
"textColor": "#fff",
"textColorCapped": "#ef5072",
"background": "rgba(40, 50, 60, 0.8)"
+ },
+
+ "zone": {
+ "borderSolid": "rgba(23, 192, 255, 1)",
+ "outerColor": "rgba(20 , 20, 25, 0.5)"
}
},
diff --git a/src/js/game/themes/light.json b/src/js/game/themes/light.json
index 0c793c26..0962eb93 100644
--- a/src/js/game/themes/light.json
+++ b/src/js/game/themes/light.json
@@ -48,6 +48,11 @@
"textColor": "#fff",
"textColorCapped": "#ef5072",
"background": "rgba(40, 50, 60, 0.8)"
+ },
+
+ "zone": {
+ "borderSolid": "rgba(23, 192, 255, 1)",
+ "outerColor": "rgba(240, 240, 255, 0.5)"
}
},
diff --git a/src/js/globals.d.ts b/src/js/globals.d.ts
index d1fb5305..5bb3bbba 100644
--- a/src/js/globals.d.ts
+++ b/src/js/globals.d.ts
@@ -185,6 +185,7 @@ declare const STOP_PROPAGATION = "stop_propagation";
declare interface TypedSignal> {
add(receiver: (...args: T) => /* STOP_PROPAGATION */ string | void, scope?: object);
+ addToTop(receiver: (...args: T) => /* STOP_PROPAGATION */ string | void, scope?: object);
remove(receiver: (...args: T) => /* STOP_PROPAGATION */ string | void);
dispatch(...args: T): /* STOP_PROPAGATION */ string | void;
diff --git a/src/js/languages.js b/src/js/languages.js
index 6899ef09..4dfb15d4 100644
--- a/src/js/languages.js
+++ b/src/js/languages.js
@@ -184,4 +184,12 @@ export const LANGUAGES = {
code: "uk",
region: "",
},
+
+ "he": {
+ // hebrew
+ name: "עברית",
+ data: require("./built-temp/base-he.json"),
+ code: "he",
+ region: "",
+ },
};
diff --git a/src/js/main.js b/src/js/main.js
index 5b9df699..94f3d37a 100644
--- a/src/js/main.js
+++ b/src/js/main.js
@@ -9,6 +9,7 @@ import { initComponentRegistry } from "./game/component_registry";
import { initDrawUtils } from "./core/draw_utils";
import { initItemRegistry } from "./game/item_registry";
import { initMetaBuildingRegistry } from "./game/meta_building_registry";
+import { initGameModeRegistry } from "./game/game_mode_registry";
import { initGameSpeedRegistry } from "./game/game_speed_registry";
const logger = createLogger("main");
@@ -81,6 +82,7 @@ initDrawUtils();
initComponentRegistry();
initItemRegistry();
initMetaBuildingRegistry();
+initGameModeRegistry();
initGameSpeedRegistry();
let app = null;
diff --git a/src/js/platform/api.js b/src/js/platform/api.js
new file mode 100644
index 00000000..cbecfb15
--- /dev/null
+++ b/src/js/platform/api.js
@@ -0,0 +1,203 @@
+/* typehints:start */
+import { Application } from "../application";
+/* typehints:end */
+import { createLogger } from "../core/logging";
+import { compressX64 } from "../core/lzstring";
+import { T } from "../translations";
+
+const logger = createLogger("puzzle-api");
+const rusha = require("rusha");
+
+export class ClientAPI {
+ /**
+ *
+ * @param {Application} app
+ */
+ constructor(app) {
+ this.app = app;
+
+ /**
+ * The current users session token
+ * @type {string|null}
+ */
+ this.token = null;
+
+ this.syncToken = window.localStorage.getItem("tmp.syncToken");
+ if (!this.syncToken) {
+ this.syncToken = rusha
+ .createHash()
+ .update(new Date().getTime() + "=" + Math.random())
+ .digest("hex");
+ window.localStorage.setItem("tmp.syncToken", this.syncToken);
+ }
+ }
+
+ getEndpoint() {
+ if (G_IS_DEV) {
+ return "http://localhost:15001";
+ }
+ if (window.location.host === "beta.shapez.io") {
+ return "https://api-staging.shapez.io";
+ }
+ return "https://api.shapez.io";
+ }
+
+ isLoggedIn() {
+ return Boolean(this.token);
+ }
+
+ /**
+ *
+ * @param {string} endpoint
+ * @param {object} options
+ * @param {"GET"|"POST"=} options.method
+ * @param {any=} options.body
+ */
+ _request(endpoint, options) {
+ const headers = {
+ "x-api-key": "d5c54aaa491f200709afff082c153ef2",
+ "Content-Type": "application/json",
+ };
+
+ if (this.token) {
+ headers["x-token"] = this.token;
+ }
+
+ return Promise.race([
+ fetch(this.getEndpoint() + endpoint, {
+ cache: "no-cache",
+ mode: "cors",
+ headers,
+ method: options.method || "GET",
+ body: options.body ? JSON.stringify(options.body) : undefined,
+ })
+ .then(res => {
+ if (res.status !== 200) {
+ throw "bad-status: " + res.status + " / " + res.statusText;
+ }
+ return res;
+ })
+ .then(res => res.json()),
+ new Promise((resolve, reject) => setTimeout(() => reject("timeout"), 15000)),
+ ])
+ .then(data => {
+ if (data && data.error) {
+ logger.warn("Got error from api:", data);
+ throw T.backendErrors[data.error] || data.error;
+ }
+ return data;
+ })
+ .catch(err => {
+ logger.warn("Failure:", endpoint, ":", err);
+ throw err;
+ });
+ }
+
+ tryLogin() {
+ return this.apiTryLogin()
+ .then(({ token }) => {
+ this.token = token;
+ return true;
+ })
+ .catch(err => {
+ logger.warn("Failed to login:", err);
+ return false;
+ });
+ }
+
+ /**
+ * @returns {Promise<{token: string}>}
+ */
+ apiTryLogin() {
+ return this._request("/v1/public/login", {
+ method: "POST",
+ body: {
+ token: this.syncToken,
+ },
+ });
+ }
+
+ /**
+ * @param {"new"|"top-rated"|"mine"} category
+ * @returns {Promise}
+ */
+ apiListPuzzles(category) {
+ if (!this.isLoggedIn()) {
+ return Promise.reject("not-logged-in");
+ }
+ return this._request("/v1/puzzles/list/" + category, {});
+ }
+
+ /**
+ * @param {number} puzzleId
+ * @returns {Promise}
+ */
+ apiDownloadPuzzle(puzzleId) {
+ if (!this.isLoggedIn()) {
+ return Promise.reject("not-logged-in");
+ }
+ return this._request("/v1/puzzles/download/" + puzzleId, {});
+ }
+
+ /**
+ * @param {number} shortKey
+ * @returns {Promise}
+ */
+ apiDownloadPuzzleByKey(shortKey) {
+ if (!this.isLoggedIn()) {
+ return Promise.reject("not-logged-in");
+ }
+ return this._request("/v1/puzzles/download/" + shortKey, {});
+ }
+
+ /**
+ * @param {number} puzzleId
+ * @returns {Promise}
+ */
+ apiReportPuzzle(puzzleId, reason) {
+ if (!this.isLoggedIn()) {
+ return Promise.reject("not-logged-in");
+ }
+ return this._request("/v1/puzzles/report/" + puzzleId, {
+ method: "POST",
+ body: { reason },
+ });
+ }
+
+ /**
+ * @param {number} puzzleId
+ * @param {object} payload
+ * @param {number} payload.time
+ * @param {boolean} payload.liked
+ * @returns {Promise<{ success: true }>}
+ */
+ apiCompletePuzzle(puzzleId, payload) {
+ if (!this.isLoggedIn()) {
+ return Promise.reject("not-logged-in");
+ }
+ return this._request("/v1/puzzles/complete/" + puzzleId, {
+ method: "POST",
+ body: payload,
+ });
+ }
+
+ /**
+ * @param {object} payload
+ * @param {string} payload.title
+ * @param {string} payload.shortKey
+ * @param {import("../savegame/savegame_typedefs").PuzzleGameData} payload.data
+ * @returns {Promise<{ success: true }>}
+ */
+ apiSubmitPuzzle(payload) {
+ if (!this.isLoggedIn()) {
+ return Promise.reject("not-logged-in");
+ }
+ return this._request("/v1/puzzles/submit", {
+ method: "POST",
+ body: {
+ ...payload,
+ data: compressX64(JSON.stringify(payload.data)),
+ },
+ });
+ }
+}
diff --git a/src/js/platform/browser/game_analytics.js b/src/js/platform/browser/game_analytics.js
index a3947be6..65fc5080 100644
--- a/src/js/platform/browser/game_analytics.js
+++ b/src/js/platform/browser/game_analytics.js
@@ -3,6 +3,7 @@ import { createLogger } from "../../core/logging";
import { queryParamOptions } from "../../core/query_parameters";
import { BeltComponent } from "../../game/components/belt";
import { StaticMapEntityComponent } from "../../game/components/static_map_entity";
+import { RegularGameMode } from "../../game/modes/regular";
import { GameRoot } from "../../game/root";
import { InGameState } from "../../states/ingame";
import { GameAnalyticsInterface } from "../game_analytics";
@@ -163,6 +164,10 @@ export class ShapezGameAnalytics extends GameAnalyticsInterface {
return;
}
+ if (!(root.gameMode instanceof RegularGameMode)) {
+ return;
+ }
+
logger.log("Sending event", category, value);
this.sendToApi("/v1/game-event", {
diff --git a/src/js/platform/sound.js b/src/js/platform/sound.js
index 9d5a8461..d43c76c2 100644
--- a/src/js/platform/sound.js
+++ b/src/js/platform/sound.js
@@ -35,6 +35,10 @@ export const MUSIC = {
menu: "menu",
};
+if (G_IS_STANDALONE || G_IS_DEV) {
+ MUSIC.puzzle = "puzzle-full";
+}
+
export class SoundInstanceInterface {
constructor(key, url) {
this.key = key;
diff --git a/src/js/savegame/puzzle_serializer.js b/src/js/savegame/puzzle_serializer.js
new file mode 100644
index 00000000..c7bfa652
--- /dev/null
+++ b/src/js/savegame/puzzle_serializer.js
@@ -0,0 +1,211 @@
+/* typehints:start */
+import { GameRoot } from "../game/root";
+import { PuzzleGameMode } from "../game/modes/puzzle";
+/* typehints:end */
+import { enumConstantSignalType } from "../game/components/constant_signal";
+import { StaticMapEntityComponent } from "../game/components/static_map_entity";
+import { ShapeItem } from "../game/items/shape_item";
+import { Vector } from "../core/vector";
+import { MetaConstantProducerBuilding } from "../game/buildings/constant_producer";
+import { defaultBuildingVariant, MetaBuilding } from "../game/meta_building";
+import { gMetaBuildingRegistry } from "../core/global_registries";
+import { MetaGoalAcceptorBuilding } from "../game/buildings/goal_acceptor";
+import { createLogger } from "../core/logging";
+import { BaseItem } from "../game/base_item";
+import trim from "trim";
+import { enumColors } from "../game/colors";
+import { COLOR_ITEM_SINGLETONS } from "../game/items/color_item";
+import { ShapeDefinition } from "../game/shape_definition";
+import { MetaBlockBuilding } from "../game/buildings/block";
+
+const logger = createLogger("puzzle-serializer");
+
+export class PuzzleSerializer {
+ /**
+ * Serializes the game root into a dump
+ * @param {GameRoot} root
+ * @returns {import("./savegame_typedefs").PuzzleGameData}
+ */
+ generateDumpFromGameRoot(root) {
+ console.log("serializing", root);
+
+ /**
+ * @type {import("./savegame_typedefs").PuzzleGameData["buildings"]}
+ */
+ let buildings = [];
+ for (const entity of root.entityMgr.getAllWithComponent(StaticMapEntityComponent)) {
+ const staticComp = entity.components.StaticMapEntity;
+ const signalComp = entity.components.ConstantSignal;
+
+ if (signalComp) {
+ assert(signalComp.type === enumConstantSignalType.wireless, "not a wireless signal");
+ assert(["shape", "color"].includes(signalComp.signal.getItemType()), "not a shape signal");
+ buildings.push({
+ type: "emitter",
+ item: signalComp.signal.getAsCopyableKey(),
+ pos: {
+ x: staticComp.origin.x,
+ y: staticComp.origin.y,
+ r: staticComp.rotation,
+ },
+ });
+ continue;
+ }
+
+ const goalComp = entity.components.GoalAcceptor;
+ if (goalComp) {
+ assert(goalComp.item, "goals is missing item");
+ assert(goalComp.item.getItemType() === "shape", "goal is not an item");
+ buildings.push({
+ type: "goal",
+ item: goalComp.item.getAsCopyableKey(),
+ pos: {
+ x: staticComp.origin.x,
+ y: staticComp.origin.y,
+ r: staticComp.rotation,
+ },
+ });
+ continue;
+ }
+
+ if (staticComp.getMetaBuilding().id === gMetaBuildingRegistry.findByClass(MetaBlockBuilding).id) {
+ buildings.push({
+ type: "block",
+ pos: {
+ x: staticComp.origin.x,
+ y: staticComp.origin.y,
+ r: staticComp.rotation,
+ },
+ });
+ }
+ }
+
+ const mode = /** @type {PuzzleGameMode} */ (root.gameMode);
+
+ const handles = root.hud.parts.buildingsToolbar.buildingHandles;
+ const ids = gMetaBuildingRegistry.getAllIds();
+
+ /** @type {Array} */
+ let excludedBuildings = [];
+ for (let i = 0; i < ids.length; ++i) {
+ const handle = handles[ids[i]];
+ if (handle && handle.puzzleLocked) {
+ // @ts-ignore
+ excludedBuildings.push(handle.metaBuilding.getId());
+ }
+ }
+
+ return {
+ version: 1,
+ buildings,
+ bounds: {
+ w: mode.zoneWidth,
+ h: mode.zoneHeight,
+ },
+ //read from the toolbar when making a puzzle
+ excludedBuildings,
+ };
+ }
+
+ /**
+ * Tries to parse a signal code
+ * @param {GameRoot} root
+ * @param {string} code
+ * @returns {BaseItem}
+ */
+ parseItemCode(root, code) {
+ if (!root || !root.shapeDefinitionMgr) {
+ // Stale reference
+ return null;
+ }
+
+ code = trim(code);
+ const codeLower = code.toLowerCase();
+
+ if (enumColors[codeLower]) {
+ return COLOR_ITEM_SINGLETONS[codeLower];
+ }
+
+ if (ShapeDefinition.isValidShortKey(code)) {
+ return root.shapeDefinitionMgr.getShapeItemFromShortKey(code);
+ }
+
+ return null;
+ }
+ /**
+ * @param {GameRoot} root
+ * @param {import("./savegame_typedefs").PuzzleGameData} puzzle
+ */
+ deserializePuzzle(root, puzzle) {
+ if (puzzle.version !== 1) {
+ return "invalid-version";
+ }
+
+ for (const building of puzzle.buildings) {
+ switch (building.type) {
+ case "emitter": {
+ const item = this.parseItemCode(root, building.item);
+ if (!item) {
+ return "bad-item:" + building.item;
+ }
+
+ const entity = root.logic.tryPlaceBuilding({
+ origin: new Vector(building.pos.x, building.pos.y),
+ building: gMetaBuildingRegistry.findByClass(MetaConstantProducerBuilding),
+ originalRotation: building.pos.r,
+ rotation: building.pos.r,
+ rotationVariant: 0,
+ variant: defaultBuildingVariant,
+ });
+ if (!entity) {
+ logger.warn("Failed to place emitter:", building);
+ return "failed-to-place-emitter";
+ }
+
+ entity.components.ConstantSignal.signal = item;
+ break;
+ }
+ case "goal": {
+ const item = this.parseItemCode(root, building.item);
+ if (!item) {
+ return "bad-item:" + building.item;
+ }
+ const entity = root.logic.tryPlaceBuilding({
+ origin: new Vector(building.pos.x, building.pos.y),
+ building: gMetaBuildingRegistry.findByClass(MetaGoalAcceptorBuilding),
+ originalRotation: building.pos.r,
+ rotation: building.pos.r,
+ rotationVariant: 0,
+ variant: defaultBuildingVariant,
+ });
+ if (!entity) {
+ logger.warn("Failed to place goal:", building);
+ return "failed-to-place-goal";
+ }
+
+ entity.components.GoalAcceptor.item = item;
+ break;
+ }
+ case "block": {
+ const entity = root.logic.tryPlaceBuilding({
+ origin: new Vector(building.pos.x, building.pos.y),
+ building: gMetaBuildingRegistry.findByClass(MetaBlockBuilding),
+ originalRotation: building.pos.r,
+ rotation: building.pos.r,
+ rotationVariant: 0,
+ variant: defaultBuildingVariant,
+ });
+ if (!entity) {
+ logger.warn("Failed to place block:", building);
+ return "failed-to-place-block";
+ }
+ break;
+ }
+ default: {
+ // @ts-ignore
+ return "invalid-building-type: " + building.type;
+ }
+ }
+ }
+ }
+}
diff --git a/src/js/savegame/savegame.js b/src/js/savegame/savegame.js
index e56ae1dc..999b90ec 100644
--- a/src/js/savegame/savegame.js
+++ b/src/js/savegame/savegame.js
@@ -13,6 +13,7 @@ import { SavegameInterface_V1005 } from "./schemas/1005";
import { SavegameInterface_V1006 } from "./schemas/1006";
import { SavegameInterface_V1007 } from "./schemas/1007";
import { SavegameInterface_V1008 } from "./schemas/1008";
+import { SavegameInterface_V1009 } from "./schemas/1009";
const logger = createLogger("savegame");
@@ -53,7 +54,7 @@ export class Savegame extends ReadWriteProxy {
* @returns {number}
*/
static getCurrentVersion() {
- return 1008;
+ return 1009;
}
/**
@@ -136,6 +137,11 @@ export class Savegame extends ReadWriteProxy {
data.version = 1008;
}
+ if (data.version === 1008) {
+ SavegameInterface_V1009.migrate1008to1009(data);
+ data.version = 1009;
+ }
+
return ExplainedResult.good();
}
diff --git a/src/js/savegame/savegame_interface_registry.js b/src/js/savegame/savegame_interface_registry.js
index 395040b3..b4dc4233 100644
--- a/src/js/savegame/savegame_interface_registry.js
+++ b/src/js/savegame/savegame_interface_registry.js
@@ -9,6 +9,7 @@ import { SavegameInterface_V1005 } from "./schemas/1005";
import { SavegameInterface_V1006 } from "./schemas/1006";
import { SavegameInterface_V1007 } from "./schemas/1007";
import { SavegameInterface_V1008 } from "./schemas/1008";
+import { SavegameInterface_V1009 } from "./schemas/1009";
/** @type {Object.} */
export const savegameInterfaces = {
@@ -21,6 +22,7 @@ export const savegameInterfaces = {
1006: SavegameInterface_V1006,
1007: SavegameInterface_V1007,
1008: SavegameInterface_V1008,
+ 1009: SavegameInterface_V1009,
};
const logger = createLogger("savegame_interface_registry");
diff --git a/src/js/savegame/savegame_serializer.js b/src/js/savegame/savegame_serializer.js
index c1247225..3230cdd5 100644
--- a/src/js/savegame/savegame_serializer.js
+++ b/src/js/savegame/savegame_serializer.js
@@ -2,6 +2,8 @@ import { ExplainedResult } from "../core/explained_result";
import { createLogger } from "../core/logging";
import { gComponentRegistry } from "../core/global_registries";
import { SerializerInternal } from "./serializer_internal";
+import { HUDPinnedShapes } from "../game/hud/parts/pinned_shapes";
+import { HUDWaypoints } from "../game/hud/parts/waypoints";
/**
* @typedef {import("../game/component").Component} Component
@@ -33,12 +35,13 @@ export class SavegameSerializer {
camera: root.camera.serialize(),
time: root.time.serialize(),
map: root.map.serialize(),
+ gameMode: root.gameMode.serialize(),
entityMgr: root.entityMgr.serialize(),
hubGoals: root.hubGoals.serialize(),
- pinnedShapes: root.hud.parts.pinnedShapes.serialize(),
- waypoints: root.hud.parts.waypoints.serialize(),
entities: this.internal.serializeEntityArray(root.entityMgr.entities),
beltPaths: root.systemMgr.systems.belt.serializePaths(),
+ pinnedShapes: root.hud.parts.pinnedShapes ? root.hud.parts.pinnedShapes.serialize() : null,
+ waypoints: root.hud.parts.waypoints ? root.hud.parts.waypoints.serialize() : null,
};
if (G_IS_DEV) {
@@ -130,12 +133,19 @@ export class SavegameSerializer {
errorReason = errorReason || root.time.deserialize(savegame.time);
errorReason = errorReason || root.camera.deserialize(savegame.camera);
errorReason = errorReason || root.map.deserialize(savegame.map);
+ errorReason = errorReason || root.gameMode.deserialize(savegame.gameMode);
errorReason = errorReason || root.hubGoals.deserialize(savegame.hubGoals, root);
- errorReason = errorReason || root.hud.parts.pinnedShapes.deserialize(savegame.pinnedShapes);
- errorReason = errorReason || root.hud.parts.waypoints.deserialize(savegame.waypoints);
errorReason = errorReason || this.internal.deserializeEntityArray(root, savegame.entities);
errorReason = errorReason || root.systemMgr.systems.belt.deserializePaths(savegame.beltPaths);
+ if (root.hud.parts.pinnedShapes) {
+ errorReason = errorReason || root.hud.parts.pinnedShapes.deserialize(savegame.pinnedShapes);
+ }
+
+ if (root.hud.parts.waypoints) {
+ errorReason = errorReason || root.hud.parts.waypoints.deserialize(savegame.waypoints);
+ }
+
// Check for errors
if (errorReason) {
return ExplainedResult.bad(errorReason);
diff --git a/src/js/savegame/savegame_typedefs.js b/src/js/savegame/savegame_typedefs.js
index fb872113..c5e0e5c5 100644
--- a/src/js/savegame/savegame_typedefs.js
+++ b/src/js/savegame/savegame_typedefs.js
@@ -12,6 +12,7 @@
* time: any,
* entityMgr: any,
* map: any,
+ * gameMode: object,
* hubGoals: any,
* pinnedShapes: any,
* waypoints: any,
@@ -40,4 +41,61 @@
* }} SavegamesData
*/
+import { MetaBuilding } from "../game/meta_building";
+
+// Notice: Update backend too
+/**
+ * @typedef {{
+ * id: number;
+ * shortKey: string;
+ * likes: number;
+ * downloads: number;
+ * completions: number;
+ * difficulty: number | null;
+ * averageTime: number | null;
+ * title: string;
+ * author: string;
+ * completed: boolean;
+ * }} PuzzleMetadata
+ */
+
+/**
+ * @typedef {{
+ * type: "emitter";
+ * item: string;
+ * pos: { x: number; y: number; r: number }
+ * }} PuzzleGameBuildingConstantProducer
+ */
+
+/**
+ * @typedef {{
+ * type: "goal";
+ * item: string;
+ * pos: { x: number; y: number; r: number }
+ * }} PuzzleGameBuildingGoal
+ */
+
+/**
+ * @typedef {{
+ * type: "block";
+ * pos: { x: number; y: number; r: number }
+ * }} PuzzleGameBuildingBlock
+ */
+
+/**
+ * @typedef {{
+ * version: number;
+ * bounds: { w: number; h: number; },
+ * buildings: (PuzzleGameBuildingGoal | PuzzleGameBuildingConstantProducer | PuzzleGameBuildingBlock)[],
+ * excludedBuildings: Array,
+ * }} PuzzleGameData
+ */
+
+/**
+ * @typedef {{
+ * meta: PuzzleMetadata,
+ * game: PuzzleGameData
+ * }} PuzzleFullData
+ */
+
export default {};
diff --git a/src/js/savegame/schemas/1009.js b/src/js/savegame/schemas/1009.js
new file mode 100644
index 00000000..e6e1abc6
--- /dev/null
+++ b/src/js/savegame/schemas/1009.js
@@ -0,0 +1,34 @@
+import { createLogger } from "../../core/logging.js";
+import { RegularGameMode } from "../../game/modes/regular.js";
+import { SavegameInterface_V1008 } from "./1008.js";
+
+const schema = require("./1009.json");
+const logger = createLogger("savegame_interface/1009");
+
+export class SavegameInterface_V1009 extends SavegameInterface_V1008 {
+ getVersion() {
+ return 1009;
+ }
+
+ getSchemaUncached() {
+ return schema;
+ }
+
+ /**
+ * @param {import("../savegame_typedefs.js").SavegameData} data
+ */
+ static migrate1008to1009(data) {
+ logger.log("Migrating 1008 to 1009");
+ const dump = data.dump;
+ if (!dump) {
+ return true;
+ }
+
+ dump.gameMode = {
+ mode: {
+ id: RegularGameMode.getId(),
+ data: {},
+ },
+ };
+ }
+}
diff --git a/src/js/savegame/schemas/1009.json b/src/js/savegame/schemas/1009.json
new file mode 100644
index 00000000..6682f615
--- /dev/null
+++ b/src/js/savegame/schemas/1009.json
@@ -0,0 +1,5 @@
+{
+ "type": "object",
+ "required": [],
+ "additionalProperties": true
+}
diff --git a/src/js/states/ingame.js b/src/js/states/ingame.js
index 316c536c..0dd6c72a 100644
--- a/src/js/states/ingame.js
+++ b/src/js/states/ingame.js
@@ -8,6 +8,7 @@ import { KeyActionMapper } from "../game/key_action_mapper";
import { Savegame } from "../savegame/savegame";
import { GameCore } from "../game/core";
import { MUSIC } from "../platform/sound";
+import { enumGameModeIds } from "../game/game_mode";
const logger = createLogger("state/ingame");
@@ -39,8 +40,14 @@ export class GameCreationPayload {
/** @type {boolean|undefined} */
this.fastEnter;
+ /** @type {string} */
+ this.gameModeId;
+
/** @type {Savegame} */
this.savegame;
+
+ /** @type {object|undefined} */
+ this.gameModeParameters;
}
}
@@ -97,6 +104,9 @@ export class InGameState extends GameState {
}
getThemeMusic() {
+ if (this.creationPayload.gameModeId && this.creationPayload.gameModeId.includes("puzzle")) {
+ return MUSIC.puzzle;
+ }
return MUSIC.theme;
}
@@ -147,7 +157,11 @@ export class InGameState extends GameState {
* Goes back to the menu state
*/
goBackToMenu() {
- this.saveThenGoToState("MainMenuState");
+ if ([enumGameModeIds.puzzleEdit, enumGameModeIds.puzzlePlay].includes(this.gameModeId)) {
+ this.saveThenGoToState("PuzzleMenuState");
+ } else {
+ this.saveThenGoToState("MainMenuState");
+ }
}
/**
@@ -220,7 +234,7 @@ export class InGameState extends GameState {
logger.log("Creating new game core");
this.core = new GameCore(this.app);
- this.core.initializeRoot(this, this.savegame);
+ this.core.initializeRoot(this, this.savegame, this.gameModeId);
if (this.savegame.hasGameDump()) {
this.stage4bResumeGame();
@@ -354,6 +368,7 @@ export class InGameState extends GameState {
this.creationPayload = payload;
this.savegame = payload.savegame;
+ this.gameModeId = payload.gameModeId;
this.loadingOverlay = new GameLoadingOverlay(this.app, this.getDivElement());
this.loadingOverlay.showBasic();
@@ -361,7 +376,13 @@ export class InGameState extends GameState {
// Remove unneded default element
document.body.querySelector(".modalDialogParent").remove();
- this.asyncChannel.watch(waitNextFrame()).then(() => this.stage3CreateCore());
+ this.asyncChannel
+ .watch(waitNextFrame())
+ .then(() => this.stage3CreateCore())
+ .catch(ex => {
+ logger.error(ex);
+ throw ex;
+ });
}
/**
@@ -433,6 +454,11 @@ export class InGameState extends GameState {
logger.warn("Skipping double save and returning same promise");
return this.currentSavePromise;
}
+
+ if (!this.core.root.gameMode.getIsSaveable()) {
+ return Promise.resolve();
+ }
+
logger.log("Starting to save game ...");
this.savegame.updateData(this.core.root);
diff --git a/src/js/states/login.js b/src/js/states/login.js
new file mode 100644
index 00000000..64f599e4
--- /dev/null
+++ b/src/js/states/login.js
@@ -0,0 +1,102 @@
+import { GameState } from "../core/game_state";
+import { getRandomHint } from "../game/hints";
+import { HUDModalDialogs } from "../game/hud/parts/modal_dialogs";
+import { T } from "../translations";
+
+export class LoginState extends GameState {
+ constructor() {
+ super("LoginState");
+ }
+
+ getInnerHTML() {
+ return `
+
+
+
+ `;
+ }
+
+ /**
+ *
+ * @param {object} payload
+ * @param {string} payload.nextStateId
+ */
+ onEnter(payload) {
+ this.payload = payload;
+ if (!this.payload.nextStateId) {
+ throw new Error("No next state id");
+ }
+
+ if (this.app.clientApi.isLoggedIn()) {
+ this.finishLoading();
+ return;
+ }
+
+ this.dialogs = new HUDModalDialogs(null, this.app);
+ const dialogsElement = document.body.querySelector(".modalDialogParent");
+ this.dialogs.initializeToElement(dialogsElement);
+
+ this.htmlElement.classList.add("prefab_LoadingState");
+
+ /** @type {HTMLElement} */
+ this.hintsText = this.htmlElement.querySelector(".prefab_GameHint");
+ this.lastHintShown = -1000;
+ this.nextHintDuration = 0;
+
+ this.tryLogin();
+ }
+
+ tryLogin() {
+ this.app.clientApi.tryLogin().then(success => {
+ console.log("Logged in:", success);
+
+ if (!success) {
+ const signals = this.dialogs.showWarning(
+ T.dialogs.offlineMode.title,
+ T.dialogs.offlineMode.desc,
+ ["retry", "playOffline:bad"]
+ );
+ signals.retry.add(() => setTimeout(() => this.tryLogin(), 2000), this);
+ signals.playOffline.add(this.finishLoading, this);
+ } else {
+ this.finishLoading();
+ }
+ });
+ }
+
+ finishLoading() {
+ this.moveToState(this.payload.nextStateId);
+ }
+
+ getDefaultPreviousState() {
+ return "MainMenuState";
+ }
+
+ update() {
+ const now = performance.now();
+ if (now - this.lastHintShown > this.nextHintDuration) {
+ this.lastHintShown = now;
+ const hintText = getRandomHint();
+
+ this.hintsText.innerHTML = hintText;
+
+ /**
+ * Compute how long the user will need to read the hint.
+ * We calculate with 130 words per minute, with an average of 5 chars
+ * that is 650 characters / minute
+ */
+ this.nextHintDuration = Math.max(2500, (hintText.length / 650) * 60 * 1000);
+ }
+ }
+
+ onRender() {
+ this.update();
+ }
+
+ onBackgroundTick() {
+ this.update();
+ }
+}
diff --git a/src/js/states/main_menu.js b/src/js/states/main_menu.js
index 3afad9bf..25d93d7a 100644
--- a/src/js/states/main_menu.js
+++ b/src/js/states/main_menu.js
@@ -66,7 +66,7 @@ export class MainMenuState extends GameState {
+ ${T.global.loggingIn}
+
+
@@ -82,6 +82,19 @@ export class MainMenuState extends GameState {
}
+
+ ${
+ // @TODO: Only display if DLC is owned, otherwise show ad for store page
+ showDemoBadges
+ ? ""
+ : `
+
+ 
+
+
`
+ }