" + binding.getKeyCodeString() + ""
- );
+ if (rawBinding) {
+ const binding = this.root.keyMapper.getBinding(rawBinding);
+ this.buildingInfoElements.hotkey.innerHTML = T.ingame.buildingPlacement.hotkeyLabel.replace(
+ "" + binding.getKeyCodeString() + ""
+ );
+ } else {
+ this.buildingInfoElements.hotkey.innerHTML = "";
+ }
this.buildingInfoElements.tutorialImage.setAttribute(
"data-icon",
@@ -355,7 +358,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
rotationVariant
);
- const canBuild = this.root.logic.checkCanPlaceEntity(this.fakeEntity);
+ const canBuild = this.root.logic.checkCanPlaceEntity(this.fakeEntity, {});
// Fade in / out
parameters.context.lineWidth = 1;
@@ -394,6 +397,46 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
}
}
+ /**
+ * Checks if there are any entities in the way, returns true if there are
+ * @param {Vector} from
+ * @param {Vector} to
+ * @param {Vector[]=} ignorePositions
+ * @returns
+ */
+ checkForObstales(from, to, ignorePositions = []) {
+ assert(from.x === to.x || from.y === to.y, "Must be a straight line");
+
+ const prop = from.x === to.x ? "y" : "x";
+ const current = from.copy();
+
+ const metaBuilding = this.currentMetaBuilding.get();
+ this.fakeEntity.layer = metaBuilding.getLayer();
+ const staticComp = this.fakeEntity.components.StaticMapEntity;
+ staticComp.origin = current;
+ staticComp.rotation = 0;
+ metaBuilding.updateVariants(this.fakeEntity, 0, this.currentVariant.get());
+ staticComp.code = getCodeFromBuildingData(
+ this.currentMetaBuilding.get(),
+ this.currentVariant.get(),
+ 0
+ );
+
+ const start = Math.min(from[prop], to[prop]);
+ const end = Math.max(from[prop], to[prop]);
+
+ for (let i = start; i <= end; i++) {
+ current[prop] = i;
+ if (ignorePositions.some(p => p.distanceSquare(current) < 0.1)) {
+ continue;
+ }
+ if (!this.root.logic.checkCanPlaceEntity(this.fakeEntity, { allowReplaceBuildings: false })) {
+ return true;
+ }
+ }
+ return false;
+ }
+
/**
* @param {DrawParameters} parameters
*/
@@ -404,55 +447,76 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
return;
}
+ const applyStyles = look => {
+ parameters.context.fillStyle = THEME.map.directionLock[look].color;
+ parameters.context.strokeStyle = THEME.map.directionLock[look].background;
+ parameters.context.lineWidth = 10;
+ };
+
+ if (!this.lastDragTile) {
+ // Not dragging yet
+ applyStyles(this.root.currentLayer);
+ const mouseWorld = this.root.camera.screenToWorld(mousePosition);
+ parameters.context.beginCircle(mouseWorld.x, mouseWorld.y, 4);
+ parameters.context.fill();
+ return;
+ }
+
const mouseWorld = this.root.camera.screenToWorld(mousePosition);
const mouseTile = mouseWorld.toTileSpace();
- parameters.context.fillStyle = THEME.map.directionLock[this.root.currentLayer].color;
- parameters.context.strokeStyle = THEME.map.directionLock[this.root.currentLayer].background;
- parameters.context.lineWidth = 10;
+ const startLine = this.lastDragTile.toWorldSpaceCenterOfTile();
+ const endLine = mouseTile.toWorldSpaceCenterOfTile();
+ const midLine = this.currentDirectionLockCorner.toWorldSpaceCenterOfTile();
+ const anyObstacle =
+ this.checkForObstales(this.lastDragTile, this.currentDirectionLockCorner, [
+ this.lastDragTile,
+ mouseTile,
+ ]) ||
+ this.checkForObstales(this.currentDirectionLockCorner, mouseTile, [this.lastDragTile, mouseTile]);
+
+ if (anyObstacle) {
+ applyStyles("error");
+ } else {
+ applyStyles(this.root.currentLayer);
+ }
parameters.context.beginCircle(mouseWorld.x, mouseWorld.y, 4);
parameters.context.fill();
- if (this.lastDragTile) {
- const startLine = this.lastDragTile.toWorldSpaceCenterOfTile();
- const endLine = mouseTile.toWorldSpaceCenterOfTile();
- const midLine = this.currentDirectionLockCorner.toWorldSpaceCenterOfTile();
+ parameters.context.beginCircle(startLine.x, startLine.y, 8);
+ parameters.context.fill();
- parameters.context.beginCircle(startLine.x, startLine.y, 8);
- parameters.context.fill();
+ parameters.context.beginPath();
+ parameters.context.moveTo(startLine.x, startLine.y);
+ parameters.context.lineTo(midLine.x, midLine.y);
+ parameters.context.lineTo(endLine.x, endLine.y);
+ parameters.context.stroke();
- parameters.context.beginPath();
- parameters.context.moveTo(startLine.x, startLine.y);
- parameters.context.lineTo(midLine.x, midLine.y);
- parameters.context.lineTo(endLine.x, endLine.y);
- parameters.context.stroke();
+ parameters.context.beginCircle(endLine.x, endLine.y, 5);
+ parameters.context.fill();
- parameters.context.beginCircle(endLine.x, endLine.y, 5);
- parameters.context.fill();
+ // Draw arrow
+ const arrowSprite = this.lockIndicatorSprites[anyObstacle ? "error" : 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();
+ const angle = Math.radians(rotation);
- // 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();
- 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 -
- 6,
- 12,
- 12
- );
- parameters.context.rotate(-angle);
- parameters.context.translate(-worldPos.x, -worldPos.y);
- }
+ 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 -
+ 6,
+ 12,
+ 12
+ );
+ parameters.context.rotate(-angle);
+ parameters.context.translate(-worldPos.x, -worldPos.y);
}
}
@@ -473,7 +537,13 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
const offsetShift = 10;
+ /**
+ * @type {Array`;
for (const property in val) {
- const isRoot = val[property] == this.root;
- const isRecursive = recursion.includes(val[property]);
-
- let hiddenValue = isRoot ? "" : null;
- if (isRecursive) {
+ let hiddenValue = null;
+ if (val[property] == this.root) {
+ hiddenValue = "";
+ } else if (val[property] instanceof Node) {
+ hiddenValue = `<${val[property].constructor.name}>`;
+ } else if (recursion.includes(val[property])) {
// Avoid recursion by not "expanding" object more than once
hiddenValue = "";
}
diff --git a/src/js/game/hud/parts/lever_toggle.js b/src/js/game/hud/parts/lever_toggle.js
index 1859f7ab..dbb36609 100644
--- a/src/js/game/hud/parts/lever_toggle.js
+++ b/src/js/game/hud/parts/lever_toggle.js
@@ -22,7 +22,9 @@ export class HUDLeverToggle extends BaseHUDPart {
leverComp.toggled = !leverComp.toggled;
return STOP_PROPAGATION;
} else if (button === enumMouseButton.right) {
- this.root.logic.tryDeleteBuilding(contents);
+ if (!this.root.hud.parts.buildingPlacer.currentMetaBuilding) {
+ this.root.logic.tryDeleteBuilding(contents);
+ }
return STOP_PROPAGATION;
}
}
diff --git a/src/js/game/hud/parts/mass_selector.js b/src/js/game/hud/parts/mass_selector.js
index b8283d55..bb032f1e 100644
--- a/src/js/game/hud/parts/mass_selector.js
+++ b/src/js/game/hud/parts/mass_selector.js
@@ -315,6 +315,7 @@ export class HUDMassSelector extends BaseHUDPart {
parameters.context.stroke();
parameters.context.fillStyle = THEME.map.selectionOverlay;
+ parameters.context.beginPath();
const renderedUids = new Set();
@@ -336,32 +337,31 @@ export class HUDMassSelector extends BaseHUDPart {
}
const bounds = staticComp.getTileSpaceBounds();
- parameters.context.beginRoundedRect(
+ parameters.context.rect(
bounds.x * globalConfig.tileSize + boundsBorder,
bounds.y * globalConfig.tileSize + boundsBorder,
bounds.w * globalConfig.tileSize - 2 * boundsBorder,
- bounds.h * globalConfig.tileSize - 2 * boundsBorder,
- 2
+ bounds.h * globalConfig.tileSize - 2 * boundsBorder
);
- parameters.context.fill();
}
}
}
+ parameters.context.fill();
}
parameters.context.fillStyle = THEME.map.selectionOverlay;
+ parameters.context.beginPath();
this.selectedUids.forEach(uid => {
const entity = this.root.entityMgr.findByUid(uid);
const staticComp = entity.components.StaticMapEntity;
const bounds = staticComp.getTileSpaceBounds();
- parameters.context.beginRoundedRect(
+ parameters.context.rect(
bounds.x * globalConfig.tileSize + boundsBorder,
bounds.y * globalConfig.tileSize + boundsBorder,
bounds.w * globalConfig.tileSize - 2 * boundsBorder,
- bounds.h * globalConfig.tileSize - 2 * boundsBorder,
- 2
+ bounds.h * globalConfig.tileSize - 2 * boundsBorder
);
- parameters.context.fill();
});
+ parameters.context.fill();
}
}
diff --git a/src/js/game/hud/parts/modal_dialogs.js b/src/js/game/hud/parts/modal_dialogs.js
index 33211cf6..f86160bc 100644
--- a/src/js/game/hud/parts/modal_dialogs.js
+++ b/src/js/game/hud/parts/modal_dialogs.js
@@ -150,7 +150,7 @@ export class HUDModalDialogs extends BaseHUDPart {
internalShowDialog(dialog) {
const elem = dialog.createElement();
- dialog.setIndex(this.dialogStack.length);
+ dialog.setIndex(1000 + this.dialogStack.length);
// Hide last dialog in queue
if (this.dialogStack.length > 0) {
diff --git a/src/js/game/hud/parts/HUDPuzzleNextPuzzle.js b/src/js/game/hud/parts/next_puzzle.js
similarity index 100%
rename from src/js/game/hud/parts/HUDPuzzleNextPuzzle.js
rename to src/js/game/hud/parts/next_puzzle.js
diff --git a/src/js/game/hud/parts/notifications.js b/src/js/game/hud/parts/notifications.js
index bef8dd0f..abeab205 100644
--- a/src/js/game/hud/parts/notifications.js
+++ b/src/js/game/hud/parts/notifications.js
@@ -7,6 +7,9 @@ export const enumNotificationType = {
saved: "saved",
upgrade: "upgrade",
success: "success",
+ info: "info",
+ warning: "warning",
+ error: "error",
};
const notificationDuration = 3;
@@ -17,14 +20,14 @@ export class HUDNotifications extends BaseHUDPart {
}
initialize() {
- this.root.hud.signals.notification.add(this.onNotification, this);
+ this.root.hud.signals.notification.add(this.internalShowNotification, this);
/** @type {Array<{ element: HTMLElement, expireAt: number}>} */
this.notificationElements = [];
// Automatic notifications
this.root.signals.gameSaved.add(() =>
- this.onNotification(T.ingame.notifications.gameSaved, enumNotificationType.saved)
+ this.internalShowNotification(T.ingame.notifications.gameSaved, enumNotificationType.saved)
);
}
@@ -32,7 +35,7 @@ export class HUDNotifications extends BaseHUDPart {
* @param {string} message
* @param {enumNotificationType} type
*/
- onNotification(message, type) {
+ internalShowNotification(message, type) {
const element = makeDiv(this.element, null, ["notification", "type-" + type], message);
element.setAttribute("data-icon", "icons/notification_" + type + ".png");
diff --git a/src/js/game/key_action_mapper.js b/src/js/game/key_action_mapper.js
index 090b8b83..3378368a 100644
--- a/src/js/game/key_action_mapper.js
+++ b/src/js/game/key_action_mapper.js
@@ -7,118 +7,152 @@ import { Application } from "../application";
import { Signal, STOP_PROPAGATION } from "../core/signal";
import { IS_MOBILE } from "../core/config";
import { T } from "../translations";
-function key(str) {
+
+export function keyToKeyCode(str) {
return str.toUpperCase().charCodeAt(0);
}
-const KEYCODE_UP_ARROW = 38;
-const KEYCODE_DOWN_ARROW = 40;
-const KEYCODE_LEFT_ARROW = 37;
-const KEYCODE_RIGHT_ARROW = 39;
+export const KEYCODES = {
+ Tab: 9,
+ Enter: 13,
+
+ Shift: 16,
+ Ctrl: 17,
+ Alt: 18,
+
+ Escape: 27,
+
+ Space: 32,
+
+ ArrowLeft: 37,
+ ArrowUp: 38,
+ ArrowRight: 39,
+ ArrowDown: 40,
+
+ Delete: 46,
+
+ F1: 112,
+ F2: 113,
+ F3: 114,
+ F4: 115,
+ F5: 116,
+ F6: 117,
+ F7: 118,
+ F8: 119,
+ F9: 120,
+ F10: 121,
+ F11: 122,
+ F12: 123,
+
+ Plus: 187,
+ Minus: 189,
+};
export const KEYMAPPINGS = {
+ // Make sure mods come first so they can override everything
+ mods: {},
+
general: {
- confirm: { keyCode: 13 }, // enter
- back: { keyCode: 27, builtin: true }, // escape
+ confirm: { keyCode: KEYCODES.Enter },
+ back: { keyCode: KEYCODES.Escape, builtin: true },
},
ingame: {
- menuOpenShop: { keyCode: key("F") },
- menuOpenStats: { keyCode: key("G") },
- menuClose: { keyCode: key("Q") },
+ menuOpenShop: { keyCode: keyToKeyCode("F") },
+ menuOpenStats: { keyCode: keyToKeyCode("G") },
+ menuClose: { keyCode: keyToKeyCode("Q") },
- toggleHud: { keyCode: 113 }, // F2
- exportScreenshot: { keyCode: 114 }, // F3PS
- toggleFPSInfo: { keyCode: 115 }, // F4
+ toggleHud: { keyCode: KEYCODES.F2 },
+ exportScreenshot: { keyCode: KEYCODES.F3 },
+ toggleFPSInfo: { keyCode: KEYCODES.F4 },
- switchLayers: { keyCode: key("E") },
+ switchLayers: { keyCode: keyToKeyCode("E") },
- showShapeTooltip: { keyCode: 18 }, // ALT
+ showShapeTooltip: { keyCode: KEYCODES.Alt },
},
navigation: {
- mapMoveUp: { keyCode: key("W") },
- mapMoveRight: { keyCode: key("D") },
- mapMoveDown: { keyCode: key("S") },
- mapMoveLeft: { keyCode: key("A") },
- mapMoveFaster: { keyCode: 16 }, //shift
+ mapMoveUp: { keyCode: keyToKeyCode("W") },
+ mapMoveRight: { keyCode: keyToKeyCode("D") },
+ mapMoveDown: { keyCode: keyToKeyCode("S") },
+ mapMoveLeft: { keyCode: keyToKeyCode("A") },
+ mapMoveFaster: { keyCode: KEYCODES.Shift },
- centerMap: { keyCode: 32 }, // SPACE
- mapZoomIn: { keyCode: 187, repeated: true }, // "+"
- mapZoomOut: { keyCode: 189, repeated: true }, // "-"
-
- createMarker: { keyCode: key("M") },
+ centerMap: { keyCode: KEYCODES.Space },
+ mapZoomIn: { keyCode: KEYCODES.Plus, repeated: true },
+ mapZoomOut: { keyCode: KEYCODES.Minus, repeated: true },
+ createMarker: { keyCode: keyToKeyCode("M") },
},
buildings: {
// Puzzle buildings
- constant_producer: { keyCode: key("H") },
- goal_acceptor: { keyCode: key("N") },
- block: { keyCode: key("4") },
+ constant_producer: { keyCode: keyToKeyCode("H") },
+ goal_acceptor: { keyCode: keyToKeyCode("N") },
+ block: { keyCode: keyToKeyCode("4") },
// Primary Toolbar
- belt: { keyCode: key("1") },
- balancer: { keyCode: key("2") },
- underground_belt: { keyCode: key("3") },
- miner: { keyCode: key("4") },
- cutter: { keyCode: key("5") },
- rotater: { keyCode: key("6") },
- stacker: { keyCode: key("7") },
- mixer: { keyCode: key("8") },
- painter: { keyCode: key("9") },
- trash: { keyCode: key("0") },
+ belt: { keyCode: keyToKeyCode("1") },
+ balancer: { keyCode: keyToKeyCode("2") },
+ underground_belt: { keyCode: keyToKeyCode("3") },
+ miner: { keyCode: keyToKeyCode("4") },
+ cutter: { keyCode: keyToKeyCode("5") },
+ rotater: { keyCode: keyToKeyCode("6") },
+ stacker: { keyCode: keyToKeyCode("7") },
+ mixer: { keyCode: keyToKeyCode("8") },
+ painter: { keyCode: keyToKeyCode("9") },
+ trash: { keyCode: keyToKeyCode("0") },
// Sandbox
- item_producer: { keyCode: key("L") },
+ item_producer: { keyCode: keyToKeyCode("L") },
// Secondary toolbar
- storage: { keyCode: key("Y") },
- reader: { keyCode: key("U") },
- lever: { keyCode: key("I") },
- filter: { keyCode: key("O") },
- display: { keyCode: key("P") },
+ storage: { keyCode: keyToKeyCode("Y") },
+ reader: { keyCode: keyToKeyCode("U") },
+ lever: { keyCode: keyToKeyCode("I") },
+ filter: { keyCode: keyToKeyCode("O") },
+ display: { keyCode: keyToKeyCode("P") },
// Wires toolbar
- wire: { keyCode: key("1") },
- wire_tunnel: { keyCode: key("2") },
- constant_signal: { keyCode: key("3") },
- logic_gate: { keyCode: key("4") },
- virtual_processor: { keyCode: key("5") },
- analyzer: { keyCode: key("6") },
- comparator: { keyCode: key("7") },
- transistor: { keyCode: key("8") },
+ wire: { keyCode: keyToKeyCode("1") },
+ wire_tunnel: { keyCode: keyToKeyCode("2") },
+ constant_signal: { keyCode: keyToKeyCode("3") },
+ logic_gate: { keyCode: keyToKeyCode("4") },
+ virtual_processor: { keyCode: keyToKeyCode("5") },
+ analyzer: { keyCode: keyToKeyCode("6") },
+ comparator: { keyCode: keyToKeyCode("7") },
+ transistor: { keyCode: keyToKeyCode("8") },
},
placement: {
- pipette: { keyCode: key("Q") },
- rotateWhilePlacing: { keyCode: key("R") },
- rotateInverseModifier: { keyCode: 16 }, // SHIFT
- rotateToUp: { keyCode: KEYCODE_UP_ARROW },
- rotateToDown: { keyCode: KEYCODE_DOWN_ARROW },
- rotateToRight: { keyCode: KEYCODE_RIGHT_ARROW },
- rotateToLeft: { keyCode: KEYCODE_LEFT_ARROW },
- cycleBuildingVariants: { keyCode: key("T") },
- cycleBuildings: { keyCode: 9 }, // TAB
- switchDirectionLockSide: { keyCode: key("R") },
+ pipette: { keyCode: keyToKeyCode("Q") },
+ rotateWhilePlacing: { keyCode: keyToKeyCode("R") },
+ rotateInverseModifier: { keyCode: KEYCODES.Shift },
+ rotateToUp: { keyCode: KEYCODES.ArrowUp },
+ rotateToDown: { keyCode: KEYCODES.ArrowDown },
+ rotateToRight: { keyCode: KEYCODES.ArrowRight },
+ rotateToLeft: { keyCode: KEYCODES.ArrowLeft },
+ cycleBuildingVariants: { keyCode: keyToKeyCode("T") },
+ cycleBuildings: { keyCode: KEYCODES.Tab },
+ switchDirectionLockSide: { keyCode: keyToKeyCode("R") },
- copyWireValue: { keyCode: key("Z") },
+ copyWireValue: { keyCode: keyToKeyCode("Z") },
},
massSelect: {
- massSelectStart: { keyCode: 17 }, // CTRL
- massSelectSelectMultiple: { keyCode: 16 }, // SHIFT
- massSelectCopy: { keyCode: key("C") },
- massSelectCut: { keyCode: key("X") },
- massSelectClear: { keyCode: key("B") },
- confirmMassDelete: { keyCode: 46 }, // DEL
- pasteLastBlueprint: { keyCode: key("V") },
+ massSelectStart: { keyCode: KEYCODES.Ctrl },
+ massSelectSelectMultiple: { keyCode: KEYCODES.Shift },
+ massSelectCopy: { keyCode: keyToKeyCode("C") },
+ massSelectCut: { keyCode: keyToKeyCode("X") },
+ massSelectClear: { keyCode: keyToKeyCode("B") },
+ confirmMassDelete: { keyCode: KEYCODES.Delete },
+ pasteLastBlueprint: { keyCode: keyToKeyCode("V") },
},
placementModifiers: {
- lockBeltDirection: { keyCode: 16 }, // SHIFT
- placementDisableAutoOrientation: { keyCode: 17 }, // CTRL
- placeMultiple: { keyCode: 16 }, // SHIFT
- placeInverse: { keyCode: 18 }, // ALT
+ lockBeltDirection: { keyCode: KEYCODES.Shift },
+ placementDisableAutoOrientation: { keyCode: KEYCODES.Ctrl },
+ placeMultiple: { keyCode: KEYCODES.Shift },
+ placeInverse: { keyCode: KEYCODES.Alt },
},
};
@@ -153,23 +187,23 @@ export function getStringForKeyCode(code) {
return "MB5";
case 8:
return "⌫";
- case 9:
+ case KEYCODES.Tab:
return T.global.keys.tab;
- case 13:
+ case KEYCODES.Enter:
return "⏎";
- case 16:
+ case KEYCODES.Shift:
return "⇪";
- case 17:
+ case KEYCODES.Ctrl:
return T.global.keys.control;
- case 18:
+ case KEYCODES.Alt:
return T.global.keys.alt;
case 19:
return "PAUSE";
case 20:
return "CAPS";
- case 27:
+ case KEYCODES.Escape:
return T.global.keys.escape;
- case 32:
+ case KEYCODES.Space:
return T.global.keys.space;
case 33:
return "PGUP";
@@ -179,13 +213,13 @@ export function getStringForKeyCode(code) {
return "END";
case 36:
return "HOME";
- case KEYCODE_LEFT_ARROW:
+ case KEYCODES.ArrowLeft:
return "⬅";
- case KEYCODE_UP_ARROW:
+ case KEYCODES.ArrowUp:
return "⬆";
- case KEYCODE_RIGHT_ARROW:
+ case KEYCODES.ArrowRight:
return "➡";
- case KEYCODE_DOWN_ARROW:
+ case KEYCODES.ArrowDown:
return "⬇";
case 44:
return "PRNT";
@@ -225,29 +259,29 @@ export function getStringForKeyCode(code) {
return ".";
case 111:
return "/";
- case 112:
+ case KEYCODES.F1:
return "F1";
- case 113:
+ case KEYCODES.F2:
return "F2";
- case 114:
+ case KEYCODES.F3:
return "F3";
- case 115:
+ case KEYCODES.F4:
return "F4";
- case 116:
+ case KEYCODES.F5:
return "F5";
- case 117:
+ case KEYCODES.F6:
return "F6";
- case 118:
+ case KEYCODES.F7:
return "F7";
- case 119:
+ case KEYCODES.F8:
return "F8";
- case 120:
+ case KEYCODES.F9:
return "F9";
- case 121:
+ case KEYCODES.F10:
return "F10";
- case 122:
+ case KEYCODES.F11:
return "F11";
- case 123:
+ case KEYCODES.F12:
return "F12";
case 144:
@@ -296,8 +330,9 @@ export class Keybinding {
* @param {number} param0.keyCode
* @param {boolean=} param0.builtin
* @param {boolean=} param0.repeated
+ * @param {{ shift?: boolean; alt?: boolean; ctrl?: boolean; }=} param0.modifiers
*/
- constructor(keyMapper, app, { keyCode, builtin = false, repeated = false }) {
+ constructor(keyMapper, app, { keyCode, builtin = false, repeated = false, modifiers = {} }) {
assert(keyCode && Number.isInteger(keyCode), "Invalid key code: " + keyCode);
this.keyMapper = keyMapper;
this.app = app;
@@ -305,6 +340,8 @@ export class Keybinding {
this.builtin = builtin;
this.repeated = repeated;
+ this.modifiers = modifiers;
+
this.signal = new Signal();
this.toggled = new Signal();
}
@@ -395,7 +432,6 @@ export class KeyActionMapper {
if (overrides[key]) {
payload.keyCode = overrides[key];
}
-
this.keybindings[key] = new Keybinding(this, this.root.app, payload);
if (G_IS_DEV) {
@@ -459,9 +495,10 @@ export class KeyActionMapper {
* @param {number} param0.keyCode
* @param {boolean} param0.shift
* @param {boolean} param0.alt
+ * @param {boolean} param0.ctrl
* @param {boolean=} param0.initial
*/
- handleKeydown({ keyCode, shift, alt, initial }) {
+ handleKeydown({ keyCode, shift, alt, ctrl, initial }) {
let stop = false;
// Find mapping
@@ -469,6 +506,18 @@ export class KeyActionMapper {
/** @type {Keybinding} */
const binding = this.keybindings[key];
if (binding.keyCode === keyCode && (initial || binding.repeated)) {
+ if (binding.modifiers.shift && !shift) {
+ continue;
+ }
+
+ if (binding.modifiers.ctrl && !ctrl) {
+ continue;
+ }
+
+ if (binding.modifiers.alt && !alt) {
+ continue;
+ }
+
/** @type {Signal} */
const signal = this.keybindings[key].signal;
if (signal.dispatch() === STOP_PROPAGATION) {
@@ -505,4 +554,14 @@ export class KeyActionMapper {
assert(this.keybindings[id], "Keybinding " + id + " not known!");
return this.keybindings[id];
}
+
+ /**
+ * Returns a given keybinding
+ * @param {string} id
+ * @returns {Keybinding}
+ */
+ getBindingById(id) {
+ 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 79104958..0e915fea 100644
--- a/src/js/game/logic.js
+++ b/src/js/game/logic.js
@@ -53,10 +53,12 @@ export class GameLogic {
/**
* Checks if the given entity can be placed
* @param {Entity} entity
- * @param {Vector=} offset Optional, move the entity by the given offset first
+ * @param {Object} param0
+ * @param {boolean=} param0.allowReplaceBuildings
+ * @param {Vector=} param0.offset Optional, move the entity by the given offset first
* @returns {boolean} true if the entity could be placed there
*/
- checkCanPlaceEntity(entity, offset = null) {
+ checkCanPlaceEntity(entity, { allowReplaceBuildings = true, offset = null }) {
// Compute area of the building
const rect = entity.components.StaticMapEntity.getTileSpaceBounds();
if (offset) {
@@ -71,7 +73,7 @@ export class GameLogic {
const otherEntity = this.root.map.getLayerContentXY(x, y, entity.layer);
if (otherEntity) {
const metaClass = otherEntity.components.StaticMapEntity.getMetaBuilding();
- if (!metaClass.getIsReplaceable()) {
+ if (!allowReplaceBuildings || !metaClass.getIsReplaceable()) {
// This one is a direct blocker
return false;
}
@@ -116,7 +118,7 @@ export class GameLogic {
rotationVariant,
variant,
});
- if (this.checkCanPlaceEntity(entity)) {
+ if (this.checkCanPlaceEntity(entity, {})) {
this.freeEntityAreaBeforeBuild(entity);
this.root.map.placeStaticEntity(entity);
this.root.entityMgr.registerEntity(entity);
@@ -393,7 +395,14 @@ export class GameLogic {
const entity = this.root.map.getLayerContentXY(tile.x + dx, tile.y + dy, "regular");
if (entity) {
+ /**
+ * @type {Array}
+ */
let ejectorSlots = [];
+
+ /**
+ * @type {Array}
+ */
let acceptorSlots = [];
const staticComp = entity.components.StaticMapEntity;
@@ -434,19 +443,16 @@ export class GameLogic {
for (let acceptorSlot = 0; acceptorSlot < acceptorSlots.length; ++acceptorSlot) {
const slot = acceptorSlots[acceptorSlot];
const wsTile = staticComp.localTileToWorld(slot.pos);
- for (let k = 0; k < slot.directions.length; ++k) {
- const direction = slot.directions[k];
- const wsDirection = staticComp.localDirectionToWorld(direction);
-
- const sourceTile = wsTile.add(enumDirectionToVector[wsDirection]);
- if (sourceTile.equals(tile)) {
- acceptors.push({
- entity,
- slot,
- toTile: wsTile,
- fromDirection: wsDirection,
- });
- }
+ const direction = slot.direction;
+ const wsDirection = staticComp.localDirectionToWorld(direction);
+ const sourceTile = wsTile.add(enumDirectionToVector[wsDirection]);
+ if (sourceTile.equals(tile)) {
+ acceptors.push({
+ entity,
+ slot,
+ toTile: wsTile,
+ fromDirection: wsDirection,
+ });
}
}
}
diff --git a/src/js/game/map_chunk.js b/src/js/game/map_chunk.js
index 54af1125..b966a322 100644
--- a/src/js/game/map_chunk.js
+++ b/src/js/game/map_chunk.js
@@ -13,6 +13,11 @@ import { Rectangle } from "../core/rectangle";
const logger = createLogger("map_chunk");
+/**
+ * @type {Object number>}
+ */
+export const MODS_ADDITIONAL_SHAPE_MAP_WEIGHTS = {};
+
export class MapChunk {
/**
*
@@ -192,6 +197,10 @@ export class MapChunk {
[enumSubShape.windmill]: Math.round(6 + clamp(distanceToOriginInChunks / 2, 0, 20)),
};
+ for (const key in MODS_ADDITIONAL_SHAPE_MAP_WEIGHTS) {
+ weights[key] = MODS_ADDITIONAL_SHAPE_MAP_WEIGHTS[key](distanceToOriginInChunks);
+ }
+
if (distanceToOriginInChunks < 7) {
// Initial chunks can not spawn the good stuff
weights[enumSubShape.star] = 0;
@@ -274,6 +283,17 @@ export class MapChunk {
const chunkCenter = new Vector(this.x, this.y).addScalar(0.5);
const distanceToOriginInChunks = Math.round(chunkCenter.length());
+ this.generatePatches({ rng, chunkCenter, distanceToOriginInChunks });
+ }
+
+ /**
+ *
+ * @param {object} param0
+ * @param {RandomNumberGenerator} param0.rng
+ * @param {Vector} param0.chunkCenter
+ * @param {number} param0.distanceToOriginInChunks
+ */
+ generatePatches({ rng, chunkCenter, distanceToOriginInChunks }) {
// Determine how likely it is that there is a color patch
const colorPatchChance = 0.9 - clamp(distanceToOriginInChunks / 25, 0, 1) * 0.5;
@@ -424,7 +444,7 @@ export class MapChunk {
* Sets the chunks contents
* @param {number} tileX
* @param {number} tileY
- * @param {Entity=} contents
+ * @param {Entity} contents
* @param {Layer} layer
*/
setLayerContentFromWorldCords(tileX, tileY, contents, layer) {
diff --git a/src/js/game/map_chunk_aggregate.js b/src/js/game/map_chunk_aggregate.js
index de15362d..f47ed676 100644
--- a/src/js/game/map_chunk_aggregate.js
+++ b/src/js/game/map_chunk_aggregate.js
@@ -2,10 +2,9 @@ import { globalConfig } from "../core/config";
import { DrawParameters } from "../core/draw_parameters";
import { drawSpriteClipped } from "../core/draw_utils";
import { safeModulo } from "../core/utils";
+import { CHUNK_OVERLAY_RES } from "./map_chunk_view";
import { GameRoot } from "./root";
-export const CHUNK_OVERLAY_RES = 3;
-
export class MapChunkAggregate {
/**
*
diff --git a/src/js/game/map_chunk_view.js b/src/js/game/map_chunk_view.js
index 947b7a9f..86c14fb8 100644
--- a/src/js/game/map_chunk_view.js
+++ b/src/js/game/map_chunk_view.js
@@ -5,10 +5,20 @@ import { Entity } from "./entity";
import { MapChunk } from "./map_chunk";
import { GameRoot } from "./root";
import { THEME } from "./theme";
-import { drawSpriteClipped } from "../core/draw_utils";
export const CHUNK_OVERLAY_RES = 3;
+export const MOD_CHUNK_DRAW_HOOKS = {
+ backgroundLayerBefore: [],
+ backgroundLayerAfter: [],
+
+ foregroundDynamicBefore: [],
+ foregroundDynamicAfter: [],
+
+ staticBefore: [],
+ staticAfter: [],
+};
+
export class MapChunkView extends MapChunk {
/**
*
@@ -42,6 +52,11 @@ export class MapChunkView extends MapChunk {
*/
drawBackgroundLayer(parameters) {
const systems = this.root.systemMgr.systems;
+
+ MOD_CHUNK_DRAW_HOOKS.backgroundLayerBefore.forEach(systemId =>
+ systems[systemId].drawChunk(parameters, this)
+ );
+
if (systems.zone) {
systems.zone.drawChunk(parameters, this);
}
@@ -52,6 +67,10 @@ export class MapChunkView extends MapChunk {
systems.beltUnderlays.drawChunk(parameters, this);
systems.belt.drawChunk(parameters, this);
+
+ MOD_CHUNK_DRAW_HOOKS.backgroundLayerAfter.forEach(systemId =>
+ systems[systemId].drawChunk(parameters, this)
+ );
}
/**
@@ -61,9 +80,17 @@ export class MapChunkView extends MapChunk {
drawForegroundDynamicLayer(parameters) {
const systems = this.root.systemMgr.systems;
+ MOD_CHUNK_DRAW_HOOKS.foregroundDynamicBefore.forEach(systemId =>
+ systems[systemId].drawChunk(parameters, this)
+ );
+
systems.itemEjector.drawChunk(parameters, this);
systems.itemAcceptor.drawChunk(parameters, this);
systems.miner.drawChunk(parameters, this);
+
+ MOD_CHUNK_DRAW_HOOKS.foregroundDynamicAfter.forEach(systemId =>
+ systems[systemId].drawChunk(parameters, this)
+ );
}
/**
@@ -73,6 +100,8 @@ export class MapChunkView extends MapChunk {
drawForegroundStaticLayer(parameters) {
const systems = this.root.systemMgr.systems;
+ MOD_CHUNK_DRAW_HOOKS.staticBefore.forEach(systemId => systems[systemId].drawChunk(parameters, this));
+
systems.staticMapEntities.drawChunk(parameters, this);
systems.lever.drawChunk(parameters, this);
systems.display.drawChunk(parameters, this);
@@ -80,6 +109,8 @@ export class MapChunkView extends MapChunk {
systems.constantProducer.drawChunk(parameters, this);
systems.goalAcceptor.drawChunk(parameters, this);
systems.itemProcessorOverlays.drawChunk(parameters, this);
+
+ MOD_CHUNK_DRAW_HOOKS.staticAfter.forEach(systemId => systems[systemId].drawChunk(parameters, this));
}
/**
diff --git a/src/js/game/meta_building.js b/src/js/game/meta_building.js
index 7bfbce25..0e92d3d9 100644
--- a/src/js/game/meta_building.js
+++ b/src/js/game/meta_building.js
@@ -18,6 +18,16 @@ export class MetaBuilding {
this.id = id;
}
+ /**
+ * Should return all possible variants of this building, no matter
+ * if they are already available or will be unlocked later on
+ *
+ * @returns {Array<{ variant: string, rotationVariant?: number, internalId?: number|string }>}
+ */
+ static getAllVariantCombinations() {
+ throw new Error("implement getAllVariantCombinations");
+ }
+
/**
* Returns the id of this building
*/
diff --git a/src/js/game/meta_building_registry.js b/src/js/game/meta_building_registry.js
index 0c93153d..55bc46d4 100644
--- a/src/js/game/meta_building_registry.js
+++ b/src/js/game/meta_building_registry.js
@@ -2,202 +2,89 @@ import { gMetaBuildingRegistry } from "../core/global_registries";
import { createLogger } from "../core/logging";
import { T } from "../translations";
import { MetaAnalyzerBuilding } from "./buildings/analyzer";
-import { enumBalancerVariants, MetaBalancerBuilding } from "./buildings/balancer";
+import { MetaBalancerBuilding } from "./buildings/balancer";
import { MetaBeltBuilding } from "./buildings/belt";
import { MetaBlockBuilding } from "./buildings/block";
import { MetaComparatorBuilding } from "./buildings/comparator";
import { MetaConstantProducerBuilding } from "./buildings/constant_producer";
import { MetaConstantSignalBuilding } from "./buildings/constant_signal";
-import { enumCutterVariants, MetaCutterBuilding } from "./buildings/cutter";
+import { MetaCutterBuilding } from "./buildings/cutter";
import { MetaDisplayBuilding } from "./buildings/display";
import { MetaFilterBuilding } from "./buildings/filter";
import { MetaGoalAcceptorBuilding } from "./buildings/goal_acceptor";
import { MetaHubBuilding } from "./buildings/hub";
import { MetaItemProducerBuilding } from "./buildings/item_producer";
import { MetaLeverBuilding } from "./buildings/lever";
-import { enumLogicGateVariants, MetaLogicGateBuilding } from "./buildings/logic_gate";
-import { enumMinerVariants, MetaMinerBuilding } from "./buildings/miner";
+import { MetaLogicGateBuilding } from "./buildings/logic_gate";
+import { MetaMinerBuilding } from "./buildings/miner";
import { MetaMixerBuilding } from "./buildings/mixer";
-import { enumPainterVariants, MetaPainterBuilding } from "./buildings/painter";
+import { MetaPainterBuilding } from "./buildings/painter";
import { MetaReaderBuilding } from "./buildings/reader";
-import { enumRotaterVariants, MetaRotaterBuilding } from "./buildings/rotater";
+import { MetaRotaterBuilding } from "./buildings/rotater";
import { MetaStackerBuilding } from "./buildings/stacker";
import { MetaStorageBuilding } from "./buildings/storage";
-import { enumTransistorVariants, MetaTransistorBuilding } from "./buildings/transistor";
+import { MetaTransistorBuilding } from "./buildings/transistor";
import { MetaTrashBuilding } from "./buildings/trash";
-import { enumUndergroundBeltVariants, MetaUndergroundBeltBuilding } from "./buildings/underground_belt";
-import { enumVirtualProcessorVariants, MetaVirtualProcessorBuilding } from "./buildings/virtual_processor";
+import { MetaUndergroundBeltBuilding } from "./buildings/underground_belt";
+import { MetaVirtualProcessorBuilding } from "./buildings/virtual_processor";
import { MetaWireBuilding } from "./buildings/wire";
import { MetaWireTunnelBuilding } from "./buildings/wire_tunnel";
import { buildBuildingCodeCache, gBuildingVariants, registerBuildingVariant } from "./building_codes";
-import { enumWireVariant } from "./components/wire";
import { KEYMAPPINGS } from "./key_action_mapper";
-import { defaultBuildingVariant } from "./meta_building";
+import { defaultBuildingVariant, MetaBuilding } from "./meta_building";
const logger = createLogger("building_registry");
-export function initMetaBuildingRegistry() {
- gMetaBuildingRegistry.register(MetaBalancerBuilding);
- gMetaBuildingRegistry.register(MetaMinerBuilding);
- gMetaBuildingRegistry.register(MetaCutterBuilding);
- gMetaBuildingRegistry.register(MetaRotaterBuilding);
- gMetaBuildingRegistry.register(MetaStackerBuilding);
- gMetaBuildingRegistry.register(MetaMixerBuilding);
- gMetaBuildingRegistry.register(MetaPainterBuilding);
- gMetaBuildingRegistry.register(MetaTrashBuilding);
- gMetaBuildingRegistry.register(MetaStorageBuilding);
- gMetaBuildingRegistry.register(MetaBeltBuilding);
- gMetaBuildingRegistry.register(MetaUndergroundBeltBuilding);
- gMetaBuildingRegistry.register(MetaGoalAcceptorBuilding);
- gMetaBuildingRegistry.register(MetaHubBuilding);
- gMetaBuildingRegistry.register(MetaWireBuilding);
- gMetaBuildingRegistry.register(MetaConstantSignalBuilding);
- gMetaBuildingRegistry.register(MetaLogicGateBuilding);
- gMetaBuildingRegistry.register(MetaLeverBuilding);
- gMetaBuildingRegistry.register(MetaFilterBuilding);
- gMetaBuildingRegistry.register(MetaWireTunnelBuilding);
- gMetaBuildingRegistry.register(MetaDisplayBuilding);
- gMetaBuildingRegistry.register(MetaVirtualProcessorBuilding);
- gMetaBuildingRegistry.register(MetaReaderBuilding);
- gMetaBuildingRegistry.register(MetaTransistorBuilding);
- gMetaBuildingRegistry.register(MetaAnalyzerBuilding);
- gMetaBuildingRegistry.register(MetaComparatorBuilding);
- gMetaBuildingRegistry.register(MetaItemProducerBuilding);
- gMetaBuildingRegistry.register(MetaConstantProducerBuilding);
- gMetaBuildingRegistry.register(MetaBlockBuilding);
-
- // Belt
- registerBuildingVariant(1, MetaBeltBuilding, defaultBuildingVariant, 0);
- registerBuildingVariant(2, MetaBeltBuilding, defaultBuildingVariant, 1);
- registerBuildingVariant(3, MetaBeltBuilding, defaultBuildingVariant, 2);
-
- // Balancer
- registerBuildingVariant(4, MetaBalancerBuilding);
- registerBuildingVariant(5, MetaBalancerBuilding, enumBalancerVariants.merger);
- registerBuildingVariant(6, MetaBalancerBuilding, enumBalancerVariants.mergerInverse);
- registerBuildingVariant(47, MetaBalancerBuilding, enumBalancerVariants.splitter);
- registerBuildingVariant(48, MetaBalancerBuilding, enumBalancerVariants.splitterInverse);
-
- // Miner
- registerBuildingVariant(7, MetaMinerBuilding);
- registerBuildingVariant(8, MetaMinerBuilding, enumMinerVariants.chainable);
-
- // Cutter
- registerBuildingVariant(9, MetaCutterBuilding);
- registerBuildingVariant(10, MetaCutterBuilding, enumCutterVariants.quad);
-
- // Rotater
- registerBuildingVariant(11, MetaRotaterBuilding);
- registerBuildingVariant(12, MetaRotaterBuilding, enumRotaterVariants.ccw);
- registerBuildingVariant(13, MetaRotaterBuilding, enumRotaterVariants.rotate180);
-
- // Stacker
- registerBuildingVariant(14, MetaStackerBuilding);
-
- // Mixer
- registerBuildingVariant(15, MetaMixerBuilding);
-
- // Painter
- registerBuildingVariant(16, MetaPainterBuilding);
- registerBuildingVariant(17, MetaPainterBuilding, enumPainterVariants.mirrored);
- registerBuildingVariant(18, MetaPainterBuilding, enumPainterVariants.double);
- registerBuildingVariant(19, MetaPainterBuilding, enumPainterVariants.quad);
-
- // Trash
- registerBuildingVariant(20, MetaTrashBuilding);
-
- // Storage
- registerBuildingVariant(21, MetaStorageBuilding);
-
- // Underground belt
- registerBuildingVariant(22, MetaUndergroundBeltBuilding, defaultBuildingVariant, 0);
- registerBuildingVariant(23, MetaUndergroundBeltBuilding, defaultBuildingVariant, 1);
- registerBuildingVariant(24, MetaUndergroundBeltBuilding, enumUndergroundBeltVariants.tier2, 0);
- registerBuildingVariant(25, MetaUndergroundBeltBuilding, enumUndergroundBeltVariants.tier2, 1);
-
- // Hub
- registerBuildingVariant(26, MetaHubBuilding);
-
- // Wire
- registerBuildingVariant(27, MetaWireBuilding, defaultBuildingVariant, 0);
- registerBuildingVariant(28, MetaWireBuilding, defaultBuildingVariant, 1);
- registerBuildingVariant(29, MetaWireBuilding, defaultBuildingVariant, 2);
- registerBuildingVariant(30, MetaWireBuilding, defaultBuildingVariant, 3);
-
- registerBuildingVariant(52, MetaWireBuilding, enumWireVariant.second, 0);
- registerBuildingVariant(53, MetaWireBuilding, enumWireVariant.second, 1);
- registerBuildingVariant(54, MetaWireBuilding, enumWireVariant.second, 2);
- registerBuildingVariant(55, MetaWireBuilding, enumWireVariant.second, 3);
-
- // Constant signal
- registerBuildingVariant(31, MetaConstantSignalBuilding);
-
- // Logic gate
- registerBuildingVariant(32, MetaLogicGateBuilding);
- registerBuildingVariant(34, MetaLogicGateBuilding, enumLogicGateVariants.not);
- registerBuildingVariant(35, MetaLogicGateBuilding, enumLogicGateVariants.xor);
- registerBuildingVariant(36, MetaLogicGateBuilding, enumLogicGateVariants.or);
-
- // Transistor
- registerBuildingVariant(38, MetaTransistorBuilding, defaultBuildingVariant);
- registerBuildingVariant(60, MetaTransistorBuilding, enumTransistorVariants.mirrored);
-
- // Lever
- registerBuildingVariant(33, MetaLeverBuilding);
-
- // Filter
- registerBuildingVariant(37, MetaFilterBuilding);
-
- // Wire tunnel
- registerBuildingVariant(39, MetaWireTunnelBuilding);
-
- // Display
- registerBuildingVariant(40, MetaDisplayBuilding);
-
- // Virtual Processor
- registerBuildingVariant(42, MetaVirtualProcessorBuilding);
- registerBuildingVariant(44, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.rotater);
- registerBuildingVariant(45, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.unstacker);
- registerBuildingVariant(50, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.stacker);
- registerBuildingVariant(51, MetaVirtualProcessorBuilding, enumVirtualProcessorVariants.painter);
-
- // Analyzer
- registerBuildingVariant(46, MetaComparatorBuilding);
- registerBuildingVariant(43, MetaAnalyzerBuilding);
-
- // Reader
- registerBuildingVariant(49, MetaReaderBuilding);
-
- // Item producer
- registerBuildingVariant(61, MetaItemProducerBuilding);
-
- // Constant producer
- registerBuildingVariant(62, MetaConstantProducerBuilding);
-
- // Goal acceptor
- registerBuildingVariant(63, MetaGoalAcceptorBuilding);
-
- // Block
- registerBuildingVariant(64, MetaBlockBuilding);
-
- // Propagate instances
- for (const key in gBuildingVariants) {
- gBuildingVariants[key].metaInstance = gMetaBuildingRegistry.findByClass(
- gBuildingVariants[key].metaClass
+/**
+ *
+ * @param {typeof MetaBuilding} metaBuilding
+ */
+export function registerBuildingVariants(metaBuilding) {
+ gMetaBuildingRegistry.register(metaBuilding);
+ const combinations = metaBuilding.getAllVariantCombinations();
+ combinations.forEach(combination => {
+ registerBuildingVariant(
+ combination.internalId,
+ metaBuilding,
+ combination.variant || defaultBuildingVariant,
+ combination.rotationVariant || 0
);
- }
+ });
+}
- for (const key in gBuildingVariants) {
- const variant = gBuildingVariants[key];
- assert(variant.metaClass, "Variant has no meta: " + key);
+export function initMetaBuildingRegistry() {
+ const buildings = [
+ MetaBalancerBuilding,
+ MetaMinerBuilding,
+ MetaCutterBuilding,
+ MetaRotaterBuilding,
+ MetaStackerBuilding,
+ MetaMixerBuilding,
+ MetaPainterBuilding,
+ MetaTrashBuilding,
+ MetaStorageBuilding,
+ MetaBeltBuilding,
+ MetaUndergroundBeltBuilding,
+ MetaGoalAcceptorBuilding,
+ MetaHubBuilding,
+ MetaWireBuilding,
+ MetaConstantSignalBuilding,
+ MetaLogicGateBuilding,
+ MetaLeverBuilding,
+ MetaFilterBuilding,
+ MetaWireTunnelBuilding,
+ MetaDisplayBuilding,
+ MetaVirtualProcessorBuilding,
+ MetaReaderBuilding,
+ MetaTransistorBuilding,
+ MetaAnalyzerBuilding,
+ MetaComparatorBuilding,
+ MetaItemProducerBuilding,
+ MetaConstantProducerBuilding,
+ MetaBlockBuilding,
+ ];
- if (typeof variant.rotationVariant === "undefined") {
- variant.rotationVariant = 0;
- }
- if (typeof variant.variant === "undefined") {
- variant.variant = defaultBuildingVariant;
- }
- }
+ buildings.forEach(registerBuildingVariants);
// Check for valid keycodes
if (G_IS_DEV) {
@@ -205,18 +92,15 @@ export function initMetaBuildingRegistry() {
const id = metaBuilding.getId();
if (!["hub"].includes(id)) {
if (!KEYMAPPINGS.buildings[id]) {
- assertAlways(
- false,
+ console.error(
"Building " + id + " has no keybinding assigned! Add it to key_action_mapper.js"
);
}
if (!T.buildings[id]) {
- assertAlways(false, "Translation for building " + id + " missing!");
- }
-
- if (!T.buildings[id].default) {
- assertAlways(false, "Translation for building " + id + " missing (default variant)!");
+ console.error("Translation for building " + id + " missing!");
+ } else if (!T.buildings[id].default) {
+ console.error("Translation for building " + id + " missing (default variant)!");
}
}
});
diff --git a/src/js/game/modes/puzzle_play.js b/src/js/game/modes/puzzle_play.js
index fc9a8f11..19957eee 100644
--- a/src/js/game/modes/puzzle_play.js
+++ b/src/js/game/modes/puzzle_play.js
@@ -30,7 +30,7 @@ import { HUDPuzzlePlaySettings } from "../hud/parts/puzzle_play_settings";
import { MetaBlockBuilding } from "../buildings/block";
import { MetaBuilding } from "../meta_building";
import { gMetaBuildingRegistry } from "../../core/global_registries";
-import { HUDPuzzleNextPuzzle } from "../hud/parts/HUDPuzzleNextPuzzle";
+import { HUDPuzzleNextPuzzle } from "../hud/parts/next_puzzle";
const logger = createLogger("puzzle-play");
const copy = require("clipboard-copy");
diff --git a/src/js/game/modes/regular.js b/src/js/game/modes/regular.js
index 429c1515..cd14833e 100644
--- a/src/js/game/modes/regular.js
+++ b/src/js/game/modes/regular.js
@@ -38,6 +38,7 @@ import { HUDSandboxController } from "../hud/parts/sandbox_controller";
import { queryParamOptions } from "../../core/query_parameters";
import { MetaBlockBuilding } from "../buildings/block";
import { MetaItemProducerBuilding } from "../buildings/item_producer";
+import { MOD_SIGNALS } from "../../mods/mod_signals";
/** @typedef {{
* shape: string,
@@ -68,10 +69,16 @@ const tierGrowth = 2.5;
const chinaShapes = G_WEGAME_VERSION || G_CHINA_VERSION;
+const upgradesCache = {};
+
/**
* Generates all upgrades
* @returns {Object} */
function generateUpgrades(limitedVersion = false) {
+ if (upgradesCache[limitedVersion]) {
+ return upgradesCache[limitedVersion];
+ }
+
const fixedImprovements = [0.5, 0.5, 1, 1, 2, 1, 1];
const numEndgameUpgrades = limitedVersion ? 0 : 1000 - fixedImprovements.length - 1;
@@ -264,6 +271,8 @@ function generateUpgrades(limitedVersion = false) {
}
}
+ MOD_SIGNALS.modifyUpgrades.dispatch(upgrades);
+
// VALIDATE
if (G_IS_DEV) {
for (const upgradeId in upgrades) {
@@ -279,14 +288,20 @@ function generateUpgrades(limitedVersion = false) {
}
}
+ upgradesCache[limitedVersion] = upgrades;
return upgrades;
}
+const levelDefinitionsCache = {};
+
/**
* Generates the level definitions
* @param {boolean} limitedVersion
*/
export function generateLevelDefinitions(limitedVersion = false) {
+ if (levelDefinitionsCache[limitedVersion]) {
+ return levelDefinitionsCache[limitedVersion];
+ }
const levelDefinitions = [
// 1
// Circle
@@ -511,6 +526,8 @@ export function generateLevelDefinitions(limitedVersion = false) {
]),
];
+ MOD_SIGNALS.modifyLevelDefinitions.dispatch(levelDefinitions);
+
if (G_IS_DEV) {
levelDefinitions.forEach(({ shape }) => {
try {
@@ -521,15 +538,11 @@ export function generateLevelDefinitions(limitedVersion = false) {
});
}
+ levelDefinitionsCache[limitedVersion] = levelDefinitions;
+
return levelDefinitions;
}
-const fullVersionUpgrades = generateUpgrades(false);
-const demoVersionUpgrades = generateUpgrades(true);
-
-const fullVersionLevels = generateLevelDefinitions(false);
-const demoVersionLevels = generateLevelDefinitions(true);
-
export class RegularGameMode extends GameMode {
static getId() {
return enumGameModeIds.regular;
@@ -589,7 +602,7 @@ export class RegularGameMode extends GameMode {
/** @type {(typeof MetaBuilding)[]} */
this.hiddenBuildings = [MetaConstantProducerBuilding, MetaGoalAcceptorBuilding, MetaBlockBuilding];
- // @ts-expect-error
+ // @ts-ignore
if (!(G_IS_DEV || window.sandboxMode || queryParamOptions.sandboxMode)) {
this.hiddenBuildings.push(MetaItemProducerBuilding);
}
@@ -600,9 +613,7 @@ export class RegularGameMode extends GameMode {
* @returns {Object}
*/
getUpgrades() {
- return this.root.app.restrictionMgr.getHasExtendedUpgrades()
- ? fullVersionUpgrades
- : demoVersionUpgrades;
+ return generateUpgrades(!this.root.app.restrictionMgr.getHasExtendedUpgrades());
}
/**
@@ -610,9 +621,7 @@ export class RegularGameMode extends GameMode {
* @returns {Array}
*/
getLevelDefinitions() {
- return this.root.app.restrictionMgr.getHasExtendedLevelsAndFreeplay()
- ? fullVersionLevels
- : demoVersionLevels;
+ return generateLevelDefinitions(!this.root.app.restrictionMgr.getHasExtendedLevelsAndFreeplay());
}
/**
diff --git a/src/js/game/shape_definition.js b/src/js/game/shape_definition.js
index b09d73c5..12d9c741 100644
--- a/src/js/game/shape_definition.js
+++ b/src/js/game/shape_definition.js
@@ -7,6 +7,19 @@ import { BasicSerializableObject, types } from "../savegame/serialization";
import { enumColors, enumColorsToHexCode, enumColorToShortcode, enumShortcodeToColor } from "./colors";
import { THEME } from "./theme";
+/**
+ * @typedef {{
+ * context: CanvasRenderingContext2D,
+ * quadrantSize: number,
+ * layerScale: number,
+ * }} SubShapeDrawOptions
+ */
+
+/**
+ * @type {Object void>}
+ */
+export const MODS_ADDITIONAL_SUB_SHAPE_DRAWERS = {};
+
/**
* @typedef {{
* subShape: enumSubShape,
@@ -14,6 +27,11 @@ import { THEME } from "./theme";
* }} ShapeLayerItem
*/
+export const TOP_RIGHT = 0;
+export const BOTTOM_RIGHT = 1;
+export const BOTTOM_LEFT = 2;
+export const TOP_LEFT = 3;
+
/**
* Order is Q1 (tr), Q2(br), Q3(bl), Q4(tl)
* @typedef {[ShapeLayerItem?, ShapeLayerItem?, ShapeLayerItem?, ShapeLayerItem?]} ShapeLayer
@@ -51,7 +69,7 @@ for (const key in enumSubShapeToShortcode) {
/**
* Converts the given parameters to a valid shape definition
* @param {*} layers
- * @returns {Array}
+ * @returns {Array}
*/
export function createSimpleShape(layers) {
layers.forEach(layer => {
@@ -229,7 +247,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* Internal method to clone the shape definition
* @returns {Array}
*/
- internalCloneLayers() {
+ getClonedLayers() {
return JSON.parse(JSON.stringify(this.layers));
}
@@ -366,74 +384,79 @@ export class ShapeDefinition extends BasicSerializableObject {
context.strokeStyle = THEME.items.outline;
context.lineWidth = THEME.items.outlineWidth;
- const insetPadding = 0.0;
+ if (MODS_ADDITIONAL_SUB_SHAPE_DRAWERS[subShape]) {
+ MODS_ADDITIONAL_SUB_SHAPE_DRAWERS[subShape]({
+ context,
+ layerScale,
+ quadrantSize,
+ });
+ } else {
+ switch (subShape) {
+ case enumSubShape.rect: {
+ context.beginPath();
+ const dims = quadrantSize * layerScale;
+ context.rect(-quadrantHalfSize, quadrantHalfSize - dims, dims, dims);
+ context.fill();
+ context.stroke();
+ break;
+ }
+ case enumSubShape.star: {
+ context.beginPath();
+ const dims = quadrantSize * layerScale;
- switch (subShape) {
- case enumSubShape.rect: {
- context.beginPath();
- const dims = quadrantSize * layerScale;
- context.rect(
- insetPadding + -quadrantHalfSize,
- -insetPadding + quadrantHalfSize - dims,
- dims,
- dims
- );
+ let originX = -quadrantHalfSize;
+ let originY = quadrantHalfSize - dims;
- break;
- }
- case enumSubShape.star: {
- context.beginPath();
- const dims = quadrantSize * layerScale;
+ const moveInwards = dims * 0.4;
+ context.moveTo(originX, originY + moveInwards);
+ context.lineTo(originX + dims, originY);
+ context.lineTo(originX + dims - moveInwards, originY + dims);
+ context.lineTo(originX, originY + dims);
+ context.closePath();
+ context.fill();
+ context.stroke();
+ break;
+ }
- let originX = insetPadding - quadrantHalfSize;
- let originY = -insetPadding + quadrantHalfSize - dims;
+ case enumSubShape.windmill: {
+ context.beginPath();
+ const dims = quadrantSize * layerScale;
- const moveInwards = dims * 0.4;
- context.moveTo(originX, originY + moveInwards);
- context.lineTo(originX + dims, originY);
- context.lineTo(originX + dims - moveInwards, originY + dims);
- context.lineTo(originX, originY + dims);
- context.closePath();
- break;
- }
+ let originX = -quadrantHalfSize;
+ let originY = quadrantHalfSize - dims;
+ const moveInwards = dims * 0.4;
+ context.moveTo(originX, originY + moveInwards);
+ context.lineTo(originX + dims, originY);
+ context.lineTo(originX + dims, originY + dims);
+ context.lineTo(originX, originY + dims);
+ context.closePath();
+ context.fill();
+ context.stroke();
+ break;
+ }
- case enumSubShape.windmill: {
- context.beginPath();
- const dims = quadrantSize * layerScale;
+ case enumSubShape.circle: {
+ context.beginPath();
+ context.moveTo(-quadrantHalfSize, quadrantHalfSize);
+ context.arc(
+ -quadrantHalfSize,
+ quadrantHalfSize,
+ quadrantSize * layerScale,
+ -Math.PI * 0.5,
+ 0
+ );
+ context.closePath();
+ context.fill();
+ context.stroke();
+ break;
+ }
- let originX = insetPadding - quadrantHalfSize;
- let originY = -insetPadding + quadrantHalfSize - dims;
- const moveInwards = dims * 0.4;
- context.moveTo(originX, originY + moveInwards);
- context.lineTo(originX + dims, originY);
- context.lineTo(originX + dims, originY + dims);
- context.lineTo(originX, originY + dims);
- context.closePath();
- break;
- }
-
- case enumSubShape.circle: {
- context.beginPath();
- context.moveTo(insetPadding + -quadrantHalfSize, -insetPadding + quadrantHalfSize);
- context.arc(
- insetPadding + -quadrantHalfSize,
- -insetPadding + quadrantHalfSize,
- quadrantSize * layerScale,
- -Math.PI * 0.5,
- 0
- );
- context.closePath();
- break;
- }
-
- default: {
- assertAlways(false, "Unkown sub shape: " + subShape);
+ default: {
+ throw new Error("Unkown sub shape: " + subShape);
+ }
}
}
- context.fill();
- context.stroke();
-
context.rotate(-rotation);
context.translate(-centerQuadrantX, -centerQuadrantY);
}
@@ -446,7 +469,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @returns {ShapeDefinition}
*/
cloneFilteredByQuadrants(includeQuadrants) {
- const newLayers = this.internalCloneLayers();
+ const newLayers = this.getClonedLayers();
for (let layerIndex = 0; layerIndex < newLayers.length; ++layerIndex) {
const quadrants = newLayers[layerIndex];
let anyContents = false;
@@ -472,7 +495,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @returns {ShapeDefinition}
*/
cloneRotateCW() {
- const newLayers = this.internalCloneLayers();
+ const newLayers = this.getClonedLayers();
for (let layerIndex = 0; layerIndex < newLayers.length; ++layerIndex) {
const quadrants = newLayers[layerIndex];
quadrants.unshift(quadrants[3]);
@@ -486,7 +509,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @returns {ShapeDefinition}
*/
cloneRotateCCW() {
- const newLayers = this.internalCloneLayers();
+ const newLayers = this.getClonedLayers();
for (let layerIndex = 0; layerIndex < newLayers.length; ++layerIndex) {
const quadrants = newLayers[layerIndex];
quadrants.push(quadrants[0]);
@@ -500,7 +523,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @returns {ShapeDefinition}
*/
cloneRotate180() {
- const newLayers = this.internalCloneLayers();
+ const newLayers = this.getClonedLayers();
for (let layerIndex = 0; layerIndex < newLayers.length; ++layerIndex) {
const quadrants = newLayers[layerIndex];
quadrants.push(quadrants.shift(), quadrants.shift());
@@ -558,7 +581,7 @@ export class ShapeDefinition extends BasicSerializableObject {
// Can't merge at a layer lower than 0
const layerToMergeAt = Math.max(1 - smallestGapBetweenShapes, 0);
- const mergedLayers = this.internalCloneLayers();
+ const mergedLayers = this.getClonedLayers();
for (let layer = mergedLayers.length; layer < layerToMergeAt + topShapeLayers.length; ++layer) {
mergedLayers.push([null, null, null, null]);
}
@@ -584,7 +607,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @param {enumColors} color
*/
cloneAndPaintWith(color) {
- const newLayers = this.internalCloneLayers();
+ const newLayers = this.getClonedLayers();
for (let layerIndex = 0; layerIndex < newLayers.length; ++layerIndex) {
const quadrants = newLayers[layerIndex];
@@ -603,7 +626,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @param {[enumColors, enumColors, enumColors, enumColors]} colors
*/
cloneAndPaintWith4Colors(colors) {
- const newLayers = this.internalCloneLayers();
+ const newLayers = this.getClonedLayers();
for (let layerIndex = 0; layerIndex < newLayers.length; ++layerIndex) {
const quadrants = newLayers[layerIndex];
diff --git a/src/js/game/systems/belt.js b/src/js/game/systems/belt.js
index 00491eff..38ac9b0b 100644
--- a/src/js/game/systems/belt.js
+++ b/src/js/game/systems/belt.js
@@ -11,6 +11,7 @@ import { arrayBeltVariantToRotation, MetaBeltBuilding } from "../buildings/belt"
import { getCodeFromBuildingData } from "../building_codes";
import { BeltComponent } from "../components/belt";
import { Entity } from "../entity";
+import { GameSystem } from "../game_system";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { MapChunkView } from "../map_chunk_view";
import { defaultBuildingVariant } from "../meta_building";
@@ -22,9 +23,9 @@ const logger = createLogger("belt");
/**
* Manages all belts
*/
-export class BeltSystem extends GameSystemWithFilter {
+export class BeltSystem extends GameSystem {
constructor(root) {
- super(root, [BeltComponent]);
+ super(root);
/**
* @type {Object.>}
*/
@@ -425,8 +426,10 @@ export class BeltSystem extends GameSystemWithFilter {
const result = [];
- for (let i = 0; i < this.allEntities.length; ++i) {
- const entity = this.allEntities[i];
+ const beltEntities = this.root.entityMgr.getAllWithComponent(BeltComponent);
+
+ for (let i = 0; i < beltEntities.length; ++i) {
+ const entity = beltEntities[i];
if (visitedUids.has(entity.uid)) {
continue;
}
@@ -494,6 +497,10 @@ export class BeltSystem extends GameSystemWithFilter {
* @param {MapChunkView} chunk
*/
drawChunk(parameters, chunk) {
+ if (G_IS_DEV && globalConfig.debug.doNotRenderStatics) {
+ return;
+ }
+
// Limit speed to avoid belts going backwards
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(), 10);
diff --git a/src/js/game/systems/belt_underlays.js b/src/js/game/systems/belt_underlays.js
index c5c69d26..ddbe051a 100644
--- a/src/js/game/systems/belt_underlays.js
+++ b/src/js/game/systems/belt_underlays.js
@@ -16,7 +16,7 @@ import { BeltUnderlaysComponent, enumClippedBeltUnderlayType } from "../componen
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { ItemEjectorComponent } from "../components/item_ejector";
import { Entity } from "../entity";
-import { GameSystemWithFilter } from "../game_system_with_filter";
+import { GameSystem } from "../game_system";
import { MapChunkView } from "../map_chunk_view";
import { BELT_ANIM_COUNT } from "./belt";
@@ -31,9 +31,9 @@ const enumUnderlayTypeToClipRect = {
[enumClippedBeltUnderlayType.bottomOnly]: new Rectangle(0, 0.5, 1, 0.5),
};
-export class BeltUnderlaysSystem extends GameSystemWithFilter {
+export class BeltUnderlaysSystem extends GameSystem {
constructor(root) {
- super(root, [BeltUnderlaysComponent]);
+ super(root);
this.underlayBeltSprites = [];
@@ -113,12 +113,10 @@ export class BeltUnderlaysSystem extends GameSystemWithFilter {
continue;
}
- // Step 2: Check if any of the directions matches
- for (let j = 0; j < slot.directions.length; ++j) {
- const slotDirection = staticComp.localDirectionToWorld(slot.directions[j]);
- if (slotDirection === fromDirection) {
- return true;
- }
+ // Step 2: Check if the direction matches
+ const slotDirection = staticComp.localDirectionToWorld(slot.direction);
+ if (slotDirection === fromDirection) {
+ return true;
}
}
}
diff --git a/src/js/game/systems/constant_producer.js b/src/js/game/systems/constant_producer.js
index 5c10b409..a95efdb0 100644
--- a/src/js/game/systems/constant_producer.js
+++ b/src/js/game/systems/constant_producer.js
@@ -5,10 +5,8 @@ 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]);
}
diff --git a/src/js/game/systems/constant_signal.js b/src/js/game/systems/constant_signal.js
index 29079825..75a4dbdd 100644
--- a/src/js/game/systems/constant_signal.js
+++ b/src/js/game/systems/constant_signal.js
@@ -1,25 +1,16 @@
-import trim from "trim";
-import { THIRDPARTY_URLS } from "../../core/config";
-import { DialogWithForm } from "../../core/modal_dialog_elements";
-import { FormElementInput, FormElementItemChooser } from "../../core/modal_dialog_forms";
-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 { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
-import { BOOL_FALSE_SINGLETON, BOOL_TRUE_SINGLETON } from "../items/boolean_item";
-import { COLOR_ITEM_SINGLETONS } from "../items/color_item";
-import { ShapeDefinition } from "../shape_definition";
export class ConstantSignalSystem extends GameSystemWithFilter {
constructor(root) {
super(root, [ConstantSignalComponent]);
- this.root.signals.entityManuallyPlaced.add(entity =>
- this.editConstantSignal(entity, { deleteOnCancel: true })
- );
+ this.root.signals.entityManuallyPlaced.add(entity => {
+ const editorHud = this.root.hud.parts.constantSignalEdit;
+ if (editorHud) {
+ editorHud.editConstantSignal(entity, { deleteOnCancel: true });
+ }
+ });
}
update() {
@@ -34,171 +25,4 @@ export class ConstantSignalSystem extends GameSystemWithFilter {
}
}
}
-
- /**
- * Asks the entity to enter a valid signal code
- * @param {Entity} entity
- * @param {object} param0
- * @param {boolean=} param0.deleteOnCancel
- */
- editConstantSignal(entity, { deleteOnCancel = true }) {
- if (!entity.components.ConstantSignal) {
- return;
- }
-
- // Ok, query, but also save the uid because it could get stale
- const uid = entity.uid;
-
- const signal = entity.components.ConstantSignal.signal;
- const signalValueInput = new FormElementInput({
- id: "signalValue",
- label: fillInLinkIntoTranslation(T.dialogs.editSignal.descShortKey, THIRDPARTY_URLS.shapeViewer),
- placeholder: "",
- defaultValue: signal ? signal.getAsCopyableKey() : "",
- validator: val => this.parseSignalCode(entity, val),
- });
-
- const items = [...Object.values(COLOR_ITEM_SINGLETONS)];
-
- if (entity.components.WiredPins) {
- items.unshift(BOOL_FALSE_SINGLETON, BOOL_TRUE_SINGLETON);
- items.push(
- this.root.shapeDefinitionMgr.getShapeItemFromShortKey(
- this.root.gameMode.getBlueprintShapeKey()
- )
- );
- } else {
- // producer which can produce virtually anything
- 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.editConstantProducer.title,
- desc: T.dialogs.editSignal.descItems,
- formElements: [itemInput, signalValueInput],
- buttons: ["cancel:bad:escape", "ok:good:enter"],
- closeButton: false,
- });
- this.root.hud.parts.dialogs.internalShowDialog(dialog);
-
- // When confirmed, set the signal
- const closeHandler = () => {
- if (!this.root || !this.root.entityMgr) {
- // Game got stopped
- return;
- }
-
- const entityRef = this.root.entityMgr.findByUid(uid, false);
- if (!entityRef) {
- // outdated
- return;
- }
-
- const constantComp = entityRef.components.ConstantSignal;
- if (!constantComp) {
- // no longer interesting
- return;
- }
-
- if (itemInput.chosenItem) {
- constantComp.signal = itemInput.chosenItem;
- } else {
- constantComp.signal = this.parseSignalCode(entity, signalValueInput.getValue());
- }
- };
-
- dialog.buttonSignals.ok.add(() => {
- closeHandler();
- });
- dialog.valueChosen.add(() => {
- dialog.closeRequested.dispatch();
- closeHandler();
- });
-
- // When cancelled, destroy the entity again
- if (deleteOnCancel) {
- dialog.buttonSignals.cancel.add(() => {
- if (!this.root || !this.root.entityMgr) {
- // Game got stopped
- return;
- }
-
- const entityRef = this.root.entityMgr.findByUid(uid, false);
- if (!entityRef) {
- // outdated
- return;
- }
-
- const constantComp = entityRef.components.ConstantSignal;
- if (!constantComp) {
- // no longer interesting
- return;
- }
-
- this.root.logic.tryDeleteBuilding(entityRef);
- });
- }
- }
-
- /**
- * Tries to parse a signal code
- * @param {Entity} entity
- * @param {string} code
- * @returns {BaseItem}
- */
- parseSignalCode(entity, code) {
- if (!this.root || !this.root.shapeDefinitionMgr) {
- // Stale reference
- return null;
- }
-
- code = trim(code);
- const codeLower = code.toLowerCase();
-
- if (enumColors[codeLower]) {
- return COLOR_ITEM_SINGLETONS[codeLower];
- }
-
- if (entity.components.WiredPins) {
- if (code === "1" || codeLower === "true") {
- return BOOL_TRUE_SINGLETON;
- }
-
- if (code === "0" || codeLower === "false") {
- return BOOL_FALSE_SINGLETON;
- }
- }
-
- if (ShapeDefinition.isValidShortKey(code)) {
- return this.root.shapeDefinitionMgr.getShapeItemFromShortKey(code);
- }
-
- return null;
- }
}
diff --git a/src/js/game/systems/display.js b/src/js/game/systems/display.js
index f11091b9..65cb3a5c 100644
--- a/src/js/game/systems/display.js
+++ b/src/js/game/systems/display.js
@@ -2,15 +2,14 @@ import { globalConfig } from "../../core/config";
import { Loader } from "../../core/loader";
import { BaseItem } from "../base_item";
import { enumColors } from "../colors";
-import { DisplayComponent } from "../components/display";
-import { GameSystemWithFilter } from "../game_system_with_filter";
+import { GameSystem } from "../game_system";
import { isTrueItem } from "../items/boolean_item";
import { ColorItem, COLOR_ITEM_SINGLETONS } from "../items/color_item";
import { MapChunkView } from "../map_chunk_view";
-export class DisplaySystem extends GameSystemWithFilter {
+export class DisplaySystem extends GameSystem {
constructor(root) {
- super(root, [DisplayComponent]);
+ super(root);
/** @type {Object} */
this.displaySprites = {};
diff --git a/src/js/game/systems/goal_acceptor.js b/src/js/game/systems/goal_acceptor.js
index 60d4a984..2ffc3b52 100644
--- a/src/js/game/systems/goal_acceptor.js
+++ b/src/js/game/systems/goal_acceptor.js
@@ -5,10 +5,8 @@ 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]);
diff --git a/src/js/game/systems/item_ejector.js b/src/js/game/systems/item_ejector.js
index db37455a..8c7468ad 100644
--- a/src/js/game/systems/item_ejector.js
+++ b/src/js/game/systems/item_ejector.js
@@ -4,7 +4,6 @@ import { createLogger } from "../../core/logging";
import { Rectangle } from "../../core/rectangle";
import { StaleAreaDetector } from "../../core/stale_area_detector";
import { enumDirection, enumDirectionToVector } from "../../core/vector";
-import { ACHIEVEMENTS } from "../../platform/achievement_provider";
import { BaseItem } from "../base_item";
import { BeltComponent } from "../components/belt";
import { ItemAcceptorComponent } from "../components/item_acceptor";
@@ -204,11 +203,7 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
if (this.tryPassOverItem(item, destEntity, destSlot.index)) {
// Handover successful, clear slot
if (!this.root.app.settings.getAllSettings().simplifiedBelts) {
- targetAcceptorComp.onItemAccepted(
- destSlot.index,
- destSlot.acceptedDirection,
- item
- );
+ targetAcceptorComp.onItemAccepted(destSlot.index, destSlot.slot.direction, item);
}
sourceSlot.item = null;
continue;
diff --git a/src/js/game/systems/item_processor.js b/src/js/game/systems/item_processor.js
index 525c242c..6e1032c9 100644
--- a/src/js/game/systems/item_processor.js
+++ b/src/js/game/systems/item_processor.js
@@ -8,7 +8,7 @@ import {
} from "../components/item_processor";
import { Entity } from "../entity";
import { GameSystemWithFilter } from "../game_system_with_filter";
-import { BOOL_TRUE_SINGLETON, isTruthyItem } from "../items/boolean_item";
+import { isTruthyItem } from "../items/boolean_item";
import { ColorItem, COLOR_ITEM_SINGLETONS } from "../items/color_item";
import { ShapeItem } from "../items/shape_item";
@@ -38,6 +38,11 @@ const MAX_QUEUED_CHARGES = 2;
* }} ProcessorImplementationPayload
*/
+/**
+ * @type {Object void>}
+ */
+export const MOD_ITEM_PROCESSOR_HANDLERS = {};
+
export class ItemProcessorSystem extends GameSystemWithFilter {
constructor(root) {
super(root, [ItemProcessorComponent]);
@@ -61,6 +66,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
[enumItemProcessorTypes.hub]: this.process_HUB,
[enumItemProcessorTypes.reader]: this.process_READER,
[enumItemProcessorTypes.goal]: this.process_GOAL,
+ ...MOD_ITEM_PROCESSOR_HANDLERS,
};
// Bind all handlers
@@ -88,49 +94,16 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
}
}
- // Check if it finished
- if (currentCharge.remainingTime <= 0.0) {
+ // Check if it finished and we don't already have queued ejects
+ if (currentCharge.remainingTime <= 0.0 && !processorComp.queuedEjects.length) {
const itemsToEject = currentCharge.items;
- // Go over all items and try to eject them
+ // Go over all items and add them to the queue
for (let j = 0; j < itemsToEject.length; ++j) {
- const { item, requiredSlot, preferredSlot } = itemsToEject[j];
-
- assert(ejectorComp, "To eject items, the building needs to have an ejector");
-
- let slot = null;
- if (requiredSlot !== null && requiredSlot !== undefined) {
- // We have a slot override, check if that is free
- if (ejectorComp.canEjectOnSlot(requiredSlot)) {
- slot = requiredSlot;
- }
- } else if (preferredSlot !== null && preferredSlot !== undefined) {
- // We have a slot preference, try using it but otherwise use a free slot
- if (ejectorComp.canEjectOnSlot(preferredSlot)) {
- slot = preferredSlot;
- } else {
- slot = ejectorComp.getFirstFreeSlot();
- }
- } else {
- // We can eject on any slot
- slot = ejectorComp.getFirstFreeSlot();
- }
-
- if (slot !== null) {
- // Alright, we can actually eject
- if (!ejectorComp.tryEject(slot, item)) {
- assert(false, "Failed to eject");
- } else {
- itemsToEject.splice(j, 1);
- j -= 1;
- }
- }
+ processorComp.queuedEjects.push(itemsToEject[j]);
}
- // If the charge was entirely emptied to the outputs, start the next charge
- if (itemsToEject.length === 0) {
- processorComp.ongoingCharges.shift();
- }
+ processorComp.ongoingCharges.shift();
}
}
@@ -140,6 +113,40 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
this.startNewCharge(entity);
}
}
+
+ for (let j = 0; j < processorComp.queuedEjects.length; ++j) {
+ const { item, requiredSlot, preferredSlot } = processorComp.queuedEjects[j];
+
+ assert(ejectorComp, "To eject items, the building needs to have an ejector");
+
+ let slot = null;
+ if (requiredSlot !== null && requiredSlot !== undefined) {
+ // We have a slot override, check if that is free
+ if (ejectorComp.canEjectOnSlot(requiredSlot)) {
+ slot = requiredSlot;
+ }
+ } else if (preferredSlot !== null && preferredSlot !== undefined) {
+ // We have a slot preference, try using it but otherwise use a free slot
+ if (ejectorComp.canEjectOnSlot(preferredSlot)) {
+ slot = preferredSlot;
+ } else {
+ slot = ejectorComp.getFirstFreeSlot();
+ }
+ } else {
+ // We can eject on any slot
+ slot = ejectorComp.getFirstFreeSlot();
+ }
+
+ if (slot !== null) {
+ // Alright, we can actually eject
+ if (!ejectorComp.tryEject(slot, item)) {
+ assert(false, "Failed to eject");
+ } else {
+ processorComp.queuedEjects.splice(j, 1);
+ j -= 1;
+ }
+ }
+ }
}
}
diff --git a/src/js/game/systems/item_producer.js b/src/js/game/systems/item_producer.js
index 0a385907..8ca29ae1 100644
--- a/src/js/game/systems/item_producer.js
+++ b/src/js/game/systems/item_producer.js
@@ -1,12 +1,7 @@
-/* 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;
diff --git a/src/js/game/systems/lever.js b/src/js/game/systems/lever.js
index 75b6cf28..343894ae 100644
--- a/src/js/game/systems/lever.js
+++ b/src/js/game/systems/lever.js
@@ -1,9 +1,8 @@
-import { GameSystemWithFilter } from "../game_system_with_filter";
-import { LeverComponent } from "../components/lever";
-import { BOOL_TRUE_SINGLETON, BOOL_FALSE_SINGLETON } from "../items/boolean_item";
-import { MapChunkView } from "../map_chunk_view";
-import { globalConfig } from "../../core/config";
import { Loader } from "../../core/loader";
+import { LeverComponent } from "../components/lever";
+import { GameSystemWithFilter } from "../game_system_with_filter";
+import { BOOL_FALSE_SINGLETON, BOOL_TRUE_SINGLETON } from "../items/boolean_item";
+import { MapChunkView } from "../map_chunk_view";
export class LeverSystem extends GameSystemWithFilter {
constructor(root) {
diff --git a/src/js/game/systems/storage.js b/src/js/game/systems/storage.js
index 80affac9..20204a89 100644
--- a/src/js/game/systems/storage.js
+++ b/src/js/game/systems/storage.js
@@ -1,9 +1,9 @@
-import { GameSystemWithFilter } from "../game_system_with_filter";
-import { StorageComponent } from "../components/storage";
import { DrawParameters } from "../../core/draw_parameters";
-import { formatBigNumber, lerp } from "../../core/utils";
import { Loader } from "../../core/loader";
-import { BOOL_TRUE_SINGLETON, BOOL_FALSE_SINGLETON } from "../items/boolean_item";
+import { formatBigNumber, lerp } from "../../core/utils";
+import { StorageComponent } from "../components/storage";
+import { GameSystemWithFilter } from "../game_system_with_filter";
+import { BOOL_FALSE_SINGLETON, BOOL_TRUE_SINGLETON } from "../items/boolean_item";
import { MapChunkView } from "../map_chunk_view";
export class StorageSystem extends GameSystemWithFilter {
@@ -50,8 +50,13 @@ export class StorageSystem extends GameSystemWithFilter {
let targetAlpha = storageComp.storedCount > 0 ? 1 : 0;
storageComp.overlayOpacity = lerp(storageComp.overlayOpacity, targetAlpha, 0.05);
- pinsComp.slots[0].value = storageComp.storedItem;
- pinsComp.slots[1].value = storageComp.getIsFull() ? BOOL_TRUE_SINGLETON : BOOL_FALSE_SINGLETON;
+ // a wired pins component is not guaranteed, but if its there, set the value
+ if (pinsComp) {
+ pinsComp.slots[0].value = storageComp.storedItem;
+ pinsComp.slots[1].value = storageComp.getIsFull()
+ ? BOOL_TRUE_SINGLETON
+ : BOOL_FALSE_SINGLETON;
+ }
}
}
diff --git a/src/js/game/systems/wire.js b/src/js/game/systems/wire.js
index 0491def6..4a255866 100644
--- a/src/js/game/systems/wire.js
+++ b/src/js/game/systems/wire.js
@@ -21,6 +21,7 @@ import { enumWireType, enumWireVariant, WireComponent } from "../components/wire
import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
import { WireTunnelComponent } from "../components/wire_tunnel";
import { Entity } from "../entity";
+import { GameSystem } from "../game_system";
import { GameSystemWithFilter } from "../game_system_with_filter";
import { isTruthyItem } from "../items/boolean_item";
import { MapChunkView } from "../map_chunk_view";
@@ -90,9 +91,9 @@ export class WireNetwork {
}
}
-export class WireSystem extends GameSystemWithFilter {
+export class WireSystem extends GameSystem {
constructor(root) {
- super(root, [WireComponent]);
+ super(root);
/**
* @type {Object>}
diff --git a/src/js/game/themes/dark.json b/src/js/game/themes/dark.json
index fec42e28..786cfda2 100644
--- a/src/js/game/themes/dark.json
+++ b/src/js/game/themes/dark.json
@@ -1,5 +1,4 @@
{
- "uiStyle": "dark",
"map": {
"background": "#3e3f47",
"grid": "rgba(255, 255, 255, 0.02)",
@@ -19,6 +18,10 @@
"wires": {
"color": "rgb(74, 237, 134)",
"background": "rgba(74, 237, 134, 0.2)"
+ },
+ "error": {
+ "color": "rgb(255, 137, 137)",
+ "background": "rgba(255, 137, 137, 0.2)"
}
},
diff --git a/src/js/game/themes/light.json b/src/js/game/themes/light.json
index d44a15ab..1236d43d 100644
--- a/src/js/game/themes/light.json
+++ b/src/js/game/themes/light.json
@@ -1,5 +1,4 @@
{
- "uiStyle": "light",
"map": {
"background": "#fff",
"grid": "#fafafa",
@@ -19,6 +18,10 @@
"wires": {
"color": "rgb(74, 237, 134)",
"background": "rgba(74, 237, 134, 0.2)"
+ },
+ "error": {
+ "color": "rgb(255, 137, 137)",
+ "background": "rgba(255, 137, 137, 0.2)"
}
},
diff --git a/src/js/globals.d.ts b/src/js/globals.d.ts
index bf870fab..f18d1d61 100644
--- a/src/js/globals.d.ts
+++ b/src/js/globals.d.ts
@@ -22,6 +22,10 @@ declare const G_IS_RELEASE: boolean;
declare const G_CHINA_VERSION: boolean;
declare const G_WEGAME_VERSION: boolean;
+declare const shapez: any;
+
+declare const ipcRenderer: any;
+
// Polyfills
declare interface String {
replaceAll(search: string, replacement: string): string;
@@ -92,9 +96,11 @@ declare interface Window {
cpmstarAPI: any;
// Mods
- registerMod: any;
+ $shapez_registerMod: any;
anyModLoaded: any;
+ shapez: any;
+
webkitRequestAnimationFrame();
assert(condition: boolean, failureMessage: string);
diff --git a/src/js/main.js b/src/js/main.js
index 94f3d37a..0f80f527 100644
--- a/src/js/main.js
+++ b/src/js/main.js
@@ -2,6 +2,8 @@ import "./core/polyfills";
import "./core/assert";
import "./core/error_handler";
+import "./mods/modloader";
+
import { createLogger, logSection } from "./core/logging";
import { Application } from "./application";
import { IS_DEBUG } from "./core/config";
@@ -19,39 +21,8 @@ if (window.coreThreadLoadedCb) {
window.coreThreadLoadedCb();
}
-// Logrocket
-// if (!G_IS_DEV && !G_IS_STANDALONE) {
-// const monthlyUsers = 300; // thousand
-// const logrocketLimit = 10; // thousand
-// const percentageOfUsers = logrocketLimit / monthlyUsers;
-
-// if (Math.random() <= percentageOfUsers) {
-// logger.log("Analyzing this session with logrocket");
-// const logrocket = require("logrocket");
-// logrocket.init("p1x9zh/shapezio");
-
-// try {
-// logrocket.getSessionURL(function (sessionURL) {
-// logger.log("Connected lockrocket to GA");
-// // @ts-ignore
-// try {
-// window.ga("send", {
-// hitType: "event",
-// eventCategory: "LogRocket",
-// eventAction: sessionURL,
-// });
-// } catch (ex) {
-// logger.warn("Logrocket connection to analytics failed:", ex);
-// }
-// });
-// } catch (ex) {
-// logger.warn("Logrocket connection to analytics failed:", ex);
-// }
-// }
-// }
-
console.log(
- `%cshapez.io ️%c\n© 2020 Tobias Springer IT Solutions\nCommit %c${G_BUILD_COMMIT_HASH}%c on %c${new Date(
+ `%cshapez.io ️%c\n© 2022 tobspr Games\nCommit %c${G_BUILD_COMMIT_HASH}%c on %c${new Date(
G_BUILD_TIME
).toLocaleString()}\n`,
"font-size: 35px; font-family: Arial;font-weight: bold; padding: 10px 0;",
diff --git a/src/js/mods/mod.js b/src/js/mods/mod.js
new file mode 100644
index 00000000..cea152d8
--- /dev/null
+++ b/src/js/mods/mod.js
@@ -0,0 +1,36 @@
+/* typehints:start */
+import { Application } from "../application";
+import { ModLoader } from "./modloader";
+/* typehints:end */
+
+import { MOD_SIGNALS } from "./mod_signals";
+
+export class Mod {
+ /**
+ * @param {object} param0
+ * @param {Application} param0.app
+ * @param {ModLoader} param0.modLoader
+ * @param {import("./modloader").ModMetadata} param0.meta
+ * @param {Object} param0.settings
+ * @param {() => Promise} param0.saveSettings
+ */
+ constructor({ app, modLoader, meta, settings, saveSettings }) {
+ this.app = app;
+ this.modLoader = modLoader;
+ this.metadata = meta;
+
+ this.signals = MOD_SIGNALS;
+ this.modInterface = modLoader.modInterface;
+
+ this.settings = settings;
+ this.saveSettings = saveSettings;
+ }
+
+ init() {
+ // to be overridden
+ }
+
+ get dialogs() {
+ return this.modInterface.dialogs;
+ }
+}
diff --git a/src/js/mods/mod_interface.js b/src/js/mods/mod_interface.js
new file mode 100644
index 00000000..13bdb9d2
--- /dev/null
+++ b/src/js/mods/mod_interface.js
@@ -0,0 +1,668 @@
+/* typehints:start */
+import { ModLoader } from "./modloader";
+import { GameSystem } from "../game/game_system";
+import { Component } from "../game/component";
+import { MetaBuilding } from "../game/meta_building";
+/* typehints:end */
+
+import { defaultBuildingVariant } from "../game/meta_building";
+import { AtlasSprite, SpriteAtlasLink } from "../core/sprites";
+import {
+ enumShortcodeToSubShape,
+ enumSubShape,
+ enumSubShapeToShortcode,
+ MODS_ADDITIONAL_SUB_SHAPE_DRAWERS,
+} from "../game/shape_definition";
+import { Loader } from "../core/loader";
+import { LANGUAGES } from "../languages";
+import { matchDataRecursive, T } from "../translations";
+import { gBuildingVariants, registerBuildingVariant } from "../game/building_codes";
+import { gComponentRegistry, gMetaBuildingRegistry } from "../core/global_registries";
+import { MODS_ADDITIONAL_SHAPE_MAP_WEIGHTS } from "../game/map_chunk";
+import { MODS_ADDITIONAL_SYSTEMS } from "../game/game_system_manager";
+import { MOD_CHUNK_DRAW_HOOKS } from "../game/map_chunk_view";
+import { KEYMAPPINGS } from "../game/key_action_mapper";
+import { HUDModalDialogs } from "../game/hud/parts/modal_dialogs";
+import { THEMES } from "../game/theme";
+import { ModMetaBuilding } from "./mod_meta_building";
+import { BaseHUDPart } from "../game/hud/base_hud_part";
+import { Vector } from "../core/vector";
+import { GameRoot } from "../game/root";
+
+/**
+ * @typedef {{new(...args: any[]): any, prototype: any}} constructable
+ */
+
+/**
+ * @template {(...args: any) => any} F The function
+ * @template {object} T The value of this
+ * @typedef {(this: T, ...args: Parameters) => ReturnType} bindThis
+ */
+
+/**
+ * @template {(...args: any[]) => any} F
+ * @template P
+ * @typedef {(...args: [P, Parameters]) => ReturnType} beforePrams IMPORTANT: this puts the original parameters into an array
+ */
+
+/**
+ * @template {(...args: any[]) => any} F
+ * @template P
+ * @typedef {(...args: [...Parameters, P]) => ReturnType} afterPrams
+ */
+
+/**
+ * @template {(...args: any[]) => any} F
+ * @typedef {(...args: [...Parameters, ...any]) => ReturnType} extendsPrams
+ */
+
+export class ModInterface {
+ /**
+ *
+ * @param {ModLoader} modLoader
+ */
+ constructor(modLoader) {
+ this.modLoader = modLoader;
+ }
+
+ registerCss(cssString) {
+ // Preprocess css
+ cssString = cssString.replace(/\$scaled\(([^)]*)\)/gim, (substr, expression) => {
+ return "calc((" + expression + ") * var(--ui-scale))";
+ });
+ const element = document.createElement("style");
+ element.textContent = cssString;
+ document.head.appendChild(element);
+ }
+
+ registerSprite(spriteId, base64string) {
+ assert(base64string.startsWith("data:image"));
+ const img = new Image();
+
+ const sprite = new AtlasSprite(spriteId);
+ sprite.frozen = true;
+
+ img.addEventListener("load", () => {
+ for (const resolution in sprite.linksByResolution) {
+ const link = sprite.linksByResolution[resolution];
+ link.w = img.width;
+ link.h = img.height;
+ link.packedW = img.width;
+ link.packedH = img.height;
+ }
+ });
+
+ img.src = base64string;
+
+ const link = new SpriteAtlasLink({
+ w: 1,
+ h: 1,
+ atlas: img,
+ packOffsetX: 0,
+ packOffsetY: 0,
+ packedW: 1,
+ packedH: 1,
+ packedX: 0,
+ packedY: 0,
+ });
+
+ sprite.linksByResolution["0.25"] = link;
+ sprite.linksByResolution["0.5"] = link;
+ sprite.linksByResolution["0.75"] = link;
+
+ Loader.sprites.set(spriteId, sprite);
+ }
+
+ /**
+ *
+ * @param {string} imageBase64
+ * @param {string} jsonTextData
+ */
+ registerAtlas(imageBase64, jsonTextData) {
+ const atlasData = JSON.parse(jsonTextData);
+ const img = new Image();
+ img.src = imageBase64;
+
+ const sourceData = atlasData.frames;
+ for (const spriteName in sourceData) {
+ const { frame, sourceSize, spriteSourceSize } = sourceData[spriteName];
+
+ let sprite = /** @type {AtlasSprite} */ (Loader.sprites.get(spriteName));
+
+ if (!sprite) {
+ sprite = new AtlasSprite(spriteName);
+ Loader.sprites.set(spriteName, sprite);
+ }
+
+ sprite.frozen = true;
+
+ const link = new SpriteAtlasLink({
+ packedX: frame.x,
+ packedY: frame.y,
+ packedW: frame.w,
+ packedH: frame.h,
+ packOffsetX: spriteSourceSize.x,
+ packOffsetY: spriteSourceSize.y,
+ atlas: img,
+ w: sourceSize.w,
+ h: sourceSize.h,
+ });
+
+ if (atlasData.meta && atlasData.meta.scale) {
+ sprite.linksByResolution[atlasData.meta.scale] = link;
+ } else {
+ sprite.linksByResolution["0.25"] = link;
+ sprite.linksByResolution["0.5"] = link;
+ sprite.linksByResolution["0.75"] = link;
+ }
+ }
+ }
+
+ /**
+ *
+ * @param {object} param0
+ * @param {string} param0.id
+ * @param {string} param0.shortCode
+ * @param {(distanceToOriginInChunks: number) => number} param0.weightComputation
+ * @param {(options: import("../game/shape_definition").SubShapeDrawOptions) => void} param0.draw
+ */
+ registerSubShapeType({ id, shortCode, weightComputation, draw }) {
+ if (shortCode.length !== 1) {
+ throw new Error("Bad short code: " + shortCode);
+ }
+ enumSubShape[id] = id;
+ enumSubShapeToShortcode[id] = shortCode;
+ enumShortcodeToSubShape[shortCode] = id;
+
+ MODS_ADDITIONAL_SHAPE_MAP_WEIGHTS[id] = weightComputation;
+ MODS_ADDITIONAL_SUB_SHAPE_DRAWERS[id] = draw;
+ }
+
+ registerTranslations(language, translations) {
+ const data = LANGUAGES[language];
+ if (!data) {
+ throw new Error("Unknown language: " + language);
+ }
+
+ matchDataRecursive(data.data, translations, true);
+ if (language === "en") {
+ matchDataRecursive(T, translations, true);
+ }
+ }
+
+ /**
+ *
+ * @param {typeof Component} component
+ */
+ registerComponent(component) {
+ gComponentRegistry.register(component);
+ }
+
+ /**
+ *
+ * @param {Object} param0
+ * @param {string} param0.id
+ * @param {new (any) => GameSystem} param0.systemClass
+ * @param {string=} param0.before
+ * @param {string[]=} param0.drawHooks
+ */
+ registerGameSystem({ id, systemClass, before, drawHooks }) {
+ const key = before || "key";
+ const payload = { id, systemClass };
+
+ if (MODS_ADDITIONAL_SYSTEMS[key]) {
+ MODS_ADDITIONAL_SYSTEMS[key].push(payload);
+ } else {
+ MODS_ADDITIONAL_SYSTEMS[key] = [payload];
+ }
+ if (drawHooks) {
+ drawHooks.forEach(hookId => this.registerGameSystemDrawHook(hookId, id));
+ }
+ }
+
+ /**
+ *
+ * @param {string} hookId
+ * @param {string} systemId
+ */
+ registerGameSystemDrawHook(hookId, systemId) {
+ if (!MOD_CHUNK_DRAW_HOOKS[hookId]) {
+ throw new Error("bad game system draw hook: " + hookId);
+ }
+ MOD_CHUNK_DRAW_HOOKS[hookId].push(systemId);
+ }
+
+ /**
+ *
+ * @param {object} param0
+ * @param {typeof ModMetaBuilding} param0.metaClass
+ * @param {string=} param0.buildingIconBase64
+ */
+ registerNewBuilding({ metaClass, buildingIconBase64 }) {
+ const id = new /** @type {new (...args) => ModMetaBuilding} */ (metaClass)().getId();
+ if (gMetaBuildingRegistry.hasId(id)) {
+ throw new Error("Tried to register building twice: " + id);
+ }
+ gMetaBuildingRegistry.register(metaClass);
+ const metaInstance = gMetaBuildingRegistry.findByClass(metaClass);
+ T.buildings[id] = {};
+
+ metaClass.getAllVariantCombinations().forEach(combination => {
+ const variant = combination.variant || defaultBuildingVariant;
+ const rotationVariant = combination.rotationVariant || 0;
+
+ const buildingIdentifier = id + (variant === defaultBuildingVariant ? "" : "-" + variant);
+
+ const uniqueTypeId = buildingIdentifier + (rotationVariant === 0 ? "" : "-" + rotationVariant);
+ registerBuildingVariant(uniqueTypeId, metaClass, variant, rotationVariant);
+
+ gBuildingVariants[id].metaInstance = metaInstance;
+
+ this.registerTranslations("en", {
+ buildings: {
+ [id]: {
+ [variant]: {
+ name: combination.name || "Name",
+ description: combination.description || "Description",
+ },
+ },
+ },
+ });
+
+ if (combination.regularImageBase64) {
+ this.registerSprite(
+ "sprites/buildings/" + buildingIdentifier + ".png",
+ combination.regularImageBase64
+ );
+ }
+
+ if (combination.blueprintImageBase64) {
+ this.registerSprite(
+ "sprites/blueprints/" + buildingIdentifier + ".png",
+ combination.blueprintImageBase64
+ );
+ }
+ if (combination.tutorialImageBase64) {
+ this.setBuildingTutorialImage(id, variant, combination.tutorialImageBase64);
+ }
+ });
+
+ if (buildingIconBase64) {
+ this.setBuildingToolbarIcon(id, buildingIconBase64);
+ }
+ }
+
+ /**
+ *
+ * @param {Object} param0
+ * @param {string} param0.id
+ * @param {number} param0.keyCode
+ * @param {string} param0.translation
+ * @param {boolean=} param0.repeated
+ * @param {((GameRoot) => void)=} param0.handler
+ * @param {{shift?: boolean; alt?: boolean; ctrl?: boolean}=} param0.modifiers
+ * @param {boolean=} param0.builtin
+ */
+ registerIngameKeybinding({
+ id,
+ keyCode,
+ translation,
+ modifiers = {},
+ repeated = false,
+ builtin = false,
+ handler = null,
+ }) {
+ if (!KEYMAPPINGS.mods) {
+ KEYMAPPINGS.mods = {};
+ }
+ const binding = (KEYMAPPINGS.mods[id] = {
+ keyCode,
+ id,
+ repeated,
+ modifiers,
+ builtin,
+ });
+ this.registerTranslations("en", {
+ keybindings: {
+ mappings: {
+ [id]: translation,
+ },
+ },
+ });
+
+ if (handler) {
+ this.modLoader.signals.gameStarted.add(root => {
+ root.keyMapper.getBindingById(id).addToTop(handler.bind(null, root));
+ });
+ }
+
+ return binding;
+ }
+
+ /**
+ * @returns {HUDModalDialogs}
+ */
+ get dialogs() {
+ const state = this.modLoader.app.stateMgr.currentState;
+ // @ts-ignore
+ if (state.dialogs) {
+ // @ts-ignore
+ return state.dialogs;
+ }
+ throw new Error("Tried to access dialogs but current state doesn't support it");
+ }
+
+ setBuildingToolbarIcon(buildingId, iconBase64) {
+ this.registerCss(`
+ [data-icon="building_icons/${buildingId}.png"] .icon {
+ background-image: url('${iconBase64}') !important;
+ }
+ `);
+ }
+
+ /**
+ *
+ * @param {string | (new () => MetaBuilding)} buildingIdOrClass
+ * @param {*} variant
+ * @param {*} imageBase64
+ */
+ setBuildingTutorialImage(buildingIdOrClass, variant, imageBase64) {
+ if (typeof buildingIdOrClass === "function") {
+ buildingIdOrClass = new buildingIdOrClass().id;
+ }
+ const buildingIdentifier =
+ buildingIdOrClass + (variant === defaultBuildingVariant ? "" : "-" + variant);
+
+ this.registerCss(`
+ [data-icon="building_tutorials/${buildingIdentifier}.png"] {
+ background-image: url('${imageBase64}') !important;
+ }
+ `);
+ }
+
+ /**
+ * @param {Object} param0
+ * @param {string} param0.id
+ * @param {string} param0.name
+ * @param {Object} param0.theme
+ */
+ registerGameTheme({ id, name, theme }) {
+ THEMES[id] = theme;
+ this.registerTranslations("en", {
+ settings: {
+ labels: {
+ theme: {
+ themes: {
+ [id]: name,
+ },
+ },
+ },
+ },
+ });
+ }
+
+ /**
+ * Registers a new state class, should be a GameState derived class
+ * @param {typeof import("../core/game_state").GameState} stateClass
+ */
+ registerGameState(stateClass) {
+ this.modLoader.app.stateMgr.register(stateClass);
+ }
+
+ /**
+ * @param {object} param0
+ * @param {"regular"|"wires"} param0.toolbar
+ * @param {"primary"|"secondary"} param0.location
+ * @param {typeof MetaBuilding} param0.metaClass
+ */
+ addNewBuildingToToolbar({ toolbar, location, metaClass }) {
+ const hudElementName = toolbar === "wires" ? "HUDWiresToolbar" : "HUDBuildingsToolbar";
+ const property = location === "secondary" ? "secondaryBuildings" : "primaryBuildings";
+
+ this.modLoader.signals.hudElementInitialized.add(element => {
+ if (element.constructor.name === hudElementName) {
+ element[property].push(metaClass);
+ }
+ });
+ }
+
+ /**
+ * Patches a method on a given class
+ * @template {constructable} C the class
+ * @template {C["prototype"]} P the prototype of said class
+ * @template {keyof P} M the name of the method we are overriding
+ * @template {extendsPrams} O the method that will override the old one
+ * @param {C} classHandle
+ * @param {M} methodName
+ * @param {bindThis, InstanceType>} override
+ */
+ replaceMethod(classHandle, methodName, override) {
+ const oldMethod = classHandle.prototype[methodName];
+ classHandle.prototype[methodName] = function () {
+ //@ts-ignore This is true I just cant tell it that arguments will be Arguments
+ return override.call(this, oldMethod.bind(this), arguments);
+ };
+ }
+
+ /**
+ * Runs before a method on a given class
+ * @template {constructable} C the class
+ * @template {C["prototype"]} P the prototype of said class
+ * @template {keyof P} M the name of the method we are overriding
+ * @template {extendsPrams} O the method that will run before the old one
+ * @param {C} classHandle
+ * @param {M} methodName
+ * @param {bindThis>} executeBefore
+ */
+ runBeforeMethod(classHandle, methodName, executeBefore) {
+ const oldHandle = classHandle.prototype[methodName];
+ classHandle.prototype[methodName] = function () {
+ //@ts-ignore Same as above
+ executeBefore.apply(this, arguments);
+ return oldHandle.apply(this, arguments);
+ };
+ }
+
+ /**
+ * Runs after a method on a given class
+ * @template {constructable} C the class
+ * @template {C["prototype"]} P the prototype of said class
+ * @template {keyof P} M the name of the method we are overriding
+ * @template {extendsPrams} O the method that will run before the old one
+ * @param {C} classHandle
+ * @param {M} methodName
+ * @param {bindThis>} executeAfter
+ */
+ runAfterMethod(classHandle, methodName, executeAfter) {
+ const oldHandle = classHandle.prototype[methodName];
+ classHandle.prototype[methodName] = function () {
+ const returnValue = oldHandle.apply(this, arguments);
+ //@ts-ignore
+ executeAfter.apply(this, arguments);
+ return returnValue;
+ };
+ }
+
+ /**
+ *
+ * @param {Object} prototype
+ * @param {({ $super, $old }) => any} extender
+ */
+ extendObject(prototype, extender) {
+ const $super = Object.getPrototypeOf(prototype);
+ const $old = {};
+ const extensionMethods = extender({ $super, $old });
+ const properties = Array.from(Object.getOwnPropertyNames(extensionMethods));
+ properties.forEach(propertyName => {
+ if (["constructor", "prototype"].includes(propertyName)) {
+ return;
+ }
+ $old[propertyName] = prototype[propertyName];
+ prototype[propertyName] = extensionMethods[propertyName];
+ });
+ }
+
+ /**
+ *
+ * @param {Class} classHandle
+ * @param {({ $super, $old }) => any} extender
+ */
+ extendClass(classHandle, extender) {
+ this.extendObject(classHandle.prototype, extender);
+ }
+
+ /**
+ *
+ * @param {string} id
+ * @param {new (...args) => BaseHUDPart} element
+ */
+ registerHudElement(id, element) {
+ this.modLoader.signals.hudInitializer.add(root => {
+ root.hud.parts[id] = new element(root);
+ });
+ }
+
+ /**
+ *
+ * @param {string | (new () => MetaBuilding)} buildingIdOrClass
+ * @param {string} variant
+ * @param {object} param0
+ * @param {string} param0.name
+ * @param {string} param0.description
+ * @param {string=} param0.language
+ */
+ registerBuildingTranslation(buildingIdOrClass, variant, { name, description, language = "en" }) {
+ if (typeof buildingIdOrClass === "function") {
+ buildingIdOrClass = new buildingIdOrClass().id;
+ }
+ this.registerTranslations(language, {
+ buildings: {
+ [buildingIdOrClass]: {
+ [variant]: {
+ name,
+ description,
+ },
+ },
+ },
+ });
+ }
+
+ /**
+ *
+ * @param {string | (new () => MetaBuilding)} buildingIdOrClass
+ * @param {string} variant
+ * @param {object} param2
+ * @param {string=} param2.regularBase64
+ * @param {string=} param2.blueprintBase64
+ */
+ registerBuildingSprites(buildingIdOrClass, variant, { regularBase64, blueprintBase64 }) {
+ if (typeof buildingIdOrClass === "function") {
+ buildingIdOrClass = new buildingIdOrClass().id;
+ }
+
+ const spriteId =
+ buildingIdOrClass + (variant === defaultBuildingVariant ? "" : "-" + variant) + ".png";
+
+ if (regularBase64) {
+ this.registerSprite("sprites/buildings/" + spriteId, regularBase64);
+ }
+
+ if (blueprintBase64) {
+ this.registerSprite("sprites/blueprints/" + spriteId, blueprintBase64);
+ }
+ }
+
+ /**
+ * @param {new () => MetaBuilding} metaClass
+ * @param {string} variant
+ * @param {object} payload
+ * @param {number[]=} payload.rotationVariants
+ * @param {string=} payload.tutorialImageBase64
+ * @param {string=} payload.regularSpriteBase64
+ * @param {string=} payload.blueprintSpriteBase64
+ * @param {string=} payload.name
+ * @param {string=} payload.description
+ * @param {Vector=} payload.dimensions
+ * @param {(root: GameRoot) => [string, string][]} payload.additionalStatistics
+ * @param {(root: GameRoot) => boolean[]} payload.isUnlocked
+ */
+ addVariantToExistingBuilding(metaClass, variant, payload) {
+ if (!payload.rotationVariants) {
+ payload.rotationVariants = [0];
+ }
+
+ if (payload.tutorialImageBase64) {
+ this.setBuildingTutorialImage(metaClass, variant, payload.tutorialImageBase64);
+ }
+ if (payload.regularSpriteBase64) {
+ this.registerBuildingSprites(metaClass, variant, { regularBase64: payload.regularSpriteBase64 });
+ }
+ if (payload.blueprintSpriteBase64) {
+ this.registerBuildingSprites(metaClass, variant, {
+ blueprintBase64: payload.blueprintSpriteBase64,
+ });
+ }
+ if (payload.name && payload.description) {
+ this.registerBuildingTranslation(metaClass, variant, {
+ name: payload.name,
+ description: payload.description,
+ });
+ }
+
+ const internalId = new metaClass().getId() + "-" + variant;
+
+ // Extend static methods
+ this.extendObject(metaClass, ({ $old }) => ({
+ getAllVariantCombinations() {
+ return [
+ ...$old.bind(this).getAllVariantCombinations(),
+ ...payload.rotationVariants.map(rotationVariant => ({
+ internalId,
+ variant,
+ rotationVariant,
+ })),
+ ];
+ },
+ }));
+
+ // Dimensions
+ const $variant = variant;
+ if (payload.dimensions) {
+ this.extendClass(metaClass, ({ $old }) => ({
+ getDimensions(variant) {
+ if (variant === $variant) {
+ return payload.dimensions;
+ }
+ return $old.getDimensions.bind(this)(...arguments);
+ },
+ }));
+ }
+
+ if (payload.additionalStatistics) {
+ this.extendClass(metaClass, ({ $old }) => ({
+ getAdditionalStatistics(root, variant) {
+ if (variant === $variant) {
+ return payload.additionalStatistics(root);
+ }
+ return $old.getAdditionalStatistics.bind(this)(root, variant);
+ },
+ }));
+ }
+
+ if (payload.isUnlocked) {
+ this.extendClass(metaClass, ({ $old }) => ({
+ getAvailableVariants(root) {
+ if (payload.isUnlocked(root)) {
+ return [...$old.getAvailableVariants.bind(this)(root), $variant];
+ }
+ return $old.getAvailableVariants.bind(this)(root);
+ },
+ }));
+ }
+
+ // Register our variant finally
+ payload.rotationVariants.forEach(rotationVariant =>
+ shapez.registerBuildingVariant(internalId, metaClass, variant, rotationVariant)
+ );
+ }
+}
diff --git a/src/js/mods/mod_meta_building.js b/src/js/mods/mod_meta_building.js
new file mode 100644
index 00000000..0d8f215a
--- /dev/null
+++ b/src/js/mods/mod_meta_building.js
@@ -0,0 +1,18 @@
+import { MetaBuilding } from "../game/meta_building";
+
+export class ModMetaBuilding extends MetaBuilding {
+ /**
+ * @returns {({
+ * variant: string;
+ * rotationVariant?: number;
+ * name: string;
+ * description: string;
+ * blueprintImageBase64?: string;
+ * regularImageBase64?: string;
+ * tutorialImageBase64?: string;
+ * }[])}
+ */
+ static getAllVariantCombinations() {
+ throw new Error("Implement getAllVariantCombinations");
+ }
+}
diff --git a/src/js/mods/mod_signals.js b/src/js/mods/mod_signals.js
new file mode 100644
index 00000000..a534dd89
--- /dev/null
+++ b/src/js/mods/mod_signals.js
@@ -0,0 +1,33 @@
+/* typehints:start */
+import { BaseHUDPart } from "../game/hud/base_hud_part";
+import { GameRoot } from "../game/root";
+import { GameState } from "../core/game_state";
+import { InGameState } from "../states/ingame";
+/* typehints:end */
+
+import { Signal } from "../core/signal";
+
+// Single file to avoid circular deps
+
+export const MOD_SIGNALS = {
+ // Called when the application has booted and instances like the app settings etc are available
+ appBooted: new Signal(),
+
+ modifyLevelDefinitions: /** @type {TypedSignal<[Array[Object]]>} */ (new Signal()),
+ modifyUpgrades: /** @type {TypedSignal<[Object]>} */ (new Signal()),
+
+ hudElementInitialized: /** @type {TypedSignal<[BaseHUDPart]>} */ (new Signal()),
+ hudElementFinalized: /** @type {TypedSignal<[BaseHUDPart]>} */ (new Signal()),
+
+ hudInitializer: /** @type {TypedSignal<[GameRoot]>} */ (new Signal()),
+
+ gameInitialized: /** @type {TypedSignal<[GameRoot]>} */ (new Signal()),
+ gameLoadingStageEntered: /** @type {TypedSignal<[InGameState, string]>} */ (new Signal()),
+
+ gameStarted: /** @type {TypedSignal<[GameRoot]>} */ (new Signal()),
+
+ stateEntered: /** @type {TypedSignal<[GameState]>} */ (new Signal()),
+
+ gameSerialized: /** @type {TypedSignal<[GameRoot, import("../savegame/savegame_typedefs").SerializedGame]>} */ (new Signal()),
+ gameDeserialized: /** @type {TypedSignal<[GameRoot, import("../savegame/savegame_typedefs").SerializedGame]>} */ (new Signal()),
+};
diff --git a/src/js/mods/modloader.js b/src/js/mods/modloader.js
new file mode 100644
index 00000000..356b7d6b
--- /dev/null
+++ b/src/js/mods/modloader.js
@@ -0,0 +1,270 @@
+/* typehints:start */
+import { Application } from "../application";
+/* typehints:end */
+import { globalConfig } from "../core/config";
+import { createLogger } from "../core/logging";
+import { StorageImplBrowserIndexedDB } from "../platform/browser/storage_indexed_db";
+import { StorageImplElectron } from "../platform/electron/storage";
+import { FILE_NOT_FOUND } from "../platform/storage";
+import { Mod } from "./mod";
+import { ModInterface } from "./mod_interface";
+import { MOD_SIGNALS } from "./mod_signals";
+
+import semverValidRange from "semver/ranges/valid";
+import semverSatisifies from "semver/functions/satisfies";
+
+const LOG = createLogger("mods");
+
+/**
+ * @typedef {{
+ * name: string;
+ * version: string;
+ * author: string;
+ * website: string;
+ * description: string;
+ * id: string;
+ * minimumGameVersion?: string;
+ * settings: [];
+ * doesNotAffectSavegame?: boolean
+ * }} ModMetadata
+ */
+
+export class ModLoader {
+ constructor() {
+ LOG.log("modloader created");
+
+ /**
+ * @type {Application}
+ */
+ this.app = undefined;
+
+ /** @type {Mod[]} */
+ this.mods = [];
+
+ this.modInterface = new ModInterface(this);
+
+ /** @type {({ meta: ModMetadata, modClass: typeof Mod})[]} */
+ this.modLoadQueue = [];
+
+ this.initialized = false;
+
+ this.signals = MOD_SIGNALS;
+ }
+
+ linkApp(app) {
+ this.app = app;
+ }
+
+ anyModsActive() {
+ return this.mods.length > 0;
+ }
+
+ /**
+ *
+ * @returns {import("../savegame/savegame_typedefs").SavegameStoredMods}
+ */
+ getModsListForSavegame() {
+ return this.mods
+ .filter(mod => !mod.metadata.doesNotAffectSavegame)
+ .map(mod => ({
+ id: mod.metadata.id,
+ version: mod.metadata.version,
+ website: mod.metadata.website,
+ name: mod.metadata.name,
+ author: mod.metadata.author,
+ }));
+ }
+
+ /**
+ *
+ * @param {import("../savegame/savegame_typedefs").SavegameStoredMods} originalMods
+ */
+ computeModDifference(originalMods) {
+ /**
+ * @type {import("../savegame/savegame_typedefs").SavegameStoredMods}
+ */
+ let missing = [];
+
+ const current = this.getModsListForSavegame();
+
+ originalMods.forEach(mod => {
+ for (let i = 0; i < current.length; ++i) {
+ const currentMod = current[i];
+ if (currentMod.id === mod.id && currentMod.version === mod.version) {
+ current.splice(i, 1);
+ return;
+ }
+ }
+ missing.push(mod);
+ });
+
+ return {
+ missing,
+ extra: current,
+ };
+ }
+
+ exposeExports() {
+ if (G_IS_DEV || G_IS_STANDALONE) {
+ let exports = {};
+ const modules = require.context("../", true, /\.js$/);
+ Array.from(modules.keys()).forEach(key => {
+ // @ts-ignore
+ const module = modules(key);
+ for (const member in module) {
+ if (member === "default" || member === "$s") {
+ // Setter
+ continue;
+ }
+ if (exports[member]) {
+ throw new Error("Duplicate export of " + member);
+ }
+
+ Object.defineProperty(exports, member, {
+ get() {
+ return module[member];
+ },
+ set(v) {
+ module["$s"](member, v);
+ },
+ });
+ }
+ });
+
+ window.shapez = exports;
+ }
+ }
+
+ async initMods() {
+ if (!G_IS_STANDALONE && !G_IS_DEV) {
+ this.initialized = true;
+ return;
+ }
+
+ // Create a storage for reading mod settings
+ const storage = G_IS_STANDALONE
+ ? new StorageImplElectron(this.app)
+ : new StorageImplBrowserIndexedDB(this.app);
+ await storage.initialize();
+
+ LOG.log("hook:init", this.app, this.app.storage);
+ this.exposeExports();
+
+ let mods = [];
+ if (G_IS_STANDALONE) {
+ mods = await ipcRenderer.invoke("get-mods");
+ }
+ if (G_IS_DEV && globalConfig.debug.externalModUrl) {
+ const modURLs = Array.isArray(globalConfig.debug.externalModUrl)
+ ? globalConfig.debug.externalModUrl
+ : [globalConfig.debug.externalModUrl];
+
+ for (let i = 0; i < modURLs.length; i++) {
+ const response = await fetch(modURLs[i], {
+ method: "GET",
+ });
+ if (response.status !== 200) {
+ throw new Error(
+ "Failed to load " + modURLs[i] + ": " + response.status + " " + response.statusText
+ );
+ }
+ mods.push(await response.text());
+ }
+ }
+
+ window.$shapez_registerMod = (modClass, meta) => {
+ if (this.initialized) {
+ throw new Error("Can't register mod after modloader is initialized");
+ }
+ if (this.modLoadQueue.some(entry => entry.meta.id === meta.id)) {
+ console.warn("Not registering mod", meta, "since a mod with the same id is already loaded");
+ return;
+ }
+ this.modLoadQueue.push({
+ modClass,
+ meta,
+ });
+ };
+
+ mods.forEach(modCode => {
+ modCode += `
+ if (typeof Mod !== 'undefined') {
+ if (typeof METADATA !== 'object') {
+ throw new Error("No METADATA variable found");
+ }
+ window.$shapez_registerMod(Mod, METADATA);
+ }
+ `;
+ try {
+ const func = new Function(modCode);
+ func();
+ } catch (ex) {
+ console.error(ex);
+ alert("Failed to parse mod (launch with --dev for more info): \n\n" + ex);
+ }
+ });
+
+ delete window.$shapez_registerMod;
+
+ for (let i = 0; i < this.modLoadQueue.length; i++) {
+ const { modClass, meta } = this.modLoadQueue[i];
+ const modDataFile = "modsettings_" + meta.id + "__" + meta.version + ".json";
+
+ if (meta.minimumGameVersion) {
+ const minimumGameVersion = meta.minimumGameVersion;
+ if (!semverValidRange(minimumGameVersion)) {
+ alert("Mod " + meta.id + " has invalid minimumGameVersion: " + minimumGameVersion);
+ continue;
+ }
+ if (!semverSatisifies(G_BUILD_VERSION, minimumGameVersion)) {
+ alert(
+ "Mod '" +
+ meta.id +
+ "' is incompatible with this version of the game: \n\n" +
+ "Mod requires version " +
+ minimumGameVersion +
+ " but this game has version " +
+ G_BUILD_VERSION
+ );
+ continue;
+ }
+ }
+
+ let settings = meta.settings;
+
+ if (meta.settings) {
+ try {
+ const storedSettings = await storage.readFileAsync(modDataFile);
+ settings = JSON.parse(storedSettings);
+ } catch (ex) {
+ if (ex === FILE_NOT_FOUND) {
+ // Write default data
+ await storage.writeFileAsync(modDataFile, JSON.stringify(meta.settings));
+ } else {
+ alert("Failed to load settings for " + meta.id + ", will use defaults:\n\n" + ex);
+ }
+ }
+ }
+
+ try {
+ const mod = new modClass({
+ app: this.app,
+ modLoader: this,
+ meta,
+ settings,
+ saveSettings: () => storage.writeFileAsync(modDataFile, JSON.stringify(mod.settings)),
+ });
+ mod.init();
+ this.mods.push(mod);
+ } catch (ex) {
+ console.error(ex);
+ alert("Failed to initialize mods (launch with --dev for more info): \n\n" + ex);
+ }
+ }
+
+ this.modLoadQueue = [];
+ this.initialized = true;
+ }
+}
+
+export const MODS = new ModLoader();
diff --git a/src/js/platform/api.js b/src/js/platform/api.js
index d518c98a..4e7a82f9 100644
--- a/src/js/platform/api.js
+++ b/src/js/platform/api.js
@@ -3,7 +3,6 @@ import { Application } from "../application";
/* typehints:end */
import { createLogger } from "../core/logging";
import { compressX64 } from "../core/lzstring";
-import { getIPCRenderer } from "../core/utils";
import { T } from "../translations";
const logger = createLogger("puzzle-api");
@@ -113,9 +112,7 @@ export class ClientAPI {
return Promise.resolve({ token });
}
- const renderer = getIPCRenderer();
-
- return renderer.invoke("steam:get-ticket").then(
+ return ipcRenderer.invoke("steam:get-ticket").then(
ticket => {
logger.log("Got auth ticket:", ticket);
return this._request("/v1/public/login", {
diff --git a/src/js/platform/electron/steam_achievement_provider.js b/src/js/platform/electron/steam_achievement_provider.js
index c0ef552c..638cdbc5 100644
--- a/src/js/platform/electron/steam_achievement_provider.js
+++ b/src/js/platform/electron/steam_achievement_provider.js
@@ -4,7 +4,6 @@ import { GameRoot } from "../../game/root";
/* typehints:end */
import { createLogger } from "../../core/logging";
-import { getIPCRenderer } from "../../core/utils";
import { ACHIEVEMENTS, AchievementCollection, AchievementProviderInterface } from "../achievement_provider";
const logger = createLogger("achievements/steam");
@@ -109,9 +108,7 @@ export class SteamAchievementProvider extends AchievementProviderInterface {
return Promise.resolve();
}
- this.ipc = getIPCRenderer();
-
- return this.ipc.invoke("steam:is-initialized").then(initialized => {
+ return ipcRenderer.invoke("steam:is-initialized").then(initialized => {
this.initialized = initialized;
if (!this.initialized) {
@@ -136,7 +133,7 @@ export class SteamAchievementProvider extends AchievementProviderInterface {
if (!this.initialized) {
promise = Promise.resolve();
} else {
- promise = this.ipc.invoke("steam:activate-achievement", ACHIEVEMENT_IDS[key]);
+ promise = ipcRenderer.invoke("steam:activate-achievement", ACHIEVEMENT_IDS[key]);
}
return promise
diff --git a/src/js/platform/electron/storage.js b/src/js/platform/electron/storage.js
index 41ed1746..65f0e507 100644
--- a/src/js/platform/electron/storage.js
+++ b/src/js/platform/electron/storage.js
@@ -1,30 +1,8 @@
-import { StorageInterface } from "../storage";
-import { getIPCRenderer } from "../../core/utils";
-import { createLogger } from "../../core/logging";
-
-const logger = createLogger("electron-storage");
+import { FILE_NOT_FOUND, StorageInterface } from "../storage";
export class StorageImplElectron extends StorageInterface {
constructor(app) {
super(app);
-
- /** @type {Object.} */
- this.jobs = {};
- this.jobId = 0;
-
- getIPCRenderer().on("fs-response", (event, arg) => {
- const id = arg.id;
- if (!this.jobs[id]) {
- logger.warn("Got unhandled FS response, job not known:", id);
- return;
- }
- const { resolve, reject } = this.jobs[id];
- if (arg.result.success) {
- resolve(arg.result.data);
- } else {
- reject(arg.result.error);
- }
- });
}
initialize() {
@@ -32,44 +10,32 @@ export class StorageImplElectron extends StorageInterface {
}
writeFileAsync(filename, contents) {
- return new Promise((resolve, reject) => {
- // ipcMain
- const jobId = ++this.jobId;
- this.jobs[jobId] = { resolve, reject };
-
- getIPCRenderer().send("fs-job", {
- type: "write",
- filename,
- contents,
- id: jobId,
- });
+ return ipcRenderer.invoke("fs-job", {
+ type: "write",
+ filename,
+ contents,
});
}
readFileAsync(filename) {
- return new Promise((resolve, reject) => {
- // ipcMain
- const jobId = ++this.jobId;
- this.jobs[jobId] = { resolve, reject };
-
- getIPCRenderer().send("fs-job", {
+ return ipcRenderer
+ .invoke("fs-job", {
type: "read",
filename,
- id: jobId,
+ })
+ .then(res => {
+ if (res && res.error === FILE_NOT_FOUND) {
+ throw FILE_NOT_FOUND;
+ }
+
+ return res;
});
- });
}
deleteFileAsync(filename) {
- return new Promise((resolve, reject) => {
- // ipcMain
- const jobId = ++this.jobId;
- this.jobs[jobId] = { resolve, reject };
- getIPCRenderer().send("fs-job", {
- type: "delete",
- filename,
- id: jobId,
- });
+ return ipcRenderer.invoke("fs-job", {
+ type: "delete",
+ filename,
});
}
}
diff --git a/src/js/platform/electron/wrapper.js b/src/js/platform/electron/wrapper.js
index c1764f68..65451395 100644
--- a/src/js/platform/electron/wrapper.js
+++ b/src/js/platform/electron/wrapper.js
@@ -1,6 +1,5 @@
import { NoAchievementProvider } from "../browser/no_achievement_provider";
import { PlatformWrapperImplBrowser } from "../browser/wrapper";
-import { getIPCRenderer } from "../../core/utils";
import { createLogger } from "../../core/logging";
import { StorageImplElectron } from "./storage";
import { SteamAchievementProvider } from "./steam_achievement_provider";
@@ -71,15 +70,13 @@ export class PlatformWrapperImplElectron extends PlatformWrapperImplBrowser {
}
initializeDlcStatus() {
- const renderer = getIPCRenderer();
-
if (G_WEGAME_VERSION) {
return Promise.resolve();
}
logger.log("Checking DLC ownership ...");
// @todo: Don't hardcode the app id
- return renderer.invoke("steam:check-app-ownership", 1625400).then(
+ return ipcRenderer.invoke("steam:check-app-ownership", 1625400).then(
res => {
logger.log("Got DLC ownership:", res);
this.dlcs.puzzle = Boolean(res);
@@ -106,7 +103,7 @@ export class PlatformWrapperImplElectron extends PlatformWrapperImplBrowser {
}
setFullscreen(flag) {
- getIPCRenderer().send("set-fullscreen", flag);
+ ipcRenderer.send("set-fullscreen", flag);
}
getSupportsAppExit() {
@@ -115,6 +112,6 @@ export class PlatformWrapperImplElectron extends PlatformWrapperImplBrowser {
exitApp() {
logger.log(this, "Sending app exit signal");
- getIPCRenderer().send("exit-app");
+ ipcRenderer.send("exit-app");
}
}
diff --git a/src/js/profile/application_settings.js b/src/js/profile/application_settings.js
index 22074eae..03f4fdcf 100644
--- a/src/js/profile/application_settings.js
+++ b/src/js/profile/application_settings.js
@@ -122,7 +122,7 @@ export const autosaveIntervals = [
},
];
-const refreshRateOptions = ["30", "60", "120", "180", "240"];
+export const refreshRateOptions = ["30", "60", "120", "180", "240"];
if (G_IS_DEV) {
refreshRateOptions.unshift("10");
@@ -133,163 +133,161 @@ if (G_IS_DEV) {
refreshRateOptions.push("10000");
}
-/** @type {Array} */
-export const allApplicationSettings = [
- new EnumSetting("language", {
- options: Object.keys(LANGUAGES),
- valueGetter: key => key,
- textGetter: key => LANGUAGES[key].name,
- category: enumCategories.general,
- restartRequired: true,
- changeCb: (app, id) => null,
- magicValue: "auto-detect",
- }),
+/** @returns {Array} */
+function initializeSettings() {
+ return [
+ new EnumSetting("language", {
+ options: Object.keys(LANGUAGES),
+ valueGetter: key => key,
+ textGetter: key => LANGUAGES[key].name,
+ category: enumCategories.general,
+ restartRequired: true,
+ changeCb: (app, id) => null,
+ magicValue: "auto-detect",
+ }),
- new EnumSetting("uiScale", {
- options: uiScales.sort((a, b) => a.size - b.size),
- valueGetter: scale => scale.id,
- textGetter: scale => T.settings.labels.uiScale.scales[scale.id],
- category: enumCategories.userInterface,
- restartRequired: false,
- changeCb:
+ new EnumSetting("uiScale", {
+ options: uiScales.sort((a, b) => a.size - b.size),
+ valueGetter: scale => scale.id,
+ textGetter: scale => T.settings.labels.uiScale.scales[scale.id],
+ category: enumCategories.userInterface,
+ restartRequired: false,
+ changeCb:
+ /**
+ * @param {Application} app
+ */
+ (app, id) => app.updateAfterUiScaleChanged(),
+ }),
+
+ new RangeSetting(
+ "soundVolume",
+ enumCategories.general,
/**
* @param {Application} app
*/
- (app, id) => app.updateAfterUiScaleChanged(),
- }),
-
- new RangeSetting(
- "soundVolume",
- enumCategories.general,
- /**
- * @param {Application} app
- */
- (app, value) => app.sound.setSoundVolume(value)
- ),
- new RangeSetting(
- "musicVolume",
- enumCategories.general,
- /**
- * @param {Application} app
- */
- (app, value) => app.sound.setMusicVolume(value)
- ),
-
- new BoolSetting(
- "fullscreen",
- enumCategories.general,
- /**
- * @param {Application} app
- */
- (app, value) => {
- if (app.platformWrapper.getSupportsFullscreen()) {
- app.platformWrapper.setFullscreen(value);
- }
- },
- /**
- * @param {Application} app
- */ app => app.restrictionMgr.getHasExtendedSettings()
- ),
-
- new BoolSetting(
- "enableColorBlindHelper",
- enumCategories.general,
- /**
- * @param {Application} app
- */
- (app, value) => null
- ),
-
- new BoolSetting("offerHints", enumCategories.userInterface, (app, value) => {}),
-
- new EnumSetting("theme", {
- options: Object.keys(THEMES),
- valueGetter: theme => theme,
- textGetter: theme => T.settings.labels.theme.themes[theme],
- category: enumCategories.userInterface,
- restartRequired: false,
- changeCb:
+ (app, value) => app.sound.setSoundVolume(value)
+ ),
+ new RangeSetting(
+ "musicVolume",
+ enumCategories.general,
/**
* @param {Application} app
*/
- (app, id) => {
- applyGameTheme(id);
- document.documentElement.setAttribute("data-theme", id);
+ (app, value) => app.sound.setMusicVolume(value)
+ ),
+
+ new BoolSetting(
+ "fullscreen",
+ enumCategories.general,
+ /**
+ * @param {Application} app
+ */
+ (app, value) => {
+ if (app.platformWrapper.getSupportsFullscreen()) {
+ app.platformWrapper.setFullscreen(value);
+ }
},
- enabledCb: /**
- * @param {Application} app
- */ app => app.restrictionMgr.getHasExtendedSettings(),
- }),
+ /**
+ * @param {Application} app
+ */ app => app.restrictionMgr.getHasExtendedSettings()
+ ),
- new EnumSetting("autosaveInterval", {
- options: autosaveIntervals,
- valueGetter: interval => interval.id,
- textGetter: interval => T.settings.labels.autosaveInterval.intervals[interval.id],
- category: enumCategories.advanced,
- restartRequired: false,
- changeCb:
+ new BoolSetting(
+ "enableColorBlindHelper",
+ enumCategories.general,
/**
* @param {Application} app
*/
- (app, id) => null,
- }),
+ (app, value) => null
+ ),
- new EnumSetting("scrollWheelSensitivity", {
- options: scrollWheelSensitivities.sort((a, b) => a.scale - b.scale),
- valueGetter: scale => scale.id,
- textGetter: scale => T.settings.labels.scrollWheelSensitivity.sensitivity[scale.id],
- category: enumCategories.advanced,
- restartRequired: false,
- changeCb:
- /**
+ new BoolSetting("offerHints", enumCategories.userInterface, (app, value) => {}),
+
+ new EnumSetting("theme", {
+ options: Object.keys(THEMES),
+ valueGetter: theme => theme,
+ textGetter: theme => T.settings.labels.theme.themes[theme],
+ category: enumCategories.userInterface,
+ restartRequired: false,
+ changeCb:
+ /**
+ * @param {Application} app
+ */
+ (app, id) => {
+ applyGameTheme(id);
+ document.documentElement.setAttribute("data-theme", id);
+ },
+ enabledCb: /**
* @param {Application} app
- */
- (app, id) => app.updateAfterUiScaleChanged(),
- }),
+ */ app => app.restrictionMgr.getHasExtendedSettings(),
+ }),
- new EnumSetting("movementSpeed", {
- options: movementSpeeds.sort((a, b) => a.multiplier - b.multiplier),
- valueGetter: multiplier => multiplier.id,
- textGetter: multiplier => T.settings.labels.movementSpeed.speeds[multiplier.id],
- category: enumCategories.advanced,
- restartRequired: false,
- changeCb: (app, id) => {},
- }),
+ new EnumSetting("autosaveInterval", {
+ options: autosaveIntervals,
+ valueGetter: interval => interval.id,
+ textGetter: interval => T.settings.labels.autosaveInterval.intervals[interval.id],
+ category: enumCategories.advanced,
+ restartRequired: false,
+ changeCb:
+ /**
+ * @param {Application} app
+ */
+ (app, id) => null,
+ }),
- new BoolSetting("enableMousePan", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("shapeTooltipAlwaysOn", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("alwaysMultiplace", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("zoomToCursor", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("clearCursorOnDeleteWhilePlacing", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("enableTunnelSmartplace", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("vignette", enumCategories.userInterface, (app, value) => {}),
- new BoolSetting("compactBuildingInfo", enumCategories.userInterface, (app, value) => {}),
- new BoolSetting("disableCutDeleteWarnings", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("rotationByBuilding", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("displayChunkBorders", enumCategories.advanced, (app, value) => {}),
- new BoolSetting("pickMinerOnPatch", enumCategories.advanced, (app, value) => {}),
- new RangeSetting("mapResourcesScale", enumCategories.advanced, () => null),
+ new EnumSetting("scrollWheelSensitivity", {
+ options: scrollWheelSensitivities.sort((a, b) => a.scale - b.scale),
+ valueGetter: scale => scale.id,
+ textGetter: scale => T.settings.labels.scrollWheelSensitivity.sensitivity[scale.id],
+ category: enumCategories.advanced,
+ restartRequired: false,
+ changeCb:
+ /**
+ * @param {Application} app
+ */
+ (app, id) => app.updateAfterUiScaleChanged(),
+ }),
- new EnumSetting("refreshRate", {
- options: refreshRateOptions,
- valueGetter: rate => rate,
- textGetter: rate => T.settings.tickrateHz.replace("", rate),
- category: enumCategories.performance,
- restartRequired: false,
- changeCb: (app, id) => {},
- enabledCb: /**
- * @param {Application} app
- */ app => app.restrictionMgr.getHasExtendedSettings(),
- }),
+ new EnumSetting("movementSpeed", {
+ options: movementSpeeds.sort((a, b) => a.multiplier - b.multiplier),
+ valueGetter: multiplier => multiplier.id,
+ textGetter: multiplier => T.settings.labels.movementSpeed.speeds[multiplier.id],
+ category: enumCategories.advanced,
+ restartRequired: false,
+ changeCb: (app, id) => {},
+ }),
- new BoolSetting("lowQualityMapResources", enumCategories.performance, (app, value) => {}),
- new BoolSetting("disableTileGrid", enumCategories.performance, (app, value) => {}),
- new BoolSetting("lowQualityTextures", enumCategories.performance, (app, value) => {}),
- new BoolSetting("simplifiedBelts", enumCategories.performance, (app, value) => {}),
-];
+ new BoolSetting("enableMousePan", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("shapeTooltipAlwaysOn", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("alwaysMultiplace", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("zoomToCursor", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("clearCursorOnDeleteWhilePlacing", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("enableTunnelSmartplace", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("vignette", enumCategories.userInterface, (app, value) => {}),
+ new BoolSetting("compactBuildingInfo", enumCategories.userInterface, (app, value) => {}),
+ new BoolSetting("disableCutDeleteWarnings", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("rotationByBuilding", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("displayChunkBorders", enumCategories.advanced, (app, value) => {}),
+ new BoolSetting("pickMinerOnPatch", enumCategories.advanced, (app, value) => {}),
+ new RangeSetting("mapResourcesScale", enumCategories.advanced, () => null),
-export function getApplicationSettingById(id) {
- return allApplicationSettings.find(setting => setting.id === id);
+ new EnumSetting("refreshRate", {
+ options: refreshRateOptions,
+ valueGetter: rate => rate,
+ textGetter: rate => T.settings.tickrateHz.replace("", rate),
+ category: enumCategories.performance,
+ restartRequired: false,
+ changeCb: (app, id) => {},
+ enabledCb: /**
+ * @param {Application} app
+ */ app => app.restrictionMgr.getHasExtendedSettings(),
+ }),
+
+ new BoolSetting("lowQualityMapResources", enumCategories.performance, (app, value) => {}),
+ new BoolSetting("disableTileGrid", enumCategories.performance, (app, value) => {}),
+ new BoolSetting("lowQualityTextures", enumCategories.performance, (app, value) => {}),
+ new BoolSetting("simplifiedBelts", enumCategories.performance, (app, value) => {}),
+ ];
}
class SettingsStorage {
@@ -339,6 +337,8 @@ class SettingsStorage {
export class ApplicationSettings extends ReadWriteProxy {
constructor(app) {
super(app, "app_settings.bin");
+
+ this.settingHandles = initializeSettings();
}
initialize() {
@@ -347,8 +347,8 @@ export class ApplicationSettings extends ReadWriteProxy {
.then(() => {
// Apply default setting callbacks
const settings = this.getAllSettings();
- for (let i = 0; i < allApplicationSettings.length; ++i) {
- const handle = allApplicationSettings[i];
+ for (let i = 0; i < this.settingHandles.length; ++i) {
+ const handle = this.settingHandles[i];
handle.apply(this.app, settings[handle.id]);
}
})
@@ -360,6 +360,10 @@ export class ApplicationSettings extends ReadWriteProxy {
return this.writeAsync();
}
+ getSettingHandleById(id) {
+ return this.settingHandles.find(setting => setting.id === id);
+ }
+
// Getters
/**
@@ -457,20 +461,18 @@ export class ApplicationSettings extends ReadWriteProxy {
* @param {string|boolean|number} value
*/
updateSetting(key, value) {
- for (let i = 0; i < allApplicationSettings.length; ++i) {
- const setting = allApplicationSettings[i];
- if (setting.id === key) {
- if (!setting.validate(value)) {
- assertAlways(false, "Bad setting value: " + key);
- }
- this.getAllSettings()[key] = value;
- if (setting.changeCb) {
- setting.changeCb(this.app, value);
- }
- return this.writeAsync();
- }
+ const setting = this.getSettingHandleById(key);
+ if (!setting) {
+ assertAlways(false, "Unknown setting: " + key);
}
- assertAlways(false, "Unknown setting: " + key);
+ if (!setting.validate(value)) {
+ assertAlways(false, "Bad setting value: " + key);
+ }
+ this.getAllSettings()[key] = value;
+ if (setting.changeCb) {
+ setting.changeCb(this.app, value);
+ }
+ return this.writeAsync();
}
/**
@@ -510,8 +512,15 @@ export class ApplicationSettings extends ReadWriteProxy {
}
const settings = data.settings;
- for (let i = 0; i < allApplicationSettings.length; ++i) {
- const setting = allApplicationSettings[i];
+
+ // MODS
+ if (!THEMES[settings.theme]) {
+ console.warn("Resetting theme because its no longer available: " + settings.theme);
+ settings.theme = "light";
+ }
+
+ for (let i = 0; i < this.settingHandles.length; ++i) {
+ const setting = this.settingHandles[i];
const storedValue = settings[setting.id];
if (!setting.validate(storedValue)) {
return ExplainedResult.bad(
@@ -690,6 +699,12 @@ export class ApplicationSettings extends ReadWriteProxy {
data.version = 31;
}
+ // MODS
+ if (!THEMES[data.settings.theme]) {
+ console.warn("Resetting theme because its no longer available: " + data.settings.theme);
+ data.settings.theme = "light";
+ }
+
return ExplainedResult.good();
}
}
diff --git a/src/js/savegame/savegame.js b/src/js/savegame/savegame.js
index 36ed884f..b4472b2b 100644
--- a/src/js/savegame/savegame.js
+++ b/src/js/savegame/savegame.js
@@ -14,6 +14,8 @@ import { SavegameInterface_V1006 } from "./schemas/1006";
import { SavegameInterface_V1007 } from "./schemas/1007";
import { SavegameInterface_V1008 } from "./schemas/1008";
import { SavegameInterface_V1009 } from "./schemas/1009";
+import { MODS } from "../mods/modloader";
+import { SavegameInterface_V1010 } from "./schemas/1010";
const logger = createLogger("savegame");
@@ -54,7 +56,7 @@ export class Savegame extends ReadWriteProxy {
* @returns {number}
*/
static getCurrentVersion() {
- return 1009;
+ return 1010;
}
/**
@@ -103,6 +105,7 @@ export class Savegame extends ReadWriteProxy {
usedInverseRotater: false,
},
lastUpdate: Date.now(),
+ mods: MODS.getModsListForSavegame(),
};
}
@@ -160,6 +163,11 @@ export class Savegame extends ReadWriteProxy {
data.version = 1009;
}
+ if (data.version === 1009) {
+ SavegameInterface_V1010.migrate1009to1010(data);
+ data.version = 1010;
+ }
+
return ExplainedResult.good();
}
@@ -269,6 +277,7 @@ export class Savegame extends ReadWriteProxy {
shadowData.dump = dump;
shadowData.lastUpdate = new Date().getTime();
shadowData.version = this.getCurrentVersion();
+ shadowData.mods = MODS.getModsListForSavegame();
const reader = this.getDumpReaderForExternalData(shadowData);
diff --git a/src/js/savegame/savegame_interface_registry.js b/src/js/savegame/savegame_interface_registry.js
index b4dc4233..089b15fc 100644
--- a/src/js/savegame/savegame_interface_registry.js
+++ b/src/js/savegame/savegame_interface_registry.js
@@ -10,6 +10,7 @@ import { SavegameInterface_V1006 } from "./schemas/1006";
import { SavegameInterface_V1007 } from "./schemas/1007";
import { SavegameInterface_V1008 } from "./schemas/1008";
import { SavegameInterface_V1009 } from "./schemas/1009";
+import { SavegameInterface_V1010 } from "./schemas/1010";
/** @type {Object.} */
export const savegameInterfaces = {
@@ -23,6 +24,7 @@ export const savegameInterfaces = {
1007: SavegameInterface_V1007,
1008: SavegameInterface_V1008,
1009: SavegameInterface_V1009,
+ 1010: SavegameInterface_V1010,
};
const logger = createLogger("savegame_interface_registry");
diff --git a/src/js/savegame/savegame_serializer.js b/src/js/savegame/savegame_serializer.js
index 3230cdd5..f95c9896 100644
--- a/src/js/savegame/savegame_serializer.js
+++ b/src/js/savegame/savegame_serializer.js
@@ -1,9 +1,8 @@
import { ExplainedResult } from "../core/explained_result";
-import { createLogger } from "../core/logging";
import { gComponentRegistry } from "../core/global_registries";
+import { createLogger } from "../core/logging";
+import { MOD_SIGNALS } from "../mods/mod_signals";
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
@@ -42,8 +41,12 @@ export class SavegameSerializer {
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,
+
+ modExtraData: {},
};
+ MOD_SIGNALS.gameSerialized.dispatch(root, data);
+
if (G_IS_DEV) {
if (sanityChecks) {
// Sanity check
@@ -151,6 +154,9 @@ export class SavegameSerializer {
return ExplainedResult.bad(errorReason);
}
+ // Mods
+ MOD_SIGNALS.gameDeserialized.dispatch(root, savegame);
+
return ExplainedResult.good();
}
}
diff --git a/src/js/savegame/savegame_typedefs.js b/src/js/savegame/savegame_typedefs.js
index c5e0e5c5..b1980115 100644
--- a/src/js/savegame/savegame_typedefs.js
+++ b/src/js/savegame/savegame_typedefs.js
@@ -2,6 +2,14 @@
* @typedef {import("../game/entity").Entity} Entity
*
* @typedef {{
+ * id: string;
+ * version: string;
+ * website: string;
+ * name: string;
+ * author: string;
+ * }[]} SavegameStoredMods
+ *
+ * @typedef {{
* failedMam: boolean,
* trashedCount: number,
* usedInverseRotater: boolean
@@ -17,7 +25,8 @@
* pinnedShapes: any,
* waypoints: any,
* entities: Array,
- * beltPaths: Array
+ * beltPaths: Array,
+ * modExtraData: Object
* }} SerializedGame
*
* @typedef {{
@@ -25,6 +34,7 @@
* dump: SerializedGame,
* stats: SavegameStats,
* lastUpdate: number,
+ * mods: SavegameStoredMods
* }} SavegameData
*
* @typedef {{
diff --git a/src/js/savegame/schemas/1010.js b/src/js/savegame/schemas/1010.js
new file mode 100644
index 00000000..8f480800
--- /dev/null
+++ b/src/js/savegame/schemas/1010.js
@@ -0,0 +1,28 @@
+import { createLogger } from "../../core/logging.js";
+import { SavegameInterface_V1009 } from "./1009.js";
+
+const schema = require("./1010.json");
+const logger = createLogger("savegame_interface/1010");
+
+export class SavegameInterface_V1010 extends SavegameInterface_V1009 {
+ getVersion() {
+ return 1010;
+ }
+
+ getSchemaUncached() {
+ return schema;
+ }
+
+ /**
+ * @param {import("../savegame_typedefs.js").SavegameData} data
+ */
+ static migrate1009to1010(data) {
+ logger.log("Migrating 1009 to 1010");
+
+ data.mods = [];
+
+ if (data.dump) {
+ data.dump.modExtraData = {};
+ }
+ }
+}
diff --git a/src/js/savegame/schemas/1010.json b/src/js/savegame/schemas/1010.json
new file mode 100644
index 00000000..6682f615
--- /dev/null
+++ b/src/js/savegame/schemas/1010.json
@@ -0,0 +1,5 @@
+{
+ "type": "object",
+ "required": [],
+ "additionalProperties": true
+}
diff --git a/src/js/savegame/serialization.js b/src/js/savegame/serialization.js
index 78642ceb..770f166f 100644
--- a/src/js/savegame/serialization.js
+++ b/src/js/savegame/serialization.js
@@ -22,6 +22,7 @@ import {
TypeString,
TypeStructuredObject,
TypeVector,
+ TypePositiveIntegerOrString,
} from "./serialization_data_types";
const logger = createLogger("serialization");
@@ -38,6 +39,7 @@ export const types = {
vector: new TypeVector(),
tileVector: new TypeVector(),
bool: new TypeBoolean(),
+ uintOrString: new TypePositiveIntegerOrString(),
/**
* @param {BaseDataType} wrapped
@@ -136,7 +138,7 @@ export const types = {
/**
* A full schema declaration
- * @typedef {Object.} Schema
+ * @typedef {Object. | object} Schema
*/
const globalSchemaCache = {};
diff --git a/src/js/savegame/serialization_data_types.js b/src/js/savegame/serialization_data_types.js
index 9d3b689f..df352e78 100644
--- a/src/js/savegame/serialization_data_types.js
+++ b/src/js/savegame/serialization_data_types.js
@@ -213,6 +213,53 @@ export class TypePositiveInteger extends BaseDataType {
}
}
+export class TypePositiveIntegerOrString extends BaseDataType {
+ serialize(value) {
+ if (Number.isInteger(value)) {
+ assert(value >= 0, "type integer got negative value: " + value);
+ } else if (typeof value === "string") {
+ // all good
+ } else {
+ assertAlways(false, "Type integer|string got non integer or string for serialize: " + value);
+ }
+ return value;
+ }
+
+ /**
+ * @see BaseDataType.deserialize
+ * @param {any} value
+ * @param {GameRoot} root
+ * @param {object} targetObject
+ * @param {string|number} targetKey
+ * @returns {string|void} String error code or null on success
+ */
+ deserialize(value, targetObject, targetKey, root) {
+ targetObject[targetKey] = value;
+ }
+
+ getAsJsonSchemaUncached() {
+ return {
+ oneOf: [{ type: "integer", minimum: 0 }, { type: "string" }],
+ };
+ }
+
+ verifySerializedValue(value) {
+ if (Number.isInteger(value)) {
+ if (value < 0) {
+ return "Negative value for positive integer";
+ }
+ } else if (typeof value === "string") {
+ // all good
+ } else {
+ return "Not a valid number or string: " + value;
+ }
+ }
+
+ getCacheKey() {
+ return "uint_str";
+ }
+}
+
export class TypeBoolean extends BaseDataType {
serialize(value) {
assert(value === true || value === false, "Type bool got non bool for serialize: " + value);
diff --git a/src/js/states/ingame.js b/src/js/states/ingame.js
index 0dd6c72a..108028a4 100644
--- a/src/js/states/ingame.js
+++ b/src/js/states/ingame.js
@@ -9,24 +9,25 @@ import { Savegame } from "../savegame/savegame";
import { GameCore } from "../game/core";
import { MUSIC } from "../platform/sound";
import { enumGameModeIds } from "../game/game_mode";
+import { MOD_SIGNALS } from "../mods/mod_signals";
const logger = createLogger("state/ingame");
// Different sub-states
-const stages = {
- s3_createCore: "🌈 3: Create core",
- s4_A_initEmptyGame: "🌈 4/A: Init empty game",
- s4_B_resumeGame: "🌈 4/B: Resume game",
+export const GAME_LOADING_STATES = {
+ s3_createCore: "s3_createCore",
+ s4_A_initEmptyGame: "s4_A_initEmptyGame",
+ s4_B_resumeGame: "s4_B_resumeGame",
- s5_firstUpdate: "🌈 5: First game update",
- s6_postLoadHook: "🌈 6: Post load hook",
- s7_warmup: "🌈 7: Warmup",
+ s5_firstUpdate: "s5_firstUpdate",
+ s6_postLoadHook: "s6_postLoadHook",
+ s7_warmup: "s7_warmup",
- s10_gameRunning: "🌈 10: Game finally running",
+ s10_gameRunning: "s10_gameRunning",
- leaving: "🌈 Saving, then leaving the game",
- destroyed: "🌈 DESTROYED: Core is empty and waits for state leave",
- initFailed: "🌈 ERROR: Initialization failed!",
+ leaving: "leaving",
+ destroyed: "destroyed",
+ initFailed: "initFailed",
};
export const gameCreationAction = {
@@ -82,6 +83,10 @@ export class InGameState extends GameState {
this.currentSavePromise = null;
}
+ get dialogs() {
+ return this.core.root.hud.parts.dialogs;
+ }
+
/**
* Switches the game into another sub-state
* @param {string} stage
@@ -91,6 +96,7 @@ export class InGameState extends GameState {
if (stage !== this.stage) {
this.stage = stage;
logger.log(this.stage);
+ MOD_SIGNALS.gameLoadingStageEntered.dispatch(this, stage);
return true;
} else {
// log(this, "Re entering", stage);
@@ -146,7 +152,7 @@ export class InGameState extends GameState {
onResized(w, h) {
super.onResized(w, h);
- if (this.stage === stages.s10_gameRunning) {
+ if (this.stage === GAME_LOADING_STATES.s10_gameRunning) {
this.core.resize(w, h);
}
}
@@ -190,7 +196,7 @@ export class InGameState extends GameState {
* @param {any=} payload
*/
saveThenGoToState(stateId, payload) {
- if (this.stage === stages.leaving || this.stage === stages.destroyed) {
+ if (this.stage === GAME_LOADING_STATES.leaving || this.stage === GAME_LOADING_STATES.destroyed) {
logger.warn(
"Tried to leave game twice or during destroy:",
this.stage,
@@ -217,7 +223,7 @@ export class InGameState extends GameState {
* @param {string} err
*/
onInitializationFailure(err) {
- if (this.switchStage(stages.initFailed)) {
+ if (this.switchStage(GAME_LOADING_STATES.initFailed)) {
logger.error("Init failure:", err);
this.stageDestroyed();
this.moveToState("MainMenuState", { loadError: err });
@@ -230,7 +236,7 @@ export class InGameState extends GameState {
* Creates the game core instance, and thus the root
*/
stage3CreateCore() {
- if (this.switchStage(stages.s3_createCore)) {
+ if (this.switchStage(GAME_LOADING_STATES.s3_createCore)) {
logger.log("Creating new game core");
this.core = new GameCore(this.app);
@@ -249,7 +255,7 @@ export class InGameState extends GameState {
* Initializes a new empty game
*/
stage4aInitEmptyGame() {
- if (this.switchStage(stages.s4_A_initEmptyGame)) {
+ if (this.switchStage(GAME_LOADING_STATES.s4_A_initEmptyGame)) {
this.core.initNewGame();
this.stage5FirstUpdate();
}
@@ -259,7 +265,7 @@ export class InGameState extends GameState {
* Resumes an existing game
*/
stage4bResumeGame() {
- if (this.switchStage(stages.s4_B_resumeGame)) {
+ if (this.switchStage(GAME_LOADING_STATES.s4_B_resumeGame)) {
if (!this.core.initExistingGame()) {
this.onInitializationFailure("Savegame is corrupt and can not be restored.");
return;
@@ -273,7 +279,7 @@ export class InGameState extends GameState {
* Performs the first game update on the game which initializes most caches
*/
stage5FirstUpdate() {
- if (this.switchStage(stages.s5_firstUpdate)) {
+ if (this.switchStage(GAME_LOADING_STATES.s5_firstUpdate)) {
this.core.root.logicInitialized = true;
this.core.updateLogic();
this.stage6PostLoadHook();
@@ -285,7 +291,7 @@ export class InGameState extends GameState {
* can operate and start to work now.
*/
stage6PostLoadHook() {
- if (this.switchStage(stages.s6_postLoadHook)) {
+ if (this.switchStage(GAME_LOADING_STATES.s6_postLoadHook)) {
logger.log("Post load hook");
this.core.postLoadHook();
this.stage7Warmup();
@@ -298,7 +304,7 @@ export class InGameState extends GameState {
* are in the VRAM and we have a smooth experience once we start.
*/
stage7Warmup() {
- if (this.switchStage(stages.s7_warmup)) {
+ if (this.switchStage(GAME_LOADING_STATES.s7_warmup)) {
if (this.creationPayload.fastEnter) {
this.warmupTimeSeconds = globalConfig.warmupTimeSecondsFast;
} else {
@@ -311,13 +317,15 @@ export class InGameState extends GameState {
* The final stage where this game is running and updating regulary.
*/
stage10GameRunning() {
- if (this.switchStage(stages.s10_gameRunning)) {
+ if (this.switchStage(GAME_LOADING_STATES.s10_gameRunning)) {
this.core.root.signals.readyToRender.dispatch();
logSection("GAME STARTED", "#26a69a");
// Initial resize, might have changed during loading (this is possible)
this.core.resize(this.app.screenWidth, this.app.screenHeight);
+
+ MOD_SIGNALS.gameStarted.dispatch(this.core.root);
}
}
@@ -325,7 +333,7 @@ export class InGameState extends GameState {
* This stage destroys the whole game, used to cleanup
*/
stageDestroyed() {
- if (this.switchStage(stages.destroyed)) {
+ if (this.switchStage(GAME_LOADING_STATES.destroyed)) {
// Cleanup all api calls
this.cancelAllAsyncOperations();
@@ -346,7 +354,7 @@ export class InGameState extends GameState {
* When leaving the game
*/
stageLeavingGame() {
- if (this.switchStage(stages.leaving)) {
+ if (this.switchStage(GAME_LOADING_STATES.leaving)) {
// ...
}
}
@@ -357,7 +365,7 @@ export class InGameState extends GameState {
* Filters the input (keybindings)
*/
filterInput() {
- return this.stage === stages.s10_gameRunning;
+ return this.stage === GAME_LOADING_STATES.s10_gameRunning;
}
/**
@@ -395,7 +403,7 @@ export class InGameState extends GameState {
return;
}
- if (this.stage === stages.s7_warmup) {
+ if (this.stage === GAME_LOADING_STATES.s7_warmup) {
this.core.draw();
this.warmupTimeSeconds -= dt / 1000.0;
if (this.warmupTimeSeconds < 0) {
@@ -404,12 +412,12 @@ export class InGameState extends GameState {
}
}
- if (this.stage === stages.s10_gameRunning) {
+ if (this.stage === GAME_LOADING_STATES.s10_gameRunning) {
this.core.tick(dt);
}
// If the stage is still active (This might not be the case if tick() moved us to game over)
- if (this.stage === stages.s10_gameRunning) {
+ if (this.stage === GAME_LOADING_STATES.s10_gameRunning) {
// Only draw if page visible
if (this.app.pageVisible) {
this.core.draw();
@@ -442,9 +450,9 @@ export class InGameState extends GameState {
}
if (
- this.stage !== stages.s10_gameRunning &&
- this.stage !== stages.s7_warmup &&
- this.stage !== stages.leaving
+ this.stage !== GAME_LOADING_STATES.s10_gameRunning &&
+ this.stage !== GAME_LOADING_STATES.s7_warmup &&
+ this.stage !== GAME_LOADING_STATES.leaving
) {
logger.warn("Skipping save because game is not ready");
return Promise.resolve();
diff --git a/src/js/states/keybindings.js b/src/js/states/keybindings.js
index a01629f1..e6721bf8 100644
--- a/src/js/states/keybindings.js
+++ b/src/js/states/keybindings.js
@@ -19,7 +19,7 @@ export class KeybindingsState extends TextualGameState {
@@ -335,6 +369,7 @@ export class MainMenuState extends GameState {
".puzzleDlcPlayButton": this.onPuzzleModeButtonClicked,
".puzzleDlcGetButton": this.onPuzzleWishlistButtonClicked,
".wegameDisclaimer > .rating": this.onWegameRatingClicked,
+ ".editMods": this.onModsClicked,
};
for (const key in clickHandling) {
@@ -353,36 +388,41 @@ export class MainMenuState extends GameState {
const buttonContainer = this.htmlElement.querySelector(".mainContainer .buttons");
removeAllChildren(buttonContainer);
+ const outerDiv = makeDivElement(null, ["outer"], null);
+
// Import button
- const importButtonElement = makeButtonElement(
- ["importButton", "styledButton"],
- T.mainMenu.importSavegame
+ this.trackClicks(
+ makeButton(outerDiv, ["importButton", "styledButton"], T.mainMenu.importSavegame),
+ this.requestImportSavegame
);
- this.trackClicks(importButtonElement, this.requestImportSavegame);
if (this.savedGames.length > 0) {
// Continue game
- const continueButton = makeButton(
- buttonContainer,
- ["continueButton", "styledButton"],
- T.mainMenu.continue
+ this.trackClicks(
+ makeButton(buttonContainer, ["continueButton", "styledButton"], T.mainMenu.continue),
+ this.onContinueButtonClicked
);
- this.trackClicks(continueButton, this.onContinueButtonClicked);
- const outerDiv = makeDiv(buttonContainer, null, ["outer"], null);
- outerDiv.appendChild(importButtonElement);
- const newGameButton = makeButton(
- this.htmlElement.querySelector(".mainContainer .outer"),
- ["newGameButton", "styledButton"],
- T.mainMenu.newGame
+ // New game
+ this.trackClicks(
+ makeButton(outerDiv, ["newGameButton", "styledButton"], T.mainMenu.newGame),
+ this.onPlayButtonClicked
);
- this.trackClicks(newGameButton, this.onPlayButtonClicked);
} else {
// New game
- const playBtn = makeButton(buttonContainer, ["playButton", "styledButton"], T.mainMenu.play);
- this.trackClicks(playBtn, this.onPlayButtonClicked);
- buttonContainer.appendChild(importButtonElement);
+ this.trackClicks(
+ makeButton(buttonContainer, ["playButton", "styledButton"], T.mainMenu.play),
+ this.onPlayButtonClicked
+ );
}
+
+ // Mods
+ this.trackClicks(
+ makeButton(outerDiv, ["modsButton", "styledButton"], T.mods.title),
+ this.onModsClicked
+ );
+
+ buttonContainer.appendChild(outerDiv);
}
onPuzzleModeButtonClicked(force = false) {
@@ -434,7 +474,7 @@ export class MainMenuState extends GameState {
onLanguageChooseClicked() {
this.app.analytics.trackUiClick("choose_language");
- const setting = /** @type {EnumSetting} */ (getApplicationSettingById("language"));
+ const setting = /** @type {EnumSetting} */ (this.app.settings.getSettingHandleById("language"));
const { optionSelected } = this.dialogs.showOptionChooser(T.settings.labels.language.title, {
active: this.app.settings.getLanguage(),
@@ -576,11 +616,13 @@ export class MainMenuState extends GameState {
const savegame = this.app.savegameMgr.getSavegameById(game.internalId);
savegame
.readAsync()
+ .then(() => this.checkForModDifferences(savegame))
.then(() => {
this.moveToState("InGameState", {
savegame,
});
})
+
.catch(err => {
this.dialogs.showWarning(
T.dialogs.gameLoadFailure.title,
@@ -590,6 +632,57 @@ export class MainMenuState extends GameState {
});
}
+ /**
+ * @param {Savegame} savegame
+ */
+ checkForModDifferences(savegame) {
+ const difference = MODS.computeModDifference(savegame.currentData.mods);
+
+ if (difference.missing.length === 0 && difference.extra.length === 0) {
+ return Promise.resolve();
+ }
+
+ let dialogHtml = T.dialogs.modsDifference.desc;
+
+ /**
+ *
+ * @param {import("../savegame/savegame_typedefs").SavegameStoredMods[0]} mod
+ */
+ function formatMod(mod) {
+ return `
+
${T.keybindings.hint}
-
+
@@ -34,6 +34,10 @@ export class KeybindingsState extends TextualGameState {
this.trackClicks(this.htmlElement.querySelector(".resetBindings"), this.resetBindings);
for (const category in KEYMAPPINGS) {
+ if (Object.keys(KEYMAPPINGS[category]).length === 0) {
+ continue;
+ }
+
const categoryDiv = document.createElement("div");
categoryDiv.classList.add("category");
keybindingsElem.appendChild(categoryDiv);
@@ -138,7 +142,19 @@ export class KeybindingsState extends TextualGameState {
}
const mappingDiv = container.querySelector(".mapping");
- mappingDiv.innerHTML = getStringForKeyCode(keyCode);
+ let modifiers = "";
+
+ if (mapped.modifiers && mapped.modifiers.shift) {
+ modifiers += "⇪ ";
+ }
+ if (mapped.modifiers && mapped.modifiers.alt) {
+ modifiers += T.global.keys.alt + " ";
+ }
+ if (mapped.modifiers && mapped.modifiers.ctrl) {
+ modifiers += T.global.keys.control + " ";
+ }
+
+ mappingDiv.innerHTML = modifiers + getStringForKeyCode(keyCode);
mappingDiv.classList.toggle("changed", !!overrides[keybindingId]);
const resetBtn = container.querySelector("button.resetKeybinding");
diff --git a/src/js/states/main_menu.js b/src/js/states/main_menu.js
index 60495a9c..10e280b9 100644
--- a/src/js/states/main_menu.js
+++ b/src/js/states/main_menu.js
@@ -10,16 +10,17 @@ import {
generateFileDownload,
isSupportedBrowser,
makeButton,
- makeButtonElement,
makeDiv,
+ makeDivElement,
removeAllChildren,
startFileChoose,
waitNextFrame,
} from "../core/utils";
import { HUDModalDialogs } from "../game/hud/parts/modal_dialogs";
+import { MODS } from "../mods/modloader";
import { PlatformWrapperImplBrowser } from "../platform/browser/wrapper";
import { PlatformWrapperImplElectron } from "../platform/electron/wrapper";
-import { getApplicationSettingById } from "../profile/application_settings";
+import { Savegame } from "../savegame/savegame";
import { T } from "../translations";
const trim = require("trim");
@@ -41,6 +42,7 @@ export class MainMenuState extends GameState {
const showBrowserWarning = !G_IS_STANDALONE && !isSupportedBrowser();
const showPuzzleDLC = !G_WEGAME_VERSION && (G_IS_STANDALONE || G_IS_DEV);
const showWegameFooter = G_WEGAME_VERSION;
+ const hasMods = MODS.anyModsActive();
let showExternalLinks = true;
@@ -94,7 +96,7 @@ export class MainMenuState extends GameState {
- ${showUpdateLabel ? `v${G_BUILD_VERSION}!` : ""}
+ ${showUpdateLabel ? `MODS UPDATE!` : ""}
@@ -147,6 +149,38 @@ export class MainMenuState extends GameState {
`
: ""
}
+ ${
+ hasMods
+ ? `
+
+
${
@@ -195,7 +229,7 @@ export class MainMenuState extends GameState {
@@ -112,7 +114,7 @@ export class MainMenuState extends GameState {
${
- showPuzzleDLC && ownsPuzzleDLC
+ showPuzzleDLC && ownsPuzzleDLC && !hasMods
? `
+
+ `
+ : ""
+ }
+
+
+ ${T.mods.title}
+ +
+ ${MODS.mods
+ .map(mod => {
+ return `
+
+
+
+
+ `;
+ })
+ .join("")}
+ ${mod.metadata.name}
+
+
+ ${T.mainMenu.mods.warningPuzzleDLC}
+
+
+
+
+
+ `;
+ }
+
+ if (difference.missing.length > 0) {
+ dialogHtml += "${mod.name}
+ ${T.mods.version} ${mod.version}
+
+
+ " + T.dialogs.modsDifference.missingMods + "
"; + dialogHtml += difference.missing.map(formatMod).join(""); + } + + if (difference.extra.length > 0) { + dialogHtml += "
" + T.dialogs.modsDifference.newMods + "
"; + dialogHtml += difference.extra.map(formatMod).join(""); + } + + const signals = this.dialogs.showWarning(T.dialogs.modsDifference.title, dialogHtml, [ + "cancel:good", + "continue:bad", + ]); + + return new Promise(resolve => { + signals.continue.add(resolve); + }); + } + /** * @param {SavegameMetadata} game */ @@ -695,6 +788,12 @@ export class MainMenuState extends GameState { ); } + onModsClicked() { + this.moveToState("ModsState", { + backToStateId: "MainMenuState", + }); + } + onContinueButtonClicked() { let latestLastUpdate = 0; let latestInternalId; @@ -709,6 +808,7 @@ export class MainMenuState extends GameState { savegame .readAsync() .then(() => this.app.adProvider.showVideoAd()) + .then(() => this.checkForModDifferences(savegame)) .then(() => { this.moveToState("InGameState", { savegame, diff --git a/src/js/states/mods.js b/src/js/states/mods.js new file mode 100644 index 00000000..1e0fe5f1 --- /dev/null +++ b/src/js/states/mods.js @@ -0,0 +1,149 @@ +import { THIRDPARTY_URLS } from "../core/config"; +import { TextualGameState } from "../core/textual_game_state"; +import { MODS } from "../mods/modloader"; +import { T } from "../translations"; + +export class ModsState extends TextualGameState { + constructor() { + super("ModsState"); + } + + getStateHeaderTitle() { + return T.mods.title; + } + + internalGetFullHtml() { + let headerHtml = ` +
+
`;
+
+ return `
+ ${headerHtml}
+ ${this.getStateHeaderTitle()}
+ +
+ ${
+ (G_IS_STANDALONE || G_IS_DEV) && MODS.mods.length > 0
+ ? ``
+ : ""
+ }
+ ${
+ G_IS_STANDALONE || G_IS_DEV
+ ? ``
+ : ""
+ }
+
+
+
+ ${this.getInnerHTML()}
+
+ `;
+ }
+
+ getMainContentHTML() {
+ if (!G_IS_STANDALONE && !G_IS_DEV) {
+ return `
+
+
+
+ `;
+ }
+
+ if (MODS.mods.length === 0) {
+ return `
+
+ ${T.mods.noModSupport}
+ + Get the shapez.io standalone! + + +
+ ${T.mods.modsInfo}
+
+
+
+
+ `;
+ }
+
+ let modsHtml = ``;
+
+ MODS.mods.forEach(mod => {
+ modsHtml += `
+
+
+ ${T.mods.version}${mod.metadata.version}
+
+
+ `;
+ });
+ return `
+
+
+
+
+
+
+ ${T.mods.modsInfo}
+
+
+
+ ${modsHtml}
+
+ `;
+ }
+
+ onEnter() {
+ const steamLink = this.htmlElement.querySelector(".steamLink");
+ if (steamLink) {
+ this.trackClicks(steamLink, this.onSteamLinkClicked);
+ }
+ const openModsFolder = this.htmlElement.querySelector(".openModsFolder");
+ if (openModsFolder) {
+ this.trackClicks(openModsFolder, this.openModsFolder);
+ }
+ const browseMods = this.htmlElement.querySelector(".browseMods");
+ if (browseMods) {
+ this.trackClicks(browseMods, this.openBrowseMods);
+ }
+
+ const checkboxes = this.htmlElement.querySelectorAll(".checkbox");
+ Array.from(checkboxes).forEach(checkbox => {
+ this.trackClicks(checkbox, this.showModTogglingComingSoon);
+ });
+ }
+
+ showModTogglingComingSoon() {
+ this.dialogs.showWarning(T.mods.togglingComingSoon.title, T.mods.togglingComingSoon.description);
+ }
+
+ openModsFolder() {
+ if (!G_IS_STANDALONE) {
+ this.dialogs.showWarning(T.global.error, T.mods.folderOnlyStandalone);
+ return;
+ }
+ ipcRenderer.invoke("open-mods-folder");
+ }
+
+ openBrowseMods() {
+ this.app.analytics.trackUiClick("mods_sbrowse_link");
+ this.app.platformWrapper.openExternalLink(THIRDPARTY_URLS.modBrowser);
+ }
+
+ onSteamLinkClicked() {
+ this.app.analytics.trackUiClick("mods_steam_link");
+ this.app.platformWrapper.openExternalLink(
+ THIRDPARTY_URLS.stanaloneCampaignLink + "/shapez_modsettings"
+ );
+
+ return false;
+ }
+
+ getDefaultPreviousState() {
+ return "SettingsState";
+ }
+}
diff --git a/src/js/states/settings.js b/src/js/states/settings.js
index 352e0153..ad52f3df 100644
--- a/src/js/states/settings.js
+++ b/src/js/states/settings.js
@@ -1,7 +1,7 @@
import { THIRDPARTY_URLS } from "../core/config";
import { TextualGameState } from "../core/textual_game_state";
import { formatSecondsToTimeAgo } from "../core/utils";
-import { allApplicationSettings, enumCategories } from "../profile/application_settings";
+import { enumCategories } from "../profile/application_settings";
import { T } from "../translations";
export class SettingsState extends TextualGameState {
@@ -19,6 +19,8 @@ export class SettingsState extends TextualGameState {