${this.getMainContentHTML()}
@@ -24,17 +28,43 @@ export class TextualGameState extends GameState {
/**
* Should return the states HTML content.
+ * @deprecated
*/
- getMainContentHTML() {
+ getMainContentHTML(): string {
return "";
}
+ /**
+ * Should return the element(s) to be displayed in the state.
+ * If not overridden, a default layout consisting of a back button,
+ * title, and content returned by {@link getInitialContent}.
+ */
+ protected override getContentLayout(): Node {
+ const initialContent = this.getInitialContent();
+ const content = initialContent !== null &&
{initialContent}
;
+
+ return (
+ <>
+
+
{content || super.getContentLayout()}
+
+ );
+ }
+
+ protected getInitialContent(): Node {
+ return null;
+ }
+
/**
* Should return the title of the game state. If null, no title and back button will
* get created
- * @returns {string|null}
*/
- getStateHeaderTitle() {
+ protected getStateHeaderTitle(): string | null {
return null;
}
@@ -44,7 +74,7 @@ export class TextualGameState extends GameState {
* Back button handler, can be overridden. Per default it goes back to the main menu,
* or if coming from the game it moves back to the game again.
*/
- onBackButton() {
+ override onBackButton() {
if (this.backToStateId) {
this.moveToState(this.backToStateId, this.backToStatePayload);
} else {
@@ -61,9 +91,9 @@ export class TextualGameState extends GameState {
/**
* Goes to a new state, telling him to go back to this state later
- * @param {string} stateId
+ * @param stateId
*/
- moveToStateAddGoBack(stateId) {
+ moveToStateAddGoBack(stateId: string) {
this.moveToState(stateId, {
backToStateId: this.key,
backToStatePayload: {
@@ -89,43 +119,20 @@ export class TextualGameState extends GameState {
}
}
- /**
- * Overrides the GameState implementation to provide our own html
- */
- internalGetFullHtml() {
- let headerHtml = "";
- if (this.getStateHeaderTitle()) {
- headerHtml = `
- `;
- }
-
- return `
- ${headerHtml}
-
- ${this.getInnerHTML()}
-
-
- `;
- }
-
//// INTERNALS /////
/**
* Overrides the GameState leave callback to cleanup stuff
*/
- internalLeaveCallback() {
+ override internalLeaveCallback() {
super.internalLeaveCallback();
this.dialogs.cleanup();
}
/**
* Overrides the GameState enter callback to setup required stuff
- * @param {any} payload
*/
- internalEnterCallback(payload) {
+ override internalEnterCallback(payload: any) {
super.internalEnterCallback(payload, false);
if (payload.backToStateId) {
this.backToStateId = payload.backToStateId;
diff --git a/src/js/core/tracked_state.js b/src/js/core/tracked_state.ts
similarity index 69%
rename from src/js/core/tracked_state.js
rename to src/js/core/tracked_state.ts
index 1a538bc6..f5da2ab4 100644
--- a/src/js/core/tracked_state.js
+++ b/src/js/core/tracked_state.ts
@@ -1,7 +1,10 @@
-export class TrackedState {
- constructor(callbackMethod = null, callbackScope = null) {
- this.lastSeenValue = null;
+export type TrackedStateCallback
= (value: T) => void;
+export class TrackedState {
+ public lastSeenValue: T = null;
+ public callback: TrackedStateCallback;
+
+ constructor(callbackMethod: TrackedStateCallback = null, callbackScope: unknown = null) {
if (callbackMethod) {
this.callback = callbackMethod;
if (callbackScope) {
@@ -10,7 +13,7 @@ export class TrackedState {
}
}
- set(value, changeHandler = null, changeScope = null) {
+ set(value: T, changeHandler: TrackedStateCallback = null, changeScope: unknown = null) {
if (value !== this.lastSeenValue) {
// Copy value since the changeHandler call could actually modify our lastSeenValue
const valueCopy = value;
@@ -29,11 +32,11 @@ export class TrackedState {
}
}
- setSilent(value) {
+ setSilent(value: T) {
this.lastSeenValue = value;
}
- get() {
+ get(): T {
return this.lastSeenValue;
}
}
diff --git a/src/js/core/utils.js b/src/js/core/utils.js
index 9e2126b1..87ec41ff 100644
--- a/src/js/core/utils.js
+++ b/src/js/core/utils.js
@@ -1,790 +1,666 @@
-import { T } from "../translations";
-import { rando } from "@nastyox/rando.js";
-import { WEB_STEAM_SSO_AUTHENTICATED } from "./steam_sso";
-
-const bigNumberSuffixTranslationKeys = ["thousands", "millions", "billions", "trillions"];
-
-/**
- * Returns a platform name
- * @returns {"android" | "browser" | "ios" | "standalone" | "unknown"}
- */
-export function getPlatformName() {
- if (G_IS_STANDALONE) {
- return "standalone";
- } else if (G_IS_BROWSER) {
- return "browser";
- }
- return "unknown";
-}
-
-/**
- * Makes a new 2D array with undefined contents
- * @param {number} w
- * @param {number} h
- * @returns {Array>}
- */
-export function make2DUndefinedArray(w, h) {
- const result = new Array(w);
- for (let x = 0; x < w; ++x) {
- result[x] = new Array(h);
- }
- return result;
-}
-
-/**
- * Creates a new map (an empty object without any props)
- */
-export function newEmptyMap() {
- return Object.create(null);
-}
-
-/**
- * Returns a random integer in the range [start,end]
- * @param {number} start
- * @param {number} end
- */
-export function randomInt(start, end) {
- return rando(start, end);
-}
-
-/**
- * Access an object in a very annoying way, used for obsfuscation.
- * @param {any} obj
- * @param {Array} keys
- */
-export function accessNestedPropertyReverse(obj, keys) {
- let result = obj;
- for (let i = keys.length - 1; i >= 0; --i) {
- result = result[keys[i]];
- }
- return result;
-}
-
-/**
- * Chooses a random entry of an array
- * @template T
- * @param {T[]} arr
- * @returns {T}
- */
-export function randomChoice(arr) {
- return arr[Math.floor(Math.random() * arr.length)];
-}
-
-/**
- * Deletes from an array by swapping with the last element
- * @param {Array} array
- * @param {number} index
- */
-export function fastArrayDelete(array, index) {
- if (index < 0 || index >= array.length) {
- throw new Error("Out of bounds");
- }
- // When the element is not the last element
- if (index !== array.length - 1) {
- // Get the last element, and swap it with the one we want to delete
- const last = array[array.length - 1];
- array[index] = last;
- }
-
- // Finally remove the last element
- array.length -= 1;
-}
-
-/**
- * Deletes from an array by swapping with the last element. Searches
- * for the value in the array first
- * @param {Array} array
- * @param {any} value
- */
-export function fastArrayDeleteValue(array, value) {
- if (array == null) {
- throw new Error("Tried to delete from non array!");
- }
- const index = array.indexOf(value);
- if (index < 0) {
- console.error("Value", value, "not contained in array:", array, "!");
- return value;
- }
- return fastArrayDelete(array, index);
-}
-
-/**
- * @see fastArrayDeleteValue
- * @param {Array} array
- * @param {any} value
- */
-export function fastArrayDeleteValueIfContained(array, value) {
- if (array == null) {
- throw new Error("Tried to delete from non array!");
- }
- const index = array.indexOf(value);
- if (index < 0) {
- return value;
- }
- return fastArrayDelete(array, index);
-}
-
-/**
- * Deletes from an array at the given index
- * @param {Array} array
- * @param {number} index
- */
-export function arrayDelete(array, index) {
- if (index < 0 || index >= array.length) {
- throw new Error("Out of bounds");
- }
- array.splice(index, 1);
-}
-
-/**
- * Deletes the given value from an array
- * @param {Array} array
- * @param {any} value
- */
-export function arrayDeleteValue(array, value) {
- if (array == null) {
- throw new Error("Tried to delete from non array!");
- }
- const index = array.indexOf(value);
- if (index < 0) {
- console.error("Value", value, "not contained in array:", array, "!");
- return value;
- }
- return arrayDelete(array, index);
-}
-
-/**
- * Compare two floats for epsilon equality
- * @param {number} a
- * @param {number} b
- * @returns {boolean}
- */
-export function epsilonCompare(a, b, epsilon = 1e-5) {
- return Math.abs(a - b) < epsilon;
-}
-
-/**
- * Interpolates two numbers
- * @param {number} a
- * @param {number} b
- * @param {number} x Mix factor, 0 means 100% a, 1 means 100%b, rest is interpolated
- */
-export function lerp(a, b, x) {
- return a * (1 - x) + b * x;
-}
-
-/**
- * Finds a value which is nice to display, e.g. 15669 -> 15000. Also handles fractional stuff
- * @param {number} num
- */
-export function findNiceValue(num) {
- if (num > 1e8) {
- return num;
- }
- if (num < 0.00001) {
- return 0;
- }
-
- let roundAmount = 1;
- if (num > 50000) {
- roundAmount = 10000;
- } else if (num > 20000) {
- roundAmount = 5000;
- } else if (num > 5000) {
- roundAmount = 1000;
- } else if (num > 2000) {
- roundAmount = 500;
- } else if (num > 1000) {
- roundAmount = 100;
- } else if (num > 100) {
- roundAmount = 20;
- } else if (num > 20) {
- roundAmount = 5;
- }
-
- const niceValue = Math.floor(num / roundAmount) * roundAmount;
- if (num >= 10) {
- return Math.round(niceValue);
- }
- if (num >= 1) {
- return Math.round(niceValue * 10) / 10;
- }
-
- return Math.round(niceValue * 100) / 100;
-}
-
-/**
- * Finds a nice integer value
- * @see findNiceValue
- * @param {number} num
- */
-export function findNiceIntegerValue(num) {
- return Math.ceil(findNiceValue(num));
-}
-
-/**
- * Formats a big number
- * @param {number} num
- * @param {string=} separator The decimal separator for numbers like 50.1 (separator='.')
- * @returns {string}
- */
-export function formatBigNumber(num, separator = T.global.decimalSeparator) {
- const sign = num < 0 ? "-" : "";
- num = Math.abs(num);
-
- if (num > 1e54) {
- return sign + T.global.infinite;
- }
-
- if (num < 10 && !Number.isInteger(num)) {
- return sign + num.toFixed(2);
- }
- if (num < 50 && !Number.isInteger(num)) {
- return sign + num.toFixed(1);
- }
- num = Math.floor(num);
-
- if (num < 1000) {
- return sign + "" + num;
- } else {
- let leadingDigits = num;
- let suffix = "";
- for (let suffixIndex = 0; suffixIndex < bigNumberSuffixTranslationKeys.length; ++suffixIndex) {
- leadingDigits = leadingDigits / 1000;
- suffix = T.global.suffix[bigNumberSuffixTranslationKeys[suffixIndex]];
- if (leadingDigits < 1000) {
- break;
- }
- }
- const leadingDigitsRounded = round1Digit(leadingDigits);
- const leadingDigitsNoTrailingDecimal = leadingDigitsRounded
- .toString()
- .replace(".0", "")
- .replace(".", separator);
- return sign + leadingDigitsNoTrailingDecimal + suffix;
- }
-}
-
-/**
- * Formats a big number, but does not add any suffix and instead uses its full representation
- * @param {number} num
- * @param {string=} divider The divider for numbers like 50,000 (divider=',')
- * @returns {string}
- */
-export function formatBigNumberFull(num, divider = T.global.thousandsDivider) {
- if (num < 1000) {
- return num + "";
- }
- if (num > 1e54) {
- return T.global.infinite;
- }
- let rest = num;
- let out = "";
- while (rest >= 1000) {
- out = (rest % 1000).toString().padStart(3, "0") + divider + out;
- rest = Math.floor(rest / 1000);
- }
- out = rest + divider + out;
-
- return out.substring(0, out.length - 1);
-}
-
-/**
- * Waits two frames so the ui is updated
- * @returns {Promise}
- */
-export function waitNextFrame() {
- return new Promise(function (resolve) {
- window.requestAnimationFrame(function () {
- window.requestAnimationFrame(function () {
- resolve();
- });
- });
- });
-}
-
-/**
- * Rounds 1 digit
- * @param {number} n
- * @returns {number}
- */
-export function round1Digit(n) {
- return Math.floor(n * 10.0) / 10.0;
-}
-
-/**
- * Rounds 2 digits
- * @param {number} n
- * @returns {number}
- */
-export function round2Digits(n) {
- return Math.floor(n * 100.0) / 100.0;
-}
-
-/**
- * Rounds 3 digits
- * @param {number} n
- * @returns {number}
- */
-export function round3Digits(n) {
- return Math.floor(n * 1000.0) / 1000.0;
-}
-
-/**
- * Rounds 4 digits
- * @param {number} n
- * @returns {number}
- */
-export function round4Digits(n) {
- return Math.floor(n * 10000.0) / 10000.0;
-}
-
-/**
- * Clamps a value between [min, max]
- * @param {number} v
- * @param {number=} minimum Default 0
- * @param {number=} maximum Default 1
- */
-export function clamp(v, minimum = 0, maximum = 1) {
- return Math.max(minimum, Math.min(maximum, v));
-}
-
-/**
- * Helper method to create a new div element
- * @param {string=} id
- * @param {Array=} classes
- * @param {string=} innerHTML
- */
-export function makeDivElement(id = null, classes = [], innerHTML = "") {
- const div = document.createElement("div");
- if (id) {
- div.id = id;
- }
- for (let i = 0; i < classes.length; ++i) {
- div.classList.add(classes[i]);
- }
- div.innerHTML = innerHTML;
- return div;
-}
-
-/**
- * Helper method to create a new div
- * @param {Element} parent
- * @param {string=} id
- * @param {Array=} classes
- * @param {string=} innerHTML
- */
-export function makeDiv(parent, id = null, classes = [], innerHTML = "") {
- const div = makeDivElement(id, classes, innerHTML);
- parent.appendChild(div);
- return div;
-}
-
-/**
- * Helper method to create a new button element
- * @param {Array=} classes
- * @param {string=} innerHTML
- */
-export function makeButtonElement(classes = [], innerHTML = "") {
- const element = document.createElement("button");
- for (let i = 0; i < classes.length; ++i) {
- element.classList.add(classes[i]);
- }
- element.classList.add("styledButton");
- element.innerHTML = innerHTML;
- return element;
-}
-
-/**
- * Helper method to create a new button
- * @param {Element} parent
- * @param {Array=} classes
- * @param {string=} innerHTML
- */
-export function makeButton(parent, classes = [], innerHTML = "") {
- const element = makeButtonElement(classes, innerHTML);
- parent.appendChild(element);
- return element;
-}
-
-/**
- * Removes all children of the given element
- * @param {Element} elem
- */
-export function removeAllChildren(elem) {
- if (elem) {
- var range = document.createRange();
- range.selectNodeContents(elem);
- range.deleteContents();
- }
-}
-
-/**
- * Returns if the game supports this browser
- */
-export function isSupportedBrowser() {
- // please note,
- // that IE11 now returns undefined again for window.chrome
- // and new Opera 30 outputs true for window.chrome
- // but needs to check if window.opr is not undefined
- // and new IE Edge outputs to true now for window.chrome
- // and if not iOS Chrome check
- // so use the below updated condition
-
- if (G_IS_STANDALONE) {
- return true;
- }
-
- // @ts-ignore
- var isChromium = window.chrome;
- var winNav = window.navigator;
- var vendorName = winNav.vendor;
- // @ts-ignore
- var isIEedge = winNav.userAgent.indexOf("Edge") > -1;
- var isIOSChrome = winNav.userAgent.match("CriOS");
-
- if (isIOSChrome) {
- // is Google Chrome on IOS
- return false;
- } else if (
- isChromium !== null &&
- typeof isChromium !== "undefined" &&
- vendorName === "Google Inc." &&
- isIEedge === false
- ) {
- // is Google Chrome
- return true;
- } else {
- // not Google Chrome
- return false;
- }
-}
-
-/**
- * Formats an amount of seconds into something like "5s ago"
- * @param {number} secs Seconds
- * @returns {string}
- */
-export function formatSecondsToTimeAgo(secs) {
- const seconds = Math.floor(secs);
- const minutes = Math.floor(seconds / 60);
- const hours = Math.floor(minutes / 60);
- const days = Math.floor(hours / 24);
-
- if (seconds < 60) {
- if (seconds === 1) {
- return T.global.time.oneSecondAgo;
- }
- return T.global.time.xSecondsAgo.replace("", "" + seconds);
- } else if (minutes < 60) {
- if (minutes === 1) {
- return T.global.time.oneMinuteAgo;
- }
- return T.global.time.xMinutesAgo.replace("", "" + minutes);
- } else if (hours < 24) {
- if (hours === 1) {
- return T.global.time.oneHourAgo;
- }
- return T.global.time.xHoursAgo.replace("", "" + hours);
- } else {
- if (days === 1) {
- return T.global.time.oneDayAgo;
- }
- return T.global.time.xDaysAgo.replace("", "" + days);
- }
-}
-
-/**
- * Formats seconds into a readable string like "5h 23m"
- * @param {number} secs Seconds
- * @returns {string}
- */
-export function formatSeconds(secs) {
- const trans = T.global.time;
- secs = Math.ceil(secs);
- if (secs < 60) {
- return trans.secondsShort.replace("", "" + secs);
- } else if (secs < 60 * 60) {
- const minutes = Math.floor(secs / 60);
- const seconds = secs % 60;
- return trans.minutesAndSecondsShort
- .replace("", "" + seconds)
- .replace("", "" + minutes);
- } else {
- const hours = Math.floor(secs / 3600);
- const minutes = Math.floor(secs / 60) % 60;
- return trans.hoursAndMinutesShort.replace("", "" + minutes).replace("", "" + hours);
- }
-}
-
-/**
- * Formats a number like 2.51 to "2.5"
- * @param {number} speed
- * @param {string=} separator The decimal separator for numbers like 50.1 (separator='.')
- */
-export function round1DigitLocalized(speed, separator = T.global.decimalSeparator) {
- return round1Digit(speed).toString().replace(".", separator);
-}
-
-/**
- * Formats a number like 2.51 to "2.51 items / s"
- * @param {number} speed
- * @param {boolean=} double
- * @param {string=} separator The decimal separator for numbers like 50.1 (separator='.')
- */
-export function formatItemsPerSecond(speed, double = false, separator = T.global.decimalSeparator) {
- return (
- (speed === 1.0
- ? T.ingame.buildingPlacement.infoTexts.oneItemPerSecond
- : T.ingame.buildingPlacement.infoTexts.itemsPerSecond.replace(
- "",
- round2Digits(speed).toString().replace(".", separator)
- )) + (double ? " " + T.ingame.buildingPlacement.infoTexts.itemsPerSecondDouble : "")
- );
-}
-
-/**
- * Rotates a flat 3x3 matrix clockwise
- * Entries:
- * 0 lo
- * 1 mo
- * 2 ro
- * 3 lm
- * 4 mm
- * 5 rm
- * 6 lu
- * 7 mu
- * 8 ru
- * @param {Array} flatMatrix
- */
-
-export function rotateFlatMatrix3x3(flatMatrix) {
- return [
- flatMatrix[6],
- flatMatrix[3],
- flatMatrix[0],
- flatMatrix[7],
- flatMatrix[4],
- flatMatrix[1],
- flatMatrix[8],
- flatMatrix[5],
- flatMatrix[2],
- ];
-}
-
-/**
- * Generates rotated variants of the matrix
- * @param {Array} originalMatrix
- * @returns {Object>}
- */
-export function generateMatrixRotations(originalMatrix) {
- const result = {
- 0: originalMatrix,
- };
-
- originalMatrix = rotateFlatMatrix3x3(originalMatrix);
- result[90] = originalMatrix;
-
- originalMatrix = rotateFlatMatrix3x3(originalMatrix);
- result[180] = originalMatrix;
-
- originalMatrix = rotateFlatMatrix3x3(originalMatrix);
- result[270] = originalMatrix;
-
- return result;
-}
-
-/**
- *
- * @typedef {{
- * top: any,
- * right: any,
- * bottom: any,
- * left: any
- * }} DirectionalObject
- */
-
-/**
- * Rotates a directional object
- * @param {DirectionalObject} obj
- * @returns {DirectionalObject}
- */
-export function rotateDirectionalObject(obj, rotation) {
- const queue = [obj.top, obj.right, obj.bottom, obj.left];
- while (rotation !== 0) {
- rotation -= 90;
- queue.push(queue.shift());
- }
-
- return {
- top: queue[0],
- right: queue[1],
- bottom: queue[2],
- left: queue[3],
- };
-}
-
-/**
- * Modulo which works for negative numbers
- * @param {number} n
- * @param {number} m
- */
-export function safeModulo(n, m) {
- return ((n % m) + m) % m;
-}
-
-/**
- * Returns a smooth pulse between 0 and 1
- * @param {number} time time in seconds
- * @returns {number}
- */
-export function smoothPulse(time) {
- return Math.sin(time * 4) * 0.5 + 0.5;
-}
-
-/**
- * Fills in a tag
- * @param {string} translation
- * @param {string} link
- */
-export function fillInLinkIntoTranslation(translation, link) {
- return translation
- .replace("", "")
- .replace("", "");
-}
-
-/**
- * Generates a file download
- * @param {string} filename
- * @param {string} text
- */
-export function generateFileDownload(filename, text) {
- var element = document.createElement("a");
- element.setAttribute("href", "data:text/plain;charset=utf-8," + encodeURIComponent(text));
- element.setAttribute("download", filename);
-
- element.style.display = "none";
- document.body.appendChild(element);
-
- element.click();
- document.body.removeChild(element);
-}
-
-/**
- * Starts a file chooser
- * @param {string} acceptedType
- */
-export function startFileChoose(acceptedType = ".bin") {
- var input = document.createElement("input");
- input.type = "file";
- input.accept = acceptedType;
-
- return new Promise(resolve => {
- input.onchange = _ => resolve(input.files[0]);
- input.click();
- });
-}
-
-const MAX_ROMAN_NUMBER = 49;
-const romanLiteralsCache = ["0"];
-
-/**
- *
- * @param {number} number
- * @returns {string}
- */
-export function getRomanNumber(number) {
- if (G_WEGAME_VERSION) {
- return String(number);
- }
-
- number = Math.max(0, Math.round(number));
- if (romanLiteralsCache[number]) {
- return romanLiteralsCache[number];
- }
-
- if (number > MAX_ROMAN_NUMBER) {
- return String(number);
- }
-
- function formatDigit(digit, unit, quintuple, decuple) {
- switch (digit) {
- case 0:
- return "";
- case 1: // I
- return unit;
- case 2: // II
- return unit + unit;
- case 3: // III
- return unit + unit + unit;
- case 4: // IV
- return unit + quintuple;
- case 9: // IX
- return unit + decuple;
- default:
- // V, VI, VII, VIII
- return quintuple + formatDigit(digit - 5, unit, quintuple, decuple);
- }
- }
-
- let thousands = Math.floor(number / 1000);
- let thousandsPart = "";
- while (thousands > 0) {
- thousandsPart += "M";
- thousands -= 1;
- }
-
- const hundreds = Math.floor((number % 1000) / 100);
- const hundredsPart = formatDigit(hundreds, "C", "D", "M");
-
- const tens = Math.floor((number % 100) / 10);
- const tensPart = formatDigit(tens, "X", "L", "C");
-
- const units = number % 10;
- const unitsPart = formatDigit(units, "I", "V", "X");
-
- const formatted = thousandsPart + hundredsPart + tensPart + unitsPart;
-
- romanLiteralsCache[number] = formatted;
- return formatted;
-}
-
-/**
- * Returns the appropriate logo sprite path
- */
-export function getLogoSprite() {
- if (G_WEGAME_VERSION) {
- return "logo_wegame.png";
- }
-
- if (G_IS_STEAM_DEMO) {
- return "logo_demo.png";
- }
-
- if (G_CHINA_VERSION) {
- return "logo_cn.png";
- }
-
- if (G_IS_STANDALONE || WEB_STEAM_SSO_AUTHENTICATED) {
- return "logo.png";
- }
-
- if (G_IS_BROWSER) {
- return "logo_demo.png";
- }
-
- return "logo.png";
-}
-
-/**
- * Rejects a promise after X ms
- * @param {Promise} promise
- */
-export function timeoutPromise(promise, timeout = 30000) {
- return Promise.race([
- new Promise((resolve, reject) => {
- setTimeout(() => reject("timeout of " + timeout + " ms exceeded"), timeout);
- }),
- promise,
- ]);
-}
+import { T } from "../translations";
+
+const bigNumberSuffixTranslationKeys = ["thousands", "millions", "billions", "trillions"];
+
+/**
+ * Returns a platform name
+ * @returns {"standalone"}
+ */
+export function getPlatformName() {
+ return "standalone";
+}
+
+/**
+ * Makes a new 2D array with undefined contents
+ * @param {number} w
+ * @param {number} h
+ * @returns {Array>}
+ */
+export function make2DUndefinedArray(w, h) {
+ const result = new Array(w);
+ for (let x = 0; x < w; ++x) {
+ result[x] = new Array(h);
+ }
+ return result;
+}
+
+/**
+ * Creates a new map (an empty object without any props)
+ */
+export function newEmptyMap() {
+ return Object.create(null);
+}
+
+/**
+ * Returns a random integer in the range [start,end]
+ * @param {number} start
+ * @param {number} end
+ */
+export function randomInt(start, end) {
+ return Math.floor(Math.random() * (end - start + 1) + start);
+}
+
+/**
+ * Chooses a random entry of an array
+ * @template T
+ * @param {T[]} arr
+ * @returns {T}
+ */
+export function randomChoice(arr) {
+ return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * Deletes from an array by swapping with the last element
+ * @param {Array} array
+ * @param {number} index
+ */
+export function fastArrayDelete(array, index) {
+ if (index < 0 || index >= array.length) {
+ throw new Error("Out of bounds");
+ }
+ // When the element is not the last element
+ if (index !== array.length - 1) {
+ // Get the last element, and swap it with the one we want to delete
+ const last = array[array.length - 1];
+ array[index] = last;
+ }
+
+ // Finally remove the last element
+ array.length -= 1;
+}
+
+/**
+ * Deletes from an array by swapping with the last element. Searches
+ * for the value in the array first
+ * @param {Array} array
+ * @param {any} value
+ */
+export function fastArrayDeleteValue(array, value) {
+ if (array == null) {
+ throw new Error("Tried to delete from non array!");
+ }
+ const index = array.indexOf(value);
+ if (index < 0) {
+ console.error("Value", value, "not contained in array:", array, "!");
+ return value;
+ }
+ return fastArrayDelete(array, index);
+}
+
+/**
+ * @see fastArrayDeleteValue
+ * @param {Array} array
+ * @param {any} value
+ */
+export function fastArrayDeleteValueIfContained(array, value) {
+ if (array == null) {
+ throw new Error("Tried to delete from non array!");
+ }
+ const index = array.indexOf(value);
+ if (index < 0) {
+ return value;
+ }
+ return fastArrayDelete(array, index);
+}
+
+/**
+ * Deletes from an array at the given index
+ * @param {Array} array
+ * @param {number} index
+ */
+export function arrayDelete(array, index) {
+ if (index < 0 || index >= array.length) {
+ throw new Error("Out of bounds");
+ }
+ array.splice(index, 1);
+}
+
+/**
+ * Deletes the given value from an array
+ * @param {Array} array
+ * @param {any} value
+ */
+export function arrayDeleteValue(array, value) {
+ if (array == null) {
+ throw new Error("Tried to delete from non array!");
+ }
+ const index = array.indexOf(value);
+ if (index < 0) {
+ console.error("Value", value, "not contained in array:", array, "!");
+ return value;
+ }
+ return arrayDelete(array, index);
+}
+
+/**
+ * Compare two floats for epsilon equality
+ * @param {number} a
+ * @param {number} b
+ * @returns {boolean}
+ */
+export function epsilonCompare(a, b, epsilon = 1e-5) {
+ return Math.abs(a - b) < epsilon;
+}
+
+/**
+ * Interpolates two numbers
+ * @param {number} a
+ * @param {number} b
+ * @param {number} x Mix factor, 0 means 100% a, 1 means 100%b, rest is interpolated
+ */
+export function lerp(a, b, x) {
+ return a * (1 - x) + b * x;
+}
+
+/**
+ * Finds a value which is nice to display, e.g. 15669 -> 15000. Also handles fractional stuff
+ * @param {number} num
+ */
+export function findNiceValue(num) {
+ if (num > 1e8) {
+ return num;
+ }
+ if (num < 0.00001) {
+ return 0;
+ }
+
+ let roundAmount = 1;
+ if (num > 50000) {
+ roundAmount = 10000;
+ } else if (num > 20000) {
+ roundAmount = 5000;
+ } else if (num > 5000) {
+ roundAmount = 1000;
+ } else if (num > 2000) {
+ roundAmount = 500;
+ } else if (num > 1000) {
+ roundAmount = 100;
+ } else if (num > 100) {
+ roundAmount = 20;
+ } else if (num > 20) {
+ roundAmount = 5;
+ }
+
+ const niceValue = Math.floor(num / roundAmount) * roundAmount;
+ if (num >= 10) {
+ return Math.round(niceValue);
+ }
+ if (num >= 1) {
+ return Math.round(niceValue * 10) / 10;
+ }
+
+ return Math.round(niceValue * 100) / 100;
+}
+
+/**
+ * Finds a nice integer value
+ * @see findNiceValue
+ * @param {number} num
+ */
+export function findNiceIntegerValue(num) {
+ return Math.ceil(findNiceValue(num));
+}
+
+/**
+ * Formats a big number
+ * @param {number} num
+ * @param {string=} separator The decimal separator for numbers like 50.1 (separator='.')
+ * @returns {string}
+ */
+export function formatBigNumber(num, separator = T.global.decimalSeparator) {
+ const sign = num < 0 ? "-" : "";
+ num = Math.abs(num);
+
+ if (num > 1e54) {
+ return sign + T.global.infinite;
+ }
+
+ if (num < 10 && !Number.isInteger(num)) {
+ return sign + num.toFixed(2);
+ }
+ if (num < 50 && !Number.isInteger(num)) {
+ return sign + num.toFixed(1);
+ }
+ num = Math.floor(num);
+
+ if (num < 1000) {
+ return sign + "" + num;
+ } else {
+ let leadingDigits = num;
+ let suffix = "";
+ for (let suffixIndex = 0; suffixIndex < bigNumberSuffixTranslationKeys.length; ++suffixIndex) {
+ leadingDigits = leadingDigits / 1000;
+ suffix = T.global.suffix[bigNumberSuffixTranslationKeys[suffixIndex]];
+ if (leadingDigits < 1000) {
+ break;
+ }
+ }
+ const leadingDigitsRounded = round1Digit(leadingDigits);
+ const leadingDigitsNoTrailingDecimal = leadingDigitsRounded
+ .toString()
+ .replace(".0", "")
+ .replace(".", separator);
+ return sign + leadingDigitsNoTrailingDecimal + suffix;
+ }
+}
+
+/**
+ * Formats a big number, but does not add any suffix and instead uses its full representation
+ * @param {number} num
+ * @param {string=} divider The divider for numbers like 50,000 (divider=',')
+ * @returns {string}
+ */
+export function formatBigNumberFull(num, divider = T.global.thousandsDivider) {
+ if (num < 1000) {
+ return num + "";
+ }
+ if (num > 1e54) {
+ return T.global.infinite;
+ }
+ let rest = num;
+ let out = "";
+ while (rest >= 1000) {
+ out = (rest % 1000).toString().padStart(3, "0") + divider + out;
+ rest = Math.floor(rest / 1000);
+ }
+ out = rest + divider + out;
+
+ return out.substring(0, out.length - 1);
+}
+
+/**
+ * Waits two frames so the ui is updated
+ * @returns {Promise}
+ */
+export function waitNextFrame() {
+ return new Promise(function (resolve) {
+ window.requestAnimationFrame(function () {
+ window.requestAnimationFrame(function () {
+ resolve();
+ });
+ });
+ });
+}
+
+/**
+ * Rounds 1 digit
+ * @param {number} n
+ * @returns {number}
+ */
+export function round1Digit(n) {
+ return Math.floor(n * 10.0) / 10.0;
+}
+
+/**
+ * Rounds 2 digits
+ * @param {number} n
+ * @returns {number}
+ */
+export function round2Digits(n) {
+ return Math.floor(n * 100.0) / 100.0;
+}
+
+/**
+ * Rounds 3 digits
+ * @param {number} n
+ * @returns {number}
+ */
+export function round3Digits(n) {
+ return Math.floor(n * 1000.0) / 1000.0;
+}
+
+/**
+ * Rounds 4 digits
+ * @param {number} n
+ * @returns {number}
+ */
+export function round4Digits(n) {
+ return Math.floor(n * 10000.0) / 10000.0;
+}
+
+/**
+ * Clamps a value between [min, max]
+ * @param {number} v
+ * @param {number=} minimum Default 0
+ * @param {number=} maximum Default 1
+ */
+export function clamp(v, minimum = 0, maximum = 1) {
+ return Math.max(minimum, Math.min(maximum, v));
+}
+
+/**
+ * Helper method to create a new div element
+ * @param {string=} id
+ * @param {Array=} classes
+ * @param {string=} innerHTML
+ */
+export function makeDivElement(id = null, classes = [], innerHTML = "") {
+ const div = document.createElement("div");
+ if (id) {
+ div.id = id;
+ }
+ for (let i = 0; i < classes.length; ++i) {
+ div.classList.add(classes[i]);
+ }
+ div.innerHTML = innerHTML;
+ return div;
+}
+
+/**
+ * Helper method to create a new div
+ * @param {Element} parent
+ * @param {string=} id
+ * @param {Array=} classes
+ * @param {string=} innerHTML
+ */
+export function makeDiv(parent, id = null, classes = [], innerHTML = "") {
+ const div = makeDivElement(id, classes, innerHTML);
+ parent.appendChild(div);
+ return div;
+}
+
+/**
+ * Helper method to create a new button element
+ * @param {Array=} classes
+ * @param {string=} innerHTML
+ */
+export function makeButtonElement(classes = [], innerHTML = "") {
+ const element = document.createElement("button");
+ for (let i = 0; i < classes.length; ++i) {
+ element.classList.add(classes[i]);
+ }
+ element.classList.add("styledButton");
+ element.innerHTML = innerHTML;
+ return element;
+}
+
+/**
+ * Helper method to create a new button
+ * @param {Element} parent
+ * @param {Array=} classes
+ * @param {string=} innerHTML
+ */
+export function makeButton(parent, classes = [], innerHTML = "") {
+ const element = makeButtonElement(classes, innerHTML);
+ parent.appendChild(element);
+ return element;
+}
+
+/**
+ * Removes all children of the given element
+ * @param {Element} elem
+ */
+export function removeAllChildren(elem) {
+ if (elem) {
+ const range = document.createRange();
+ range.selectNodeContents(elem);
+ range.deleteContents();
+ }
+}
+
+/**
+ * Formats an amount of seconds into something like "5s ago"
+ * @param {number} secs Seconds
+ * @returns {string}
+ */
+export function formatSecondsToTimeAgo(secs) {
+ const seconds = Math.floor(secs);
+ const minutes = Math.floor(seconds / 60);
+ const hours = Math.floor(minutes / 60);
+ const days = Math.floor(hours / 24);
+
+ if (seconds < 60) {
+ if (seconds === 1) {
+ return T.global.time.oneSecondAgo;
+ }
+ return T.global.time.xSecondsAgo.replace("", "" + seconds);
+ } else if (minutes < 60) {
+ if (minutes === 1) {
+ return T.global.time.oneMinuteAgo;
+ }
+ return T.global.time.xMinutesAgo.replace("", "" + minutes);
+ } else if (hours < 24) {
+ if (hours === 1) {
+ return T.global.time.oneHourAgo;
+ }
+ return T.global.time.xHoursAgo.replace("", "" + hours);
+ } else {
+ if (days === 1) {
+ return T.global.time.oneDayAgo;
+ }
+ return T.global.time.xDaysAgo.replace("", "" + days);
+ }
+}
+
+/**
+ * Formats seconds into a readable string like "5h 23m"
+ * @param {number} secs Seconds
+ * @returns {string}
+ */
+export function formatSeconds(secs) {
+ const trans = T.global.time;
+ secs = Math.ceil(secs);
+ if (secs < 60) {
+ return trans.secondsShort.replace("", "" + secs);
+ } else if (secs < 60 * 60) {
+ const minutes = Math.floor(secs / 60);
+ const seconds = secs % 60;
+ return trans.minutesAndSecondsShort
+ .replace("", "" + seconds)
+ .replace("", "" + minutes);
+ } else {
+ const hours = Math.floor(secs / 3600);
+ const minutes = Math.floor(secs / 60) % 60;
+ return trans.hoursAndMinutesShort.replace("", "" + minutes).replace("", "" + hours);
+ }
+}
+
+/**
+ * Formats a number like 2.51 to "2.5"
+ * @param {number} speed
+ * @param {string=} separator The decimal separator for numbers like 50.1 (separator='.')
+ */
+export function round1DigitLocalized(speed, separator = T.global.decimalSeparator) {
+ return round1Digit(speed).toString().replace(".", separator);
+}
+
+/**
+ * Formats a number like 2.51 to "2.51 items / s"
+ * @param {number} speed
+ * @param {boolean=} double
+ * @param {string=} separator The decimal separator for numbers like 50.1 (separator='.')
+ */
+export function formatItemsPerSecond(speed, double = false, separator = T.global.decimalSeparator) {
+ return (
+ (speed === 1.0
+ ? T.ingame.buildingPlacement.infoTexts.oneItemPerSecond
+ : T.ingame.buildingPlacement.infoTexts.itemsPerSecond.replace(
+ "",
+ round2Digits(speed).toString().replace(".", separator)
+ )) + (double ? " " + T.ingame.buildingPlacement.infoTexts.itemsPerSecondDouble : "")
+ );
+}
+
+/**
+ * Rotates a flat 3x3 matrix clockwise
+ * Entries:
+ * 0 lo
+ * 1 mo
+ * 2 ro
+ * 3 lm
+ * 4 mm
+ * 5 rm
+ * 6 lu
+ * 7 mu
+ * 8 ru
+ * @param {Array} flatMatrix
+ */
+
+export function rotateFlatMatrix3x3(flatMatrix) {
+ return [
+ flatMatrix[6],
+ flatMatrix[3],
+ flatMatrix[0],
+ flatMatrix[7],
+ flatMatrix[4],
+ flatMatrix[1],
+ flatMatrix[8],
+ flatMatrix[5],
+ flatMatrix[2],
+ ];
+}
+
+/**
+ * Generates rotated variants of the matrix
+ * @param {Array} originalMatrix
+ * @returns {Object>}
+ */
+export function generateMatrixRotations(originalMatrix) {
+ const result = {
+ 0: originalMatrix,
+ };
+
+ originalMatrix = rotateFlatMatrix3x3(originalMatrix);
+ result[90] = originalMatrix;
+
+ originalMatrix = rotateFlatMatrix3x3(originalMatrix);
+ result[180] = originalMatrix;
+
+ originalMatrix = rotateFlatMatrix3x3(originalMatrix);
+ result[270] = originalMatrix;
+
+ return result;
+}
+
+/**
+ *
+ * @typedef {{
+ * top: any,
+ * right: any,
+ * bottom: any,
+ * left: any
+ * }} DirectionalObject
+ */
+
+/**
+ * Rotates a directional object
+ * @param {DirectionalObject} obj
+ * @returns {DirectionalObject}
+ */
+export function rotateDirectionalObject(obj, rotation) {
+ const queue = [obj.top, obj.right, obj.bottom, obj.left];
+ while (rotation !== 0) {
+ rotation -= 90;
+ queue.push(queue.shift());
+ }
+
+ return {
+ top: queue[0],
+ right: queue[1],
+ bottom: queue[2],
+ left: queue[3],
+ };
+}
+
+/**
+ * Modulo which works for negative numbers
+ * @param {number} n
+ * @param {number} m
+ */
+export function safeModulo(n, m) {
+ return ((n % m) + m) % m;
+}
+
+/**
+ * Returns a smooth pulse between 0 and 1
+ * @param {number} time time in seconds
+ * @returns {number}
+ */
+export function smoothPulse(time) {
+ return Math.sin(time * 4) * 0.5 + 0.5;
+}
+
+/**
+ * Fills in a tag
+ * @param {string} translation
+ * @param {string} link
+ */
+export function fillInLinkIntoTranslation(translation, link) {
+ return translation
+ .replace("", "")
+ .replace("", "");
+}
+
+const MAX_ROMAN_NUMBER = 49;
+const romanLiteralsCache = ["0"];
+
+/**
+ *
+ * @param {number} number
+ * @returns {string}
+ */
+export function getRomanNumber(number) {
+ number = Math.max(0, Math.round(number));
+ if (romanLiteralsCache[number]) {
+ return romanLiteralsCache[number];
+ }
+
+ if (number > MAX_ROMAN_NUMBER) {
+ return String(number);
+ }
+
+ function formatDigit(digit, unit, quintuple, decuple) {
+ switch (digit) {
+ case 0:
+ return "";
+ case 1: // I
+ return unit;
+ case 2: // II
+ return unit + unit;
+ case 3: // III
+ return unit + unit + unit;
+ case 4: // IV
+ return unit + quintuple;
+ case 9: // IX
+ return unit + decuple;
+ default:
+ // V, VI, VII, VIII
+ return quintuple + formatDigit(digit - 5, unit, quintuple, decuple);
+ }
+ }
+
+ let thousands = Math.floor(number / 1000);
+ let thousandsPart = "";
+ while (thousands > 0) {
+ thousandsPart += "M";
+ thousands -= 1;
+ }
+
+ const hundreds = Math.floor((number % 1000) / 100);
+ const hundredsPart = formatDigit(hundreds, "C", "D", "M");
+
+ const tens = Math.floor((number % 100) / 10);
+ const tensPart = formatDigit(tens, "X", "L", "C");
+
+ const units = number % 10;
+ const unitsPart = formatDigit(units, "I", "V", "X");
+
+ const formatted = thousandsPart + hundredsPart + tensPart + unitsPart;
+
+ romanLiteralsCache[number] = formatted;
+ return formatted;
+}
+
+/**
+ * Rejects a promise after X ms
+ * @param {Promise} promise
+ */
+export function timeoutPromise(promise, timeout = 30000) {
+ return Promise.race([
+ new Promise((resolve, reject) => {
+ setTimeout(() => reject("timeout of " + timeout + " ms exceeded"), timeout);
+ }),
+ promise,
+ ]);
+}
diff --git a/src/js/core/vector.js b/src/js/core/vector.js
index 50fa9433..9525f5b3 100644
--- a/src/js/core/vector.js
+++ b/src/js/core/vector.js
@@ -489,7 +489,6 @@ export class Vector {
}
default: {
assertAlways(false, "Invalid fast inplace rotation: " + angle);
- return this;
}
}
// return new Vector(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
@@ -519,7 +518,6 @@ export class Vector {
}
default: {
assertAlways(false, "Invalid fast inplace rotation: " + angle);
- return new Vector();
}
}
}
@@ -593,7 +591,6 @@ export class Vector {
}
default:
assertAlways(false, "Invalid angle: " + angle);
- return;
}
}
@@ -603,7 +600,7 @@ export class Vector {
* @returns {Boolean}
*/
equalsEpsilon(v, epsilon = 1e-5) {
- return Math.abs(this.x - v.x) < 1e-5 && Math.abs(this.y - v.y) < epsilon;
+ return Math.abs(this.x - v.x) < epsilon && Math.abs(this.y - v.y) < epsilon;
}
/**
diff --git a/src/js/game/achievement_proxy.js b/src/js/game/achievement_proxy.js
deleted file mode 100644
index 9077b283..00000000
--- a/src/js/game/achievement_proxy.js
+++ /dev/null
@@ -1,154 +0,0 @@
-/* typehints:start */
-import { Entity } from "./entity";
-import { GameRoot } from "./root";
-/* typehints:end */
-
-import { globalConfig } from "../core/config";
-import { createLogger } from "../core/logging";
-import { ACHIEVEMENTS } from "../platform/achievement_provider";
-import { getBuildingDataFromCode } from "./building_codes";
-
-const logger = createLogger("achievement_proxy");
-
-const ROTATER = "rotater";
-const DEFAULT = "default";
-
-export class AchievementProxy {
- /** @param {GameRoot} root */
- constructor(root) {
- this.root = root;
- this.provider = this.root.app.achievementProvider;
- this.disabled = true;
-
- if (G_IS_DEV && globalConfig.debug.testAchievements) {
- // still enable the proxy
- } else if (!this.provider.hasAchievements()) {
- return;
- }
-
- this.sliceTime = 0;
-
- this.root.signals.postLoadHook.add(this.onLoad, this);
- }
-
- onLoad() {
- if (!this.root.gameMode.hasAchievements()) {
- logger.log("Disabling achievements because game mode does not have achievements");
- this.disabled = true;
- return;
- }
-
- this.provider
- .onLoad(this.root)
- .then(() => {
- this.disabled = false;
- logger.log("Recieving achievement signals");
- this.initialize();
- })
- .catch(err => {
- this.disabled = true;
- logger.error("Ignoring achievement signals", err);
- });
- }
-
- initialize() {
- this.root.signals.achievementCheck.dispatch(ACHIEVEMENTS.darkMode, null);
-
- if (this.has(ACHIEVEMENTS.mam)) {
- this.root.signals.entityAdded.add(this.onMamFailure, this);
- this.root.signals.entityDestroyed.add(this.onMamFailure, this);
- this.root.signals.storyGoalCompleted.add(this.onStoryGoalCompleted, this);
- }
-
- if (this.has(ACHIEVEMENTS.noInverseRotater)) {
- this.root.signals.entityAdded.add(this.onEntityAdded, this);
- }
-
- this.startSlice();
- }
-
- startSlice() {
- this.sliceTime = this.root.time.now();
-
- this.root.signals.bulkAchievementCheck.dispatch(
- ACHIEVEMENTS.storeShape,
- this.sliceTime,
- ACHIEVEMENTS.throughputBp25,
- this.sliceTime,
- ACHIEVEMENTS.throughputBp50,
- this.sliceTime,
- ACHIEVEMENTS.throughputLogo25,
- this.sliceTime,
- ACHIEVEMENTS.throughputLogo50,
- this.sliceTime,
- ACHIEVEMENTS.throughputRocket10,
- this.sliceTime,
- ACHIEVEMENTS.throughputRocket20,
- this.sliceTime,
- ACHIEVEMENTS.play1h,
- this.sliceTime,
- ACHIEVEMENTS.play10h,
- this.sliceTime,
- ACHIEVEMENTS.play20h,
- this.sliceTime
- );
- }
-
- update() {
- if (this.disabled) {
- return;
- }
-
- if (this.root.time.now() - this.sliceTime > globalConfig.achievementSliceDuration) {
- this.startSlice();
- }
- }
-
- /**
- * @param {string} key
- * @returns {boolean}
- */
- has(key) {
- if (!this.provider.collection) {
- return false;
- }
- return this.provider.collection.map.has(key);
- }
-
- /** @param {Entity} entity */
- onEntityAdded(entity) {
- if (!entity.components.StaticMapEntity) {
- return;
- }
-
- const building = getBuildingDataFromCode(entity.components.StaticMapEntity.code);
-
- if (building.metaInstance.id !== ROTATER) {
- return;
- }
-
- if (building.variant === DEFAULT) {
- return;
- }
-
- this.root.savegame.currentData.stats.usedInverseRotater = true;
- this.root.signals.entityAdded.remove(this.onEntityAdded);
- }
-
- /** @param {number} level */
- onStoryGoalCompleted(level) {
- if (level > 26) {
- this.root.signals.entityAdded.add(this.onMamFailure, this);
- this.root.signals.entityDestroyed.add(this.onMamFailure, this);
- }
-
- this.root.signals.achievementCheck.dispatch(ACHIEVEMENTS.mam, null);
-
- // reset on every level
- this.root.savegame.currentData.stats.failedMam = false;
- }
-
- onMamFailure() {
- this.root.savegame.currentData.stats.failedMam = true;
- }
-}
diff --git a/src/js/game/automatic_save.js b/src/js/game/automatic_save.js
index 9d841966..eeccfe78 100644
--- a/src/js/game/automatic_save.js
+++ b/src/js/game/automatic_save.js
@@ -1,79 +1,79 @@
-import { globalConfig } from "../core/config";
-import { createLogger } from "../core/logging";
-import { GameRoot } from "./root";
-
-// How important it is that a savegame is created
-/**
- * @enum {number}
- */
-export const enumSavePriority = {
- regular: 2,
- asap: 100,
-};
-
-const logger = createLogger("autosave");
-
-export class AutomaticSave {
- constructor(root) {
- /** @type {GameRoot} */
- this.root = root;
-
- // Store the current maximum save importance
- this.saveImportance = enumSavePriority.regular;
-
- this.lastSaveAttempt = -1000;
- }
-
- setSaveImportance(importance) {
- this.saveImportance = Math.max(this.saveImportance, importance);
- }
-
- doSave() {
- if (G_IS_DEV && globalConfig.debug.disableSavegameWrite) {
- return;
- }
-
- this.root.gameState.doSave();
- this.saveImportance = enumSavePriority.regular;
- }
-
- update() {
- if (!this.root.gameInitialized) {
- // Bad idea
- return;
- }
-
- const saveInterval = this.root.app.settings.getAutosaveIntervalSeconds();
- if (!saveInterval) {
- // Disabled
- return;
- }
-
- // Check when the last save was, but make sure that if it fails, we don't spam
- const lastSaveTime = Math.max(this.lastSaveAttempt, this.root.savegame.getRealLastUpdate());
-
- const secondsSinceLastSave = (Date.now() - lastSaveTime) / 1000.0;
- let shouldSave = false;
-
- switch (this.saveImportance) {
- case enumSavePriority.asap:
- // High always should save
- shouldSave = true;
- break;
-
- case enumSavePriority.regular:
- // Could determine if there is a good / bad point here
- shouldSave = secondsSinceLastSave > saveInterval;
- break;
-
- default:
- assert(false, "Unknown save prio: " + this.saveImportance);
- break;
- }
- if (shouldSave) {
- logger.log("Saving automatically");
- this.lastSaveAttempt = Date.now();
- this.doSave();
- }
- }
-}
+import { globalConfig } from "../core/config";
+import { createLogger } from "../core/logging";
+import { GameRoot } from "./root";
+
+// How important it is that a savegame is created
+/**
+ * @enum {number}
+ */
+export const enumSavePriority = {
+ regular: 2,
+ asap: 100,
+};
+
+const logger = createLogger("autosave");
+
+export class AutomaticSave {
+ constructor(root) {
+ /** @type {GameRoot} */
+ this.root = root;
+
+ // Store the current maximum save importance
+ this.saveImportance = enumSavePriority.regular;
+
+ this.lastSaveAttempt = -1000;
+ }
+
+ setSaveImportance(importance) {
+ this.saveImportance = Math.max(this.saveImportance, importance);
+ }
+
+ doSave() {
+ if (G_IS_DEV && globalConfig.debug.disableSavegameWrite) {
+ return;
+ }
+
+ this.root.gameState.doSave();
+ this.saveImportance = enumSavePriority.regular;
+ }
+
+ update() {
+ if (!this.root.gameInitialized) {
+ // Bad idea
+ return;
+ }
+
+ const saveInterval = this.root.app.settings.getAutosaveIntervalSeconds();
+ if (!saveInterval) {
+ // Disabled
+ return;
+ }
+
+ // Check when the last save was, but make sure that if it fails, we don't spam
+ const lastSaveTime = Math.max(this.lastSaveAttempt, this.root.savegame.getRealLastUpdate());
+
+ const secondsSinceLastSave = (Date.now() - lastSaveTime) / 1000.0;
+ let shouldSave = false;
+
+ switch (this.saveImportance) {
+ case enumSavePriority.asap:
+ // High always should save
+ shouldSave = true;
+ break;
+
+ case enumSavePriority.regular:
+ // Could determine if there is a good / bad point here
+ shouldSave = secondsSinceLastSave > saveInterval;
+ break;
+
+ default:
+ assert(false, "Unknown save prio: " + this.saveImportance);
+ break;
+ }
+ if (shouldSave) {
+ logger.log("Saving automatically");
+ this.lastSaveAttempt = Date.now();
+ this.doSave();
+ }
+ }
+}
diff --git a/src/js/game/base_item.js b/src/js/game/base_item.js
index a6b38a08..d5861415 100644
--- a/src/js/game/base_item.js
+++ b/src/js/game/base_item.js
@@ -1,101 +1,101 @@
-import { globalConfig } from "../core/config";
-import { DrawParameters } from "../core/draw_parameters";
-import { BasicSerializableObject } from "../savegame/serialization";
-
-/**
- * Class for items on belts etc. Not an entity for performance reasons
- */
-export class BaseItem extends BasicSerializableObject {
- constructor() {
- super();
- this._type = this.getItemType();
- }
-
- static getId() {
- return "base_item";
- }
-
- /** @returns {import("../savegame/serialization").Schema} */
- static getSchema() {
- return {};
- }
-
- /** @returns {ItemType} **/
- getItemType() {
- abstract;
- return "shape";
- }
-
- /**
- * Returns a string id of the item
- * @returns {string}
- * @abstract
- */
- getAsCopyableKey() {
- abstract;
- return "";
- }
-
- /**
- * Returns if the item equals the other itme
- * @param {BaseItem} other
- * @returns {boolean}
- */
- equals(other) {
- if (this.getItemType() !== other.getItemType()) {
- return false;
- }
- return this.equalsImpl(other);
- }
-
- /**
- * Override for custom comparison
- * @param {BaseItem} other
- * @returns {boolean}
- * @abstract
- */
- equalsImpl(other) {
- abstract;
- return false;
- }
-
- /**
- * Draws the item to a canvas
- * @param {CanvasRenderingContext2D} context
- * @param {number} size
- * @abstract
- */
- drawFullSizeOnCanvas(context, size) {
- abstract;
- }
-
- /**
- * Draws the item at the given position
- * @param {number} x
- * @param {number} y
- * @param {DrawParameters} parameters
- * @param {number=} diameter
- */
- drawItemCenteredClipped(x, y, parameters, diameter = globalConfig.defaultItemDiameter) {
- if (parameters.visibleRect.containsCircle(x, y, diameter / 2)) {
- this.drawItemCenteredImpl(x, y, parameters, diameter);
- }
- }
-
- /**
- * INTERNAL
- * @param {number} x
- * @param {number} y
- * @param {DrawParameters} parameters
- * @param {number=} diameter
- * @abstract
- */
- drawItemCenteredImpl(x, y, parameters, diameter = globalConfig.defaultItemDiameter) {
- abstract;
- }
-
- getBackgroundColorAsResource() {
- abstract;
- return "";
- }
-}
+import { globalConfig } from "../core/config";
+import { DrawParameters } from "../core/draw_parameters";
+import { BasicSerializableObject } from "../savegame/serialization";
+
+/**
+ * Class for items on belts etc. Not an entity for performance reasons
+ */
+export class BaseItem extends BasicSerializableObject {
+ constructor() {
+ super();
+ this._type = this.getItemType();
+ }
+
+ static getId() {
+ return "base_item";
+ }
+
+ /** @returns {import("../savegame/serialization").Schema} */
+ static getSchema() {
+ return {};
+ }
+
+ /** @returns {ItemType} **/
+ getItemType() {
+ abstract;
+ return "shape";
+ }
+
+ /**
+ * Returns a string id of the item
+ * @returns {string}
+ * @abstract
+ */
+ getAsCopyableKey() {
+ abstract;
+ return "";
+ }
+
+ /**
+ * Returns if the item equals the other itme
+ * @param {BaseItem} other
+ * @returns {boolean}
+ */
+ equals(other) {
+ if (this.getItemType() !== other.getItemType()) {
+ return false;
+ }
+ return this.equalsImpl(other);
+ }
+
+ /**
+ * Override for custom comparison
+ * @param {BaseItem} other
+ * @returns {boolean}
+ * @abstract
+ */
+ equalsImpl(other) {
+ abstract;
+ return false;
+ }
+
+ /**
+ * Draws the item to a canvas
+ * @param {CanvasRenderingContext2D} context
+ * @param {number} size
+ * @abstract
+ */
+ drawFullSizeOnCanvas(context, size) {
+ abstract;
+ }
+
+ /**
+ * Draws the item at the given position
+ * @param {number} x
+ * @param {number} y
+ * @param {DrawParameters} parameters
+ * @param {number=} diameter
+ */
+ drawItemCenteredClipped(x, y, parameters, diameter = globalConfig.defaultItemDiameter) {
+ if (parameters.visibleRect.containsCircle(x, y, diameter / 2)) {
+ this.drawItemCenteredImpl(x, y, parameters, diameter);
+ }
+ }
+
+ /**
+ * INTERNAL
+ * @param {number} x
+ * @param {number} y
+ * @param {DrawParameters} parameters
+ * @param {number=} diameter
+ * @abstract
+ */
+ drawItemCenteredImpl(x, y, parameters, diameter = globalConfig.defaultItemDiameter) {
+ abstract;
+ }
+
+ getBackgroundColorAsResource() {
+ abstract;
+ return "";
+ }
+}
diff --git a/src/js/game/belt_path.js b/src/js/game/belt_path.js
index 9ef4a3f3..dbb298a1 100644
--- a/src/js/game/belt_path.js
+++ b/src/js/game/belt_path.js
@@ -1,1661 +1,1662 @@
-import { globalConfig } from "../core/config";
-import { smoothenDpi } from "../core/dpi_manager";
-import { DrawParameters } from "../core/draw_parameters";
-import { createLogger } from "../core/logging";
-import { Rectangle } from "../core/rectangle";
-import { ORIGINAL_SPRITE_SCALE } from "../core/sprites";
-import { clamp, epsilonCompare, round4Digits } from "../core/utils";
-import { enumDirection, enumDirectionToVector, enumInvertedDirections, Vector } from "../core/vector";
-import { BasicSerializableObject, types } from "../savegame/serialization";
-import { BaseItem } from "./base_item";
-import { Entity } from "./entity";
-import { typeItemSingleton } from "./item_resolver";
-import { GameRoot } from "./root";
-
-const logger = createLogger("belt_path");
-
-// Helpers for more semantic access into interleaved arrays
-
-const DEBUG = G_IS_DEV && false;
-
-/**
- * Stores a path of belts, used for optimizing performance
- */
-export class BeltPath extends BasicSerializableObject {
- static getId() {
- return "BeltPath";
- }
-
- static getSchema() {
- return {
- entityPath: types.array(types.entity),
- items: types.array(types.pair(types.ufloat, typeItemSingleton)),
- spacingToFirstItem: types.ufloat,
- };
- }
-
- /**
- * Creates a path from a serialized object
- * @param {GameRoot} root
- * @param {Object} data
- * @returns {BeltPath|string}
- */
- static fromSerialized(root, data) {
- // Create fake object which looks like a belt path but skips the constructor
- const fakeObject = /** @type {BeltPath} */ (Object.create(BeltPath.prototype));
- fakeObject.root = root;
-
- // Deserialize the data
- const errorCodeDeserialize = fakeObject.deserialize(data);
- if (errorCodeDeserialize) {
- return errorCodeDeserialize;
- }
-
- // Compute other properties
- fakeObject.init(false);
-
- return fakeObject;
- }
-
- /**
- * @param {GameRoot} root
- * @param {Array} entityPath
- */
- constructor(root, entityPath) {
- super();
- this.root = root;
-
- assert(entityPath.length > 0, "invalid entity path");
- this.entityPath = entityPath;
-
- /**
- * Stores the items sorted, and their distance to the previous item (or start)
- * Layout: [distanceToNext, item]
- * @type {Array<[number, BaseItem]>}
- */
- this.items = [];
-
- /**
- * Stores the spacing to the first item
- */
-
- this.init();
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("constructor");
- }
- }
- /**
- * Initializes the path by computing the properties which are not saved
- * @param {boolean} computeSpacing Whether to also compute the spacing
- */
- init(computeSpacing = true) {
- this.onPathChanged();
-
- this.totalLength = this.computeTotalLength();
-
- if (computeSpacing) {
- this.spacingToFirstItem = this.totalLength;
- }
-
- /**
- * Current bounds of this path
- * @type {Rectangle}
- */
- this.worldBounds = this.computeBounds();
-
- // Connect the belts
- for (let i = 0; i < this.entityPath.length; ++i) {
- this.entityPath[i].components.Belt.assignedPath = this;
- }
- }
-
- /**
- * Clears all items
- */
- clearAllItems() {
- this.items = [];
- this.spacingToFirstItem = this.totalLength;
- this.numCompressedItemsAfterFirstItem = 0;
- }
-
- /**
- * Returns whether this path can accept a new item
- * @returns {boolean}
- */
- canAcceptItem() {
- return this.spacingToFirstItem >= globalConfig.itemSpacingOnBelts;
- }
-
- /**
- * Tries to accept the item
- * @param {BaseItem} item
- */
- tryAcceptItem(item) {
- if (this.spacingToFirstItem >= globalConfig.itemSpacingOnBelts) {
- // So, since we already need one tick to accept this item we will add this directly.
- const beltProgressPerTick =
- this.root.hubGoals.getBeltBaseSpeed() *
- this.root.dynamicTickrate.deltaSeconds *
- globalConfig.itemSpacingOnBelts;
-
- // First, compute how much progress we can make *at max*
- const maxProgress = Math.max(0, this.spacingToFirstItem - globalConfig.itemSpacingOnBelts);
- const initialProgress = Math.min(maxProgress, beltProgressPerTick);
-
- this.items.unshift([this.spacingToFirstItem - initialProgress, item]);
- this.spacingToFirstItem = initialProgress;
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("accept-item");
- }
-
- return true;
- }
- return false;
- }
-
- /**
- * SLOW / Tries to find the item closest to the given tile
- * @param {Vector} tile
- * @returns {BaseItem|null}
- */
- findItemAtTile(tile) {
- // @TODO: This breaks color blind mode otherwise
- return null;
- }
-
- /**
- * Computes the tile bounds of the path
- * @returns {Rectangle}
- */
- computeBounds() {
- let bounds = this.entityPath[0].components.StaticMapEntity.getTileSpaceBounds();
- for (let i = 1; i < this.entityPath.length; ++i) {
- const staticComp = this.entityPath[i].components.StaticMapEntity;
- const otherBounds = staticComp.getTileSpaceBounds();
- bounds = bounds.getUnion(otherBounds);
- }
- return bounds.allScaled(globalConfig.tileSize);
- }
-
- /**
- * Recomputes cache variables once the path was changed
- */
- onPathChanged() {
- this.boundAcceptor = this.computeAcceptingEntityAndSlot().acceptor;
-
- /**
- * How many items past the first item are compressed
- */
- this.numCompressedItemsAfterFirstItem = 0;
- }
-
- /**
- * Called by the belt system when the surroundings changed
- */
- onSurroundingsChanged() {
- this.onPathChanged();
- }
-
- /**
- * Finds the entity which accepts our items
- * @param {boolean=} debug_Silent Whether debug output should be silent
- * @return { { acceptor?: (BaseItem, number?) => boolean, entity?: Entity } }
- */
- computeAcceptingEntityAndSlot(debug_Silent = false) {
- DEBUG && !debug_Silent && logger.log("Recomputing acceptor target");
-
- const lastEntity = this.entityPath[this.entityPath.length - 1];
- const lastStatic = lastEntity.components.StaticMapEntity;
- const lastBeltComp = lastEntity.components.Belt;
-
- // Figure out where and into which direction we eject items
- const ejectSlotWsTile = lastStatic.localTileToWorld(new Vector(0, 0));
- const ejectSlotWsDirection = lastStatic.localDirectionToWorld(lastBeltComp.direction);
- const ejectSlotWsDirectionVector = enumDirectionToVector[ejectSlotWsDirection];
- const ejectSlotTargetWsTile = ejectSlotWsTile.add(ejectSlotWsDirectionVector);
-
- // Try to find the given acceptor component to take the item
- const targetEntity = this.root.map.getLayerContentXY(
- ejectSlotTargetWsTile.x,
- ejectSlotTargetWsTile.y,
- "regular"
- );
-
- if (!targetEntity) {
- return {};
- }
-
- const noSimplifiedBelts = !this.root.app.settings.getAllSettings().simplifiedBelts;
-
- DEBUG && !debug_Silent && logger.log(" Found target entity", targetEntity.uid);
- const targetStaticComp = targetEntity.components.StaticMapEntity;
- const targetBeltComp = targetEntity.components.Belt;
-
- // Check for belts (special case)
- if (targetBeltComp) {
- const beltAcceptingDirection = targetStaticComp.localDirectionToWorld(enumDirection.top);
- DEBUG &&
- !debug_Silent &&
- logger.log(
- " Entity is accepting items from",
- ejectSlotWsDirection,
- "vs",
- beltAcceptingDirection,
- "Rotation:",
- targetStaticComp.rotation
- );
- if (ejectSlotWsDirection === beltAcceptingDirection) {
- return {
- entity: targetEntity,
- acceptor: item => {
- const path = targetBeltComp.assignedPath;
- assert(path, "belt has no path");
- return path.tryAcceptItem(item);
- },
- };
- }
- }
-
- // Check for item acceptors
- const targetAcceptorComp = targetEntity.components.ItemAcceptor;
- if (!targetAcceptorComp) {
- // Entity doesn't accept items
- return {};
- }
-
- const ejectingDirection = targetStaticComp.worldDirectionToLocal(ejectSlotWsDirection);
- const matchingSlot = targetAcceptorComp.findMatchingSlot(
- targetStaticComp.worldToLocalTile(ejectSlotTargetWsTile),
- ejectingDirection
- );
-
- if (!matchingSlot) {
- // No matching slot found
- return {};
- }
-
- const matchingSlotIndex = matchingSlot.index;
- const passOver = this.computePassOverFunctionWithoutBelts(targetEntity, matchingSlotIndex);
- if (!passOver) {
- return {};
- }
-
- const matchingDirection = enumInvertedDirections[ejectingDirection];
- const filter = matchingSlot.slot.filter;
-
- return {
- entity: targetEntity,
- acceptor: function (item, remainingProgress = 0.0) {
- // Check if the acceptor has a filter
- if (filter && item._type !== filter) {
- return false;
- }
-
- // Try to pass over
- if (passOver(item, matchingSlotIndex)) {
- // Trigger animation on the acceptor comp
- if (noSimplifiedBelts) {
- targetAcceptorComp.onItemAccepted(
- matchingSlotIndex,
- matchingDirection,
- item,
- remainingProgress
- );
- }
- return true;
- }
- return false;
- },
- };
- }
-
- /**
- * Computes a method to pass over the item to the entity
- * @param {Entity} entity
- * @param {number} matchingSlotIndex
- * @returns {(item: BaseItem, slotIndex: number) => boolean | void}
- */
- computePassOverFunctionWithoutBelts(entity, matchingSlotIndex) {
- const systems = this.root.systemMgr.systems;
- const hubGoals = this.root.hubGoals;
-
- // NOTICE: THIS IS COPIED FROM THE ITEM EJECTOR SYSTEM FOR PEROFMANCE REASONS
-
- const itemProcessorComp = entity.components.ItemProcessor;
- if (itemProcessorComp) {
- // Its an item processor ..
- return function (item) {
- // Check for potential filters
- if (!systems.itemProcessor.checkRequirements(entity, item, matchingSlotIndex)) {
- return;
- }
- return itemProcessorComp.tryTakeItem(item, matchingSlotIndex);
- };
- }
-
- const undergroundBeltComp = entity.components.UndergroundBelt;
- if (undergroundBeltComp) {
- // Its an underground belt. yay.
- return function (item) {
- return undergroundBeltComp.tryAcceptExternalItem(
- item,
- hubGoals.getUndergroundBeltBaseSpeed()
- );
- };
- }
-
- const storageComp = entity.components.Storage;
- if (storageComp) {
- // It's a storage
- return function (item) {
- if (storageComp.canAcceptItem(item)) {
- storageComp.takeItem(item);
- return true;
- }
- };
- }
-
- const filterComp = entity.components.Filter;
- if (filterComp) {
- // It's a filter! Unfortunately the filter has to know a lot about it's
- // surrounding state and components, so it can't be within the component itself.
- return function (item) {
- if (systems.filter.tryAcceptItem(entity, matchingSlotIndex, item)) {
- return true;
- }
- };
- }
- }
-
- // Following code will be compiled out outside of dev versions
- /* dev:start */
-
- /**
- * Helper to throw an error on mismatch
- * @param {string} change
- * @param {Array} reason
- */
- debug_failIntegrity(change, ...reason) {
- throw new Error("belt path invalid (" + change + "): " + reason.map(i => "" + i).join(" "));
- }
-
- /**
- * Checks if this path is valid
- */
- debug_checkIntegrity(currentChange = "change") {
- const fail = (...args) => this.debug_failIntegrity(currentChange, ...args);
-
- // Check for empty path
- if (this.entityPath.length === 0) {
- return fail("Belt path is empty");
- }
-
- // Check for mismatching length
- const totalLength = this.computeTotalLength();
- if (!epsilonCompare(this.totalLength, totalLength, 0.01)) {
- return this.debug_failIntegrity(
- currentChange,
- "Total length mismatch, stored =",
- this.totalLength,
- "but correct is",
- totalLength
- );
- }
-
- // Check for misconnected entities
- for (let i = 0; i < this.entityPath.length - 1; ++i) {
- const entity = this.entityPath[i];
- if (entity.destroyed) {
- return fail("Reference to destroyed entity " + entity.uid);
- }
-
- const followUp = this.root.systemMgr.systems.belt.findFollowUpEntity(entity);
- if (!followUp) {
- return fail(
- "Follow up entity for the",
- i,
- "-th entity (total length",
- this.entityPath.length,
- ") was null!"
- );
- }
- if (followUp !== this.entityPath[i + 1]) {
- return fail(
- "Follow up entity mismatch, stored is",
- this.entityPath[i + 1].uid,
- "but real one is",
- followUp.uid
- );
- }
- if (entity.components.Belt.assignedPath !== this) {
- return fail(
- "Entity with uid",
- entity.uid,
- "doesn't have this path assigned, but this path contains the entity."
- );
- }
- }
-
- // Check spacing
- if (this.spacingToFirstItem > this.totalLength + 0.005) {
- return fail(
- currentChange,
- "spacing to first item (",
- this.spacingToFirstItem,
- ") is greater than total length (",
- this.totalLength,
- ")"
- );
- }
-
- // Check distance if empty
- if (this.items.length === 0 && !epsilonCompare(this.spacingToFirstItem, this.totalLength, 0.01)) {
- return fail(
- currentChange,
- "Path is empty but spacing to first item (",
- this.spacingToFirstItem,
- ") does not equal total length (",
- this.totalLength,
- ")"
- );
- }
-
- // Check items etc
- let currentPos = this.spacingToFirstItem;
- for (let i = 0; i < this.items.length; ++i) {
- const item = this.items[i];
-
- if (item[0 /* nextDistance */] < 0 || item[0 /* nextDistance */] > this.totalLength + 0.02) {
- return fail(
- "Item has invalid offset to next item: ",
- item[0 /* nextDistance */],
- "(total length:",
- this.totalLength,
- ")"
- );
- }
-
- currentPos += item[0 /* nextDistance */];
- }
-
- // Check the total sum matches
- if (!epsilonCompare(currentPos, this.totalLength, 0.01)) {
- return fail(
- "total sum (",
- currentPos,
- ") of first item spacing (",
- this.spacingToFirstItem,
- ") and items does not match total length (",
- this.totalLength,
- ") -> items: " + this.items.map(i => i[0 /* nextDistance */]).join("|")
- );
- }
-
- // Check bounds
- const actualBounds = this.computeBounds();
- if (!actualBounds.equalsEpsilon(this.worldBounds, 0.01)) {
- return fail("Bounds are stale");
- }
-
- // Check acceptor
- const acceptor = this.computeAcceptingEntityAndSlot(true).acceptor;
- if (!!acceptor !== !!this.boundAcceptor) {
- return fail("Acceptor target mismatch, acceptor", !!acceptor, "vs stored", !!this.boundAcceptor);
- }
-
- // Check first nonzero offset
- let firstNonzero = 0;
- for (let i = this.items.length - 2; i >= 0; --i) {
- if (this.items[i][0 /* nextDistance */] < globalConfig.itemSpacingOnBelts + 1e-5) {
- ++firstNonzero;
- } else {
- break;
- }
- }
-
- // Should warn, but this check isn't actually accurate
- // if (firstNonzero !== this.numCompressedItemsAfterFirstItem) {
- // console.warn(
- // "First nonzero index is " +
- // firstNonzero +
- // " but stored is " +
- // this.numCompressedItemsAfterFirstItem
- // );
- // }
- }
-
- /* dev:end */
-
- /**
- * Extends the belt path by the given belt
- * @param {Entity} entity
- */
- extendOnEnd(entity) {
- DEBUG && logger.log("Extending belt path by entity at", entity.components.StaticMapEntity.origin);
-
- const beltComp = entity.components.Belt;
-
- // Append the entity
- this.entityPath.push(entity);
- this.onPathChanged();
-
- // Extend the path length
- const additionalLength = beltComp.getEffectiveLengthTiles();
- this.totalLength += additionalLength;
- DEBUG && logger.log(" Extended total length by", additionalLength, "to", this.totalLength);
-
- // If we have no item, just update the distance to the first item
- if (this.items.length === 0) {
- this.spacingToFirstItem = this.totalLength;
- DEBUG && logger.log(" Extended spacing to first to", this.totalLength, "(= total length)");
- } else {
- // Otherwise, update the next-distance of the last item
- const lastItem = this.items[this.items.length - 1];
- DEBUG &&
- logger.log(
- " Extended spacing of last item from",
- lastItem[0 /* nextDistance */],
- "to",
- lastItem[0 /* nextDistance */] + additionalLength
- );
- lastItem[0 /* nextDistance */] += additionalLength;
- }
-
- // Assign reference
- beltComp.assignedPath = this;
-
- // Update bounds
- this.worldBounds = this.computeBounds();
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("extend-on-end");
- }
- }
-
- /**
- * Extends the path with the given entity on the beginning
- * @param {Entity} entity
- */
- extendOnBeginning(entity) {
- const beltComp = entity.components.Belt;
-
- DEBUG && logger.log("Extending the path on the beginning");
-
- // All items on that belt are simply lost (for now)
-
- const length = beltComp.getEffectiveLengthTiles();
-
- // Extend the length of this path
- this.totalLength += length;
-
- // Simply adjust the first item spacing cuz we have no items contained
- this.spacingToFirstItem += length;
-
- // Set handles and append entity
- beltComp.assignedPath = this;
- this.entityPath.unshift(entity);
- this.onPathChanged();
-
- // Update bounds
- this.worldBounds = this.computeBounds();
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("extend-on-begin");
- }
- }
-
- /**
- * Returns if the given entity is the end entity of the path
- * @param {Entity} entity
- * @returns {boolean}
- */
- isEndEntity(entity) {
- return this.entityPath[this.entityPath.length - 1] === entity;
- }
-
- /**
- * Returns if the given entity is the start entity of the path
- * @param {Entity} entity
- * @returns {boolean}
- */
- isStartEntity(entity) {
- return this.entityPath[0] === entity;
- }
-
- /**
- * Splits this path at the given entity by removing it, and
- * returning the new secondary paht
- * @param {Entity} entity
- * @returns {BeltPath}
- */
- deleteEntityOnPathSplitIntoTwo(entity) {
- DEBUG && logger.log("Splitting path at entity", entity.components.StaticMapEntity.origin);
-
- // First, find where the current path ends
- const beltComp = entity.components.Belt;
- beltComp.assignedPath = null;
-
- const entityLength = beltComp.getEffectiveLengthTiles();
- assert(this.entityPath.indexOf(entity) >= 0, "Entity not contained for split");
- assert(this.entityPath.indexOf(entity) !== 0, "Entity is first");
- assert(this.entityPath.indexOf(entity) !== this.entityPath.length - 1, "Entity is last");
-
- let firstPathEntityCount = 0;
- let firstPathLength = 0;
- let firstPathEndEntity = null;
-
- for (let i = 0; i < this.entityPath.length; ++i) {
- const otherEntity = this.entityPath[i];
- if (otherEntity === entity) {
- DEBUG && logger.log("Found entity at", i, "of length", firstPathLength);
- break;
- }
-
- ++firstPathEntityCount;
- firstPathEndEntity = otherEntity;
- firstPathLength += otherEntity.components.Belt.getEffectiveLengthTiles();
- }
-
- DEBUG &&
- logger.log(
- "First path ends at",
- firstPathLength,
- "and entity",
- firstPathEndEntity.components.StaticMapEntity.origin,
- "and has",
- firstPathEntityCount,
- "entities"
- );
-
- // Compute length of second path
- const secondPathLength = this.totalLength - firstPathLength - entityLength;
- const secondPathStart = firstPathLength + entityLength;
- const secondEntities = this.entityPath.splice(firstPathEntityCount + 1);
- DEBUG &&
- logger.log(
- "Second path starts at",
- secondPathStart,
- "and has a length of ",
- secondPathLength,
- "with",
- secondEntities.length,
- "entities"
- );
-
- // Remove the last item
- this.entityPath.pop();
-
- DEBUG && logger.log("Splitting", this.items.length, "items");
- DEBUG &&
- logger.log(
- "Old items are",
- this.items.map(i => i[0 /* nextDistance */])
- );
-
- // Create second path
- const secondPath = new BeltPath(this.root, secondEntities);
-
- // Remove all items which are no longer relevant and transfer them to the second path
- let itemPos = this.spacingToFirstItem;
- for (let i = 0; i < this.items.length; ++i) {
- const item = this.items[i];
- const distanceToNext = item[0 /* nextDistance */];
-
- DEBUG && logger.log(" Checking item at", itemPos, "with distance of", distanceToNext, "to next");
-
- // Check if this item is past the first path
- if (itemPos >= firstPathLength) {
- // Remove it from the first path
- this.items.splice(i, 1);
- i -= 1;
- DEBUG &&
- logger.log(" Removed item from first path since its no longer contained @", itemPos);
-
- // Check if its on the second path (otherwise its on the removed belt and simply lost)
- if (itemPos >= secondPathStart) {
- // Put item on second path
- secondPath.items.push([distanceToNext, item[1 /* item */]]);
- DEBUG &&
- logger.log(
- " Put item to second path @",
- itemPos,
- "with distance to next =",
- distanceToNext
- );
-
- // If it was the first item, adjust the distance to the first item
- if (secondPath.items.length === 1) {
- DEBUG && logger.log(" Sinc it was the first, set sapcing of first to", itemPos);
- secondPath.spacingToFirstItem = itemPos - secondPathStart;
- }
- } else {
- DEBUG && logger.log(" Item was on the removed belt, so its gone - forever!");
- }
- } else {
- // Seems this item is on the first path (so all good), so just make sure it doesn't
- // have a nextDistance which is bigger than the total path length
- const clampedDistanceToNext = Math.min(itemPos + distanceToNext, firstPathLength) - itemPos;
- if (clampedDistanceToNext < distanceToNext) {
- DEBUG &&
- logger.log(
- "Correcting next distance (first path) from",
- distanceToNext,
- "to",
- clampedDistanceToNext
- );
- item[0 /* nextDistance */] = clampedDistanceToNext;
- }
- }
-
- // Advance items
- itemPos += distanceToNext;
- }
-
- DEBUG &&
- logger.log(
- "New items are",
- this.items.map(i => i[0 /* nextDistance */])
- );
-
- DEBUG &&
- logger.log(
- "And second path items are",
- secondPath.items.map(i => i[0 /* nextDistance */])
- );
-
- // Adjust our total length
- this.totalLength = firstPathLength;
-
- // Make sure that if we are empty, we set our first distance properly
- if (this.items.length === 0) {
- this.spacingToFirstItem = this.totalLength;
- }
-
- this.onPathChanged();
- secondPath.onPathChanged();
-
- // Update bounds
- this.worldBounds = this.computeBounds();
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("split-two-first");
- secondPath.debug_checkIntegrity("split-two-second");
- }
-
- return secondPath;
- }
-
- /**
- * Deletes the last entity
- * @param {Entity} entity
- */
- deleteEntityOnEnd(entity) {
- assert(
- this.entityPath[this.entityPath.length - 1] === entity,
- "Not actually the last entity (instead " + this.entityPath.indexOf(entity) + ")"
- );
-
- // Ok, first remove the entity
- const beltComp = entity.components.Belt;
- const beltLength = beltComp.getEffectiveLengthTiles();
-
- DEBUG &&
- logger.log(
- "Deleting last entity on path with length",
- this.entityPath.length,
- "(reducing",
- this.totalLength,
- " by",
- beltLength,
- ")"
- );
- this.totalLength -= beltLength;
- this.entityPath.pop();
- this.onPathChanged();
-
- DEBUG &&
- logger.log(
- " New path has length of",
- this.totalLength,
- "with",
- this.entityPath.length,
- "entities"
- );
-
- // This is just for sanity
- beltComp.assignedPath = null;
-
- // Clean up items
- if (this.items.length === 0) {
- // Simple case with no items, just update the first item spacing
- this.spacingToFirstItem = this.totalLength;
- } else {
- // Ok, make sure we simply drop all items which are no longer contained
- let itemOffset = this.spacingToFirstItem;
- let lastItemOffset = itemOffset;
-
- DEBUG && logger.log(" Adjusting", this.items.length, "items");
-
- for (let i = 0; i < this.items.length; ++i) {
- const item = this.items[i];
-
- // Get rid of items past this path
- if (itemOffset >= this.totalLength) {
- DEBUG && logger.log("Dropping item (current index=", i, ")");
- this.items.splice(i, 1);
- i -= 1;
- continue;
- }
-
- DEBUG &&
- logger.log(
- "Item",
- i,
- "is at",
- itemOffset,
- "with next offset",
- item[0 /* nextDistance */]
- );
- lastItemOffset = itemOffset;
- itemOffset += item[0 /* nextDistance */];
- }
-
- // If we still have an item, make sure the last item matches
- if (this.items.length > 0) {
- // We can easily compute the next distance since we know where the last item is now
- const lastDistance = this.totalLength - lastItemOffset;
- assert(
- lastDistance >= 0.0,
- "Last item distance mismatch: " +
- lastDistance +
- " -> Total length was " +
- this.totalLength +
- " and lastItemOffset was " +
- lastItemOffset
- );
-
- DEBUG &&
- logger.log(
- "Adjusted distance of last item: it is at",
- lastItemOffset,
- "so it has a distance of",
- lastDistance,
- "to the end (",
- this.totalLength,
- ")"
- );
- this.items[this.items.length - 1][0 /* nextDistance */] = lastDistance;
- } else {
- DEBUG && logger.log(" Removed all items so we'll update spacing to total length");
-
- // We removed all items so update our spacing
- this.spacingToFirstItem = this.totalLength;
- }
- }
-
- // Update bounds
- this.worldBounds = this.computeBounds();
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("delete-on-end");
- }
- }
-
- /**
- * Deletes the entity of the start of the path
- * @see deleteEntityOnEnd
- * @param {Entity} entity
- */
- deleteEntityOnStart(entity) {
- assert(
- entity === this.entityPath[0],
- "Not actually the start entity (instead " + this.entityPath.indexOf(entity) + ")"
- );
-
- // Ok, first remove the entity
- const beltComp = entity.components.Belt;
- const beltLength = beltComp.getEffectiveLengthTiles();
-
- DEBUG &&
- logger.log(
- "Deleting first entity on path with length",
- this.entityPath.length,
- "(reducing",
- this.totalLength,
- " by",
- beltLength,
- ")"
- );
- this.totalLength -= beltLength;
- this.entityPath.shift();
- this.onPathChanged();
-
- DEBUG &&
- logger.log(
- " New path has length of",
- this.totalLength,
- "with",
- this.entityPath.length,
- "entities"
- );
-
- // This is just for sanity
- beltComp.assignedPath = null;
-
- // Clean up items
- if (this.items.length === 0) {
- // Simple case with no items, just update the first item spacing
- this.spacingToFirstItem = this.totalLength;
- } else {
- // Simple case, we had no item on the beginning -> all good
- if (this.spacingToFirstItem >= beltLength) {
- DEBUG &&
- logger.log(
- " No item on the first place, so we can just adjust the spacing (spacing=",
- this.spacingToFirstItem,
- ") removed =",
- beltLength
- );
- this.spacingToFirstItem -= beltLength;
- } else {
- // Welp, okay we need to drop all items which are < beltLength and adjust
- // the other item offsets as well
-
- DEBUG &&
- logger.log(
- " We have at least one item in the beginning, drop those and adjust spacing (first item @",
- this.spacingToFirstItem,
- ") since we removed",
- beltLength,
- "length from path"
- );
- DEBUG &&
- logger.log(
- " Items:",
- this.items.map(i => i[0 /* nextDistance */])
- );
-
- // Find offset to first item
- let itemOffset = this.spacingToFirstItem;
- for (let i = 0; i < this.items.length; ++i) {
- const item = this.items[i];
- if (itemOffset <= beltLength) {
- DEBUG &&
- logger.log(
- " -> Dropping item with index",
- i,
- "at",
- itemOffset,
- "since it was on the removed belt"
- );
- // This item must be dropped
- this.items.splice(i, 1);
- i -= 1;
- itemOffset += item[0 /* nextDistance */];
- continue;
- } else {
- // This item can be kept, thus its the first we know
- break;
- }
- }
-
- if (this.items.length > 0) {
- DEBUG &&
- logger.log(
- " Offset of first non-dropped item was at:",
- itemOffset,
- "-> setting spacing to it (total length=",
- this.totalLength,
- ")"
- );
-
- this.spacingToFirstItem = itemOffset - beltLength;
- assert(
- this.spacingToFirstItem >= 0.0,
- "Invalid spacing after delete on start: " + this.spacingToFirstItem
- );
- } else {
- DEBUG && logger.log(" We dropped all items, simply set spacing to total length");
- // We dropped all items, simple one
- this.spacingToFirstItem = this.totalLength;
- }
- }
- }
-
- // Update bounds
- this.worldBounds = this.computeBounds();
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("delete-on-start");
- }
- }
-
- /**
- * Extends the path by the given other path
- * @param {BeltPath} otherPath
- */
- extendByPath(otherPath) {
- assert(otherPath !== this, "Circular path dependency");
-
- const entities = otherPath.entityPath;
- DEBUG && logger.log("Extending path by other path, starting to add entities");
-
- const oldLength = this.totalLength;
-
- DEBUG && logger.log(" Adding", entities.length, "new entities, current length =", this.totalLength);
-
- // First, append entities
- for (let i = 0; i < entities.length; ++i) {
- const entity = entities[i];
- const beltComp = entity.components.Belt;
-
- // Add to path and update references
- this.entityPath.push(entity);
- beltComp.assignedPath = this;
-
- // Update our length
- const additionalLength = beltComp.getEffectiveLengthTiles();
- this.totalLength += additionalLength;
- }
-
- DEBUG &&
- logger.log(
- " Path is now",
- this.entityPath.length,
- "entities and has a length of",
- this.totalLength
- );
-
- // Now, update the distance of our last item
- if (this.items.length !== 0) {
- const lastItem = this.items[this.items.length - 1];
- lastItem[0 /* nextDistance */] += otherPath.spacingToFirstItem;
- DEBUG &&
- logger.log(
- " Add distance to last item, effectively being",
- lastItem[0 /* nextDistance */],
- "now"
- );
- } else {
- // Seems we have no items, update our first item distance
- this.spacingToFirstItem = oldLength + otherPath.spacingToFirstItem;
- DEBUG &&
- logger.log(
- " We had no items, so our new spacing to first is old length (",
- oldLength,
- ") plus others spacing to first (",
- otherPath.spacingToFirstItem,
- ") =",
- this.spacingToFirstItem
- );
- }
-
- DEBUG && logger.log(" Pushing", otherPath.items.length, "items from other path");
-
- // Aaand push the other paths items
- for (let i = 0; i < otherPath.items.length; ++i) {
- const item = otherPath.items[i];
- this.items.push([item[0 /* nextDistance */], item[1 /* item */]]);
- }
-
- // Update bounds
- this.worldBounds = this.computeBounds();
-
- this.onPathChanged();
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("extend-by-path");
- }
- }
-
- /**
- * Computes the total length of the path
- * @returns {number}
- */
- computeTotalLength() {
- let length = 0;
- for (let i = 0; i < this.entityPath.length; ++i) {
- const entity = this.entityPath[i];
- length += entity.components.Belt.getEffectiveLengthTiles();
- }
- return length;
- }
-
- /**
- * Performs one tick
- */
- update() {
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("pre-update");
- }
-
- // Skip empty belts
- if (this.items.length === 0) {
- return;
- }
-
- // Divide by item spacing on belts since we use throughput and not speed
- let beltSpeed =
- this.root.hubGoals.getBeltBaseSpeed() *
- this.root.dynamicTickrate.deltaSeconds *
- globalConfig.itemSpacingOnBelts;
-
- if (G_IS_DEV && globalConfig.debug.instantBelts) {
- beltSpeed *= 100;
- }
-
- // Store whether this is the first item we processed, so premature
- // item ejection is available
- let isFirstItemProcessed = true;
-
- // Store how much velocity (strictly its distance, not velocity) we have to distribute over all items
- let remainingVelocity = beltSpeed;
-
- // Store the last item we processed, so we can skip clashed ones
- let lastItemProcessed;
-
- for (lastItemProcessed = this.items.length - 1; lastItemProcessed >= 0; --lastItemProcessed) {
- const nextDistanceAndItem = this.items[lastItemProcessed];
-
- // Compute how much spacing we need at least
- const minimumSpacing =
- lastItemProcessed === this.items.length - 1 ? 0 : globalConfig.itemSpacingOnBelts;
-
- // Compute how much we can advance
- let clampedProgress = nextDistanceAndItem[0 /* nextDistance */] - minimumSpacing;
-
- // Make sure we don't advance more than the remaining velocity has stored
- if (remainingVelocity < clampedProgress) {
- clampedProgress = remainingVelocity;
- }
-
- // Make sure we don't advance back
- if (clampedProgress < 0) {
- clampedProgress = 0;
- }
-
- // Reduce our velocity by the amount we consumed
- remainingVelocity -= clampedProgress;
-
- // Reduce the spacing
- nextDistanceAndItem[0 /* nextDistance */] -= clampedProgress;
-
- // Advance all items behind by the progress we made
- this.spacingToFirstItem += clampedProgress;
-
- // If the last item can be ejected, eject it and reduce the spacing, because otherwise
- // we lose velocity
- if (isFirstItemProcessed && nextDistanceAndItem[0 /* nextDistance */] < 1e-7) {
- // Store how much velocity we "lost" because we bumped the item to the end of the
- // belt but couldn't move it any farther. We need this to tell the item acceptor
- // animation to start a tad later, so everything matches up. Yes I'm a perfectionist.
- const excessVelocity = beltSpeed - clampedProgress;
-
- // Try to directly get rid of the item
- if (
- this.boundAcceptor &&
- this.boundAcceptor(nextDistanceAndItem[1 /* item */], excessVelocity)
- ) {
- this.items.pop();
-
- const itemBehind = this.items[lastItemProcessed - 1];
- if (itemBehind && this.numCompressedItemsAfterFirstItem > 0) {
- // So, with the next tick we will skip this item, but it actually has the potential
- // to process farther -> If we don't advance here, we loose a tiny bit of progress
- // every tick which causes the belt to be slower than it actually is.
- // Also see #999
- const fixupProgress = Math.max(
- 0,
- Math.min(remainingVelocity, itemBehind[0 /* nextDistance */])
- );
-
- // See above
- itemBehind[0 /* nextDistance */] -= fixupProgress;
- remainingVelocity -= fixupProgress;
- this.spacingToFirstItem += fixupProgress;
- }
-
- // Reduce the number of compressed items since the first item no longer exists
- this.numCompressedItemsAfterFirstItem = Math.max(
- 0,
- this.numCompressedItemsAfterFirstItem - 1
- );
- }
- }
-
- if (isFirstItemProcessed) {
- // Skip N null items after first items
- lastItemProcessed -= this.numCompressedItemsAfterFirstItem;
- }
-
- isFirstItemProcessed = false;
- if (remainingVelocity < 1e-7) {
- break;
- }
- }
-
- // Compute compressed item count
- this.numCompressedItemsAfterFirstItem = Math.max(
- 0,
- this.numCompressedItemsAfterFirstItem,
- this.items.length - 2 - lastItemProcessed
- );
-
- // Check if we have an item which is ready to be emitted
- const lastItem = this.items[this.items.length - 1];
- if (lastItem && lastItem[0 /* nextDistance */] === 0) {
- if (this.boundAcceptor && this.boundAcceptor(lastItem[1 /* item */])) {
- this.items.pop();
- this.numCompressedItemsAfterFirstItem = Math.max(
- 0,
- this.numCompressedItemsAfterFirstItem - 1
- );
- }
- }
-
- if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
- this.debug_checkIntegrity("post-update");
- }
- }
-
- /**
- * Computes a world space position from the given progress
- * @param {number} progress
- * @returns {Vector}
- */
- computePositionFromProgress(progress) {
- let currentLength = 0;
-
- // floating point issues ..
- assert(progress <= this.totalLength + 0.02, "Progress too big: " + progress);
-
- for (let i = 0; i < this.entityPath.length; ++i) {
- const beltComp = this.entityPath[i].components.Belt;
- const localLength = beltComp.getEffectiveLengthTiles();
-
- if (currentLength + localLength >= progress || i === this.entityPath.length - 1) {
- // Min required here due to floating point issues
- const localProgress = Math.min(1.0, progress - currentLength);
-
- assert(localProgress >= 0.0, "Invalid local progress: " + localProgress);
- const localSpace = beltComp.transformBeltToLocalSpace(localProgress);
- return this.entityPath[i].components.StaticMapEntity.localTileToWorld(localSpace);
- }
- currentLength += localLength;
- }
-
- assert(false, "invalid progress: " + progress + " (max: " + this.totalLength + ")");
- }
-
- /**
- *
- * @param {DrawParameters} parameters
- */
- drawDebug(parameters) {
- if (!parameters.visibleRect.containsRect(this.worldBounds)) {
- return;
- }
-
- parameters.context.fillStyle = "#d79a25";
- parameters.context.strokeStyle = "#d79a25";
- parameters.context.beginPath();
-
- for (let i = 0; i < this.entityPath.length; ++i) {
- const entity = this.entityPath[i];
- const pos = entity.components.StaticMapEntity;
- const worldPos = pos.origin.toWorldSpaceCenterOfTile();
-
- if (i === 0) {
- parameters.context.moveTo(worldPos.x, worldPos.y);
- } else {
- parameters.context.lineTo(worldPos.x, worldPos.y);
- }
- }
- parameters.context.stroke();
-
- // Items
- let progress = this.spacingToFirstItem;
- for (let i = 0; i < this.items.length; ++i) {
- const nextDistanceAndItem = this.items[i];
- const worldPos = this.computePositionFromProgress(progress).toWorldSpaceCenterOfTile();
- parameters.context.fillStyle = "#268e4d";
- parameters.context.beginRoundedRect(worldPos.x - 5, worldPos.y - 5, 10, 10, 3);
- parameters.context.fill();
- parameters.context.font = "6px GameFont";
- parameters.context.fillStyle = "#111";
- parameters.context.fillText(
- "" + round4Digits(nextDistanceAndItem[0 /* nextDistance */]),
- worldPos.x + 5,
- worldPos.y + 2
- );
- progress += nextDistanceAndItem[0 /* nextDistance */];
-
- if (this.items.length - 1 - this.numCompressedItemsAfterFirstItem === i) {
- parameters.context.fillStyle = "red";
- parameters.context.fillRect(worldPos.x + 5, worldPos.y, 20, 3);
- }
- }
-
- for (let i = 0; i < this.entityPath.length; ++i) {
- const entity = this.entityPath[i];
- parameters.context.fillStyle = "#d79a25";
- const pos = entity.components.StaticMapEntity;
- const worldPos = pos.origin.toWorldSpaceCenterOfTile();
- parameters.context.beginCircle(worldPos.x, worldPos.y, i === 0 ? 5 : 3);
- parameters.context.fill();
- }
-
- for (let progress = 0; progress <= this.totalLength + 0.01; progress += 0.2) {
- const worldPos = this.computePositionFromProgress(progress).toWorldSpaceCenterOfTile();
- parameters.context.fillStyle = "red";
- parameters.context.beginCircle(worldPos.x, worldPos.y, 1);
- parameters.context.fill();
- }
-
- const firstItemIndicator = this.computePositionFromProgress(
- this.spacingToFirstItem
- ).toWorldSpaceCenterOfTile();
- parameters.context.fillStyle = "purple";
- parameters.context.fillRect(firstItemIndicator.x - 3, firstItemIndicator.y - 1, 6, 2);
- }
-
- /**
- * Checks if this belt path should render simplified
- */
- checkIsPotatoMode() {
- // POTATO Mode: Only show items when belt is hovered
- if (!this.root.app.settings.getAllSettings().simplifiedBelts) {
- return false;
- }
-
- if (this.root.currentLayer !== "regular") {
- // Not in regular layer
- return true;
- }
-
- const mousePos = this.root.app.mousePosition;
- if (!mousePos) {
- // Mouse not registered
- return true;
- }
-
- const tile = this.root.camera.screenToWorld(mousePos).toTileSpace();
- const contents = this.root.map.getLayerContentXY(tile.x, tile.y, "regular");
- if (!contents || !contents.components.Belt) {
- // Nothing below
- return true;
- }
-
- if (contents.components.Belt.assignedPath !== this) {
- // Not this path
- return true;
- }
- return false;
- }
-
- /**
- * Draws the path
- * @param {DrawParameters} parameters
- */
- draw(parameters) {
- if (!parameters.visibleRect.containsRect(this.worldBounds)) {
- return;
- }
-
- if (this.items.length === 0) {
- // Early out
- return;
- }
-
- if (this.checkIsPotatoMode()) {
- const firstItem = this.items[0];
- if (this.entityPath.length > 1 && firstItem) {
- const medianBeltIndex = clamp(
- Math.round(this.entityPath.length / 2 - 1),
- 0,
- this.entityPath.length - 1
- );
- const medianBelt = this.entityPath[medianBeltIndex];
- const beltComp = medianBelt.components.Belt;
- const staticComp = medianBelt.components.StaticMapEntity;
- const centerPosLocal = beltComp.transformBeltToLocalSpace(
- this.entityPath.length % 2 === 0 ? beltComp.getEffectiveLengthTiles() : 0.5
- );
- const centerPos = staticComp.localTileToWorld(centerPosLocal).toWorldSpaceCenterOfTile();
-
- parameters.context.globalAlpha = 0.5;
- firstItem[1 /* item */].drawItemCenteredClipped(centerPos.x, centerPos.y, parameters);
- parameters.context.globalAlpha = 1;
- }
-
- return;
- }
-
- let currentItemPos = this.spacingToFirstItem;
- let currentItemIndex = 0;
-
- let trackPos = 0.0;
-
- /**
- * @type {Array<[Vector, BaseItem]>}
- */
- let drawStack = [];
- let drawStackProp = "";
-
- // Iterate whole track and check items
- for (let i = 0; i < this.entityPath.length; ++i) {
- const entity = this.entityPath[i];
- const beltComp = entity.components.Belt;
- const beltLength = beltComp.getEffectiveLengthTiles();
-
- // Check if the current items are on the belt
- while (trackPos + beltLength >= currentItemPos - 1e-5) {
- // It's on the belt, render it now
- const staticComp = entity.components.StaticMapEntity;
- assert(
- currentItemPos - trackPos >= 0,
- "invalid track pos: " + currentItemPos + " vs " + trackPos + " (l =" + beltLength + ")"
- );
-
- const localPos = beltComp.transformBeltToLocalSpace(currentItemPos - trackPos);
- const worldPos = staticComp.localTileToWorld(localPos).toWorldSpaceCenterOfTile();
-
- const distanceAndItem = this.items[currentItemIndex];
- const item = distanceAndItem[1 /* item */];
- const nextItemDistance = distanceAndItem[0 /* nextDistance */];
-
- if (
- !parameters.visibleRect.containsCircle(
- worldPos.x,
- worldPos.y,
- globalConfig.defaultItemDiameter
- )
- ) {
- // this one isn't visible, do not append it
- // Start a new stack
- this.drawDrawStack(drawStack, parameters, drawStackProp);
- drawStack = [];
- drawStackProp = "";
- } else {
- if (drawStack.length > 1) {
- // Check if we can append to the stack, since its already a stack of two same items
- const referenceItem = drawStack[0];
-
- if (
- referenceItem[1].equals(item) &&
- Math.abs(referenceItem[0][drawStackProp] - worldPos[drawStackProp]) < 0.001
- ) {
- // Will continue stack
- } else {
- // Start a new stack, since item doesn't follow in row
- this.drawDrawStack(drawStack, parameters, drawStackProp);
- drawStack = [];
- drawStackProp = "";
- }
- } else if (drawStack.length === 1) {
- const firstItem = drawStack[0];
-
- // Check if we can make it a stack
- if (firstItem[1 /* item */].equals(item)) {
- // Same item, check if it is either horizontal or vertical
- const startPos = firstItem[0 /* pos */];
-
- if (Math.abs(startPos.x - worldPos.x) < 0.001) {
- drawStackProp = "x";
- } else if (Math.abs(startPos.y - worldPos.y) < 0.001) {
- drawStackProp = "y";
- } else {
- // Start a new stack
- this.drawDrawStack(drawStack, parameters, drawStackProp);
- drawStack = [];
- drawStackProp = "";
- }
- } else {
- // Start a new stack, since item doesn't equal
- this.drawDrawStack(drawStack, parameters, drawStackProp);
- drawStack = [];
- drawStackProp = "";
- }
- } else {
- // First item of stack, do nothing
- }
-
- drawStack.push([worldPos, item]);
- }
-
- // Check for the next item
- currentItemPos += nextItemDistance;
- ++currentItemIndex;
-
- if (
- nextItemDistance > globalConfig.itemSpacingOnBelts + 0.001 ||
- drawStack.length > globalConfig.maxBeltShapeBundleSize
- ) {
- // If next item is not directly following, abort drawing
- this.drawDrawStack(drawStack, parameters, drawStackProp);
- drawStack = [];
- drawStackProp = "";
- }
-
- if (currentItemIndex >= this.items.length) {
- // We rendered all items
-
- this.drawDrawStack(drawStack, parameters, drawStackProp);
- return;
- }
- }
-
- trackPos += beltLength;
- }
-
- this.drawDrawStack(drawStack, parameters, drawStackProp);
- }
-
- /**
- *
- * @param {HTMLCanvasElement} canvas
- * @param {CanvasRenderingContext2D} context
- * @param {number} w
- * @param {number} h
- * @param {number} dpi
- * @param {object} param0
- * @param {string} param0.direction
- * @param {Array<[Vector, BaseItem]>} param0.stack
- * @param {GameRoot} param0.root
- * @param {number} param0.zoomLevel
- */
- drawShapesInARow(canvas, context, w, h, dpi, { direction, stack, root, zoomLevel }) {
- context.scale(dpi, dpi);
-
- if (G_IS_DEV && globalConfig.debug.showShapeGrouping) {
- context.fillStyle = "rgba(0, 0, 255, 0.5)";
- context.fillRect(0, 0, w, h);
- }
-
- const parameters = new DrawParameters({
- context,
- desiredAtlasScale: ORIGINAL_SPRITE_SCALE,
- root,
- visibleRect: new Rectangle(-1000, -1000, 2000, 2000),
- zoomLevel,
- });
-
- const itemSize = globalConfig.itemSpacingOnBelts * globalConfig.tileSize;
- const item = stack[0];
- const pos = new Vector(itemSize / 2, itemSize / 2);
-
- for (let i = 0; i < stack.length; i++) {
- item[1].drawItemCenteredClipped(pos.x, pos.y, parameters, globalConfig.defaultItemDiameter);
- pos[direction] += globalConfig.itemSpacingOnBelts * globalConfig.tileSize;
- }
- }
-
- /**
- * @param {Array<[Vector, BaseItem]>} stack
- * @param {DrawParameters} parameters
- */
- drawDrawStack(stack, parameters, directionProp) {
- if (stack.length === 0) {
- return;
- }
-
- const firstItem = stack[0];
- const firstItemPos = firstItem[0];
- if (stack.length === 1) {
- firstItem[1].drawItemCenteredClipped(
- firstItemPos.x,
- firstItemPos.y,
- parameters,
- globalConfig.defaultItemDiameter
- );
- return;
- }
-
- const itemSize = globalConfig.itemSpacingOnBelts * globalConfig.tileSize;
- const inverseDirection = directionProp === "x" ? "y" : "x";
-
- const dimensions = new Vector(itemSize, itemSize);
- dimensions[inverseDirection] *= stack.length;
-
- const directionVector = firstItemPos.copy().sub(stack[1][0]);
-
- const dpi = smoothenDpi(globalConfig.shapesSharpness * parameters.zoomLevel);
-
- const sprite = this.root.buffers.getForKey({
- key: "beltpaths",
- subKey:
- "stack-" +
- directionProp +
- "-" +
- dpi +
- "#" +
- stack.length +
- "#" +
- firstItem[1].getItemType() +
- "#" +
- firstItem[1].serialize(),
- dpi,
- w: dimensions.x,
- h: dimensions.y,
- redrawMethod: this.drawShapesInARow.bind(this),
- additionalParams: {
- direction: inverseDirection,
- stack,
- root: this.root,
- zoomLevel: parameters.zoomLevel,
- },
- });
-
- const anchor = directionVector[inverseDirection] < 0 ? firstItem : stack[stack.length - 1];
-
- parameters.context.drawImage(
- sprite,
- anchor[0].x - itemSize / 2,
- anchor[0].y - itemSize / 2,
- dimensions.x,
- dimensions.y
- );
- }
-}
+import { globalConfig } from "../core/config";
+import { smoothenDpi } from "../core/dpi_manager";
+import { DrawParameters } from "../core/draw_parameters";
+import { createLogger } from "../core/logging";
+import { Rectangle } from "../core/rectangle";
+import { ORIGINAL_SPRITE_SCALE } from "../core/sprites";
+import { clamp, epsilonCompare, round4Digits } from "../core/utils";
+import { enumDirection, enumDirectionToVector, enumInvertedDirections, Vector } from "../core/vector";
+import { BasicSerializableObject, types } from "../savegame/serialization";
+import { BaseItem } from "./base_item";
+import { Entity } from "./entity";
+import { typeItemSingleton } from "./item_resolver";
+import { GameRoot } from "./root";
+
+const logger = createLogger("belt_path");
+
+// Helpers for more semantic access into interleaved arrays
+
+const DEBUG = G_IS_DEV && false;
+
+/**
+ * Stores a path of belts, used for optimizing performance
+ */
+export class BeltPath extends BasicSerializableObject {
+ static getId() {
+ return "BeltPath";
+ }
+
+ static getSchema() {
+ return {
+ entityPath: types.array(types.entity),
+ items: types.array(types.pair(types.ufloat, typeItemSingleton)),
+ spacingToFirstItem: types.ufloat,
+ };
+ }
+
+ /**
+ * Creates a path from a serialized object
+ * @param {GameRoot} root
+ * @param {Object} data
+ * @returns {BeltPath|string}
+ */
+ static fromSerialized(root, data) {
+ // Create fake object which looks like a belt path but skips the constructor
+ const fakeObject = /** @type {BeltPath} */ (Object.create(BeltPath.prototype));
+ fakeObject.root = root;
+
+ // Deserialize the data
+ const errorCodeDeserialize = fakeObject.deserialize(data);
+ if (errorCodeDeserialize) {
+ return errorCodeDeserialize;
+ }
+
+ // Compute other properties
+ fakeObject.init(false);
+
+ return fakeObject;
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {Array} entityPath
+ */
+ constructor(root, entityPath) {
+ super();
+ this.root = root;
+
+ assert(entityPath.length > 0, "invalid entity path");
+ this.entityPath = entityPath;
+
+ /**
+ * Stores the items sorted, and their distance to the previous item (or start)
+ * Layout: [distanceToNext, item]
+ * @type {Array<[number, BaseItem]>}
+ */
+ this.items = [];
+
+ /**
+ * Stores the spacing to the first item
+ */
+
+ this.init();
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("constructor");
+ }
+ }
+ /**
+ * Initializes the path by computing the properties which are not saved
+ * @param {boolean} computeSpacing Whether to also compute the spacing
+ */
+ init(computeSpacing = true) {
+ this.onPathChanged();
+
+ this.totalLength = this.computeTotalLength();
+
+ if (computeSpacing) {
+ this.spacingToFirstItem = this.totalLength;
+ }
+
+ /**
+ * Current bounds of this path
+ * @type {Rectangle}
+ */
+ this.worldBounds = this.computeBounds();
+
+ // Connect the belts
+ for (let i = 0; i < this.entityPath.length; ++i) {
+ this.entityPath[i].components.Belt.assignedPath = this;
+ }
+ }
+
+ /**
+ * Clears all items
+ */
+ clearAllItems() {
+ this.items = [];
+ this.spacingToFirstItem = this.totalLength;
+ this.numCompressedItemsAfterFirstItem = 0;
+ }
+
+ /**
+ * Returns whether this path can accept a new item
+ * @returns {boolean}
+ */
+ canAcceptItem() {
+ return this.spacingToFirstItem >= globalConfig.itemSpacingOnBelts;
+ }
+
+ /**
+ * Tries to accept the item
+ * @param {BaseItem} item
+ */
+ tryAcceptItem(item) {
+ if (this.spacingToFirstItem >= globalConfig.itemSpacingOnBelts) {
+ // So, since we already need one tick to accept this item we will add this directly.
+ const beltProgressPerTick =
+ this.root.hubGoals.getBeltBaseSpeed() *
+ this.root.dynamicTickrate.deltaSeconds *
+ globalConfig.itemSpacingOnBelts;
+
+ // First, compute how much progress we can make *at max*
+ const maxProgress = Math.max(0, this.spacingToFirstItem - globalConfig.itemSpacingOnBelts);
+ const initialProgress = Math.min(maxProgress, beltProgressPerTick);
+
+ this.items.unshift([this.spacingToFirstItem - initialProgress, item]);
+ this.spacingToFirstItem = initialProgress;
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("accept-item");
+ }
+
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * SLOW / Tries to find the item closest to the given tile
+ * @param {Vector} tile
+ * @returns {BaseItem|null}
+ */
+ findItemAtTile(tile) {
+ // @TODO: This breaks color blind mode otherwise
+ return null;
+ }
+
+ /**
+ * Computes the tile bounds of the path
+ * @returns {Rectangle}
+ */
+ computeBounds() {
+ let bounds = this.entityPath[0].components.StaticMapEntity.getTileSpaceBounds();
+ for (let i = 1; i < this.entityPath.length; ++i) {
+ const staticComp = this.entityPath[i].components.StaticMapEntity;
+ const otherBounds = staticComp.getTileSpaceBounds();
+ bounds = bounds.getUnion(otherBounds);
+ }
+ return bounds.allScaled(globalConfig.tileSize);
+ }
+
+ /**
+ * Recomputes cache variables once the path was changed
+ */
+ onPathChanged() {
+ this.boundAcceptor = this.computeAcceptingEntityAndSlot().acceptor;
+
+ /**
+ * How many items past the first item are compressed
+ */
+ this.numCompressedItemsAfterFirstItem = 0;
+ }
+
+ /**
+ * Called by the belt system when the surroundings changed
+ */
+ onSurroundingsChanged() {
+ this.onPathChanged();
+ }
+
+ /**
+ * Finds the entity which accepts our items
+ * @param {boolean=} debug_Silent Whether debug output should be silent
+ * @return { { acceptor?: (BaseItem, number?) => boolean, entity?: Entity } }
+ */
+ computeAcceptingEntityAndSlot(debug_Silent = false) {
+ DEBUG && !debug_Silent && logger.log("Recomputing acceptor target");
+
+ const lastEntity = this.entityPath[this.entityPath.length - 1];
+ const lastStatic = lastEntity.components.StaticMapEntity;
+ const lastBeltComp = lastEntity.components.Belt;
+
+ // Figure out where and into which direction we eject items
+ const ejectSlotWsTile = lastStatic.localTileToWorld(new Vector(0, 0));
+ const ejectSlotWsDirection = lastStatic.localDirectionToWorld(lastBeltComp.direction);
+ const ejectSlotWsDirectionVector = enumDirectionToVector[ejectSlotWsDirection];
+ const ejectSlotTargetWsTile = ejectSlotWsTile.add(ejectSlotWsDirectionVector);
+
+ // Try to find the given acceptor component to take the item
+ const targetEntity = this.root.map.getLayerContentXY(
+ ejectSlotTargetWsTile.x,
+ ejectSlotTargetWsTile.y,
+ "regular"
+ );
+
+ if (!targetEntity) {
+ return {};
+ }
+
+ const noSimplifiedBelts = !this.root.app.settings.getAllSettings().simplifiedBelts;
+
+ DEBUG && !debug_Silent && logger.log(" Found target entity", targetEntity.uid);
+ const targetStaticComp = targetEntity.components.StaticMapEntity;
+ const targetBeltComp = targetEntity.components.Belt;
+
+ // Check for belts (special case)
+ if (targetBeltComp) {
+ const beltAcceptingDirection = targetStaticComp.localDirectionToWorld(enumDirection.top);
+ DEBUG &&
+ !debug_Silent &&
+ logger.log(
+ " Entity is accepting items from",
+ ejectSlotWsDirection,
+ "vs",
+ beltAcceptingDirection,
+ "Rotation:",
+ targetStaticComp.rotation
+ );
+ if (ejectSlotWsDirection === beltAcceptingDirection) {
+ return {
+ entity: targetEntity,
+ acceptor: item => {
+ const path = targetBeltComp.assignedPath;
+ assert(path, "belt has no path");
+ return path.tryAcceptItem(item);
+ },
+ };
+ }
+ }
+
+ // Check for item acceptors
+ const targetAcceptorComp = targetEntity.components.ItemAcceptor;
+ if (!targetAcceptorComp) {
+ // Entity doesn't accept items
+ return {};
+ }
+
+ const ejectingDirection = targetStaticComp.worldDirectionToLocal(ejectSlotWsDirection);
+ const matchingSlot = targetAcceptorComp.findMatchingSlot(
+ targetStaticComp.worldToLocalTile(ejectSlotTargetWsTile),
+ ejectingDirection
+ );
+
+ if (!matchingSlot) {
+ // No matching slot found
+ return {};
+ }
+
+ const matchingSlotIndex = matchingSlot.index;
+ const passOver = this.computePassOverFunctionWithoutBelts(targetEntity, matchingSlotIndex);
+ if (!passOver) {
+ return {};
+ }
+
+ const matchingDirection = enumInvertedDirections[ejectingDirection];
+ const filter = matchingSlot.slot.filter;
+
+ return {
+ entity: targetEntity,
+ acceptor: function (item, remainingProgress = 0.0) {
+ // Check if the acceptor has a filter
+ if (filter && item._type !== filter) {
+ return false;
+ }
+
+ // Try to pass over
+ if (passOver(item, matchingSlotIndex)) {
+ // Trigger animation on the acceptor comp
+ if (noSimplifiedBelts) {
+ targetAcceptorComp.onItemAccepted(
+ matchingSlotIndex,
+ matchingDirection,
+ item,
+ remainingProgress
+ );
+ }
+ return true;
+ }
+ return false;
+ },
+ };
+ }
+
+ /**
+ * Computes a method to pass over the item to the entity
+ * @param {Entity} entity
+ * @param {number} matchingSlotIndex
+ * @returns {(item: BaseItem, slotIndex: number) => boolean | void}
+ */
+ computePassOverFunctionWithoutBelts(entity, matchingSlotIndex) {
+ const systems = this.root.systemMgr.systems;
+ const hubGoals = this.root.hubGoals;
+
+ // NOTICE: THIS IS COPIED FROM THE ITEM EJECTOR SYSTEM FOR PEROFMANCE REASONS
+
+ const itemProcessorComp = entity.components.ItemProcessor;
+ if (itemProcessorComp) {
+ // Its an item processor ..
+ return function (item) {
+ // Check for potential filters
+ if (!systems.itemProcessor.checkRequirements(entity, item, matchingSlotIndex)) {
+ return;
+ }
+ return itemProcessorComp.tryTakeItem(item, matchingSlotIndex);
+ };
+ }
+
+ const undergroundBeltComp = entity.components.UndergroundBelt;
+ if (undergroundBeltComp) {
+ // Its an underground belt. yay.
+ return function (item) {
+ return undergroundBeltComp.tryAcceptExternalItem(
+ item,
+ hubGoals.getUndergroundBeltBaseSpeed()
+ );
+ };
+ }
+
+ const storageComp = entity.components.Storage;
+ if (storageComp) {
+ // It's a storage
+ return function (item) {
+ if (storageComp.canAcceptItem(item)) {
+ storageComp.takeItem(item);
+ return true;
+ }
+ };
+ }
+
+ const filterComp = entity.components.Filter;
+ if (filterComp) {
+ // It's a filter! Unfortunately the filter has to know a lot about it's
+ // surrounding state and components, so it can't be within the component itself.
+ return function (item) {
+ if (systems.filter.tryAcceptItem(entity, matchingSlotIndex, item)) {
+ return true;
+ }
+ };
+ }
+ }
+
+ // Following code will be compiled out outside of dev versions
+ /* dev:start */
+
+ /**
+ * Helper to throw an error on mismatch
+ * @param {string} change
+ * @param {Array} reason
+ */
+ debug_failIntegrity(change, ...reason) {
+ throw new Error("belt path invalid (" + change + "): " + reason.map(i => "" + i).join(" "));
+ }
+
+ /**
+ * Checks if this path is valid
+ */
+ debug_checkIntegrity(currentChange = "change") {
+ const fail = (...args) => this.debug_failIntegrity(currentChange, ...args);
+
+ // Check for empty path
+ if (this.entityPath.length === 0) {
+ return fail("Belt path is empty");
+ }
+
+ // Check for mismatching length
+ const totalLength = this.computeTotalLength();
+ if (!epsilonCompare(this.totalLength, totalLength, 0.01)) {
+ return this.debug_failIntegrity(
+ currentChange,
+ "Total length mismatch, stored =",
+ this.totalLength,
+ "but correct is",
+ totalLength
+ );
+ }
+
+ // Check for misconnected entities
+ for (let i = 0; i < this.entityPath.length - 1; ++i) {
+ const entity = this.entityPath[i];
+ if (entity.destroyed) {
+ return fail("Reference to destroyed entity " + entity.uid);
+ }
+
+ const followUp = this.root.systemMgr.systems.belt.findFollowUpEntity(entity);
+ if (!followUp) {
+ return fail(
+ "Follow up entity for the",
+ i,
+ "-th entity (total length",
+ this.entityPath.length,
+ ") was null!"
+ );
+ }
+ if (followUp !== this.entityPath[i + 1]) {
+ return fail(
+ "Follow up entity mismatch, stored is",
+ this.entityPath[i + 1].uid,
+ "but real one is",
+ followUp.uid
+ );
+ }
+ if (entity.components.Belt.assignedPath !== this) {
+ return fail(
+ "Entity with uid",
+ entity.uid,
+ "doesn't have this path assigned, but this path contains the entity."
+ );
+ }
+ }
+
+ // Check spacing
+ if (this.spacingToFirstItem > this.totalLength + 0.005) {
+ return fail(
+ currentChange,
+ "spacing to first item (",
+ this.spacingToFirstItem,
+ ") is greater than total length (",
+ this.totalLength,
+ ")"
+ );
+ }
+
+ // Check distance if empty
+ if (this.items.length === 0 && !epsilonCompare(this.spacingToFirstItem, this.totalLength, 0.01)) {
+ return fail(
+ currentChange,
+ "Path is empty but spacing to first item (",
+ this.spacingToFirstItem,
+ ") does not equal total length (",
+ this.totalLength,
+ ")"
+ );
+ }
+
+ // Check items etc
+ let currentPos = this.spacingToFirstItem;
+ for (let i = 0; i < this.items.length; ++i) {
+ const item = this.items[i];
+
+ if (item[0 /* nextDistance */] < 0 || item[0 /* nextDistance */] > this.totalLength + 0.02) {
+ return fail(
+ "Item has invalid offset to next item: ",
+ item[0 /* nextDistance */],
+ "(total length:",
+ this.totalLength,
+ ")"
+ );
+ }
+
+ currentPos += item[0 /* nextDistance */];
+ }
+
+ // Check the total sum matches
+ if (!epsilonCompare(currentPos, this.totalLength, 0.01)) {
+ return fail(
+ "total sum (",
+ currentPos,
+ ") of first item spacing (",
+ this.spacingToFirstItem,
+ ") and items does not match total length (",
+ this.totalLength,
+ ") -> items: " + this.items.map(i => i[0 /* nextDistance */]).join("|")
+ );
+ }
+
+ // Check bounds
+ const actualBounds = this.computeBounds();
+ if (!actualBounds.equalsEpsilon(this.worldBounds, 0.01)) {
+ return fail("Bounds are stale");
+ }
+
+ // Check acceptor
+ const acceptor = this.computeAcceptingEntityAndSlot(true).acceptor;
+ if (!!acceptor !== !!this.boundAcceptor) {
+ return fail("Acceptor target mismatch, acceptor", !!acceptor, "vs stored", !!this.boundAcceptor);
+ }
+
+ // Check first nonzero offset
+ let firstNonzero = 0;
+ for (let i = this.items.length - 2; i >= 0; --i) {
+ if (this.items[i][0 /* nextDistance */] < globalConfig.itemSpacingOnBelts + 1e-5) {
+ ++firstNonzero;
+ } else {
+ break;
+ }
+ }
+
+ // Should warn, but this check isn't actually accurate
+ // if (firstNonzero !== this.numCompressedItemsAfterFirstItem) {
+ // console.warn(
+ // "First nonzero index is " +
+ // firstNonzero +
+ // " but stored is " +
+ // this.numCompressedItemsAfterFirstItem
+ // );
+ // }
+ }
+
+ /* dev:end */
+
+ /**
+ * Extends the belt path by the given belt
+ * @param {Entity} entity
+ */
+ extendOnEnd(entity) {
+ DEBUG && logger.log("Extending belt path by entity at", entity.components.StaticMapEntity.origin);
+
+ const beltComp = entity.components.Belt;
+
+ // Append the entity
+ this.entityPath.push(entity);
+ this.onPathChanged();
+
+ // Extend the path length
+ const additionalLength = beltComp.getEffectiveLengthTiles();
+ this.totalLength += additionalLength;
+ DEBUG && logger.log(" Extended total length by", additionalLength, "to", this.totalLength);
+
+ // If we have no item, just update the distance to the first item
+ if (this.items.length === 0) {
+ this.spacingToFirstItem = this.totalLength;
+ DEBUG && logger.log(" Extended spacing to first to", this.totalLength, "(= total length)");
+ } else {
+ // Otherwise, update the next-distance of the last item
+ const lastItem = this.items[this.items.length - 1];
+ DEBUG &&
+ logger.log(
+ " Extended spacing of last item from",
+ lastItem[0 /* nextDistance */],
+ "to",
+ lastItem[0 /* nextDistance */] + additionalLength
+ );
+ lastItem[0 /* nextDistance */] += additionalLength;
+ }
+
+ // Assign reference
+ beltComp.assignedPath = this;
+
+ // Update bounds
+ this.worldBounds = this.computeBounds();
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("extend-on-end");
+ }
+ }
+
+ /**
+ * Extends the path with the given entity on the beginning
+ * @param {Entity} entity
+ */
+ extendOnBeginning(entity) {
+ const beltComp = entity.components.Belt;
+
+ DEBUG && logger.log("Extending the path on the beginning");
+
+ // All items on that belt are simply lost (for now)
+
+ const length = beltComp.getEffectiveLengthTiles();
+
+ // Extend the length of this path
+ this.totalLength += length;
+
+ // Simply adjust the first item spacing cuz we have no items contained
+ this.spacingToFirstItem += length;
+
+ // Set handles and append entity
+ beltComp.assignedPath = this;
+ this.entityPath.unshift(entity);
+ this.onPathChanged();
+
+ // Update bounds
+ this.worldBounds = this.computeBounds();
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("extend-on-begin");
+ }
+ }
+
+ /**
+ * Returns if the given entity is the end entity of the path
+ * @param {Entity} entity
+ * @returns {boolean}
+ */
+ isEndEntity(entity) {
+ return this.entityPath[this.entityPath.length - 1] === entity;
+ }
+
+ /**
+ * Returns if the given entity is the start entity of the path
+ * @param {Entity} entity
+ * @returns {boolean}
+ */
+ isStartEntity(entity) {
+ return this.entityPath[0] === entity;
+ }
+
+ /**
+ * Splits this path at the given entity by removing it, and
+ * returning the new secondary paht
+ * @param {Entity} entity
+ * @returns {BeltPath}
+ */
+ deleteEntityOnPathSplitIntoTwo(entity) {
+ DEBUG && logger.log("Splitting path at entity", entity.components.StaticMapEntity.origin);
+
+ // First, find where the current path ends
+ const beltComp = entity.components.Belt;
+ beltComp.assignedPath = null;
+
+ const entityLength = beltComp.getEffectiveLengthTiles();
+ assert(this.entityPath.indexOf(entity) >= 0, "Entity not contained for split");
+ assert(this.entityPath.indexOf(entity) !== 0, "Entity is first");
+ assert(this.entityPath.indexOf(entity) !== this.entityPath.length - 1, "Entity is last");
+
+ let firstPathEntityCount = 0;
+ let firstPathLength = 0;
+ let firstPathEndEntity = null;
+
+ for (let i = 0; i < this.entityPath.length; ++i) {
+ const otherEntity = this.entityPath[i];
+ if (otherEntity === entity) {
+ DEBUG && logger.log("Found entity at", i, "of length", firstPathLength);
+ break;
+ }
+
+ ++firstPathEntityCount;
+ firstPathEndEntity = otherEntity;
+ firstPathLength += otherEntity.components.Belt.getEffectiveLengthTiles();
+ }
+
+ DEBUG &&
+ logger.log(
+ "First path ends at",
+ firstPathLength,
+ "and entity",
+ firstPathEndEntity.components.StaticMapEntity.origin,
+ "and has",
+ firstPathEntityCount,
+ "entities"
+ );
+
+ // Compute length of second path
+ const secondPathLength = this.totalLength - firstPathLength - entityLength;
+ const secondPathStart = firstPathLength + entityLength;
+ const secondEntities = this.entityPath.splice(firstPathEntityCount + 1);
+ DEBUG &&
+ logger.log(
+ "Second path starts at",
+ secondPathStart,
+ "and has a length of ",
+ secondPathLength,
+ "with",
+ secondEntities.length,
+ "entities"
+ );
+
+ // Remove the last item
+ this.entityPath.pop();
+
+ DEBUG && logger.log("Splitting", this.items.length, "items");
+ DEBUG &&
+ logger.log(
+ "Old items are",
+ this.items.map(i => i[0 /* nextDistance */])
+ );
+
+ // Create second path
+ const secondPath = new BeltPath(this.root, secondEntities);
+
+ // Remove all items which are no longer relevant and transfer them to the second path
+ let itemPos = this.spacingToFirstItem;
+ for (let i = 0; i < this.items.length; ++i) {
+ const item = this.items[i];
+ const distanceToNext = item[0 /* nextDistance */];
+
+ DEBUG && logger.log(" Checking item at", itemPos, "with distance of", distanceToNext, "to next");
+
+ // Check if this item is past the first path
+ if (itemPos >= firstPathLength) {
+ // Remove it from the first path
+ this.items.splice(i, 1);
+ i -= 1;
+ DEBUG &&
+ logger.log(" Removed item from first path since its no longer contained @", itemPos);
+
+ // Check if its on the second path (otherwise its on the removed belt and simply lost)
+ if (itemPos >= secondPathStart) {
+ // Put item on second path
+ secondPath.items.push([distanceToNext, item[1 /* item */]]);
+ DEBUG &&
+ logger.log(
+ " Put item to second path @",
+ itemPos,
+ "with distance to next =",
+ distanceToNext
+ );
+
+ // If it was the first item, adjust the distance to the first item
+ if (secondPath.items.length === 1) {
+ DEBUG && logger.log(" Sinc it was the first, set sapcing of first to", itemPos);
+ secondPath.spacingToFirstItem = itemPos - secondPathStart;
+ }
+ } else {
+ DEBUG && logger.log(" Item was on the removed belt, so its gone - forever!");
+ }
+ } else {
+ // Seems this item is on the first path (so all good), so just make sure it doesn't
+ // have a nextDistance which is bigger than the total path length
+ const clampedDistanceToNext = Math.min(itemPos + distanceToNext, firstPathLength) - itemPos;
+ if (clampedDistanceToNext < distanceToNext) {
+ DEBUG &&
+ logger.log(
+ "Correcting next distance (first path) from",
+ distanceToNext,
+ "to",
+ clampedDistanceToNext
+ );
+ item[0 /* nextDistance */] = clampedDistanceToNext;
+ }
+ }
+
+ // Advance items
+ itemPos += distanceToNext;
+ }
+
+ DEBUG &&
+ logger.log(
+ "New items are",
+ this.items.map(i => i[0 /* nextDistance */])
+ );
+
+ DEBUG &&
+ logger.log(
+ "And second path items are",
+ secondPath.items.map(i => i[0 /* nextDistance */])
+ );
+
+ // Adjust our total length
+ this.totalLength = firstPathLength;
+
+ // Make sure that if we are empty, we set our first distance properly
+ if (this.items.length === 0) {
+ this.spacingToFirstItem = this.totalLength;
+ }
+
+ this.onPathChanged();
+ secondPath.onPathChanged();
+
+ // Update bounds
+ this.worldBounds = this.computeBounds();
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("split-two-first");
+ secondPath.debug_checkIntegrity("split-two-second");
+ }
+
+ return secondPath;
+ }
+
+ /**
+ * Deletes the last entity
+ * @param {Entity} entity
+ */
+ deleteEntityOnEnd(entity) {
+ assert(
+ this.entityPath[this.entityPath.length - 1] === entity,
+ "Not actually the last entity (instead " + this.entityPath.indexOf(entity) + ")"
+ );
+
+ // Ok, first remove the entity
+ const beltComp = entity.components.Belt;
+ const beltLength = beltComp.getEffectiveLengthTiles();
+
+ DEBUG &&
+ logger.log(
+ "Deleting last entity on path with length",
+ this.entityPath.length,
+ "(reducing",
+ this.totalLength,
+ " by",
+ beltLength,
+ ")"
+ );
+ this.totalLength -= beltLength;
+ this.entityPath.pop();
+ this.onPathChanged();
+
+ DEBUG &&
+ logger.log(
+ " New path has length of",
+ this.totalLength,
+ "with",
+ this.entityPath.length,
+ "entities"
+ );
+
+ // This is just for sanity
+ beltComp.assignedPath = null;
+
+ // Clean up items
+ if (this.items.length === 0) {
+ // Simple case with no items, just update the first item spacing
+ this.spacingToFirstItem = this.totalLength;
+ } else {
+ // Ok, make sure we simply drop all items which are no longer contained
+ let itemOffset = this.spacingToFirstItem;
+ let lastItemOffset = itemOffset;
+
+ DEBUG && logger.log(" Adjusting", this.items.length, "items");
+
+ for (let i = 0; i < this.items.length; ++i) {
+ const item = this.items[i];
+
+ // Get rid of items past this path
+ if (itemOffset >= this.totalLength) {
+ DEBUG && logger.log("Dropping item (current index=", i, ")");
+ this.items.splice(i, 1);
+ i -= 1;
+ continue;
+ }
+
+ DEBUG &&
+ logger.log(
+ "Item",
+ i,
+ "is at",
+ itemOffset,
+ "with next offset",
+ item[0 /* nextDistance */]
+ );
+ lastItemOffset = itemOffset;
+ itemOffset += item[0 /* nextDistance */];
+ }
+
+ // If we still have an item, make sure the last item matches
+ if (this.items.length > 0) {
+ // We can easily compute the next distance since we know where the last item is now
+ const lastDistance = this.totalLength - lastItemOffset;
+ assert(
+ lastDistance >= 0.0,
+ "Last item distance mismatch: " +
+ lastDistance +
+ " -> Total length was " +
+ this.totalLength +
+ " and lastItemOffset was " +
+ lastItemOffset
+ );
+
+ DEBUG &&
+ logger.log(
+ "Adjusted distance of last item: it is at",
+ lastItemOffset,
+ "so it has a distance of",
+ lastDistance,
+ "to the end (",
+ this.totalLength,
+ ")"
+ );
+ this.items[this.items.length - 1][0 /* nextDistance */] = lastDistance;
+ } else {
+ DEBUG && logger.log(" Removed all items so we'll update spacing to total length");
+
+ // We removed all items so update our spacing
+ this.spacingToFirstItem = this.totalLength;
+ }
+ }
+
+ // Update bounds
+ this.worldBounds = this.computeBounds();
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("delete-on-end");
+ }
+ }
+
+ /**
+ * Deletes the entity of the start of the path
+ * @see deleteEntityOnEnd
+ * @param {Entity} entity
+ */
+ deleteEntityOnStart(entity) {
+ assert(
+ entity === this.entityPath[0],
+ "Not actually the start entity (instead " + this.entityPath.indexOf(entity) + ")"
+ );
+
+ // Ok, first remove the entity
+ const beltComp = entity.components.Belt;
+ const beltLength = beltComp.getEffectiveLengthTiles();
+
+ DEBUG &&
+ logger.log(
+ "Deleting first entity on path with length",
+ this.entityPath.length,
+ "(reducing",
+ this.totalLength,
+ " by",
+ beltLength,
+ ")"
+ );
+ this.totalLength -= beltLength;
+ this.entityPath.shift();
+ this.onPathChanged();
+
+ DEBUG &&
+ logger.log(
+ " New path has length of",
+ this.totalLength,
+ "with",
+ this.entityPath.length,
+ "entities"
+ );
+
+ // This is just for sanity
+ beltComp.assignedPath = null;
+
+ // Clean up items
+ if (this.items.length === 0) {
+ // Simple case with no items, just update the first item spacing
+ this.spacingToFirstItem = this.totalLength;
+ } else {
+ // Simple case, we had no item on the beginning -> all good
+ if (this.spacingToFirstItem >= beltLength) {
+ DEBUG &&
+ logger.log(
+ " No item on the first place, so we can just adjust the spacing (spacing=",
+ this.spacingToFirstItem,
+ ") removed =",
+ beltLength
+ );
+ this.spacingToFirstItem -= beltLength;
+ } else {
+ // Welp, okay we need to drop all items which are < beltLength and adjust
+ // the other item offsets as well
+
+ DEBUG &&
+ logger.log(
+ " We have at least one item in the beginning, drop those and adjust spacing (first item @",
+ this.spacingToFirstItem,
+ ") since we removed",
+ beltLength,
+ "length from path"
+ );
+ DEBUG &&
+ logger.log(
+ " Items:",
+ this.items.map(i => i[0 /* nextDistance */])
+ );
+
+ // Find offset to first item
+ let itemOffset = this.spacingToFirstItem;
+ for (let i = 0; i < this.items.length; ++i) {
+ const item = this.items[i];
+ if (itemOffset <= beltLength) {
+ DEBUG &&
+ logger.log(
+ " -> Dropping item with index",
+ i,
+ "at",
+ itemOffset,
+ "since it was on the removed belt"
+ );
+ // This item must be dropped
+ this.items.splice(i, 1);
+ i -= 1;
+ itemOffset += item[0 /* nextDistance */];
+ continue;
+ } else {
+ // This item can be kept, thus its the first we know
+ break;
+ }
+ }
+
+ if (this.items.length > 0) {
+ DEBUG &&
+ logger.log(
+ " Offset of first non-dropped item was at:",
+ itemOffset,
+ "-> setting spacing to it (total length=",
+ this.totalLength,
+ ")"
+ );
+
+ this.spacingToFirstItem = itemOffset - beltLength;
+ assert(
+ this.spacingToFirstItem >= 0.0,
+ "Invalid spacing after delete on start: " + this.spacingToFirstItem
+ );
+ } else {
+ DEBUG && logger.log(" We dropped all items, simply set spacing to total length");
+ // We dropped all items, simple one
+ this.spacingToFirstItem = this.totalLength;
+ }
+ }
+ }
+
+ // Update bounds
+ this.worldBounds = this.computeBounds();
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("delete-on-start");
+ }
+ }
+
+ /**
+ * Extends the path by the given other path
+ * @param {BeltPath} otherPath
+ */
+ extendByPath(otherPath) {
+ assert(otherPath !== this, "Circular path dependency");
+
+ const entities = otherPath.entityPath;
+ DEBUG && logger.log("Extending path by other path, starting to add entities");
+
+ const oldLength = this.totalLength;
+
+ DEBUG && logger.log(" Adding", entities.length, "new entities, current length =", this.totalLength);
+
+ // First, append entities
+ for (let i = 0; i < entities.length; ++i) {
+ const entity = entities[i];
+ const beltComp = entity.components.Belt;
+
+ // Add to path and update references
+ this.entityPath.push(entity);
+ beltComp.assignedPath = this;
+
+ // Update our length
+ const additionalLength = beltComp.getEffectiveLengthTiles();
+ this.totalLength += additionalLength;
+ }
+
+ DEBUG &&
+ logger.log(
+ " Path is now",
+ this.entityPath.length,
+ "entities and has a length of",
+ this.totalLength
+ );
+
+ // Now, update the distance of our last item
+ if (this.items.length !== 0) {
+ const lastItem = this.items[this.items.length - 1];
+ lastItem[0 /* nextDistance */] += otherPath.spacingToFirstItem;
+ DEBUG &&
+ logger.log(
+ " Add distance to last item, effectively being",
+ lastItem[0 /* nextDistance */],
+ "now"
+ );
+ } else {
+ // Seems we have no items, update our first item distance
+ this.spacingToFirstItem = oldLength + otherPath.spacingToFirstItem;
+ DEBUG &&
+ logger.log(
+ " We had no items, so our new spacing to first is old length (",
+ oldLength,
+ ") plus others spacing to first (",
+ otherPath.spacingToFirstItem,
+ ") =",
+ this.spacingToFirstItem
+ );
+ }
+
+ DEBUG && logger.log(" Pushing", otherPath.items.length, "items from other path");
+
+ // Aaand push the other paths items
+ for (let i = 0; i < otherPath.items.length; ++i) {
+ const item = otherPath.items[i];
+ this.items.push([item[0 /* nextDistance */], item[1 /* item */]]);
+ }
+
+ // Update bounds
+ this.worldBounds = this.computeBounds();
+
+ this.onPathChanged();
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("extend-by-path");
+ }
+ }
+
+ /**
+ * Computes the total length of the path
+ * @returns {number}
+ */
+ computeTotalLength() {
+ let length = 0;
+ for (let i = 0; i < this.entityPath.length; ++i) {
+ const entity = this.entityPath[i];
+ length += entity.components.Belt.getEffectiveLengthTiles();
+ }
+ return length;
+ }
+
+ /**
+ * Performs one tick
+ */
+ update() {
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("pre-update");
+ }
+
+ // Skip empty belts
+ if (this.items.length === 0) {
+ return;
+ }
+
+ // Divide by item spacing on belts since we use throughput and not speed
+ let beltSpeed =
+ this.root.hubGoals.getBeltBaseSpeed() *
+ this.root.dynamicTickrate.deltaSeconds *
+ globalConfig.itemSpacingOnBelts;
+
+ if (G_IS_DEV && globalConfig.debug.instantBelts) {
+ beltSpeed *= 100;
+ }
+
+ // Store whether this is the first item we processed, so premature
+ // item ejection is available
+ let isFirstItemProcessed = true;
+
+ // Store how much velocity (strictly its distance, not velocity) we have to distribute over all items
+ let remainingVelocity = beltSpeed;
+
+ // Store the last item we processed, so we can skip clashed ones
+ let lastItemProcessed;
+
+ for (lastItemProcessed = this.items.length - 1; lastItemProcessed >= 0; --lastItemProcessed) {
+ const nextDistanceAndItem = this.items[lastItemProcessed];
+
+ // Compute how much spacing we need at least
+ const minimumSpacing =
+ lastItemProcessed === this.items.length - 1 ? 0 : globalConfig.itemSpacingOnBelts;
+
+ // Compute how much we can advance
+ let clampedProgress = nextDistanceAndItem[0 /* nextDistance */] - minimumSpacing;
+
+ // Make sure we don't advance more than the remaining velocity has stored
+ if (remainingVelocity < clampedProgress) {
+ clampedProgress = remainingVelocity;
+ }
+
+ // Make sure we don't advance back
+ if (clampedProgress < 0) {
+ clampedProgress = 0;
+ }
+
+ // Reduce our velocity by the amount we consumed
+ remainingVelocity -= clampedProgress;
+
+ // Reduce the spacing
+ nextDistanceAndItem[0 /* nextDistance */] -= clampedProgress;
+
+ // Advance all items behind by the progress we made
+ this.spacingToFirstItem += clampedProgress;
+
+ // If the last item can be ejected, eject it and reduce the spacing, because otherwise
+ // we lose velocity
+ if (isFirstItemProcessed && nextDistanceAndItem[0 /* nextDistance */] < 1e-7) {
+ // Store how much velocity we "lost" because we bumped the item to the end of the
+ // belt but couldn't move it any farther. We need this to tell the item acceptor
+ // animation to start a tad later, so everything matches up. Yes I'm a perfectionist.
+ const excessVelocity = beltSpeed - clampedProgress;
+
+ // Try to directly get rid of the item
+ if (
+ this.boundAcceptor &&
+ this.boundAcceptor(nextDistanceAndItem[1 /* item */], excessVelocity)
+ ) {
+ this.items.pop();
+
+ const itemBehind = this.items[lastItemProcessed - 1];
+ if (itemBehind && this.numCompressedItemsAfterFirstItem > 0) {
+ // So, with the next tick we will skip this item, but it actually has the potential
+ // to process farther -> If we don't advance here, we loose a tiny bit of progress
+ // every tick which causes the belt to be slower than it actually is.
+ // Also see #999
+ const fixupProgress = Math.max(
+ 0,
+ Math.min(remainingVelocity, itemBehind[0 /* nextDistance */])
+ );
+
+ // See above
+ itemBehind[0 /* nextDistance */] -= fixupProgress;
+ remainingVelocity -= fixupProgress;
+ this.spacingToFirstItem += fixupProgress;
+ }
+
+ // Reduce the number of compressed items since the first item no longer exists
+ this.numCompressedItemsAfterFirstItem = Math.max(
+ 0,
+ this.numCompressedItemsAfterFirstItem - 1
+ );
+ }
+ }
+
+ if (isFirstItemProcessed) {
+ // Skip N null items after first items
+ lastItemProcessed -= this.numCompressedItemsAfterFirstItem;
+ }
+
+ isFirstItemProcessed = false;
+ if (remainingVelocity < 1e-7) {
+ break;
+ }
+ }
+
+ // Compute compressed item count
+ this.numCompressedItemsAfterFirstItem = Math.max(
+ 0,
+ this.numCompressedItemsAfterFirstItem,
+ this.items.length - 2 - lastItemProcessed
+ );
+
+ // Check if we have an item which is ready to be emitted
+ const lastItem = this.items[this.items.length - 1];
+ if (lastItem && lastItem[0 /* nextDistance */] === 0) {
+ if (this.boundAcceptor && this.boundAcceptor(lastItem[1 /* item */])) {
+ this.items.pop();
+ this.numCompressedItemsAfterFirstItem = Math.max(
+ 0,
+ this.numCompressedItemsAfterFirstItem - 1
+ );
+ }
+ }
+
+ if (G_IS_DEV && globalConfig.debug.checkBeltPaths) {
+ this.debug_checkIntegrity("post-update");
+ }
+ }
+
+ /**
+ * Computes a world space position from the given progress
+ * @param {number} progress
+ * @returns {Vector}
+ */
+ computePositionFromProgress(progress) {
+ let currentLength = 0;
+
+ // floating point issues ..
+ assert(progress <= this.totalLength + 0.02, "Progress too big: " + progress);
+
+ for (let i = 0; i < this.entityPath.length; ++i) {
+ const beltComp = this.entityPath[i].components.Belt;
+ const localLength = beltComp.getEffectiveLengthTiles();
+
+ if (currentLength + localLength >= progress || i === this.entityPath.length - 1) {
+ // Min required here due to floating point issues
+ const localProgress = Math.min(1.0, progress - currentLength);
+
+ assert(localProgress >= 0.0, "Invalid local progress: " + localProgress);
+ const localSpace = beltComp.transformBeltToLocalSpace(localProgress);
+ return this.entityPath[i].components.StaticMapEntity.localTileToWorld(localSpace);
+ }
+ currentLength += localLength;
+ }
+
+ assert(false, "invalid progress: " + progress + " (max: " + this.totalLength + ")");
+ }
+
+ /**
+ *
+ * @param {DrawParameters} parameters
+ */
+ drawDebug(parameters) {
+ if (!parameters.visibleRect.containsRect(this.worldBounds)) {
+ return;
+ }
+
+ parameters.context.fillStyle = "#d79a25";
+ parameters.context.strokeStyle = "#d79a25";
+ parameters.context.beginPath();
+
+ for (let i = 0; i < this.entityPath.length; ++i) {
+ const entity = this.entityPath[i];
+ const pos = entity.components.StaticMapEntity;
+ const worldPos = pos.origin.toWorldSpaceCenterOfTile();
+
+ if (i === 0) {
+ parameters.context.moveTo(worldPos.x, worldPos.y);
+ } else {
+ parameters.context.lineTo(worldPos.x, worldPos.y);
+ }
+ }
+ parameters.context.stroke();
+
+ // Items
+ let progress = this.spacingToFirstItem;
+ for (let i = 0; i < this.items.length; ++i) {
+ const nextDistanceAndItem = this.items[i];
+ const worldPos = this.computePositionFromProgress(progress).toWorldSpaceCenterOfTile();
+ parameters.context.fillStyle = "#268e4d";
+ parameters.context.beginPath();
+ parameters.context.roundRect(worldPos.x - 5, worldPos.y - 5, 10, 10, 3);
+ parameters.context.fill();
+ parameters.context.font = "6px GameFont";
+ parameters.context.fillStyle = "#111";
+ parameters.context.fillText(
+ "" + round4Digits(nextDistanceAndItem[0 /* nextDistance */]),
+ worldPos.x + 5,
+ worldPos.y + 2
+ );
+ progress += nextDistanceAndItem[0 /* nextDistance */];
+
+ if (this.items.length - 1 - this.numCompressedItemsAfterFirstItem === i) {
+ parameters.context.fillStyle = "red";
+ parameters.context.fillRect(worldPos.x + 5, worldPos.y, 20, 3);
+ }
+ }
+
+ for (let i = 0; i < this.entityPath.length; ++i) {
+ const entity = this.entityPath[i];
+ parameters.context.fillStyle = "#d79a25";
+ const pos = entity.components.StaticMapEntity;
+ const worldPos = pos.origin.toWorldSpaceCenterOfTile();
+ parameters.context.beginCircle(worldPos.x, worldPos.y, i === 0 ? 5 : 3);
+ parameters.context.fill();
+ }
+
+ for (let progress = 0; progress <= this.totalLength + 0.01; progress += 0.2) {
+ const worldPos = this.computePositionFromProgress(progress).toWorldSpaceCenterOfTile();
+ parameters.context.fillStyle = "red";
+ parameters.context.beginCircle(worldPos.x, worldPos.y, 1);
+ parameters.context.fill();
+ }
+
+ const firstItemIndicator = this.computePositionFromProgress(
+ this.spacingToFirstItem
+ ).toWorldSpaceCenterOfTile();
+ parameters.context.fillStyle = "purple";
+ parameters.context.fillRect(firstItemIndicator.x - 3, firstItemIndicator.y - 1, 6, 2);
+ }
+
+ /**
+ * Checks if this belt path should render simplified
+ */
+ checkIsPotatoMode() {
+ // POTATO Mode: Only show items when belt is hovered
+ if (!this.root.app.settings.getAllSettings().simplifiedBelts) {
+ return false;
+ }
+
+ if (this.root.currentLayer !== "regular") {
+ // Not in regular layer
+ return true;
+ }
+
+ const mousePos = this.root.app.mousePosition;
+ if (!mousePos) {
+ // Mouse not registered
+ return true;
+ }
+
+ const tile = this.root.camera.screenToWorld(mousePos).toTileSpace();
+ const contents = this.root.map.getLayerContentXY(tile.x, tile.y, "regular");
+ if (!contents || !contents.components.Belt) {
+ // Nothing below
+ return true;
+ }
+
+ if (contents.components.Belt.assignedPath !== this) {
+ // Not this path
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Draws the path
+ * @param {DrawParameters} parameters
+ */
+ draw(parameters) {
+ if (!parameters.visibleRect.containsRect(this.worldBounds)) {
+ return;
+ }
+
+ if (this.items.length === 0) {
+ // Early out
+ return;
+ }
+
+ if (this.checkIsPotatoMode()) {
+ const firstItem = this.items[0];
+ if (this.entityPath.length > 1 && firstItem) {
+ const medianBeltIndex = clamp(
+ Math.round(this.entityPath.length / 2 - 1),
+ 0,
+ this.entityPath.length - 1
+ );
+ const medianBelt = this.entityPath[medianBeltIndex];
+ const beltComp = medianBelt.components.Belt;
+ const staticComp = medianBelt.components.StaticMapEntity;
+ const centerPosLocal = beltComp.transformBeltToLocalSpace(
+ this.entityPath.length % 2 === 0 ? beltComp.getEffectiveLengthTiles() : 0.5
+ );
+ const centerPos = staticComp.localTileToWorld(centerPosLocal).toWorldSpaceCenterOfTile();
+
+ parameters.context.globalAlpha = 0.5;
+ firstItem[1 /* item */].drawItemCenteredClipped(centerPos.x, centerPos.y, parameters);
+ parameters.context.globalAlpha = 1;
+ }
+
+ return;
+ }
+
+ let currentItemPos = this.spacingToFirstItem;
+ let currentItemIndex = 0;
+
+ let trackPos = 0.0;
+
+ /**
+ * @type {Array<[Vector, BaseItem]>}
+ */
+ let drawStack = [];
+ let drawStackProp = "";
+
+ // Iterate whole track and check items
+ for (let i = 0; i < this.entityPath.length; ++i) {
+ const entity = this.entityPath[i];
+ const beltComp = entity.components.Belt;
+ const beltLength = beltComp.getEffectiveLengthTiles();
+
+ // Check if the current items are on the belt
+ while (trackPos + beltLength >= currentItemPos - 1e-5) {
+ // It's on the belt, render it now
+ const staticComp = entity.components.StaticMapEntity;
+ assert(
+ currentItemPos - trackPos >= 0,
+ "invalid track pos: " + currentItemPos + " vs " + trackPos + " (l =" + beltLength + ")"
+ );
+
+ const localPos = beltComp.transformBeltToLocalSpace(currentItemPos - trackPos);
+ const worldPos = staticComp.localTileToWorld(localPos).toWorldSpaceCenterOfTile();
+
+ const distanceAndItem = this.items[currentItemIndex];
+ const item = distanceAndItem[1 /* item */];
+ const nextItemDistance = distanceAndItem[0 /* nextDistance */];
+
+ if (
+ !parameters.visibleRect.containsCircle(
+ worldPos.x,
+ worldPos.y,
+ globalConfig.defaultItemDiameter
+ )
+ ) {
+ // this one isn't visible, do not append it
+ // Start a new stack
+ this.drawDrawStack(drawStack, parameters, drawStackProp);
+ drawStack = [];
+ drawStackProp = "";
+ } else {
+ if (drawStack.length > 1) {
+ // Check if we can append to the stack, since its already a stack of two same items
+ const referenceItem = drawStack[0];
+
+ if (
+ referenceItem[1].equals(item) &&
+ Math.abs(referenceItem[0][drawStackProp] - worldPos[drawStackProp]) < 0.001
+ ) {
+ // Will continue stack
+ } else {
+ // Start a new stack, since item doesn't follow in row
+ this.drawDrawStack(drawStack, parameters, drawStackProp);
+ drawStack = [];
+ drawStackProp = "";
+ }
+ } else if (drawStack.length === 1) {
+ const firstItem = drawStack[0];
+
+ // Check if we can make it a stack
+ if (firstItem[1 /* item */].equals(item)) {
+ // Same item, check if it is either horizontal or vertical
+ const startPos = firstItem[0 /* pos */];
+
+ if (Math.abs(startPos.x - worldPos.x) < 0.001) {
+ drawStackProp = "x";
+ } else if (Math.abs(startPos.y - worldPos.y) < 0.001) {
+ drawStackProp = "y";
+ } else {
+ // Start a new stack
+ this.drawDrawStack(drawStack, parameters, drawStackProp);
+ drawStack = [];
+ drawStackProp = "";
+ }
+ } else {
+ // Start a new stack, since item doesn't equal
+ this.drawDrawStack(drawStack, parameters, drawStackProp);
+ drawStack = [];
+ drawStackProp = "";
+ }
+ } else {
+ // First item of stack, do nothing
+ }
+
+ drawStack.push([worldPos, item]);
+ }
+
+ // Check for the next item
+ currentItemPos += nextItemDistance;
+ ++currentItemIndex;
+
+ if (
+ nextItemDistance > globalConfig.itemSpacingOnBelts + 0.001 ||
+ drawStack.length > globalConfig.maxBeltShapeBundleSize
+ ) {
+ // If next item is not directly following, abort drawing
+ this.drawDrawStack(drawStack, parameters, drawStackProp);
+ drawStack = [];
+ drawStackProp = "";
+ }
+
+ if (currentItemIndex >= this.items.length) {
+ // We rendered all items
+
+ this.drawDrawStack(drawStack, parameters, drawStackProp);
+ return;
+ }
+ }
+
+ trackPos += beltLength;
+ }
+
+ this.drawDrawStack(drawStack, parameters, drawStackProp);
+ }
+
+ /**
+ *
+ * @param {HTMLCanvasElement} canvas
+ * @param {CanvasRenderingContext2D} context
+ * @param {number} w
+ * @param {number} h
+ * @param {number} dpi
+ * @param {object} param0
+ * @param {string} param0.direction
+ * @param {Array<[Vector, BaseItem]>} param0.stack
+ * @param {GameRoot} param0.root
+ * @param {number} param0.zoomLevel
+ */
+ drawShapesInARow(canvas, context, w, h, dpi, { direction, stack, root, zoomLevel }) {
+ context.scale(dpi, dpi);
+
+ if (G_IS_DEV && globalConfig.debug.showShapeGrouping) {
+ context.fillStyle = "rgba(0, 0, 255, 0.5)";
+ context.fillRect(0, 0, w, h);
+ }
+
+ const parameters = new DrawParameters({
+ context,
+ desiredAtlasScale: ORIGINAL_SPRITE_SCALE,
+ root,
+ visibleRect: new Rectangle(-1000, -1000, 2000, 2000),
+ zoomLevel,
+ });
+
+ const itemSize = globalConfig.itemSpacingOnBelts * globalConfig.tileSize;
+ const item = stack[0];
+ const pos = new Vector(itemSize / 2, itemSize / 2);
+
+ for (let i = 0; i < stack.length; i++) {
+ item[1].drawItemCenteredClipped(pos.x, pos.y, parameters, globalConfig.defaultItemDiameter);
+ pos[direction] += globalConfig.itemSpacingOnBelts * globalConfig.tileSize;
+ }
+ }
+
+ /**
+ * @param {Array<[Vector, BaseItem]>} stack
+ * @param {DrawParameters} parameters
+ */
+ drawDrawStack(stack, parameters, directionProp) {
+ if (stack.length === 0) {
+ return;
+ }
+
+ const firstItem = stack[0];
+ const firstItemPos = firstItem[0];
+ if (stack.length === 1) {
+ firstItem[1].drawItemCenteredClipped(
+ firstItemPos.x,
+ firstItemPos.y,
+ parameters,
+ globalConfig.defaultItemDiameter
+ );
+ return;
+ }
+
+ const itemSize = globalConfig.itemSpacingOnBelts * globalConfig.tileSize;
+ const inverseDirection = directionProp === "x" ? "y" : "x";
+
+ const dimensions = new Vector(itemSize, itemSize);
+ dimensions[inverseDirection] *= stack.length;
+
+ const directionVector = firstItemPos.copy().sub(stack[1][0]);
+
+ const dpi = smoothenDpi(globalConfig.shapesSharpness * parameters.zoomLevel);
+
+ const sprite = this.root.buffers.getForKey({
+ key: "beltpaths",
+ subKey:
+ "stack-" +
+ directionProp +
+ "-" +
+ dpi +
+ "#" +
+ stack.length +
+ "#" +
+ firstItem[1].getItemType() +
+ "#" +
+ firstItem[1].serialize(),
+ dpi,
+ w: dimensions.x,
+ h: dimensions.y,
+ redrawMethod: this.drawShapesInARow.bind(this),
+ additionalParams: {
+ direction: inverseDirection,
+ stack,
+ root: this.root,
+ zoomLevel: parameters.zoomLevel,
+ },
+ });
+
+ const anchor = directionVector[inverseDirection] < 0 ? firstItem : stack[stack.length - 1];
+
+ parameters.context.drawImage(
+ sprite,
+ anchor[0].x - itemSize / 2,
+ anchor[0].y - itemSize / 2,
+ dimensions.x,
+ dimensions.y
+ );
+ }
+}
diff --git a/src/js/game/blueprint.js b/src/js/game/blueprint.js
index 14848485..34e4ed23 100644
--- a/src/js/game/blueprint.js
+++ b/src/js/game/blueprint.js
@@ -3,7 +3,6 @@ import { DrawParameters } from "../core/draw_parameters";
import { findNiceIntegerValue } from "../core/utils";
import { Vector } from "../core/vector";
import { Entity } from "./entity";
-import { ACHIEVEMENTS } from "../platform/achievement_provider";
import { GameRoot } from "./root";
export class Blueprint {
@@ -88,7 +87,13 @@ export class Blueprint {
parameters.context.globalAlpha = 1;
}
- staticComp.drawSpriteOnBoundsClipped(parameters, staticComp.getBlueprintSprite(), 0, newPos);
+ staticComp.drawSpriteOnBoundsClipped(
+ parameters,
+ staticComp.getBlueprintSprite(),
+ 0,
+ newPos,
+ true
+ );
}
parameters.context.globalAlpha = 1;
}
@@ -172,13 +177,6 @@ export class Blueprint {
count++;
}
- root.signals.bulkAchievementCheck.dispatch(
- ACHIEVEMENTS.placeBlueprint,
- count,
- ACHIEVEMENTS.placeBp1000,
- count
- );
-
return count !== 0;
});
});
diff --git a/src/js/game/building_codes.js b/src/js/game/building_codes.js
index 1d178daf..7dd853ba 100644
--- a/src/js/game/building_codes.js
+++ b/src/js/game/building_codes.js
@@ -1,109 +1,109 @@
-/* typehints:start */
-import { MetaBuilding } from "./meta_building";
-import { AtlasSprite } from "../core/sprites";
-import { Vector } from "../core/vector";
-/* typehints:end */
-
-import { gMetaBuildingRegistry } from "../core/global_registries";
-
-/**
- * @typedef {{
- * metaClass: typeof MetaBuilding,
- * metaInstance?: MetaBuilding,
- * variant?: string,
- * rotationVariant?: number,
- * tileSize?: Vector,
- * sprite?: AtlasSprite,
- * blueprintSprite?: AtlasSprite,
- * silhouetteColor?: string
- * }} BuildingVariantIdentifier
- */
-
-/**
- * Stores a lookup table for all building variants (for better performance)
- * @type {Object}
- */
-export const gBuildingVariants = {
- // Set later
-};
-
-/**
- * Mapping from 'metaBuildingId/variant/rotationVariant' to building code
- * @type {Map}
- */
-const variantsCache = new Map();
-
-/**
- * Registers a new variant
- * @param {number|string} code
- * @param {typeof MetaBuilding} meta
- * @param {string} variant
- * @param {number} rotationVariant
- */
-export function registerBuildingVariant(
- code,
- meta,
- variant = "default" /* @TODO: Circular dependency, actually its defaultBuildingVariant */,
- rotationVariant = 0
-) {
- assert(!gBuildingVariants[code], "Duplicate id: " + code);
- gBuildingVariants[code] = {
- metaClass: meta,
- metaInstance: gMetaBuildingRegistry.findByClass(meta),
- variant,
- rotationVariant,
- // @ts-ignore
- tileSize: new meta().getDimensions(variant),
- };
-}
-
-/**
- * Hashes the combination of buildng, variant and rotation variant
- * @param {string} buildingId
- * @param {string} variant
- * @param {number} rotationVariant
- * @returns
- */
-function generateBuildingHash(buildingId, variant, rotationVariant) {
- return buildingId + "/" + variant + "/" + rotationVariant;
-}
-
-/**
- *
- * @param {string|number} code
- * @returns {BuildingVariantIdentifier}
- */
-export function getBuildingDataFromCode(code) {
- assert(gBuildingVariants[code], "Invalid building code: " + code);
- return gBuildingVariants[code];
-}
-
-/**
- * Builds the cache for the codes
- */
-export function buildBuildingCodeCache() {
- for (const code in gBuildingVariants) {
- const data = gBuildingVariants[code];
- const hash = generateBuildingHash(data.metaInstance.getId(), data.variant, data.rotationVariant);
- variantsCache.set(hash, isNaN(+code) ? code : +code);
- }
-}
-
-/**
- * Finds the code for a given variant
- * @param {MetaBuilding} metaBuilding
- * @param {string} variant
- * @param {number} rotationVariant
- * @returns {number|string}
- */
-export function getCodeFromBuildingData(metaBuilding, variant, rotationVariant) {
- const hash = generateBuildingHash(metaBuilding.getId(), variant, rotationVariant);
- const result = variantsCache.get(hash);
- if (G_IS_DEV) {
- if (!result) {
- console.warn("Known hashes:", Array.from(variantsCache.keys()));
- assertAlways(false, "Building not found by data: " + hash);
- }
- }
- return result;
-}
+/* typehints:start */
+import { MetaBuilding } from "./meta_building";
+import { AtlasSprite } from "../core/sprites";
+import { Vector } from "../core/vector";
+/* typehints:end */
+
+import { gMetaBuildingRegistry } from "../core/global_registries";
+
+/**
+ * @typedef {{
+ * metaClass: typeof MetaBuilding,
+ * metaInstance?: MetaBuilding,
+ * variant?: string,
+ * rotationVariant?: number,
+ * tileSize?: Vector,
+ * sprite?: AtlasSprite,
+ * blueprintSprite?: AtlasSprite,
+ * silhouetteColor?: string
+ * }} BuildingVariantIdentifier
+ */
+
+/**
+ * Stores a lookup table for all building variants (for better performance)
+ * @type {Object}
+ */
+export const gBuildingVariants = {
+ // Set later
+};
+
+/**
+ * Mapping from 'metaBuildingId/variant/rotationVariant' to building code
+ * @type {Map}
+ */
+const variantsCache = new Map();
+
+/**
+ * Registers a new variant
+ * @param {number|string} code
+ * @param {typeof MetaBuilding} meta
+ * @param {string} variant
+ * @param {number} rotationVariant
+ */
+export function registerBuildingVariant(
+ code,
+ meta,
+ variant = "default" /* @TODO: Circular dependency, actually its defaultBuildingVariant */,
+ rotationVariant = 0
+) {
+ assert(!gBuildingVariants[code], "Duplicate id: " + code);
+ gBuildingVariants[code] = {
+ metaClass: meta,
+ metaInstance: gMetaBuildingRegistry.findByClass(meta),
+ variant,
+ rotationVariant,
+ // @ts-ignore
+ tileSize: new meta().getDimensions(variant),
+ };
+}
+
+/**
+ * Hashes the combination of buildng, variant and rotation variant
+ * @param {string} buildingId
+ * @param {string} variant
+ * @param {number} rotationVariant
+ * @returns
+ */
+function generateBuildingHash(buildingId, variant, rotationVariant) {
+ return buildingId + "/" + variant + "/" + rotationVariant;
+}
+
+/**
+ *
+ * @param {string|number} code
+ * @returns {BuildingVariantIdentifier}
+ */
+export function getBuildingDataFromCode(code) {
+ assert(gBuildingVariants[code], "Invalid building code: " + code);
+ return gBuildingVariants[code];
+}
+
+/**
+ * Builds the cache for the codes
+ */
+export function buildBuildingCodeCache() {
+ for (const code in gBuildingVariants) {
+ const data = gBuildingVariants[code];
+ const hash = generateBuildingHash(data.metaInstance.getId(), data.variant, data.rotationVariant);
+ variantsCache.set(hash, isNaN(+code) ? code : +code);
+ }
+}
+
+/**
+ * Finds the code for a given variant
+ * @param {MetaBuilding} metaBuilding
+ * @param {string} variant
+ * @param {number} rotationVariant
+ * @returns {number|string}
+ */
+export function getCodeFromBuildingData(metaBuilding, variant, rotationVariant) {
+ const hash = generateBuildingHash(metaBuilding.getId(), variant, rotationVariant);
+ const result = variantsCache.get(hash);
+ if (G_IS_DEV) {
+ if (!result) {
+ console.warn("Known hashes:", Array.from(variantsCache.keys()));
+ assertAlways(false, "Building not found by data: " + hash);
+ }
+ }
+ return result;
+}
diff --git a/src/js/game/buildings/analyzer.js b/src/js/game/buildings/analyzer.js
index 13597d7b..68cfbfa2 100644
--- a/src/js/game/buildings/analyzer.js
+++ b/src/js/game/buildings/analyzer.js
@@ -1,88 +1,88 @@
-import { generateMatrixRotations } from "../../core/utils";
-import { enumDirection, Vector } from "../../core/vector";
-import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-const overlayMatrix = generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 0]);
-
-export class MetaAnalyzerBuilding extends MetaBuilding {
- constructor() {
- super("analyzer");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 43,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#3a52bc";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing);
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getRenderPins() {
- // We already have it included
- return false;
- }
-
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant) {
- return overlayMatrix[rotation];
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.right,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- type: enumPinSlotType.logicalAcceptor,
- },
- ],
- })
- );
-
- entity.addComponent(
- new LogicGateComponent({
- type: enumLogicGateType.analyzer,
- })
- );
- }
-}
+import { generateMatrixRotations } from "../../core/utils";
+import { enumDirection, Vector } from "../../core/vector";
+import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+const overlayMatrix = generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 0]);
+
+export class MetaAnalyzerBuilding extends MetaBuilding {
+ constructor() {
+ super("analyzer");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 43,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#3a52bc";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing);
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getRenderPins() {
+ // We already have it included
+ return false;
+ }
+
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant) {
+ return overlayMatrix[rotation];
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.right,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new LogicGateComponent({
+ type: enumLogicGateType.analyzer,
+ })
+ );
+ }
+}
diff --git a/src/js/game/buildings/balancer.js b/src/js/game/buildings/balancer.js
index ce685a9a..181bcb87 100644
--- a/src/js/game/buildings/balancer.js
+++ b/src/js/game/buildings/balancer.js
@@ -1,261 +1,261 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
-import { Entity } from "../entity";
-import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-import { T } from "../../translations";
-import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
-import { BeltUnderlaysComponent } from "../components/belt_underlays";
-
-/** @enum {string} */
-export const enumBalancerVariants = {
- merger: "merger",
- mergerInverse: "merger-inverse",
- splitter: "splitter",
- splitterInverse: "splitter-inverse",
-};
-
-const overlayMatrices = {
- [defaultBuildingVariant]: null,
- [enumBalancerVariants.merger]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
- [enumBalancerVariants.mergerInverse]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
- [enumBalancerVariants.splitter]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
- [enumBalancerVariants.splitterInverse]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
-};
-
-export class MetaBalancerBuilding extends MetaBuilding {
- constructor() {
- super("balancer");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 4,
- variant: defaultBuildingVariant,
- },
- {
- internalId: 5,
- variant: enumBalancerVariants.merger,
- },
- {
- internalId: 6,
- variant: enumBalancerVariants.mergerInverse,
- },
- {
- internalId: 47,
- variant: enumBalancerVariants.splitter,
- },
- {
- internalId: 48,
- variant: enumBalancerVariants.splitterInverse,
- },
- ];
- }
-
- getDimensions(variant) {
- switch (variant) {
- case defaultBuildingVariant:
- return new Vector(2, 1);
- case enumBalancerVariants.merger:
- case enumBalancerVariants.mergerInverse:
- case enumBalancerVariants.splitter:
- case enumBalancerVariants.splitterInverse:
- return new Vector(1, 1);
- default:
- assertAlways(false, "Unknown balancer variant: " + variant);
- }
- }
-
- /**
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- * @returns {Array|null}
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- const matrix = overlayMatrices[variant];
- if (matrix) {
- return matrix[rotation];
- }
- return null;
- }
-
- /**
- * @param {GameRoot} root
- * @param {string} variant
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- if (root.gameMode.throughputDoesNotMatter()) {
- return [];
- }
-
- let speedMultiplier = 2;
- switch (variant) {
- case enumBalancerVariants.merger:
- case enumBalancerVariants.mergerInverse:
- case enumBalancerVariants.splitter:
- case enumBalancerVariants.splitterInverse:
- speedMultiplier = 1;
- }
-
- const speed =
- (root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2) * speedMultiplier;
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
- }
-
- getSilhouetteColor() {
- return "#555759";
- }
-
- /**
- * @param {GameRoot} root
- */
- getAvailableVariants(root) {
- const deterministic = root.gameMode.getIsDeterministic();
-
- let available = deterministic ? [] : [defaultBuildingVariant];
-
- if (!deterministic && root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_merger)) {
- available.push(enumBalancerVariants.merger, enumBalancerVariants.mergerInverse);
- }
-
- if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_splitter)) {
- available.push(enumBalancerVariants.splitter, enumBalancerVariants.splitterInverse);
- }
-
- return available;
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_balancer);
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new ItemAcceptorComponent({
- slots: [], // set later
- })
- );
-
- entity.addComponent(
- new ItemProcessorComponent({
- inputsPerCharge: 1,
- processorType: enumItemProcessorTypes.balancer,
- })
- );
-
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [], // set later
- renderFloatingItems: false,
- })
- );
-
- entity.addComponent(new BeltUnderlaysComponent({ underlays: [] }));
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- * @param {string} variant
- */
- updateVariants(entity, rotationVariant, variant) {
- switch (variant) {
- case defaultBuildingVariant: {
- entity.components.ItemAcceptor.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- },
- {
- pos: new Vector(1, 0),
- direction: enumDirection.bottom,
- },
- ]);
-
- entity.components.ItemEjector.setSlots([
- { pos: new Vector(0, 0), direction: enumDirection.top },
- { pos: new Vector(1, 0), direction: enumDirection.top },
- ]);
-
- entity.components.BeltUnderlays.underlays = [
- { pos: new Vector(0, 0), direction: enumDirection.top },
- { pos: new Vector(1, 0), direction: enumDirection.top },
- ];
-
- break;
- }
- case enumBalancerVariants.merger:
- case enumBalancerVariants.mergerInverse: {
- entity.components.ItemAcceptor.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- },
- {
- pos: new Vector(0, 0),
- direction:
- variant === enumBalancerVariants.mergerInverse
- ? enumDirection.left
- : enumDirection.right,
- },
- ]);
-
- entity.components.ItemEjector.setSlots([
- { pos: new Vector(0, 0), direction: enumDirection.top },
- ]);
-
- entity.components.BeltUnderlays.underlays = [
- { pos: new Vector(0, 0), direction: enumDirection.top },
- ];
-
- break;
- }
- case enumBalancerVariants.splitter:
- case enumBalancerVariants.splitterInverse: {
- entity.components.ItemAcceptor.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- },
- ]);
-
- entity.components.ItemEjector.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- },
- {
- pos: new Vector(0, 0),
- direction:
- variant === enumBalancerVariants.splitterInverse
- ? enumDirection.left
- : enumDirection.right,
- },
- ]);
-
- entity.components.BeltUnderlays.underlays = [
- { pos: new Vector(0, 0), direction: enumDirection.top },
- ];
-
- break;
- }
- default:
- assertAlways(false, "Unknown balancer variant: " + variant);
- }
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { Entity } from "../entity";
+import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+import { T } from "../../translations";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
+import { BeltUnderlaysComponent } from "../components/belt_underlays";
+
+/** @enum {string} */
+export const enumBalancerVariants = {
+ merger: "merger",
+ mergerInverse: "merger-inverse",
+ splitter: "splitter",
+ splitterInverse: "splitter-inverse",
+};
+
+const overlayMatrices = {
+ [defaultBuildingVariant]: null,
+ [enumBalancerVariants.merger]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
+ [enumBalancerVariants.mergerInverse]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
+ [enumBalancerVariants.splitter]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
+ [enumBalancerVariants.splitterInverse]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
+};
+
+export class MetaBalancerBuilding extends MetaBuilding {
+ constructor() {
+ super("balancer");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 4,
+ variant: defaultBuildingVariant,
+ },
+ {
+ internalId: 5,
+ variant: enumBalancerVariants.merger,
+ },
+ {
+ internalId: 6,
+ variant: enumBalancerVariants.mergerInverse,
+ },
+ {
+ internalId: 47,
+ variant: enumBalancerVariants.splitter,
+ },
+ {
+ internalId: 48,
+ variant: enumBalancerVariants.splitterInverse,
+ },
+ ];
+ }
+
+ getDimensions(variant) {
+ switch (variant) {
+ case defaultBuildingVariant:
+ return new Vector(2, 1);
+ case enumBalancerVariants.merger:
+ case enumBalancerVariants.mergerInverse:
+ case enumBalancerVariants.splitter:
+ case enumBalancerVariants.splitterInverse:
+ return new Vector(1, 1);
+ default:
+ assertAlways(false, "Unknown balancer variant: " + variant);
+ }
+ }
+
+ /**
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ * @returns {Array|null}
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ const matrix = overlayMatrices[variant];
+ if (matrix) {
+ return matrix[rotation];
+ }
+ return null;
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {string} variant
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ if (root.gameMode.throughputDoesNotMatter()) {
+ return [];
+ }
+
+ let speedMultiplier = 2;
+ switch (variant) {
+ case enumBalancerVariants.merger:
+ case enumBalancerVariants.mergerInverse:
+ case enumBalancerVariants.splitter:
+ case enumBalancerVariants.splitterInverse:
+ speedMultiplier = 1;
+ }
+
+ const speed =
+ (root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2) * speedMultiplier;
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
+ }
+
+ getSilhouetteColor() {
+ return "#555759";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getAvailableVariants(root) {
+ const deterministic = root.gameMode.getIsDeterministic();
+
+ let available = deterministic ? [] : [defaultBuildingVariant];
+
+ if (!deterministic && root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_merger)) {
+ available.push(enumBalancerVariants.merger, enumBalancerVariants.mergerInverse);
+ }
+
+ if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_splitter)) {
+ available.push(enumBalancerVariants.splitter, enumBalancerVariants.splitterInverse);
+ }
+
+ return available;
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_balancer);
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new ItemAcceptorComponent({
+ slots: [], // set later
+ })
+ );
+
+ entity.addComponent(
+ new ItemProcessorComponent({
+ inputsPerCharge: 1,
+ processorType: enumItemProcessorTypes.balancer,
+ })
+ );
+
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [], // set later
+ renderFloatingItems: false,
+ })
+ );
+
+ entity.addComponent(new BeltUnderlaysComponent({ underlays: [] }));
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ switch (variant) {
+ case defaultBuildingVariant: {
+ entity.components.ItemAcceptor.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ },
+ {
+ pos: new Vector(1, 0),
+ direction: enumDirection.bottom,
+ },
+ ]);
+
+ entity.components.ItemEjector.setSlots([
+ { pos: new Vector(0, 0), direction: enumDirection.top },
+ { pos: new Vector(1, 0), direction: enumDirection.top },
+ ]);
+
+ entity.components.BeltUnderlays.underlays = [
+ { pos: new Vector(0, 0), direction: enumDirection.top },
+ { pos: new Vector(1, 0), direction: enumDirection.top },
+ ];
+
+ break;
+ }
+ case enumBalancerVariants.merger:
+ case enumBalancerVariants.mergerInverse: {
+ entity.components.ItemAcceptor.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction:
+ variant === enumBalancerVariants.mergerInverse
+ ? enumDirection.left
+ : enumDirection.right,
+ },
+ ]);
+
+ entity.components.ItemEjector.setSlots([
+ { pos: new Vector(0, 0), direction: enumDirection.top },
+ ]);
+
+ entity.components.BeltUnderlays.underlays = [
+ { pos: new Vector(0, 0), direction: enumDirection.top },
+ ];
+
+ break;
+ }
+ case enumBalancerVariants.splitter:
+ case enumBalancerVariants.splitterInverse: {
+ entity.components.ItemAcceptor.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ },
+ ]);
+
+ entity.components.ItemEjector.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction:
+ variant === enumBalancerVariants.splitterInverse
+ ? enumDirection.left
+ : enumDirection.right,
+ },
+ ]);
+
+ entity.components.BeltUnderlays.underlays = [
+ { pos: new Vector(0, 0), direction: enumDirection.top },
+ ];
+
+ break;
+ }
+ default:
+ assertAlways(false, "Unknown balancer variant: " + variant);
+ }
+ }
+}
diff --git a/src/js/game/buildings/belt.js b/src/js/game/buildings/belt.js
index 11a53cdf..14d629db 100644
--- a/src/js/game/buildings/belt.js
+++ b/src/js/game/buildings/belt.js
@@ -1,252 +1,252 @@
-import { Loader } from "../../core/loader";
-import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
-import { enumAngleToDirection, enumDirection, Vector } from "../../core/vector";
-import { SOUNDS } from "../../platform/sound";
-import { T } from "../../translations";
-import { BeltComponent } from "../components/belt";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { THEME } from "../theme";
-
-export const arrayBeltVariantToRotation = [enumDirection.top, enumDirection.left, enumDirection.right];
-
-export const beltOverlayMatrices = {
- [enumDirection.top]: generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
- [enumDirection.left]: generateMatrixRotations([0, 0, 0, 1, 1, 0, 0, 1, 0]),
- [enumDirection.right]: generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
-};
-
-export class MetaBeltBuilding extends MetaBuilding {
- constructor() {
- super("belt");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 1,
- variant: defaultBuildingVariant,
- rotationVariant: 0,
- },
- {
- internalId: 2,
- variant: defaultBuildingVariant,
- rotationVariant: 1,
- },
- {
- internalId: 3,
- variant: defaultBuildingVariant,
- rotationVariant: 2,
- },
- ];
- }
-
- getSilhouetteColor() {
- return THEME.map.chunkOverview.beltColor;
- }
-
- getPlacementSound() {
- return SOUNDS.placeBelt;
- }
-
- getHasDirectionLockAvailable() {
- return true;
- }
- getStayInPlacementMode() {
- return true;
- }
-
- getRotateAutomaticallyWhilePlacing() {
- return true;
- }
-
- getSprite() {
- return null;
- }
-
- getIsReplaceable() {
- return true;
- }
-
- /**
- * @param {GameRoot} root
- * @param {string} variant
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- if (root.gameMode.throughputDoesNotMatter()) {
- return [];
- }
- const beltSpeed = root.hubGoals.getBeltBaseSpeed();
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]];
- }
-
- getPreviewSprite(rotationVariant) {
- switch (arrayBeltVariantToRotation[rotationVariant]) {
- case enumDirection.top: {
- return Loader.getSprite("sprites/buildings/belt_top.png");
- }
- case enumDirection.left: {
- return Loader.getSprite("sprites/buildings/belt_left.png");
- }
- case enumDirection.right: {
- return Loader.getSprite("sprites/buildings/belt_right.png");
- }
- default: {
- assertAlways(false, "Invalid belt rotation variant");
- }
- }
- }
-
- getBlueprintSprite(rotationVariant) {
- switch (arrayBeltVariantToRotation[rotationVariant]) {
- case enumDirection.top: {
- return Loader.getSprite("sprites/blueprints/belt_top.png");
- }
- case enumDirection.left: {
- return Loader.getSprite("sprites/blueprints/belt_left.png");
- }
- case enumDirection.right: {
- return Loader.getSprite("sprites/blueprints/belt_right.png");
- }
- default: {
- assertAlways(false, "Invalid belt rotation variant");
- }
- }
- }
-
- /**
- *
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- return beltOverlayMatrices[entity.components.Belt.direction][rotation];
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new BeltComponent({
- direction: enumDirection.top, // updated later
- })
- );
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- */
- updateVariants(entity, rotationVariant) {
- entity.components.Belt.direction = arrayBeltVariantToRotation[rotationVariant];
- }
-
- /**
- * Should compute the optimal rotation variant on the given tile
- * @param {object} param0
- * @param {GameRoot} param0.root
- * @param {Vector} param0.tile
- * @param {number} param0.rotation
- * @param {string} param0.variant
- * @param {Layer} param0.layer
- * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array }}
- */
- computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
- const topDirection = enumAngleToDirection[rotation];
- const rightDirection = enumAngleToDirection[(rotation + 90) % 360];
- const bottomDirection = enumAngleToDirection[(rotation + 180) % 360];
- const leftDirection = enumAngleToDirection[(rotation + 270) % 360];
-
- const { ejectors, acceptors } = root.logic.getEjectorsAndAcceptorsAtTile(tile);
-
- let hasBottomEjector = false;
- let hasRightEjector = false;
- let hasLeftEjector = false;
-
- let hasTopAcceptor = false;
- let hasLeftAcceptor = false;
- let hasRightAcceptor = false;
-
- // Check all ejectors
- for (let i = 0; i < ejectors.length; ++i) {
- const ejector = ejectors[i];
-
- if (ejector.toDirection === topDirection) {
- hasBottomEjector = true;
- } else if (ejector.toDirection === leftDirection) {
- hasRightEjector = true;
- } else if (ejector.toDirection === rightDirection) {
- hasLeftEjector = true;
- }
- }
-
- // Check all acceptors
- for (let i = 0; i < acceptors.length; ++i) {
- const acceptor = acceptors[i];
- if (acceptor.fromDirection === bottomDirection) {
- hasTopAcceptor = true;
- } else if (acceptor.fromDirection === rightDirection) {
- hasLeftAcceptor = true;
- } else if (acceptor.fromDirection === leftDirection) {
- hasRightAcceptor = true;
- }
- }
-
- // Soo .. if there is any ejector below us we always prioritize
- // this ejector
- if (!hasBottomEjector) {
- // When something ejects to us from the left and nothing from the right,
- // do a curve from the left to the top
-
- if (hasRightEjector && !hasLeftEjector) {
- return {
- rotation: (rotation + 270) % 360,
- rotationVariant: 2,
- };
- }
-
- // When something ejects to us from the right and nothing from the left,
- // do a curve from the right to the top
- if (hasLeftEjector && !hasRightEjector) {
- return {
- rotation: (rotation + 90) % 360,
- rotationVariant: 1,
- };
- }
- }
-
- // When there is a top acceptor, ignore sides
- // NOTICE: This makes the belt prefer side turns *way* too much!
- if (!hasTopAcceptor) {
- // When there is an acceptor to the right but no acceptor to the left,
- // do a turn to the right
- if (hasRightAcceptor && !hasLeftAcceptor) {
- return {
- rotation,
- rotationVariant: 2,
- };
- }
-
- // When there is an acceptor to the left but no acceptor to the right,
- // do a turn to the left
- if (hasLeftAcceptor && !hasRightAcceptor) {
- return {
- rotation,
- rotationVariant: 1,
- };
- }
- }
-
- return {
- rotation,
- rotationVariant: 0,
- };
- }
-}
+import { Loader } from "../../core/loader";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
+import { enumAngleToDirection, enumDirection, Vector } from "../../core/vector";
+import { SOUNDS } from "../../platform/sound";
+import { T } from "../../translations";
+import { BeltComponent } from "../components/belt";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { THEME } from "../theme";
+
+export const arrayBeltVariantToRotation = [enumDirection.top, enumDirection.left, enumDirection.right];
+
+export const beltOverlayMatrices = {
+ [enumDirection.top]: generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
+ [enumDirection.left]: generateMatrixRotations([0, 0, 0, 1, 1, 0, 0, 1, 0]),
+ [enumDirection.right]: generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
+};
+
+export class MetaBeltBuilding extends MetaBuilding {
+ constructor() {
+ super("belt");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 1,
+ variant: defaultBuildingVariant,
+ rotationVariant: 0,
+ },
+ {
+ internalId: 2,
+ variant: defaultBuildingVariant,
+ rotationVariant: 1,
+ },
+ {
+ internalId: 3,
+ variant: defaultBuildingVariant,
+ rotationVariant: 2,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return THEME.map.chunkOverview.beltColor;
+ }
+
+ getPlacementSound() {
+ return SOUNDS.placeBelt;
+ }
+
+ getHasDirectionLockAvailable() {
+ return true;
+ }
+ getStayInPlacementMode() {
+ return true;
+ }
+
+ getRotateAutomaticallyWhilePlacing() {
+ return true;
+ }
+
+ getSprite() {
+ return null;
+ }
+
+ getIsReplaceable() {
+ return true;
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {string} variant
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ if (root.gameMode.throughputDoesNotMatter()) {
+ return [];
+ }
+ const beltSpeed = root.hubGoals.getBeltBaseSpeed();
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]];
+ }
+
+ getPreviewSprite(rotationVariant) {
+ switch (arrayBeltVariantToRotation[rotationVariant]) {
+ case enumDirection.top: {
+ return Loader.getSprite("sprites/buildings/belt_top.png");
+ }
+ case enumDirection.left: {
+ return Loader.getSprite("sprites/buildings/belt_left.png");
+ }
+ case enumDirection.right: {
+ return Loader.getSprite("sprites/buildings/belt_right.png");
+ }
+ default: {
+ assertAlways(false, "Invalid belt rotation variant");
+ }
+ }
+ }
+
+ getBlueprintSprite(rotationVariant) {
+ switch (arrayBeltVariantToRotation[rotationVariant]) {
+ case enumDirection.top: {
+ return Loader.getSprite("sprites/blueprints/belt_top.png");
+ }
+ case enumDirection.left: {
+ return Loader.getSprite("sprites/blueprints/belt_left.png");
+ }
+ case enumDirection.right: {
+ return Loader.getSprite("sprites/blueprints/belt_right.png");
+ }
+ default: {
+ assertAlways(false, "Invalid belt rotation variant");
+ }
+ }
+ }
+
+ /**
+ *
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ return beltOverlayMatrices[entity.components.Belt.direction][rotation];
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new BeltComponent({
+ direction: enumDirection.top, // updated later
+ })
+ );
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ */
+ updateVariants(entity, rotationVariant) {
+ entity.components.Belt.direction = arrayBeltVariantToRotation[rotationVariant];
+ }
+
+ /**
+ * Should compute the optimal rotation variant on the given tile
+ * @param {object} param0
+ * @param {GameRoot} param0.root
+ * @param {Vector} param0.tile
+ * @param {number} param0.rotation
+ * @param {string} param0.variant
+ * @param {Layer} param0.layer
+ * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array }}
+ */
+ computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
+ const topDirection = enumAngleToDirection[rotation];
+ const rightDirection = enumAngleToDirection[(rotation + 90) % 360];
+ const bottomDirection = enumAngleToDirection[(rotation + 180) % 360];
+ const leftDirection = enumAngleToDirection[(rotation + 270) % 360];
+
+ const { ejectors, acceptors } = root.logic.getEjectorsAndAcceptorsAtTile(tile);
+
+ let hasBottomEjector = false;
+ let hasRightEjector = false;
+ let hasLeftEjector = false;
+
+ let hasTopAcceptor = false;
+ let hasLeftAcceptor = false;
+ let hasRightAcceptor = false;
+
+ // Check all ejectors
+ for (let i = 0; i < ejectors.length; ++i) {
+ const ejector = ejectors[i];
+
+ if (ejector.toDirection === topDirection) {
+ hasBottomEjector = true;
+ } else if (ejector.toDirection === leftDirection) {
+ hasRightEjector = true;
+ } else if (ejector.toDirection === rightDirection) {
+ hasLeftEjector = true;
+ }
+ }
+
+ // Check all acceptors
+ for (let i = 0; i < acceptors.length; ++i) {
+ const acceptor = acceptors[i];
+ if (acceptor.fromDirection === bottomDirection) {
+ hasTopAcceptor = true;
+ } else if (acceptor.fromDirection === rightDirection) {
+ hasLeftAcceptor = true;
+ } else if (acceptor.fromDirection === leftDirection) {
+ hasRightAcceptor = true;
+ }
+ }
+
+ // Soo .. if there is any ejector below us we always prioritize
+ // this ejector
+ if (!hasBottomEjector) {
+ // When something ejects to us from the left and nothing from the right,
+ // do a curve from the left to the top
+
+ if (hasRightEjector && !hasLeftEjector) {
+ return {
+ rotation: (rotation + 270) % 360,
+ rotationVariant: 2,
+ };
+ }
+
+ // When something ejects to us from the right and nothing from the left,
+ // do a curve from the right to the top
+ if (hasLeftEjector && !hasRightEjector) {
+ return {
+ rotation: (rotation + 90) % 360,
+ rotationVariant: 1,
+ };
+ }
+ }
+
+ // When there is a top acceptor, ignore sides
+ // NOTICE: This makes the belt prefer side turns *way* too much!
+ if (!hasTopAcceptor) {
+ // When there is an acceptor to the right but no acceptor to the left,
+ // do a turn to the right
+ if (hasRightAcceptor && !hasLeftAcceptor) {
+ return {
+ rotation,
+ rotationVariant: 2,
+ };
+ }
+
+ // When there is an acceptor to the left but no acceptor to the right,
+ // do a turn to the left
+ if (hasLeftAcceptor && !hasRightAcceptor) {
+ return {
+ rotation,
+ rotationVariant: 1,
+ };
+ }
+ }
+
+ return {
+ rotation,
+ rotationVariant: 0,
+ };
+ }
+}
diff --git a/src/js/game/buildings/comparator.js b/src/js/game/buildings/comparator.js
index 1f45dbbb..f6dc727b 100644
--- a/src/js/game/buildings/comparator.js
+++ b/src/js/game/buildings/comparator.js
@@ -1,81 +1,81 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-export class MetaComparatorBuilding extends MetaBuilding {
- constructor() {
- super("comparator");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 46,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#823cab";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing);
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getRenderPins() {
- // We already have it included
- return false;
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalAcceptor,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.right,
- type: enumPinSlotType.logicalAcceptor,
- },
- ],
- })
- );
-
- entity.addComponent(
- new LogicGateComponent({
- type: enumLogicGateType.compare,
- })
- );
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+export class MetaComparatorBuilding extends MetaBuilding {
+ constructor() {
+ super("comparator");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 46,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#823cab";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing);
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getRenderPins() {
+ // We already have it included
+ return false;
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.right,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new LogicGateComponent({
+ type: enumLogicGateType.compare,
+ })
+ );
+ }
+}
diff --git a/src/js/game/buildings/constant_signal.js b/src/js/game/buildings/constant_signal.js
index 2bb72def..d4056309 100644
--- a/src/js/game/buildings/constant_signal.js
+++ b/src/js/game/buildings/constant_signal.js
@@ -1,72 +1,72 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { ConstantSignalComponent } from "../components/constant_signal";
-import { generateMatrixRotations } from "../../core/utils";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-const overlayMatrix = generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]);
-
-export class MetaConstantSignalBuilding extends MetaBuilding {
- constructor() {
- super("constant_signal");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 31,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#2b84fd";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_constant_signal);
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getRenderPins() {
- return false;
- }
-
- getSpecialOverlayRenderMatrix(rotation) {
- return overlayMatrix[rotation];
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- ],
- })
- );
- entity.addComponent(new ConstantSignalComponent({}));
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { ConstantSignalComponent } from "../components/constant_signal";
+import { generateMatrixRotations } from "../../core/utils";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+const overlayMatrix = generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]);
+
+export class MetaConstantSignalBuilding extends MetaBuilding {
+ constructor() {
+ super("constant_signal");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 31,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#2b84fd";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_constant_signal);
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getRenderPins() {
+ return false;
+ }
+
+ getSpecialOverlayRenderMatrix(rotation) {
+ return overlayMatrix[rotation];
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ ],
+ })
+ );
+ entity.addComponent(new ConstantSignalComponent({}));
+ }
+}
diff --git a/src/js/game/buildings/cutter.js b/src/js/game/buildings/cutter.js
index 21acdaa0..dd71b527 100644
--- a/src/js/game/buildings/cutter.js
+++ b/src/js/game/buildings/cutter.js
@@ -1,138 +1,138 @@
-import { formatItemsPerSecond } from "../../core/utils";
-import { enumDirection, Vector } from "../../core/vector";
-import { T } from "../../translations";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-/** @enum {string} */
-export const enumCutterVariants = { quad: "quad" };
-
-export class MetaCutterBuilding extends MetaBuilding {
- constructor() {
- super("cutter");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 9,
- variant: defaultBuildingVariant,
- },
- {
- internalId: 10,
- variant: enumCutterVariants.quad,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#7dcda2";
- }
-
- getDimensions(variant) {
- switch (variant) {
- case defaultBuildingVariant:
- return new Vector(2, 1);
- case enumCutterVariants.quad:
- return new Vector(4, 1);
- default:
- assertAlways(false, "Unknown cutter variant: " + variant);
- }
- }
-
- /**
- * @param {GameRoot} root
- * @param {string} variant
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- if (root.gameMode.throughputDoesNotMatter()) {
- return [];
- }
- const speed = root.hubGoals.getProcessorBaseSpeed(
- variant === enumCutterVariants.quad
- ? enumItemProcessorTypes.cutterQuad
- : enumItemProcessorTypes.cutter
- );
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
- }
-
- /**
- * @param {GameRoot} root
- */
- getAvailableVariants(root) {
- if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_quad)) {
- return [defaultBuildingVariant, enumCutterVariants.quad];
- }
- return super.getAvailableVariants(root);
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_and_trash);
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new ItemProcessorComponent({
- inputsPerCharge: 1,
- processorType: enumItemProcessorTypes.cutter,
- })
- );
- entity.addComponent(new ItemEjectorComponent({}));
- entity.addComponent(
- new ItemAcceptorComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- filter: "shape",
- },
- ],
- })
- );
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- * @param {string} variant
- */
- updateVariants(entity, rotationVariant, variant) {
- switch (variant) {
- case defaultBuildingVariant: {
- entity.components.ItemEjector.setSlots([
- { pos: new Vector(0, 0), direction: enumDirection.top },
- { pos: new Vector(1, 0), direction: enumDirection.top },
- ]);
- entity.components.ItemProcessor.type = enumItemProcessorTypes.cutter;
- break;
- }
- case enumCutterVariants.quad: {
- entity.components.ItemEjector.setSlots([
- { pos: new Vector(0, 0), direction: enumDirection.top },
- { pos: new Vector(1, 0), direction: enumDirection.top },
- { pos: new Vector(2, 0), direction: enumDirection.top },
- { pos: new Vector(3, 0), direction: enumDirection.top },
- ]);
- entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad;
- break;
- }
-
- default:
- assertAlways(false, "Unknown painter variant: " + variant);
- }
- }
-}
+import { formatItemsPerSecond } from "../../core/utils";
+import { enumDirection, Vector } from "../../core/vector";
+import { T } from "../../translations";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+/** @enum {string} */
+export const enumCutterVariants = { quad: "quad" };
+
+export class MetaCutterBuilding extends MetaBuilding {
+ constructor() {
+ super("cutter");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 9,
+ variant: defaultBuildingVariant,
+ },
+ {
+ internalId: 10,
+ variant: enumCutterVariants.quad,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#7dcda2";
+ }
+
+ getDimensions(variant) {
+ switch (variant) {
+ case defaultBuildingVariant:
+ return new Vector(2, 1);
+ case enumCutterVariants.quad:
+ return new Vector(4, 1);
+ default:
+ assertAlways(false, "Unknown cutter variant: " + variant);
+ }
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {string} variant
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ if (root.gameMode.throughputDoesNotMatter()) {
+ return [];
+ }
+ const speed = root.hubGoals.getProcessorBaseSpeed(
+ variant === enumCutterVariants.quad
+ ? enumItemProcessorTypes.cutterQuad
+ : enumItemProcessorTypes.cutter
+ );
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getAvailableVariants(root) {
+ if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_quad)) {
+ return [defaultBuildingVariant, enumCutterVariants.quad];
+ }
+ return super.getAvailableVariants(root);
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_and_trash);
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new ItemProcessorComponent({
+ inputsPerCharge: 1,
+ processorType: enumItemProcessorTypes.cutter,
+ })
+ );
+ entity.addComponent(new ItemEjectorComponent({}));
+ entity.addComponent(
+ new ItemAcceptorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ filter: "shape",
+ },
+ ],
+ })
+ );
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ switch (variant) {
+ case defaultBuildingVariant: {
+ entity.components.ItemEjector.setSlots([
+ { pos: new Vector(0, 0), direction: enumDirection.top },
+ { pos: new Vector(1, 0), direction: enumDirection.top },
+ ]);
+ entity.components.ItemProcessor.type = enumItemProcessorTypes.cutter;
+ break;
+ }
+ case enumCutterVariants.quad: {
+ entity.components.ItemEjector.setSlots([
+ { pos: new Vector(0, 0), direction: enumDirection.top },
+ { pos: new Vector(1, 0), direction: enumDirection.top },
+ { pos: new Vector(2, 0), direction: enumDirection.top },
+ { pos: new Vector(3, 0), direction: enumDirection.top },
+ ]);
+ entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad;
+ break;
+ }
+
+ default:
+ assertAlways(false, "Unknown painter variant: " + variant);
+ }
+ }
+}
diff --git a/src/js/game/buildings/display.js b/src/js/game/buildings/display.js
index 7c1277c2..a3819ec2 100644
--- a/src/js/game/buildings/display.js
+++ b/src/js/game/buildings/display.js
@@ -1,60 +1,60 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { DisplayComponent } from "../components/display";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-export class MetaDisplayBuilding extends MetaBuilding {
- constructor() {
- super("display");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 40,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#aaaaaa";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_display);
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getShowWiresLayerPreview() {
- return true;
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- type: enumPinSlotType.logicalAcceptor,
- },
- ],
- })
- );
- entity.addComponent(new DisplayComponent());
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { DisplayComponent } from "../components/display";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+export class MetaDisplayBuilding extends MetaBuilding {
+ constructor() {
+ super("display");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 40,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#aaaaaa";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_display);
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getShowWiresLayerPreview() {
+ return true;
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ],
+ })
+ );
+ entity.addComponent(new DisplayComponent());
+ }
+}
diff --git a/src/js/game/buildings/filter.js b/src/js/game/buildings/filter.js
index f8c29b1f..9276159f 100644
--- a/src/js/game/buildings/filter.js
+++ b/src/js/game/buildings/filter.js
@@ -1,104 +1,104 @@
-import { formatItemsPerSecond } from "../../core/utils";
-import { enumDirection, Vector } from "../../core/vector";
-import { T } from "../../translations";
-import { FilterComponent } from "../components/filter";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-export class MetaFilterBuilding extends MetaBuilding {
- constructor() {
- super("filter");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 37,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#c45c2e";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_filter);
- }
-
- getDimensions() {
- return new Vector(2, 1);
- }
-
- getShowWiresLayerPreview() {
- return true;
- }
-
- /**
- * @param {GameRoot} root
- * @param {string} variant
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- if (root.gameMode.throughputDoesNotMatter()) {
- return [];
- }
- const beltSpeed = root.hubGoals.getBeltBaseSpeed();
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]];
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalAcceptor,
- },
- ],
- })
- );
-
- entity.addComponent(
- new ItemAcceptorComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- },
- ],
- })
- );
-
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- },
- {
- pos: new Vector(1, 0),
- direction: enumDirection.right,
- },
- ],
- })
- );
-
- entity.addComponent(new FilterComponent());
- }
-}
+import { formatItemsPerSecond } from "../../core/utils";
+import { enumDirection, Vector } from "../../core/vector";
+import { T } from "../../translations";
+import { FilterComponent } from "../components/filter";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+export class MetaFilterBuilding extends MetaBuilding {
+ constructor() {
+ super("filter");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 37,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#c45c2e";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_filter);
+ }
+
+ getDimensions() {
+ return new Vector(2, 1);
+ }
+
+ getShowWiresLayerPreview() {
+ return true;
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {string} variant
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ if (root.gameMode.throughputDoesNotMatter()) {
+ return [];
+ }
+ const beltSpeed = root.hubGoals.getBeltBaseSpeed();
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]];
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new ItemAcceptorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ },
+ {
+ pos: new Vector(1, 0),
+ direction: enumDirection.right,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(new FilterComponent());
+ }
+}
diff --git a/src/js/game/buildings/hub.js b/src/js/game/buildings/hub.js
index a0a9227e..7620ebfe 100644
--- a/src/js/game/buildings/hub.js
+++ b/src/js/game/buildings/hub.js
@@ -36,11 +36,6 @@ export class MetaHubBuilding extends MetaBuilding {
return null;
}
- getSprite() {
- // We render it ourself
- return null;
- }
-
getIsRemovable() {
return false;
}
diff --git a/src/js/game/buildings/item_producer.js b/src/js/game/buildings/item_producer.js
index a367beae..f6378931 100644
--- a/src/js/game/buildings/item_producer.js
+++ b/src/js/game/buildings/item_producer.js
@@ -1,53 +1,53 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { ItemProducerComponent } from "../components/item_producer";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-
-export class MetaItemProducerBuilding extends MetaBuilding {
- constructor() {
- super("item_producer");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 61,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#b37dcd";
- }
-
- getShowWiresLayerPreview() {
- return true;
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
- })
- );
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- type: enumPinSlotType.logicalAcceptor,
- direction: enumDirection.bottom,
- },
- ],
- })
- );
- entity.addComponent(new ItemProducerComponent({}));
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { ItemProducerComponent } from "../components/item_producer";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+
+export class MetaItemProducerBuilding extends MetaBuilding {
+ constructor() {
+ super("item_producer");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 61,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#b37dcd";
+ }
+
+ getShowWiresLayerPreview() {
+ return true;
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
+ })
+ );
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ type: enumPinSlotType.logicalAcceptor,
+ direction: enumDirection.bottom,
+ },
+ ],
+ })
+ );
+ entity.addComponent(new ItemProducerComponent({}));
+ }
+}
diff --git a/src/js/game/buildings/lever.js b/src/js/game/buildings/lever.js
index 970a4bc6..5f593e8b 100644
--- a/src/js/game/buildings/lever.js
+++ b/src/js/game/buildings/lever.js
@@ -1,66 +1,66 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { LeverComponent } from "../components/lever";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-export class MetaLeverBuilding extends MetaBuilding {
- constructor() {
- super("lever");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 33,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- // @todo: Render differently based on if its activated or not
- return "#1a678b";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers);
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getSprite() {
- return null;
- }
-
- getShowWiresLayerPreview() {
- return true;
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- ],
- })
- );
-
- entity.addComponent(new LeverComponent({}));
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { LeverComponent } from "../components/lever";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+export class MetaLeverBuilding extends MetaBuilding {
+ constructor() {
+ super("lever");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 33,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ // @todo: Render differently based on if its activated or not
+ return "#1a678b";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers);
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getSprite() {
+ return null;
+ }
+
+ getShowWiresLayerPreview() {
+ return true;
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(new LeverComponent({}));
+ }
+}
diff --git a/src/js/game/buildings/logic_gate.js b/src/js/game/buildings/logic_gate.js
index bd5e1940..0052363e 100644
--- a/src/js/game/buildings/logic_gate.js
+++ b/src/js/game/buildings/logic_gate.js
@@ -1,172 +1,172 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
-import { generateMatrixRotations } from "../../core/utils";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-/** @enum {string} */
-export const enumLogicGateVariants = {
- not: "not",
- xor: "xor",
- or: "or",
-};
-
-/** @enum {string} */
-const enumVariantToGate = {
- [defaultBuildingVariant]: enumLogicGateType.and,
- [enumLogicGateVariants.not]: enumLogicGateType.not,
- [enumLogicGateVariants.xor]: enumLogicGateType.xor,
- [enumLogicGateVariants.or]: enumLogicGateType.or,
-};
-
-const overlayMatrices = {
- [defaultBuildingVariant]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
- [enumLogicGateVariants.xor]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
- [enumLogicGateVariants.or]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
- [enumLogicGateVariants.not]: generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
-};
-
-const colors = {
- [defaultBuildingVariant]: "#f48d41",
- [enumLogicGateVariants.xor]: "#f4a241",
- [enumLogicGateVariants.or]: "#f4d041",
- [enumLogicGateVariants.not]: "#f44184",
-};
-
-export class MetaLogicGateBuilding extends MetaBuilding {
- constructor() {
- super("logic_gate");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 32,
- variant: defaultBuildingVariant,
- },
- {
- internalId: 34,
- variant: enumLogicGateVariants.not,
- },
- {
- internalId: 35,
- variant: enumLogicGateVariants.xor,
- },
- {
- internalId: 36,
- variant: enumLogicGateVariants.or,
- },
- ];
- }
-
- getSilhouetteColor(variant) {
- return colors[variant];
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates);
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant) {
- return overlayMatrices[variant][rotation];
- }
-
- getAvailableVariants() {
- return [
- defaultBuildingVariant,
- enumLogicGateVariants.or,
- enumLogicGateVariants.not,
- enumLogicGateVariants.xor,
- ];
- }
-
- getRenderPins() {
- // We already have it included
- return false;
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- */
- updateVariants(entity, rotationVariant, variant) {
- const gateType = enumVariantToGate[variant];
- entity.components.LogicGate.type = gateType;
-
- const pinComp = entity.components.WiredPins;
-
- switch (gateType) {
- case enumLogicGateType.and:
- case enumLogicGateType.xor:
- case enumLogicGateType.or: {
- pinComp.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalAcceptor,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.right,
- type: enumPinSlotType.logicalAcceptor,
- },
- ]);
- break;
- }
-
- case enumLogicGateType.not: {
- pinComp.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- type: enumPinSlotType.logicalAcceptor,
- },
- ]);
- break;
- }
-
- default:
- assertAlways("unknown logic gate type: " + gateType);
- }
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [],
- })
- );
-
- entity.addComponent(new LogicGateComponent({}));
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
+import { generateMatrixRotations } from "../../core/utils";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+/** @enum {string} */
+export const enumLogicGateVariants = {
+ not: "not",
+ xor: "xor",
+ or: "or",
+};
+
+/** @enum {string} */
+const enumVariantToGate = {
+ [defaultBuildingVariant]: enumLogicGateType.and,
+ [enumLogicGateVariants.not]: enumLogicGateType.not,
+ [enumLogicGateVariants.xor]: enumLogicGateType.xor,
+ [enumLogicGateVariants.or]: enumLogicGateType.or,
+};
+
+const overlayMatrices = {
+ [defaultBuildingVariant]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
+ [enumLogicGateVariants.xor]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
+ [enumLogicGateVariants.or]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
+ [enumLogicGateVariants.not]: generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
+};
+
+const colors = {
+ [defaultBuildingVariant]: "#f48d41",
+ [enumLogicGateVariants.xor]: "#f4a241",
+ [enumLogicGateVariants.or]: "#f4d041",
+ [enumLogicGateVariants.not]: "#f44184",
+};
+
+export class MetaLogicGateBuilding extends MetaBuilding {
+ constructor() {
+ super("logic_gate");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 32,
+ variant: defaultBuildingVariant,
+ },
+ {
+ internalId: 34,
+ variant: enumLogicGateVariants.not,
+ },
+ {
+ internalId: 35,
+ variant: enumLogicGateVariants.xor,
+ },
+ {
+ internalId: 36,
+ variant: enumLogicGateVariants.or,
+ },
+ ];
+ }
+
+ getSilhouetteColor(variant) {
+ return colors[variant];
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates);
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant) {
+ return overlayMatrices[variant][rotation];
+ }
+
+ getAvailableVariants() {
+ return [
+ defaultBuildingVariant,
+ enumLogicGateVariants.or,
+ enumLogicGateVariants.not,
+ enumLogicGateVariants.xor,
+ ];
+ }
+
+ getRenderPins() {
+ // We already have it included
+ return false;
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ const gateType = enumVariantToGate[variant];
+ entity.components.LogicGate.type = gateType;
+
+ const pinComp = entity.components.WiredPins;
+
+ switch (gateType) {
+ case enumLogicGateType.and:
+ case enumLogicGateType.xor:
+ case enumLogicGateType.or: {
+ pinComp.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.right,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ]);
+ break;
+ }
+
+ case enumLogicGateType.not: {
+ pinComp.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ]);
+ break;
+ }
+
+ default:
+ assertAlways("unknown logic gate type: " + gateType);
+ }
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [],
+ })
+ );
+
+ entity.addComponent(new LogicGateComponent({}));
+ }
+}
diff --git a/src/js/game/buildings/miner.js b/src/js/game/buildings/miner.js
index b086a562..5365b67f 100644
--- a/src/js/game/buildings/miner.js
+++ b/src/js/game/buildings/miner.js
@@ -1,97 +1,97 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { MinerComponent } from "../components/miner";
-import { Entity } from "../entity";
-import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-import { T } from "../../translations";
-import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
-
-/** @enum {string} */
-export const enumMinerVariants = { chainable: "chainable" };
-
-const overlayMatrix = {
- [defaultBuildingVariant]: generateMatrixRotations([1, 1, 1, 1, 0, 1, 1, 1, 1]),
- [enumMinerVariants.chainable]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]),
-};
-
-export class MetaMinerBuilding extends MetaBuilding {
- constructor() {
- super("miner");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 7,
- variant: defaultBuildingVariant,
- },
- {
- internalId: 8,
- variant: enumMinerVariants.chainable,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#b37dcd";
- }
-
- /**
- * @param {GameRoot} root
- * @param {string} variant
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- if (root.gameMode.throughputDoesNotMatter()) {
- return [];
- }
- const speed = root.hubGoals.getMinerBaseSpeed();
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
- }
-
- /**
- *
- * @param {GameRoot} root
- */
- getAvailableVariants(root) {
- if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_miner_chainable)) {
- return [enumMinerVariants.chainable];
- }
- return super.getAvailableVariants(root);
- }
-
- /**
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- return overlayMatrix[variant][rotation];
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(new MinerComponent({}));
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
- })
- );
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- * @param {string} variant
- */
- updateVariants(entity, rotationVariant, variant) {
- entity.components.Miner.chainable = variant === enumMinerVariants.chainable;
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { MinerComponent } from "../components/miner";
+import { Entity } from "../entity";
+import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+import { T } from "../../translations";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
+
+/** @enum {string} */
+export const enumMinerVariants = { chainable: "chainable" };
+
+const overlayMatrix = {
+ [defaultBuildingVariant]: generateMatrixRotations([1, 1, 1, 1, 0, 1, 1, 1, 1]),
+ [enumMinerVariants.chainable]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]),
+};
+
+export class MetaMinerBuilding extends MetaBuilding {
+ constructor() {
+ super("miner");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 7,
+ variant: defaultBuildingVariant,
+ },
+ {
+ internalId: 8,
+ variant: enumMinerVariants.chainable,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#b37dcd";
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {string} variant
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ if (root.gameMode.throughputDoesNotMatter()) {
+ return [];
+ }
+ const speed = root.hubGoals.getMinerBaseSpeed();
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
+ }
+
+ /**
+ *
+ * @param {GameRoot} root
+ */
+ getAvailableVariants(root) {
+ if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_miner_chainable)) {
+ return [enumMinerVariants.chainable];
+ }
+ return super.getAvailableVariants(root);
+ }
+
+ /**
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ return overlayMatrix[variant][rotation];
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(new MinerComponent({}));
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
+ })
+ );
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ entity.components.Miner.chainable = variant === enumMinerVariants.chainable;
+ }
+}
diff --git a/src/js/game/buildings/reader.js b/src/js/game/buildings/reader.js
index 5c9307c3..417d2fcb 100644
--- a/src/js/game/buildings/reader.js
+++ b/src/js/game/buildings/reader.js
@@ -1,124 +1,124 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { BeltUnderlaysComponent } from "../components/belt_underlays";
-import { BeltReaderComponent } from "../components/belt_reader";
-import { enumHubGoalRewards } from "../tutorial_goals";
-import { generateMatrixRotations } from "../../core/utils";
-
-const overlayMatrix = generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]);
-
-export class MetaReaderBuilding extends MetaBuilding {
- constructor() {
- super("reader");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 49,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#25fff2";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_belt_reader);
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getShowWiresLayerPreview() {
- return true;
- }
-
- /**
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- * @returns {Array|null}
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- return overlayMatrix[rotation];
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.right,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalEjector,
- },
- ],
- })
- );
-
- entity.addComponent(
- new ItemAcceptorComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- },
- ],
- })
- );
-
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- },
- ],
- })
- );
-
- entity.addComponent(
- new ItemProcessorComponent({
- processorType: enumItemProcessorTypes.reader,
- inputsPerCharge: 1,
- })
- );
-
- entity.addComponent(
- new BeltUnderlaysComponent({
- underlays: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- },
- ],
- })
- );
-
- entity.addComponent(new BeltReaderComponent());
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { BeltUnderlaysComponent } from "../components/belt_underlays";
+import { BeltReaderComponent } from "../components/belt_reader";
+import { enumHubGoalRewards } from "../tutorial_goals";
+import { generateMatrixRotations } from "../../core/utils";
+
+const overlayMatrix = generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]);
+
+export class MetaReaderBuilding extends MetaBuilding {
+ constructor() {
+ super("reader");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 49,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#25fff2";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_belt_reader);
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getShowWiresLayerPreview() {
+ return true;
+ }
+
+ /**
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ * @returns {Array|null}
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ return overlayMatrix[rotation];
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.right,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalEjector,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new ItemAcceptorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new ItemProcessorComponent({
+ processorType: enumItemProcessorTypes.reader,
+ inputsPerCharge: 1,
+ })
+ );
+
+ entity.addComponent(
+ new BeltUnderlaysComponent({
+ underlays: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(new BeltReaderComponent());
+ }
+}
diff --git a/src/js/game/buildings/rotater.js b/src/js/game/buildings/rotator.js
similarity index 78%
rename from src/js/game/buildings/rotater.js
rename to src/js/game/buildings/rotator.js
index e1080767..b0a86f67 100644
--- a/src/js/game/buildings/rotater.js
+++ b/src/js/game/buildings/rotator.js
@@ -1,163 +1,163 @@
-import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
-import { enumDirection, Vector } from "../../core/vector";
-import { T } from "../../translations";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-/** @enum {string} */
-export const enumRotaterVariants = { ccw: "ccw", rotate180: "rotate180" };
-
-const overlayMatrices = {
- [defaultBuildingVariant]: generateMatrixRotations([0, 1, 1, 1, 1, 0, 0, 1, 1]),
- [enumRotaterVariants.ccw]: generateMatrixRotations([1, 1, 0, 0, 1, 1, 1, 1, 0]),
- [enumRotaterVariants.rotate180]: generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 1]),
-};
-
-export class MetaRotaterBuilding extends MetaBuilding {
- constructor() {
- super("rotater");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 11,
- variant: defaultBuildingVariant,
- },
- {
- internalId: 12,
- variant: enumRotaterVariants.ccw,
- },
- {
- internalId: 13,
- variant: enumRotaterVariants.rotate180,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#7dc6cd";
- }
-
- /**
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- * @returns {Array|null}
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- const matrix = overlayMatrices[variant];
- if (matrix) {
- return matrix[rotation];
- }
- return null;
- }
-
- /**
- * @param {GameRoot} root
- * @param {string} variant
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- if (root.gameMode.throughputDoesNotMatter()) {
- return [];
- }
- switch (variant) {
- case defaultBuildingVariant: {
- const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotater);
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
- }
- case enumRotaterVariants.ccw: {
- const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotaterCCW);
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
- }
- case enumRotaterVariants.rotate180: {
- const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotater180);
- return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
- }
- }
- }
-
- /**
- *
- * @param {GameRoot} root
- */
- getAvailableVariants(root) {
- let variants = [defaultBuildingVariant];
- if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater_ccw)) {
- variants.push(enumRotaterVariants.ccw);
- }
- if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater_180)) {
- variants.push(enumRotaterVariants.rotate180);
- }
- return variants;
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater);
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new ItemProcessorComponent({
- inputsPerCharge: 1,
- processorType: enumItemProcessorTypes.rotater,
- })
- );
-
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
- })
- );
- entity.addComponent(
- new ItemAcceptorComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- filter: "shape",
- },
- ],
- })
- );
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- * @param {string} variant
- */
- updateVariants(entity, rotationVariant, variant) {
- switch (variant) {
- case defaultBuildingVariant: {
- entity.components.ItemProcessor.type = enumItemProcessorTypes.rotater;
- break;
- }
- case enumRotaterVariants.ccw: {
- entity.components.ItemProcessor.type = enumItemProcessorTypes.rotaterCCW;
- break;
- }
- case enumRotaterVariants.rotate180: {
- entity.components.ItemProcessor.type = enumItemProcessorTypes.rotater180;
- break;
- }
- default:
- assertAlways(false, "Unknown rotater variant: " + variant);
- }
- }
-}
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
+import { enumDirection, Vector } from "../../core/vector";
+import { T } from "../../translations";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+/** @enum {string} */
+export const enumRotatorVariants = { ccw: "ccw", rotate180: "rotate180" };
+
+const overlayMatrices = {
+ [defaultBuildingVariant]: generateMatrixRotations([0, 1, 1, 1, 1, 0, 0, 1, 1]),
+ [enumRotatorVariants.ccw]: generateMatrixRotations([1, 1, 0, 0, 1, 1, 1, 1, 0]),
+ [enumRotatorVariants.rotate180]: generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 1]),
+};
+
+export class MetaRotatorBuilding extends MetaBuilding {
+ constructor() {
+ super("rotator");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 11,
+ variant: defaultBuildingVariant,
+ },
+ {
+ internalId: 12,
+ variant: enumRotatorVariants.ccw,
+ },
+ {
+ internalId: 13,
+ variant: enumRotatorVariants.rotate180,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#7dc6cd";
+ }
+
+ /**
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ * @returns {Array|null}
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ const matrix = overlayMatrices[variant];
+ if (matrix) {
+ return matrix[rotation];
+ }
+ return null;
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {string} variant
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ if (root.gameMode.throughputDoesNotMatter()) {
+ return [];
+ }
+ switch (variant) {
+ case defaultBuildingVariant: {
+ const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotator);
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
+ }
+ case enumRotatorVariants.ccw: {
+ const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotatorCCW);
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
+ }
+ case enumRotatorVariants.rotate180: {
+ const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotator180);
+ return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
+ }
+ }
+ }
+
+ /**
+ *
+ * @param {GameRoot} root
+ */
+ getAvailableVariants(root) {
+ let variants = [defaultBuildingVariant];
+ if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotator_ccw)) {
+ variants.push(enumRotatorVariants.ccw);
+ }
+ if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotator_180)) {
+ variants.push(enumRotatorVariants.rotate180);
+ }
+ return variants;
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotator);
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new ItemProcessorComponent({
+ inputsPerCharge: 1,
+ processorType: enumItemProcessorTypes.rotator,
+ })
+ );
+
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
+ })
+ );
+ entity.addComponent(
+ new ItemAcceptorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ filter: "shape",
+ },
+ ],
+ })
+ );
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ switch (variant) {
+ case defaultBuildingVariant: {
+ entity.components.ItemProcessor.type = enumItemProcessorTypes.rotator;
+ break;
+ }
+ case enumRotatorVariants.ccw: {
+ entity.components.ItemProcessor.type = enumItemProcessorTypes.rotatorCCW;
+ break;
+ }
+ case enumRotatorVariants.rotate180: {
+ entity.components.ItemProcessor.type = enumItemProcessorTypes.rotator180;
+ break;
+ }
+ default:
+ assertAlways(false, "Unknown rotator variant: " + variant);
+ }
+ }
+}
diff --git a/src/js/game/buildings/storage.js b/src/js/game/buildings/storage.js
index 78f398be..4a8d39c5 100644
--- a/src/js/game/buildings/storage.js
+++ b/src/js/game/buildings/storage.js
@@ -1,110 +1,110 @@
-import { formatBigNumber } from "../../core/utils";
-import { enumDirection, Vector } from "../../core/vector";
-import { T } from "../../translations";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { StorageComponent } from "../components/storage";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-const storageSize = 5000;
-
-export class MetaStorageBuilding extends MetaBuilding {
- constructor() {
- super("storage");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 21,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#bbdf6d";
- }
-
- /**
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- return [[T.ingame.buildingPlacement.infoTexts.storage, formatBigNumber(storageSize)]];
- }
-
- getDimensions() {
- return new Vector(2, 2);
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_storage);
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- // Required, since the item processor needs this.
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- },
- {
- pos: new Vector(1, 0),
- direction: enumDirection.top,
- },
- ],
- })
- );
-
- entity.addComponent(
- new ItemAcceptorComponent({
- slots: [
- {
- pos: new Vector(0, 1),
- direction: enumDirection.bottom,
- },
- {
- pos: new Vector(1, 1),
- direction: enumDirection.bottom,
- },
- ],
- })
- );
-
- entity.addComponent(
- new StorageComponent({
- maximumStorage: storageSize,
- })
- );
-
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(1, 1),
- direction: enumDirection.right,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 1),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalEjector,
- },
- ],
- })
- );
- }
-}
+import { formatBigNumber } from "../../core/utils";
+import { enumDirection, Vector } from "../../core/vector";
+import { T } from "../../translations";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { StorageComponent } from "../components/storage";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+const storageSize = 5000;
+
+export class MetaStorageBuilding extends MetaBuilding {
+ constructor() {
+ super("storage");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 21,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#bbdf6d";
+ }
+
+ /**
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ return [[T.ingame.buildingPlacement.infoTexts.storage, formatBigNumber(storageSize)]];
+ }
+
+ getDimensions() {
+ return new Vector(2, 2);
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_storage);
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ // Required, since the item processor needs this.
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ },
+ {
+ pos: new Vector(1, 0),
+ direction: enumDirection.top,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new ItemAcceptorComponent({
+ slots: [
+ {
+ pos: new Vector(0, 1),
+ direction: enumDirection.bottom,
+ },
+ {
+ pos: new Vector(1, 1),
+ direction: enumDirection.bottom,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new StorageComponent({
+ maximumStorage: storageSize,
+ })
+ );
+
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(1, 1),
+ direction: enumDirection.right,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 1),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalEjector,
+ },
+ ],
+ })
+ );
+ }
+}
diff --git a/src/js/game/buildings/transistor.js b/src/js/game/buildings/transistor.js
index 1505903a..8db1dbac 100644
--- a/src/js/game/buildings/transistor.js
+++ b/src/js/game/buildings/transistor.js
@@ -1,114 +1,114 @@
-import { generateMatrixRotations } from "../../core/utils";
-import { enumDirection, Vector } from "../../core/vector";
-import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
-import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-/** @enum {string} */
-export const enumTransistorVariants = {
- mirrored: "mirrored",
-};
-
-const overlayMatrices = {
- [defaultBuildingVariant]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
- [enumTransistorVariants.mirrored]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
-};
-
-export class MetaTransistorBuilding extends MetaBuilding {
- constructor() {
- super("transistor");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 38,
- variant: defaultBuildingVariant,
- },
- {
- internalId: 60,
- variant: enumTransistorVariants.mirrored,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#bc3a61";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates);
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getAvailableVariants() {
- return [defaultBuildingVariant, enumTransistorVariants.mirrored];
- }
-
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant) {
- return overlayMatrices[variant][rotation];
- }
-
- getRenderPins() {
- // We already have it included
- return false;
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- */
- updateVariants(entity, rotationVariant, variant) {
- entity.components.WiredPins.slots[1].direction =
- variant === enumTransistorVariants.mirrored ? enumDirection.right : enumDirection.left;
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalAcceptor,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- type: enumPinSlotType.logicalAcceptor,
- },
- ],
- })
- );
-
- entity.addComponent(
- new LogicGateComponent({
- type: enumLogicGateType.transistor,
- })
- );
- }
-}
+import { generateMatrixRotations } from "../../core/utils";
+import { enumDirection, Vector } from "../../core/vector";
+import { enumLogicGateType, LogicGateComponent } from "../components/logic_gate";
+import { enumPinSlotType, WiredPinsComponent } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+/** @enum {string} */
+export const enumTransistorVariants = {
+ mirrored: "mirrored",
+};
+
+const overlayMatrices = {
+ [defaultBuildingVariant]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
+ [enumTransistorVariants.mirrored]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
+};
+
+export class MetaTransistorBuilding extends MetaBuilding {
+ constructor() {
+ super("transistor");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 38,
+ variant: defaultBuildingVariant,
+ },
+ {
+ internalId: 60,
+ variant: enumTransistorVariants.mirrored,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#bc3a61";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates);
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getAvailableVariants() {
+ return [defaultBuildingVariant, enumTransistorVariants.mirrored];
+ }
+
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant) {
+ return overlayMatrices[variant][rotation];
+ }
+
+ getRenderPins() {
+ // We already have it included
+ return false;
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ entity.components.WiredPins.slots[1].direction =
+ variant === enumTransistorVariants.mirrored ? enumDirection.right : enumDirection.left;
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ],
+ })
+ );
+
+ entity.addComponent(
+ new LogicGateComponent({
+ type: enumLogicGateType.transistor,
+ })
+ );
+ }
+}
diff --git a/src/js/game/buildings/trash.js b/src/js/game/buildings/trash.js
index fcf7f11f..87dbcf09 100644
--- a/src/js/game/buildings/trash.js
+++ b/src/js/game/buildings/trash.js
@@ -1,6 +1,5 @@
import { generateMatrixRotations } from "../../core/utils";
import { enumDirection, Vector } from "../../core/vector";
-import { ACHIEVEMENTS } from "../../platform/achievement_provider";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
import { Entity } from "../entity";
@@ -47,25 +46,6 @@ export class MetaTrashBuilding extends MetaBuilding {
return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_and_trash);
}
- addAchievementReceiver(entity) {
- if (!entity.root) {
- return;
- }
-
- const itemProcessor = entity.components.ItemProcessor;
- const tryTakeItem = itemProcessor.tryTakeItem.bind(itemProcessor);
-
- itemProcessor.tryTakeItem = () => {
- const taken = tryTakeItem(...arguments);
-
- if (taken) {
- entity.root.signals.achievementCheck.dispatch(ACHIEVEMENTS.trash1000, 1);
- }
-
- return taken;
- };
- }
-
/**
* Creates the entity at the given location
* @param {Entity} entity
@@ -100,7 +80,5 @@ export class MetaTrashBuilding extends MetaBuilding {
processorType: enumItemProcessorTypes.trash,
})
);
-
- this.addAchievementReceiver(entity);
}
}
diff --git a/src/js/game/buildings/underground_belt.js b/src/js/game/buildings/underground_belt.js
index 7009ebd7..e9d0e8e9 100644
--- a/src/js/game/buildings/underground_belt.js
+++ b/src/js/game/buildings/underground_belt.js
@@ -1,300 +1,300 @@
-import { Loader } from "../../core/loader";
-import { enumDirection, Vector, enumAngleToDirection, enumDirectionToVector } from "../../core/vector";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
-import { Entity } from "../entity";
-import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
-import { GameRoot } from "../root";
-import { globalConfig } from "../../core/config";
-import { enumHubGoalRewards } from "../tutorial_goals";
-import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
-import { T } from "../../translations";
-
-/** @enum {string} */
-export const arrayUndergroundRotationVariantToMode = [
- enumUndergroundBeltMode.sender,
- enumUndergroundBeltMode.receiver,
-];
-
-/** @enum {string} */
-export const enumUndergroundBeltVariants = { tier2: "tier2" };
-
-export const enumUndergroundBeltVariantToTier = {
- [defaultBuildingVariant]: 0,
- [enumUndergroundBeltVariants.tier2]: 1,
-};
-
-const colorsByRotationVariant = ["#6d9dff", "#71ff9c"];
-
-const overlayMatrices = [
- // Sender
- generateMatrixRotations([1, 1, 1, 0, 1, 0, 0, 1, 0]),
-
- // Receiver
- generateMatrixRotations([0, 1, 0, 0, 1, 0, 1, 1, 1]),
-];
-
-export class MetaUndergroundBeltBuilding extends MetaBuilding {
- constructor() {
- super("underground_belt");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 22,
- variant: defaultBuildingVariant,
- rotationVariant: 0,
- },
- {
- internalId: 23,
- variant: defaultBuildingVariant,
- rotationVariant: 1,
- },
- {
- internalId: 24,
- variant: enumUndergroundBeltVariants.tier2,
- rotationVariant: 0,
- },
- {
- internalId: 25,
- variant: enumUndergroundBeltVariants.tier2,
- rotationVariant: 1,
- },
- ];
- }
-
- getSilhouetteColor(variant, rotationVariant) {
- return colorsByRotationVariant[rotationVariant];
- }
-
- getFlipOrientationAfterPlacement() {
- return true;
- }
-
- getStayInPlacementMode() {
- return true;
- }
-
- /**
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- return overlayMatrices[rotationVariant][rotation];
- }
-
- /**
- * @param {GameRoot} root
- * @param {string} variant
- * @returns {Array<[string, string]>}
- */
- getAdditionalStatistics(root, variant) {
- const rangeTiles =
- globalConfig.undergroundBeltMaxTilesByTier[enumUndergroundBeltVariantToTier[variant]];
-
- const beltSpeed = root.hubGoals.getUndergroundBeltBaseSpeed();
-
- /** @type {Array<[string, string]>} */
- const stats = [
- [
- T.ingame.buildingPlacement.infoTexts.range,
- T.ingame.buildingPlacement.infoTexts.tiles.replace("", "" + rangeTiles),
- ],
- ];
-
- if (root.gameMode.throughputDoesNotMatter()) {
- return stats;
- }
- stats.push([T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]);
-
- return stats;
- }
-
- /**
- * @param {GameRoot} root
- */
- getAvailableVariants(root) {
- if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_underground_belt_tier_2)) {
- return [defaultBuildingVariant, enumUndergroundBeltVariants.tier2];
- }
- return super.getAvailableVariants(root);
- }
-
- /**
- * @param {number} rotationVariant
- * @param {string} variant
- */
- getPreviewSprite(rotationVariant, variant) {
- let suffix = "";
- if (variant !== defaultBuildingVariant) {
- suffix = "-" + variant;
- }
-
- switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
- case enumUndergroundBeltMode.sender:
- return Loader.getSprite("sprites/buildings/underground_belt_entry" + suffix + ".png");
- case enumUndergroundBeltMode.receiver:
- return Loader.getSprite("sprites/buildings/underground_belt_exit" + suffix + ".png");
- default:
- assertAlways(false, "Invalid rotation variant");
- }
- }
-
- /**
- * @param {number} rotationVariant
- * @param {string} variant
- */
- getBlueprintSprite(rotationVariant, variant) {
- let suffix = "";
- if (variant !== defaultBuildingVariant) {
- suffix = "-" + variant;
- }
-
- switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
- case enumUndergroundBeltMode.sender:
- return Loader.getSprite("sprites/blueprints/underground_belt_entry" + suffix + ".png");
- case enumUndergroundBeltMode.receiver:
- return Loader.getSprite("sprites/blueprints/underground_belt_exit" + suffix + ".png");
- default:
- assertAlways(false, "Invalid rotation variant");
- }
- }
-
- /**
- * @param {number} rotationVariant
- * @param {string} variant
- */
- getSprite(rotationVariant, variant) {
- return this.getPreviewSprite(rotationVariant, variant);
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_tunnel);
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- // Required, since the item processor needs this.
- entity.addComponent(
- new ItemEjectorComponent({
- slots: [],
- })
- );
-
- entity.addComponent(new UndergroundBeltComponent({}));
- entity.addComponent(
- new ItemAcceptorComponent({
- slots: [],
- })
- );
- }
-
- /**
- * Should compute the optimal rotation variant on the given tile
- * @param {object} param0
- * @param {GameRoot} param0.root
- * @param {Vector} param0.tile
- * @param {number} param0.rotation
- * @param {string} param0.variant
- * @param {Layer} param0.layer
- * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array }}
- */
- computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
- const searchDirection = enumAngleToDirection[rotation];
- const searchVector = enumDirectionToVector[searchDirection];
- const tier = enumUndergroundBeltVariantToTier[variant];
-
- const targetRotation = (rotation + 180) % 360;
- const targetSenderRotation = rotation;
-
- for (
- let searchOffset = 1;
- searchOffset <= globalConfig.undergroundBeltMaxTilesByTier[tier];
- ++searchOffset
- ) {
- tile = tile.addScalars(searchVector.x, searchVector.y);
-
- const contents = root.map.getTileContent(tile, "regular");
- if (contents) {
- const undergroundComp = contents.components.UndergroundBelt;
- if (undergroundComp && undergroundComp.tier === tier) {
- const staticComp = contents.components.StaticMapEntity;
- if (staticComp.rotation === targetRotation) {
- if (undergroundComp.mode !== enumUndergroundBeltMode.sender) {
- // If we encounter an underground receiver on our way which is also faced in our direction, we don't accept that
- break;
- }
- return {
- rotation: targetRotation,
- rotationVariant: 1,
- connectedEntities: [contents],
- };
- } else if (staticComp.rotation === targetSenderRotation) {
- // Draw connections to receivers
- if (undergroundComp.mode === enumUndergroundBeltMode.receiver) {
- return {
- rotation: rotation,
- rotationVariant: 0,
- connectedEntities: [contents],
- };
- } else {
- break;
- }
- }
- }
- }
- }
-
- return {
- rotation,
- rotationVariant: 0,
- };
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- * @param {string} variant
- */
- updateVariants(entity, rotationVariant, variant) {
- entity.components.UndergroundBelt.tier = enumUndergroundBeltVariantToTier[variant];
-
- switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
- case enumUndergroundBeltMode.sender: {
- entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.sender;
- entity.components.ItemEjector.setSlots([]);
- entity.components.ItemAcceptor.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- },
- ]);
- return;
- }
- case enumUndergroundBeltMode.receiver: {
- entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.receiver;
- entity.components.ItemAcceptor.setSlots([]);
- entity.components.ItemEjector.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- },
- ]);
- return;
- }
- default:
- assertAlways(false, "Invalid rotation variant");
- }
- }
-}
+import { Loader } from "../../core/loader";
+import { enumDirection, Vector, enumAngleToDirection, enumDirectionToVector } from "../../core/vector";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
+import { Entity } from "../entity";
+import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
+import { GameRoot } from "../root";
+import { globalConfig } from "../../core/config";
+import { enumHubGoalRewards } from "../tutorial_goals";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
+import { T } from "../../translations";
+
+/** @enum {string} */
+export const arrayUndergroundRotationVariantToMode = [
+ enumUndergroundBeltMode.sender,
+ enumUndergroundBeltMode.receiver,
+];
+
+/** @enum {string} */
+export const enumUndergroundBeltVariants = { tier2: "tier2" };
+
+export const enumUndergroundBeltVariantToTier = {
+ [defaultBuildingVariant]: 0,
+ [enumUndergroundBeltVariants.tier2]: 1,
+};
+
+const colorsByRotationVariant = ["#6d9dff", "#71ff9c"];
+
+const overlayMatrices = [
+ // Sender
+ generateMatrixRotations([1, 1, 1, 0, 1, 0, 0, 1, 0]),
+
+ // Receiver
+ generateMatrixRotations([0, 1, 0, 0, 1, 0, 1, 1, 1]),
+];
+
+export class MetaUndergroundBeltBuilding extends MetaBuilding {
+ constructor() {
+ super("underground_belt");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 22,
+ variant: defaultBuildingVariant,
+ rotationVariant: 0,
+ },
+ {
+ internalId: 23,
+ variant: defaultBuildingVariant,
+ rotationVariant: 1,
+ },
+ {
+ internalId: 24,
+ variant: enumUndergroundBeltVariants.tier2,
+ rotationVariant: 0,
+ },
+ {
+ internalId: 25,
+ variant: enumUndergroundBeltVariants.tier2,
+ rotationVariant: 1,
+ },
+ ];
+ }
+
+ getSilhouetteColor(variant, rotationVariant) {
+ return colorsByRotationVariant[rotationVariant];
+ }
+
+ getFlipOrientationAfterPlacement() {
+ return true;
+ }
+
+ getStayInPlacementMode() {
+ return true;
+ }
+
+ /**
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ return overlayMatrices[rotationVariant][rotation];
+ }
+
+ /**
+ * @param {GameRoot} root
+ * @param {string} variant
+ * @returns {Array<[string, string]>}
+ */
+ getAdditionalStatistics(root, variant) {
+ const rangeTiles =
+ globalConfig.undergroundBeltMaxTilesByTier[enumUndergroundBeltVariantToTier[variant]];
+
+ const beltSpeed = root.hubGoals.getUndergroundBeltBaseSpeed();
+
+ /** @type {Array<[string, string]>} */
+ const stats = [
+ [
+ T.ingame.buildingPlacement.infoTexts.range,
+ T.ingame.buildingPlacement.infoTexts.tiles.replace("", "" + rangeTiles),
+ ],
+ ];
+
+ if (root.gameMode.throughputDoesNotMatter()) {
+ return stats;
+ }
+ stats.push([T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)]);
+
+ return stats;
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getAvailableVariants(root) {
+ if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_underground_belt_tier_2)) {
+ return [defaultBuildingVariant, enumUndergroundBeltVariants.tier2];
+ }
+ return super.getAvailableVariants(root);
+ }
+
+ /**
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ getPreviewSprite(rotationVariant, variant) {
+ let suffix = "";
+ if (variant !== defaultBuildingVariant) {
+ suffix = "-" + variant;
+ }
+
+ switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
+ case enumUndergroundBeltMode.sender:
+ return Loader.getSprite("sprites/buildings/underground_belt_entry" + suffix + ".png");
+ case enumUndergroundBeltMode.receiver:
+ return Loader.getSprite("sprites/buildings/underground_belt_exit" + suffix + ".png");
+ default:
+ assertAlways(false, "Invalid rotation variant");
+ }
+ }
+
+ /**
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ getBlueprintSprite(rotationVariant, variant) {
+ let suffix = "";
+ if (variant !== defaultBuildingVariant) {
+ suffix = "-" + variant;
+ }
+
+ switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
+ case enumUndergroundBeltMode.sender:
+ return Loader.getSprite("sprites/blueprints/underground_belt_entry" + suffix + ".png");
+ case enumUndergroundBeltMode.receiver:
+ return Loader.getSprite("sprites/blueprints/underground_belt_exit" + suffix + ".png");
+ default:
+ assertAlways(false, "Invalid rotation variant");
+ }
+ }
+
+ /**
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ getSprite(rotationVariant, variant) {
+ return this.getPreviewSprite(rotationVariant, variant);
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_tunnel);
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ // Required, since the item processor needs this.
+ entity.addComponent(
+ new ItemEjectorComponent({
+ slots: [],
+ })
+ );
+
+ entity.addComponent(new UndergroundBeltComponent({}));
+ entity.addComponent(
+ new ItemAcceptorComponent({
+ slots: [],
+ })
+ );
+ }
+
+ /**
+ * Should compute the optimal rotation variant on the given tile
+ * @param {object} param0
+ * @param {GameRoot} param0.root
+ * @param {Vector} param0.tile
+ * @param {number} param0.rotation
+ * @param {string} param0.variant
+ * @param {Layer} param0.layer
+ * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array }}
+ */
+ computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
+ const searchDirection = enumAngleToDirection[rotation];
+ const searchVector = enumDirectionToVector[searchDirection];
+ const tier = enumUndergroundBeltVariantToTier[variant];
+
+ const targetRotation = (rotation + 180) % 360;
+ const targetSenderRotation = rotation;
+
+ for (
+ let searchOffset = 1;
+ searchOffset <= globalConfig.undergroundBeltMaxTilesByTier[tier];
+ ++searchOffset
+ ) {
+ tile = tile.addScalars(searchVector.x, searchVector.y);
+
+ const contents = root.map.getTileContent(tile, "regular");
+ if (contents) {
+ const undergroundComp = contents.components.UndergroundBelt;
+ if (undergroundComp && undergroundComp.tier === tier) {
+ const staticComp = contents.components.StaticMapEntity;
+ if (staticComp.rotation === targetRotation) {
+ if (undergroundComp.mode !== enumUndergroundBeltMode.sender) {
+ // If we encounter an underground receiver on our way which is also faced in our direction, we don't accept that
+ break;
+ }
+ return {
+ rotation: targetRotation,
+ rotationVariant: 1,
+ connectedEntities: [contents],
+ };
+ } else if (staticComp.rotation === targetSenderRotation) {
+ // Draw connections to receivers
+ if (undergroundComp.mode === enumUndergroundBeltMode.receiver) {
+ return {
+ rotation: rotation,
+ rotationVariant: 0,
+ connectedEntities: [contents],
+ };
+ } else {
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return {
+ rotation,
+ rotationVariant: 0,
+ };
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ entity.components.UndergroundBelt.tier = enumUndergroundBeltVariantToTier[variant];
+
+ switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
+ case enumUndergroundBeltMode.sender: {
+ entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.sender;
+ entity.components.ItemEjector.setSlots([]);
+ entity.components.ItemAcceptor.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ },
+ ]);
+ return;
+ }
+ case enumUndergroundBeltMode.receiver: {
+ entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.receiver;
+ entity.components.ItemAcceptor.setSlots([]);
+ entity.components.ItemEjector.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ },
+ ]);
+ return;
+ }
+ default:
+ assertAlways(false, "Invalid rotation variant");
+ }
+ }
+}
diff --git a/src/js/game/buildings/virtual_processor.js b/src/js/game/buildings/virtual_processor.js
index b42ceb5d..477a4bd9 100644
--- a/src/js/game/buildings/virtual_processor.js
+++ b/src/js/game/buildings/virtual_processor.js
@@ -1,188 +1,188 @@
-import { Vector, enumDirection } from "../../core/vector";
-import { LogicGateComponent, enumLogicGateType } from "../components/logic_gate";
-import { WiredPinsComponent, enumPinSlotType } from "../components/wired_pins";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-import { MetaCutterBuilding } from "./cutter";
-import { MetaPainterBuilding } from "./painter";
-import { MetaRotaterBuilding } from "./rotater";
-import { MetaStackerBuilding } from "./stacker";
-
-/** @enum {string} */
-export const enumVirtualProcessorVariants = {
- rotater: "rotater",
- unstacker: "unstacker",
- stacker: "stacker",
- painter: "painter",
-};
-
-/** @enum {string} */
-const enumVariantToGate = {
- [defaultBuildingVariant]: enumLogicGateType.cutter,
- [enumVirtualProcessorVariants.rotater]: enumLogicGateType.rotater,
- [enumVirtualProcessorVariants.unstacker]: enumLogicGateType.unstacker,
- [enumVirtualProcessorVariants.stacker]: enumLogicGateType.stacker,
- [enumVirtualProcessorVariants.painter]: enumLogicGateType.painter,
-};
-
-const colors = {
- [defaultBuildingVariant]: new MetaCutterBuilding().getSilhouetteColor(),
- [enumVirtualProcessorVariants.rotater]: new MetaRotaterBuilding().getSilhouetteColor(),
- [enumVirtualProcessorVariants.unstacker]: new MetaStackerBuilding().getSilhouetteColor(),
- [enumVirtualProcessorVariants.stacker]: new MetaStackerBuilding().getSilhouetteColor(),
- [enumVirtualProcessorVariants.painter]: new MetaPainterBuilding().getSilhouetteColor(),
-};
-
-export class MetaVirtualProcessorBuilding extends MetaBuilding {
- constructor() {
- super("virtual_processor");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 42,
- variant: defaultBuildingVariant,
- },
- {
- internalId: 44,
- variant: enumVirtualProcessorVariants.rotater,
- },
- {
- internalId: 45,
- variant: enumVirtualProcessorVariants.unstacker,
- },
- {
- internalId: 50,
- variant: enumVirtualProcessorVariants.stacker,
- },
- {
- internalId: 51,
- variant: enumVirtualProcessorVariants.painter,
- },
- ];
- }
-
- getSilhouetteColor(variant) {
- return colors[variant];
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing);
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getAvailableVariants() {
- return [
- defaultBuildingVariant,
- enumVirtualProcessorVariants.rotater,
- enumVirtualProcessorVariants.stacker,
- enumVirtualProcessorVariants.painter,
- enumVirtualProcessorVariants.unstacker,
- ];
- }
-
- getRenderPins() {
- // We already have it included
- return false;
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- */
- updateVariants(entity, rotationVariant, variant) {
- const gateType = enumVariantToGate[variant];
- entity.components.LogicGate.type = gateType;
- const pinComp = entity.components.WiredPins;
- switch (gateType) {
- case enumLogicGateType.cutter:
- case enumLogicGateType.unstacker: {
- pinComp.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.left,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.right,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- type: enumPinSlotType.logicalAcceptor,
- },
- ]);
- break;
- }
- case enumLogicGateType.rotater: {
- pinComp.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- type: enumPinSlotType.logicalAcceptor,
- },
- ]);
- break;
- }
- case enumLogicGateType.stacker:
- case enumLogicGateType.painter: {
- pinComp.setSlots([
- {
- pos: new Vector(0, 0),
- direction: enumDirection.top,
- type: enumPinSlotType.logicalEjector,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.bottom,
- type: enumPinSlotType.logicalAcceptor,
- },
- {
- pos: new Vector(0, 0),
- direction: enumDirection.right,
- type: enumPinSlotType.logicalAcceptor,
- },
- ]);
- break;
- }
- default:
- assertAlways("unknown logic gate type: " + gateType);
- }
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(
- new WiredPinsComponent({
- slots: [],
- })
- );
-
- entity.addComponent(new LogicGateComponent({}));
- }
-}
+import { Vector, enumDirection } from "../../core/vector";
+import { LogicGateComponent, enumLogicGateType } from "../components/logic_gate";
+import { WiredPinsComponent, enumPinSlotType } from "../components/wired_pins";
+import { Entity } from "../entity";
+import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+import { MetaCutterBuilding } from "./cutter";
+import { MetaPainterBuilding } from "./painter";
+import { MetaRotatorBuilding } from "./rotator";
+import { MetaStackerBuilding } from "./stacker";
+
+/** @enum {string} */
+export const enumVirtualProcessorVariants = {
+ rotator: "rotator",
+ unstacker: "unstacker",
+ stacker: "stacker",
+ painter: "painter",
+};
+
+/** @enum {string} */
+const enumVariantToGate = {
+ [defaultBuildingVariant]: enumLogicGateType.cutter,
+ [enumVirtualProcessorVariants.rotator]: enumLogicGateType.rotator,
+ [enumVirtualProcessorVariants.unstacker]: enumLogicGateType.unstacker,
+ [enumVirtualProcessorVariants.stacker]: enumLogicGateType.stacker,
+ [enumVirtualProcessorVariants.painter]: enumLogicGateType.painter,
+};
+
+const colors = {
+ [defaultBuildingVariant]: new MetaCutterBuilding().getSilhouetteColor(),
+ [enumVirtualProcessorVariants.rotator]: new MetaRotatorBuilding().getSilhouetteColor(),
+ [enumVirtualProcessorVariants.unstacker]: new MetaStackerBuilding().getSilhouetteColor(),
+ [enumVirtualProcessorVariants.stacker]: new MetaStackerBuilding().getSilhouetteColor(),
+ [enumVirtualProcessorVariants.painter]: new MetaPainterBuilding().getSilhouetteColor(),
+};
+
+export class MetaVirtualProcessorBuilding extends MetaBuilding {
+ constructor() {
+ super("virtual_processor");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 42,
+ variant: defaultBuildingVariant,
+ },
+ {
+ internalId: 44,
+ variant: enumVirtualProcessorVariants.rotator,
+ },
+ {
+ internalId: 45,
+ variant: enumVirtualProcessorVariants.unstacker,
+ },
+ {
+ internalId: 50,
+ variant: enumVirtualProcessorVariants.stacker,
+ },
+ {
+ internalId: 51,
+ variant: enumVirtualProcessorVariants.painter,
+ },
+ ];
+ }
+
+ getSilhouetteColor(variant) {
+ return colors[variant];
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing);
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getAvailableVariants() {
+ return [
+ defaultBuildingVariant,
+ enumVirtualProcessorVariants.rotator,
+ enumVirtualProcessorVariants.stacker,
+ enumVirtualProcessorVariants.painter,
+ enumVirtualProcessorVariants.unstacker,
+ ];
+ }
+
+ getRenderPins() {
+ // We already have it included
+ return false;
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ const gateType = enumVariantToGate[variant];
+ entity.components.LogicGate.type = gateType;
+ const pinComp = entity.components.WiredPins;
+ switch (gateType) {
+ case enumLogicGateType.cutter:
+ case enumLogicGateType.unstacker: {
+ pinComp.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.left,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.right,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ]);
+ break;
+ }
+ case enumLogicGateType.rotator: {
+ pinComp.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ]);
+ break;
+ }
+ case enumLogicGateType.stacker:
+ case enumLogicGateType.painter: {
+ pinComp.setSlots([
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.top,
+ type: enumPinSlotType.logicalEjector,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.bottom,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ {
+ pos: new Vector(0, 0),
+ direction: enumDirection.right,
+ type: enumPinSlotType.logicalAcceptor,
+ },
+ ]);
+ break;
+ }
+ default:
+ assertAlways("unknown logic gate type: " + gateType);
+ }
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(
+ new WiredPinsComponent({
+ slots: [],
+ })
+ );
+
+ entity.addComponent(new LogicGateComponent({}));
+ }
+}
diff --git a/src/js/game/buildings/wire.js b/src/js/game/buildings/wire.js
index c69dbfa1..1c2fced5 100644
--- a/src/js/game/buildings/wire.js
+++ b/src/js/game/buildings/wire.js
@@ -1,315 +1,315 @@
-import { Loader } from "../../core/loader";
-import { generateMatrixRotations } from "../../core/utils";
-import { enumDirection, Vector } from "../../core/vector";
-import { SOUNDS } from "../../platform/sound";
-import { enumWireType, enumWireVariant, WireComponent } from "../components/wire";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-export const arrayWireRotationVariantToType = [
- enumWireType.forward,
- enumWireType.turn,
- enumWireType.split,
- enumWireType.cross,
-];
-
-export const wireOverlayMatrices = {
- [enumWireType.forward]: generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
- [enumWireType.split]: generateMatrixRotations([0, 0, 0, 1, 1, 1, 0, 1, 0]),
- [enumWireType.turn]: generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
- [enumWireType.cross]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]),
-};
-
-/** @enum {string} */
-export const wireVariants = {
- second: "second",
-};
-
-const enumWireVariantToVariant = {
- [defaultBuildingVariant]: enumWireVariant.first,
- [wireVariants.second]: enumWireVariant.second,
-};
-
-export class MetaWireBuilding extends MetaBuilding {
- constructor() {
- super("wire");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 27,
- variant: defaultBuildingVariant,
- rotationVariant: 0,
- },
- {
- internalId: 28,
- variant: defaultBuildingVariant,
- rotationVariant: 1,
- },
- {
- internalId: 29,
- variant: defaultBuildingVariant,
- rotationVariant: 2,
- },
- {
- internalId: 30,
- variant: defaultBuildingVariant,
- rotationVariant: 3,
- },
- {
- internalId: 52,
- variant: enumWireVariant.second,
- rotationVariant: 0,
- },
- {
- internalId: 53,
- variant: enumWireVariant.second,
- rotationVariant: 1,
- },
- {
- internalId: 54,
- variant: enumWireVariant.second,
- rotationVariant: 2,
- },
- {
- internalId: 55,
- variant: enumWireVariant.second,
- rotationVariant: 3,
- },
- ];
- }
-
- getHasDirectionLockAvailable() {
- return true;
- }
-
- getSilhouetteColor() {
- return "#61ef6f";
- }
-
- getAvailableVariants() {
- return [defaultBuildingVariant, wireVariants.second];
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- getStayInPlacementMode() {
- return true;
- }
-
- getPlacementSound() {
- return SOUNDS.placeBelt;
- }
-
- getRotateAutomaticallyWhilePlacing() {
- return true;
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- getSprite() {
- return null;
- }
-
- getIsReplaceable() {
- return true;
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers);
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(new WireComponent({}));
- }
-
- /**
- *
- * @param {Entity} entity
- * @param {number} rotationVariant
- * @param {string} variant
- */
- updateVariants(entity, rotationVariant, variant) {
- entity.components.Wire.type = arrayWireRotationVariantToType[rotationVariant];
- entity.components.Wire.variant = enumWireVariantToVariant[variant];
- }
-
- /**
- *
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- return wireOverlayMatrices[entity.components.Wire.type][rotation];
- }
-
- /**
- *
- * @param {number} rotationVariant
- * @param {string} variant
- * @returns {import("../../core/draw_utils").AtlasSprite}
- */
- getPreviewSprite(rotationVariant, variant) {
- const wireVariant = enumWireVariantToVariant[variant];
- switch (arrayWireRotationVariantToType[rotationVariant]) {
- case enumWireType.forward: {
- return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_forward.png");
- }
- case enumWireType.turn: {
- return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_turn.png");
- }
- case enumWireType.split: {
- return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_split.png");
- }
- case enumWireType.cross: {
- return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_cross.png");
- }
- default: {
- assertAlways(false, "Invalid wire rotation variant");
- }
- }
- }
-
- getBlueprintSprite(rotationVariant, variant) {
- return this.getPreviewSprite(rotationVariant, variant);
- }
-
- /**
- * Should compute the optimal rotation variant on the given tile
- * @param {object} param0
- * @param {GameRoot} param0.root
- * @param {Vector} param0.tile
- * @param {number} param0.rotation
- * @param {string} param0.variant
- * @param {string} param0.layer
- * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array }}
- */
- computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
- const wireVariant = enumWireVariantToVariant[variant];
- const connections = {
- top: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.top }),
- right: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.right }),
- bottom: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.bottom }),
- left: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.left }),
- };
-
- let flag = 0;
- flag |= connections.top ? 0x1000 : 0;
- flag |= connections.right ? 0x100 : 0;
- flag |= connections.bottom ? 0x10 : 0;
- flag |= connections.left ? 0x1 : 0;
-
- let targetType = enumWireType.forward;
-
- // First, reset rotation
- rotation = 0;
-
- switch (flag) {
- case 0x0000:
- // Nothing
- break;
-
- case 0x0001:
- // Left
- rotation += 90;
- break;
-
- case 0x0010:
- // Bottom
- // END
- break;
-
- case 0x0011:
- // Bottom | Left
- targetType = enumWireType.turn;
- rotation += 90;
- break;
-
- case 0x0100:
- // Right
- rotation += 90;
- break;
-
- case 0x0101:
- // Right | Left
- rotation += 90;
- break;
-
- case 0x0110:
- // Right | Bottom
- targetType = enumWireType.turn;
- break;
-
- case 0x0111:
- // Right | Bottom | Left
- targetType = enumWireType.split;
- break;
-
- case 0x1000:
- // Top
- break;
-
- case 0x1001:
- // Top | Left
- targetType = enumWireType.turn;
- rotation += 180;
- break;
-
- case 0x1010:
- // Top | Bottom
- break;
-
- case 0x1011:
- // Top | Bottom | Left
- targetType = enumWireType.split;
- rotation += 90;
- break;
-
- case 0x1100:
- // Top | Right
- targetType = enumWireType.turn;
- rotation -= 90;
- break;
-
- case 0x1101:
- // Top | Right | Left
- targetType = enumWireType.split;
- rotation += 180;
- break;
-
- case 0x1110:
- // Top | Right | Bottom
- targetType = enumWireType.split;
- rotation -= 90;
- break;
-
- case 0x1111:
- // Top | Right | Bottom | Left
- targetType = enumWireType.cross;
- break;
- }
-
- return {
- // Clamp rotation
- rotation: (rotation + 360 * 10) % 360,
- rotationVariant: arrayWireRotationVariantToType.indexOf(targetType),
- };
- }
-}
+import { Loader } from "../../core/loader";
+import { generateMatrixRotations } from "../../core/utils";
+import { enumDirection, Vector } from "../../core/vector";
+import { SOUNDS } from "../../platform/sound";
+import { enumWireType, enumWireVariant, WireComponent } from "../components/wire";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+export const arrayWireRotationVariantToType = [
+ enumWireType.forward,
+ enumWireType.turn,
+ enumWireType.split,
+ enumWireType.cross,
+];
+
+export const wireOverlayMatrices = {
+ [enumWireType.forward]: generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
+ [enumWireType.split]: generateMatrixRotations([0, 0, 0, 1, 1, 1, 0, 1, 0]),
+ [enumWireType.turn]: generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
+ [enumWireType.cross]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]),
+};
+
+/** @enum {string} */
+export const wireVariants = {
+ second: "second",
+};
+
+const enumWireVariantToVariant = {
+ [defaultBuildingVariant]: enumWireVariant.first,
+ [wireVariants.second]: enumWireVariant.second,
+};
+
+export class MetaWireBuilding extends MetaBuilding {
+ constructor() {
+ super("wire");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 27,
+ variant: defaultBuildingVariant,
+ rotationVariant: 0,
+ },
+ {
+ internalId: 28,
+ variant: defaultBuildingVariant,
+ rotationVariant: 1,
+ },
+ {
+ internalId: 29,
+ variant: defaultBuildingVariant,
+ rotationVariant: 2,
+ },
+ {
+ internalId: 30,
+ variant: defaultBuildingVariant,
+ rotationVariant: 3,
+ },
+ {
+ internalId: 52,
+ variant: enumWireVariant.second,
+ rotationVariant: 0,
+ },
+ {
+ internalId: 53,
+ variant: enumWireVariant.second,
+ rotationVariant: 1,
+ },
+ {
+ internalId: 54,
+ variant: enumWireVariant.second,
+ rotationVariant: 2,
+ },
+ {
+ internalId: 55,
+ variant: enumWireVariant.second,
+ rotationVariant: 3,
+ },
+ ];
+ }
+
+ getHasDirectionLockAvailable() {
+ return true;
+ }
+
+ getSilhouetteColor() {
+ return "#61ef6f";
+ }
+
+ getAvailableVariants() {
+ return [defaultBuildingVariant, wireVariants.second];
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ getStayInPlacementMode() {
+ return true;
+ }
+
+ getPlacementSound() {
+ return SOUNDS.placeBelt;
+ }
+
+ getRotateAutomaticallyWhilePlacing() {
+ return true;
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ getSprite() {
+ return null;
+ }
+
+ getIsReplaceable() {
+ return true;
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers);
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(new WireComponent({}));
+ }
+
+ /**
+ *
+ * @param {Entity} entity
+ * @param {number} rotationVariant
+ * @param {string} variant
+ */
+ updateVariants(entity, rotationVariant, variant) {
+ entity.components.Wire.type = arrayWireRotationVariantToType[rotationVariant];
+ entity.components.Wire.variant = enumWireVariantToVariant[variant];
+ }
+
+ /**
+ *
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ return wireOverlayMatrices[entity.components.Wire.type][rotation];
+ }
+
+ /**
+ *
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @returns {import("../../core/draw_utils").AtlasSprite}
+ */
+ getPreviewSprite(rotationVariant, variant) {
+ const wireVariant = enumWireVariantToVariant[variant];
+ switch (arrayWireRotationVariantToType[rotationVariant]) {
+ case enumWireType.forward: {
+ return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_forward.png");
+ }
+ case enumWireType.turn: {
+ return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_turn.png");
+ }
+ case enumWireType.split: {
+ return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_split.png");
+ }
+ case enumWireType.cross: {
+ return Loader.getSprite("sprites/wires/sets/" + wireVariant + "_cross.png");
+ }
+ default: {
+ assertAlways(false, "Invalid wire rotation variant");
+ }
+ }
+ }
+
+ getBlueprintSprite(rotationVariant, variant) {
+ return this.getPreviewSprite(rotationVariant, variant);
+ }
+
+ /**
+ * Should compute the optimal rotation variant on the given tile
+ * @param {object} param0
+ * @param {GameRoot} param0.root
+ * @param {Vector} param0.tile
+ * @param {number} param0.rotation
+ * @param {string} param0.variant
+ * @param {string} param0.layer
+ * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array }}
+ */
+ computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
+ const wireVariant = enumWireVariantToVariant[variant];
+ const connections = {
+ top: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.top }),
+ right: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.right }),
+ bottom: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.bottom }),
+ left: root.logic.computeWireEdgeStatus({ tile, wireVariant, edge: enumDirection.left }),
+ };
+
+ let flag = 0;
+ flag |= connections.top ? 0x1000 : 0;
+ flag |= connections.right ? 0x100 : 0;
+ flag |= connections.bottom ? 0x10 : 0;
+ flag |= connections.left ? 0x1 : 0;
+
+ let targetType = enumWireType.forward;
+
+ // First, reset rotation
+ rotation = 0;
+
+ switch (flag) {
+ case 0x0000:
+ // Nothing
+ break;
+
+ case 0x0001:
+ // Left
+ rotation += 90;
+ break;
+
+ case 0x0010:
+ // Bottom
+ // END
+ break;
+
+ case 0x0011:
+ // Bottom | Left
+ targetType = enumWireType.turn;
+ rotation += 90;
+ break;
+
+ case 0x0100:
+ // Right
+ rotation += 90;
+ break;
+
+ case 0x0101:
+ // Right | Left
+ rotation += 90;
+ break;
+
+ case 0x0110:
+ // Right | Bottom
+ targetType = enumWireType.turn;
+ break;
+
+ case 0x0111:
+ // Right | Bottom | Left
+ targetType = enumWireType.split;
+ break;
+
+ case 0x1000:
+ // Top
+ break;
+
+ case 0x1001:
+ // Top | Left
+ targetType = enumWireType.turn;
+ rotation += 180;
+ break;
+
+ case 0x1010:
+ // Top | Bottom
+ break;
+
+ case 0x1011:
+ // Top | Bottom | Left
+ targetType = enumWireType.split;
+ rotation += 90;
+ break;
+
+ case 0x1100:
+ // Top | Right
+ targetType = enumWireType.turn;
+ rotation -= 90;
+ break;
+
+ case 0x1101:
+ // Top | Right | Left
+ targetType = enumWireType.split;
+ rotation += 180;
+ break;
+
+ case 0x1110:
+ // Top | Right | Bottom
+ targetType = enumWireType.split;
+ rotation -= 90;
+ break;
+
+ case 0x1111:
+ // Top | Right | Bottom | Left
+ targetType = enumWireType.cross;
+ break;
+ }
+
+ return {
+ // Clamp rotation
+ rotation: (rotation + 360 * 10) % 360,
+ rotationVariant: arrayWireRotationVariantToType.indexOf(targetType),
+ };
+ }
+}
diff --git a/src/js/game/buildings/wire_tunnel.js b/src/js/game/buildings/wire_tunnel.js
index 80faa9df..36197622 100644
--- a/src/js/game/buildings/wire_tunnel.js
+++ b/src/js/game/buildings/wire_tunnel.js
@@ -1,67 +1,67 @@
-import { generateMatrixRotations } from "../../core/utils";
-import { Vector } from "../../core/vector";
-import { WireTunnelComponent } from "../components/wire_tunnel";
-import { Entity } from "../entity";
-import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
-import { GameRoot } from "../root";
-import { enumHubGoalRewards } from "../tutorial_goals";
-
-const wireTunnelOverlayMatrix = generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]);
-
-export class MetaWireTunnelBuilding extends MetaBuilding {
- constructor() {
- super("wire_tunnel");
- }
-
- static getAllVariantCombinations() {
- return [
- {
- internalId: 39,
- variant: defaultBuildingVariant,
- },
- ];
- }
-
- getSilhouetteColor() {
- return "#777a86";
- }
-
- /**
- * @param {GameRoot} root
- */
- getIsUnlocked(root) {
- return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers);
- }
-
- /**
- *
- * @param {number} rotation
- * @param {number} rotationVariant
- * @param {string} variant
- * @param {Entity} entity
- */
- getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
- return wireTunnelOverlayMatrix[rotation];
- }
-
- getIsRotateable() {
- return false;
- }
-
- getDimensions() {
- return new Vector(1, 1);
- }
-
- /** @returns {"wires"} **/
- getLayer() {
- return "wires";
- }
-
- /**
- * Creates the entity at the given location
- * @param {Entity} entity
- */
- setupEntityComponents(entity) {
- entity.addComponent(new WireTunnelComponent());
- }
-}
+import { generateMatrixRotations } from "../../core/utils";
+import { Vector } from "../../core/vector";
+import { WireTunnelComponent } from "../components/wire_tunnel";
+import { Entity } from "../entity";
+import { defaultBuildingVariant, MetaBuilding } from "../meta_building";
+import { GameRoot } from "../root";
+import { enumHubGoalRewards } from "../tutorial_goals";
+
+const wireTunnelOverlayMatrix = generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]);
+
+export class MetaWireTunnelBuilding extends MetaBuilding {
+ constructor() {
+ super("wire_tunnel");
+ }
+
+ static getAllVariantCombinations() {
+ return [
+ {
+ internalId: 39,
+ variant: defaultBuildingVariant,
+ },
+ ];
+ }
+
+ getSilhouetteColor() {
+ return "#777a86";
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ getIsUnlocked(root) {
+ return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers);
+ }
+
+ /**
+ *
+ * @param {number} rotation
+ * @param {number} rotationVariant
+ * @param {string} variant
+ * @param {Entity} entity
+ */
+ getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+ return wireTunnelOverlayMatrix[rotation];
+ }
+
+ getIsRotateable() {
+ return false;
+ }
+
+ getDimensions() {
+ return new Vector(1, 1);
+ }
+
+ /** @returns {"wires"} **/
+ getLayer() {
+ return "wires";
+ }
+
+ /**
+ * Creates the entity at the given location
+ * @param {Entity} entity
+ */
+ setupEntityComponents(entity) {
+ entity.addComponent(new WireTunnelComponent());
+ }
+}
diff --git a/src/js/game/camera.js b/src/js/game/camera.js
index fc08d73f..b5001f45 100644
--- a/src/js/game/camera.js
+++ b/src/js/game/camera.js
@@ -1,1039 +1,1041 @@
-import { clickDetectorGlobals } from "../core/click_detector";
-import { globalConfig, SUPPORT_TOUCH } from "../core/config";
-import { createLogger } from "../core/logging";
-import { Rectangle } from "../core/rectangle";
-import { Signal, STOP_PROPAGATION } from "../core/signal";
-import { clamp } from "../core/utils";
-import { mixVector, Vector } from "../core/vector";
-import { BasicSerializableObject, types } from "../savegame/serialization";
-import { KEYMAPPINGS } from "./key_action_mapper";
-import { GameRoot } from "./root";
-
-const logger = createLogger("camera");
-
-export const USER_INTERACT_MOVE = "move";
-export const USER_INTERACT_ZOOM = "zoom";
-export const USER_INTERACT_TOUCHEND = "touchend";
-
-const velocitySmoothing = 0.5;
-const velocityFade = 0.98;
-const velocityStrength = 0.4;
-const velocityMax = 20;
-const ticksBeforeErasingVelocity = 10;
-
-/**
- * @enum {string}
- */
-export const enumMouseButton = {
- left: "left",
- middle: "middle",
- right: "right",
-};
-
-export class Camera extends BasicSerializableObject {
- constructor(root) {
- super();
-
- /** @type {GameRoot} */
- this.root = root;
-
- // Zoom level, 2 means double size
-
- // Find optimal initial zoom
-
- this.zoomLevel = this.findInitialZoom();
- this.clampZoomLevel();
-
- /** @type {Vector} */
- this.center = new Vector(0, 0);
-
- // Input handling
- this.currentlyMoving = false;
- this.lastMovingPosition = null;
- this.lastMovingPositionLastTick = null;
- this.numTicksStandingStill = null;
- this.cameraUpdateTimeBucket = 0.0;
- this.didMoveSinceTouchStart = false;
- this.currentlyPinching = false;
- this.lastPinchPositions = null;
-
- this.keyboardForce = new Vector();
-
- // Signal which gets emitted once the user changed something
- this.userInteraction = new Signal();
-
- /** @type {Vector} */
- this.currentShake = new Vector(0, 0);
-
- /** @type {Vector} */
- this.currentPan = new Vector(0, 0);
-
- // Set desired pan (camera movement)
- /** @type {Vector} */
- this.desiredPan = new Vector(0, 0);
-
- // Set desired camera center
- /** @type {Vector} */
- this.desiredCenter = null;
-
- // Set desired camera zoom
- /** @type {number} */
- this.desiredZoom = null;
-
- /** @type {Vector} */
- this.touchPostMoveVelocity = new Vector(0, 0);
-
- // Handlers
- this.downPreHandler = /** @type {TypedSignal<[Vector, enumMouseButton]>} */ (new Signal());
- this.movePreHandler = /** @type {TypedSignal<[Vector]>} */ (new Signal());
- // this.pinchPreHandler = /** @type {TypedSignal<[Vector]>} */ (new Signal());
- this.upPostHandler = /** @type {TypedSignal<[Vector]>} */ (new Signal());
-
- this.internalInitEvents();
- this.clampZoomLevel();
- this.bindKeys();
- if (G_IS_DEV) {
- window.addEventListener("keydown", ev => {
- if (ev.key === "i") {
- this.zoomLevel = 3;
- }
- });
- }
- }
-
- // Serialization
- static getId() {
- return "Camera";
- }
-
- static getSchema() {
- return {
- zoomLevel: types.float,
- center: types.vector,
- };
- }
-
- deserialize(data) {
- const errorCode = super.deserialize(data);
- if (errorCode) {
- return errorCode;
- }
-
- // Safety
- this.clampZoomLevel();
- }
-
- // Simple getters & setters
-
- addScreenShake(amount) {
- const currentShakeAmount = this.currentShake.length();
- const scale = 1 / (1 + 3 * currentShakeAmount);
- this.currentShake.x = this.currentShake.x + 2 * (Math.random() - 0.5) * scale * amount;
- this.currentShake.y = this.currentShake.y + 2 * (Math.random() - 0.5) * scale * amount;
- }
-
- /**
- * Sets a point in world space to focus on
- * @param {Vector} center
- */
- setDesiredCenter(center) {
- this.desiredCenter = center.copy();
- this.currentlyMoving = false;
- }
-
- /**
- * Sets a desired zoom level
- * @param {number} zoom
- */
- setDesiredZoom(zoom) {
- this.desiredZoom = zoom;
- }
-
- /**
- * Returns if this camera is currently moving by a non-user interaction
- */
- isCurrentlyMovingToDesiredCenter() {
- return this.desiredCenter !== null;
- }
-
- /**
- * Sets the camera pan, every frame the camera will move by this amount
- * @param {Vector} pan
- */
- setPan(pan) {
- this.desiredPan = pan.copy();
- }
-
- /**
- * Finds a good initial zoom level
- */
- findInitialZoom() {
- let desiredWorldSpaceWidth = 18 * globalConfig.tileSize;
- if (window.innerWidth < 1000) {
- desiredWorldSpaceWidth = 12 * globalConfig.tileSize;
- }
-
- const zoomLevelX = this.root.gameWidth / desiredWorldSpaceWidth;
- const zoomLevelY = this.root.gameHeight / desiredWorldSpaceWidth;
-
- const finalLevel = Math.min(zoomLevelX, zoomLevelY);
- assert(
- Number.isFinite(finalLevel) && finalLevel > 0,
- "Invalid zoom level computed for initial zoom: " + finalLevel
- );
- return finalLevel;
- }
-
- /**
- * Clears all animations
- */
- clearAnimations() {
- this.touchPostMoveVelocity.x = 0;
- this.touchPostMoveVelocity.y = 0;
- this.desiredCenter = null;
- this.desiredPan.x = 0;
- this.desiredPan.y = 0;
- this.currentPan.x = 0;
- this.currentPan.y = 0;
- this.currentlyPinching = false;
- this.currentlyMoving = false;
- this.lastMovingPosition = null;
- this.didMoveSinceTouchStart = false;
- this.desiredZoom = null;
- }
-
- /**
- * Returns if the user is currently interacting with the camera
- * @returns {boolean} true if the user interacts
- */
- isCurrentlyInteracting() {
- if (this.currentlyPinching) {
- return true;
- }
- if (this.currentlyMoving) {
- // Only interacting if moved at least once
- return this.didMoveSinceTouchStart;
- }
- if (this.touchPostMoveVelocity.lengthSquare() > 1) {
- return true;
- }
- return false;
- }
-
- /**
- * Returns if in the next frame the viewport will change
- * @returns {boolean} true if it willchange
- */
- viewportWillChange() {
- return this.desiredCenter !== null || this.desiredZoom !== null || this.isCurrentlyInteracting();
- }
-
- /**
- * Cancels all interactions, that is user interaction and non user interaction
- */
- cancelAllInteractions() {
- this.touchPostMoveVelocity = new Vector(0, 0);
- this.desiredCenter = null;
- this.currentlyMoving = false;
- this.currentlyPinching = false;
- this.desiredZoom = null;
- }
-
- /**
- * Returns effective viewport width
- */
- getViewportWidth() {
- return this.root.gameWidth / this.zoomLevel;
- }
-
- /**
- * Returns effective viewport height
- */
- getViewportHeight() {
- return this.root.gameHeight / this.zoomLevel;
- }
-
- /**
- * Returns effective world space viewport left
- */
- getViewportLeft() {
- return this.center.x - this.getViewportWidth() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
- }
-
- /**
- * Returns effective world space viewport right
- */
- getViewportRight() {
- return this.center.x + this.getViewportWidth() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
- }
-
- /**
- * Returns effective world space viewport top
- */
- getViewportTop() {
- return this.center.y - this.getViewportHeight() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
- }
-
- /**
- * Returns effective world space viewport bottom
- */
- getViewportBottom() {
- return this.center.y + this.getViewportHeight() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
- }
-
- /**
- * Returns the visible world space rect
- * @returns {Rectangle}
- */
- getVisibleRect() {
- return Rectangle.fromTRBL(
- Math.floor(this.getViewportTop()),
- Math.ceil(this.getViewportRight()),
- Math.ceil(this.getViewportBottom()),
- Math.floor(this.getViewportLeft())
- );
- }
-
- getIsMapOverlayActive() {
- return this.zoomLevel < globalConfig.mapChunkOverviewMinZoom;
- }
-
- /**
- * Attaches all event listeners
- */
- internalInitEvents() {
- this.eventListenerTouchStart = this.onTouchStart.bind(this);
- this.eventListenerTouchEnd = this.onTouchEnd.bind(this);
- this.eventListenerTouchMove = this.onTouchMove.bind(this);
- this.eventListenerMousewheel = this.onMouseWheel.bind(this);
- this.eventListenerMouseDown = this.onMouseDown.bind(this);
- this.eventListenerMouseMove = this.onMouseMove.bind(this);
- this.eventListenerMouseUp = this.onMouseUp.bind(this);
-
- if (SUPPORT_TOUCH) {
- this.root.canvas.addEventListener("touchstart", this.eventListenerTouchStart);
- this.root.canvas.addEventListener("touchend", this.eventListenerTouchEnd);
- this.root.canvas.addEventListener("touchcancel", this.eventListenerTouchEnd);
- this.root.canvas.addEventListener("touchmove", this.eventListenerTouchMove);
- }
-
- this.root.canvas.addEventListener("wheel", this.eventListenerMousewheel);
- this.root.canvas.addEventListener("mousedown", this.eventListenerMouseDown);
- this.root.canvas.addEventListener("mousemove", this.eventListenerMouseMove);
- window.addEventListener("mouseup", this.eventListenerMouseUp);
- // this.root.canvas.addEventListener("mouseout", this.eventListenerMouseUp);
- }
-
- /**
- * Cleans up all event listeners
- */
- cleanup() {
- if (SUPPORT_TOUCH) {
- this.root.canvas.removeEventListener("touchstart", this.eventListenerTouchStart);
- this.root.canvas.removeEventListener("touchend", this.eventListenerTouchEnd);
- this.root.canvas.removeEventListener("touchcancel", this.eventListenerTouchEnd);
- this.root.canvas.removeEventListener("touchmove", this.eventListenerTouchMove);
- }
-
- this.root.canvas.removeEventListener("wheel", this.eventListenerMousewheel);
- this.root.canvas.removeEventListener("mousedown", this.eventListenerMouseDown);
- this.root.canvas.removeEventListener("mousemove", this.eventListenerMouseMove);
- window.removeEventListener("mouseup", this.eventListenerMouseUp);
- // this.root.canvas.removeEventListener("mouseout", this.eventListenerMouseUp);
- }
-
- /**
- * Binds the arrow keys
- */
- bindKeys() {
- const mapper = this.root.keyMapper;
- mapper.getBinding(KEYMAPPINGS.navigation.mapMoveUp).add(() => (this.keyboardForce.y = -1));
- mapper.getBinding(KEYMAPPINGS.navigation.mapMoveDown).add(() => (this.keyboardForce.y = 1));
- mapper.getBinding(KEYMAPPINGS.navigation.mapMoveRight).add(() => (this.keyboardForce.x = 1));
- mapper.getBinding(KEYMAPPINGS.navigation.mapMoveLeft).add(() => (this.keyboardForce.x = -1));
-
- mapper
- .getBinding(KEYMAPPINGS.navigation.mapZoomIn)
- .add(() => (this.desiredZoom = this.zoomLevel * 1.2));
- mapper
- .getBinding(KEYMAPPINGS.navigation.mapZoomOut)
- .add(() => (this.desiredZoom = this.zoomLevel / 1.2));
-
- mapper.getBinding(KEYMAPPINGS.navigation.centerMap).add(() => this.centerOnMap());
- }
-
- centerOnMap() {
- this.desiredCenter = new Vector(0, 0);
- }
-
- /**
- * Converts from screen to world space
- * @param {Vector} screen
- * @returns {Vector} world space
- */
- screenToWorld(screen) {
- const centerSpace = screen.subScalars(this.root.gameWidth / 2, this.root.gameHeight / 2);
- return centerSpace.divideScalar(this.zoomLevel).add(this.center);
- }
-
- /**
- * Converts from world to screen space
- * @param {Vector} world
- * @returns {Vector} screen space
- */
- worldToScreen(world) {
- const screenSpace = world.sub(this.center).multiplyScalar(this.zoomLevel);
- return screenSpace.addScalars(this.root.gameWidth / 2, this.root.gameHeight / 2);
- }
-
- /**
- * Returns if a point is on screen
- * @param {Vector} point
- * @returns {boolean} true if its on screen
- */
- isWorldPointOnScreen(point) {
- const rect = this.getVisibleRect();
- return rect.containsPoint(point.x, point.y);
- }
-
- getMaximumZoom() {
- return this.root.gameMode.getMaximumZoom();
- }
-
- getMinimumZoom() {
- return this.root.gameMode.getMinimumZoom();
- }
-
- /**
- * Returns if we can further zoom in
- * @returns {boolean}
- */
- canZoomIn() {
- return this.zoomLevel <= this.getMaximumZoom() - 0.01;
- }
-
- /**
- * Returns if we can further zoom out
- * @returns {boolean}
- */
- canZoomOut() {
- return this.zoomLevel >= this.getMinimumZoom() + 0.01;
- }
-
- // EVENTS
-
- /**
- * Checks if the mouse event is too close after a touch event and thus
- * should get ignored
- */
- checkPreventDoubleMouse() {
- if (performance.now() - clickDetectorGlobals.lastTouchTime < 1000.0) {
- return false;
- }
- return true;
- }
-
- /**
- * Mousedown handler
- * @param {MouseEvent} event
- */
- onMouseDown(event) {
- if (event.cancelable) {
- event.preventDefault();
- // event.stopPropagation();
- }
-
- if (!this.checkPreventDoubleMouse()) {
- return;
- }
-
- this.touchPostMoveVelocity = new Vector(0, 0);
- if (event.button === 0) {
- this.combinedSingleTouchStartHandler(event.clientX, event.clientY);
- } else if (event.button === 1) {
- this.downPreHandler.dispatch(new Vector(event.clientX, event.clientY), enumMouseButton.middle);
- } else if (event.button === 2) {
- this.downPreHandler.dispatch(new Vector(event.clientX, event.clientY), enumMouseButton.right);
- }
- return false;
- }
-
- /**
- * Mousemove handler
- * @param {MouseEvent} event
- */
- onMouseMove(event) {
- if (event.cancelable) {
- event.preventDefault();
- // event.stopPropagation();
- }
-
- if (!this.checkPreventDoubleMouse()) {
- return;
- }
-
- if (event.button === 0) {
- this.combinedSingleTouchMoveHandler(event.clientX, event.clientY);
- }
-
- // Clamp everything afterwards
- this.clampZoomLevel();
- this.clampToBounds();
- return false;
- }
-
- /**
- * Mouseup handler
- * @param {MouseEvent=} event
- */
- onMouseUp(event) {
- if (event) {
- if (event.cancelable) {
- event.preventDefault();
- // event.stopPropagation();
- }
- }
-
- if (!this.checkPreventDoubleMouse()) {
- return;
- }
-
- this.combinedSingleTouchStopHandler(event.clientX, event.clientY);
- return false;
- }
-
- /**
- * Mousewheel event
- * @param {WheelEvent} event
- */
- onMouseWheel(event) {
- if (event.cancelable) {
- event.preventDefault();
- // event.stopPropagation();
- }
- const prevZoom = this.zoomLevel;
-
- const scale = 1 + 0.15 * this.root.app.settings.getScrollWheelSensitivity();
- assert(Number.isFinite(scale), "Got invalid scale in mouse wheel event: " + event.deltaY);
- assert(Number.isFinite(this.zoomLevel), "Got invalid zoom level *before* wheel: " + this.zoomLevel);
- this.zoomLevel *= event.deltaY < 0 ? scale : 1 / scale;
- assert(Number.isFinite(this.zoomLevel), "Got invalid zoom level *after* wheel: " + this.zoomLevel);
-
- this.clampZoomLevel();
- this.desiredZoom = null;
-
- let mousePosition = this.root.app.mousePosition;
- if (!this.root.app.settings.getAllSettings().zoomToCursor) {
- mousePosition = new Vector(this.root.gameWidth / 2, this.root.gameHeight / 2);
- }
-
- if (mousePosition) {
- const worldPos = this.root.camera.screenToWorld(mousePosition);
- const worldDelta = worldPos.sub(this.center);
- const actualDelta = this.zoomLevel / prevZoom - 1;
- this.center = this.center.add(worldDelta.multiplyScalar(actualDelta));
- this.desiredCenter = null;
- }
-
- return false;
- }
-
- /**
- * Touch start handler
- * @param {TouchEvent} event
- */
- onTouchStart(event) {
- if (event.cancelable) {
- event.preventDefault();
- // event.stopPropagation();
- }
-
- clickDetectorGlobals.lastTouchTime = performance.now();
- this.touchPostMoveVelocity = new Vector(0, 0);
-
- if (event.touches.length === 1) {
- const touch = event.touches[0];
- this.combinedSingleTouchStartHandler(touch.clientX, touch.clientY);
- } else if (event.touches.length === 2) {
- // if (this.pinchPreHandler.dispatch() === STOP_PROPAGATION) {
- // // Something prevented pinching
- // return false;
- // }
-
- const touch1 = event.touches[0];
- const touch2 = event.touches[1];
- this.currentlyMoving = false;
- this.currentlyPinching = true;
- this.lastPinchPositions = [
- new Vector(touch1.clientX, touch1.clientY),
- new Vector(touch2.clientX, touch2.clientY),
- ];
- }
- return false;
- }
-
- /**
- * Touch move handler
- * @param {TouchEvent} event
- */
- onTouchMove(event) {
- if (event.cancelable) {
- event.preventDefault();
- // event.stopPropagation();
- }
-
- clickDetectorGlobals.lastTouchTime = performance.now();
-
- if (event.touches.length === 1) {
- const touch = event.touches[0];
- this.combinedSingleTouchMoveHandler(touch.clientX, touch.clientY);
- } else if (event.touches.length === 2) {
- if (this.currentlyPinching) {
- const touch1 = event.touches[0];
- const touch2 = event.touches[1];
-
- const newPinchPositions = [
- new Vector(touch1.clientX, touch1.clientY),
- new Vector(touch2.clientX, touch2.clientY),
- ];
-
- // Get distance of taps last time and now
- const lastDistance = this.lastPinchPositions[0].distance(this.lastPinchPositions[1]);
- const thisDistance = newPinchPositions[0].distance(newPinchPositions[1]);
-
- // IMPORTANT to do math max here to avoid NaN and causing an invalid zoom level
- const difference = thisDistance / Math.max(0.001, lastDistance);
-
- // Find old center of zoom
- let oldCenter = this.lastPinchPositions[0].centerPoint(this.lastPinchPositions[1]);
-
- // Find new center of zoom
- let center = newPinchPositions[0].centerPoint(newPinchPositions[1]);
-
- // Compute movement
- let movement = oldCenter.sub(center);
- this.center.x += movement.x / this.zoomLevel;
- this.center.y += movement.y / this.zoomLevel;
-
- // Compute zoom
- center = center.sub(new Vector(this.root.gameWidth / 2, this.root.gameHeight / 2));
-
- // Apply zoom
- assert(
- Number.isFinite(difference),
- "Invalid pinch difference: " +
- difference +
- "(last=" +
- lastDistance +
- ", new = " +
- thisDistance +
- ")"
- );
- this.zoomLevel *= difference;
-
- // Stick to pivot point
- const correcture = center.multiplyScalar(difference - 1).divideScalar(this.zoomLevel);
-
- this.center = this.center.add(correcture);
- this.lastPinchPositions = newPinchPositions;
- this.userInteraction.dispatch(USER_INTERACT_MOVE);
-
- // Since we zoomed, abort any programmed zooming
- if (this.desiredZoom) {
- this.desiredZoom = null;
- }
- }
- }
-
- // Clamp everything afterwards
- this.clampZoomLevel();
- return false;
- }
-
- /**
- * Touch end and cancel handler
- * @param {TouchEvent=} event
- */
- onTouchEnd(event) {
- if (event) {
- if (event.cancelable) {
- event.preventDefault();
- // event.stopPropagation();
- }
- }
-
- clickDetectorGlobals.lastTouchTime = performance.now();
- if (event.changedTouches.length === 0) {
- logger.warn("Touch end without changed touches");
- }
-
- const touch = event.changedTouches[0];
- this.combinedSingleTouchStopHandler(touch.clientX, touch.clientY);
- return false;
- }
-
- /**
- * Internal touch start handler
- * @param {number} x
- * @param {number} y
- */
- combinedSingleTouchStartHandler(x, y) {
- const pos = new Vector(x, y);
- if (this.downPreHandler.dispatch(pos, enumMouseButton.left) === STOP_PROPAGATION) {
- // Somebody else captured it
- return;
- }
-
- this.touchPostMoveVelocity = new Vector(0, 0);
- this.currentlyMoving = true;
- this.lastMovingPosition = pos;
- this.lastMovingPositionLastTick = null;
- this.numTicksStandingStill = 0;
- this.didMoveSinceTouchStart = false;
- }
-
- /**
- * Internal touch move handler
- * @param {number} x
- * @param {number} y
- */
- combinedSingleTouchMoveHandler(x, y) {
- const pos = new Vector(x, y);
- if (this.movePreHandler.dispatch(pos) === STOP_PROPAGATION) {
- // Somebody else captured it
- return;
- }
-
- if (!this.currentlyMoving) {
- return false;
- }
-
- let delta = this.lastMovingPosition.sub(pos).divideScalar(this.zoomLevel);
- if (G_IS_DEV && globalConfig.debug.testCulling) {
- // When testing culling, we see everything from the same distance
- delta = delta.multiplyScalar(this.zoomLevel * -2);
- }
-
- this.didMoveSinceTouchStart = this.didMoveSinceTouchStart || delta.length() > 0;
- this.center = this.center.add(delta);
-
- this.touchPostMoveVelocity = this.touchPostMoveVelocity
- .multiplyScalar(velocitySmoothing)
- .add(delta.multiplyScalar(1 - velocitySmoothing));
-
- this.lastMovingPosition = pos;
- this.userInteraction.dispatch(USER_INTERACT_MOVE);
-
- // Since we moved, abort any programmed moving
- if (this.desiredCenter) {
- this.desiredCenter = null;
- }
- }
-
- /**
- * Internal touch stop handler
- */
- combinedSingleTouchStopHandler(x, y) {
- if (this.currentlyMoving || this.currentlyPinching) {
- this.currentlyMoving = false;
- this.currentlyPinching = false;
- this.lastMovingPosition = null;
- this.lastMovingPositionLastTick = null;
- this.numTicksStandingStill = 0;
- this.lastPinchPositions = null;
- this.userInteraction.dispatch(USER_INTERACT_TOUCHEND);
- this.didMoveSinceTouchStart = false;
- }
- this.upPostHandler.dispatch(new Vector(x, y));
- }
-
- /**
- * Clamps the camera zoom level within the allowed range
- */
- clampZoomLevel() {
- if (G_IS_DEV && globalConfig.debug.disableZoomLimits) {
- return;
- }
- assert(Number.isFinite(this.zoomLevel), "Invalid zoom level *before* clamp: " + this.zoomLevel);
- this.zoomLevel = clamp(this.zoomLevel, this.getMinimumZoom(), this.getMaximumZoom());
- assert(Number.isFinite(this.zoomLevel), "Invalid zoom level *after* clamp: " + this.zoomLevel);
-
- if (this.desiredZoom) {
- this.desiredZoom = clamp(this.desiredZoom, this.getMinimumZoom(), this.getMaximumZoom());
- }
- }
-
- /**
- * Clamps the center within set boundaries
- */
- clampToBounds() {
- const bounds = this.root.gameMode.getCameraBounds();
- if (!bounds) {
- return;
- }
-
- const tileScaleBounds = this.root.gameMode.getCameraBounds().allScaled(globalConfig.tileSize);
- this.center.x = clamp(this.center.x, tileScaleBounds.x, tileScaleBounds.x + tileScaleBounds.w);
- this.center.y = clamp(this.center.y, tileScaleBounds.y, tileScaleBounds.y + tileScaleBounds.h);
- }
-
- /**
- * Updates the camera
- * @param {number} dt Delta time in milliseconds
- */
- update(dt) {
- dt = Math.min(dt, 33);
- this.cameraUpdateTimeBucket += dt;
-
- // Simulate movement of N FPS
- const updatesPerFrame = 4;
- const physicsStepSizeMs = 1000.0 / (60.0 * updatesPerFrame);
-
- let now = this.root.time.systemNow() - 3 * physicsStepSizeMs;
-
- while (this.cameraUpdateTimeBucket > physicsStepSizeMs) {
- now += physicsStepSizeMs;
- this.cameraUpdateTimeBucket -= physicsStepSizeMs;
-
- this.internalUpdatePanning(now, physicsStepSizeMs);
- this.internalUpdateMousePanning(now, physicsStepSizeMs);
- this.internalUpdateZooming(now, physicsStepSizeMs);
- this.internalUpdateCentering(now, physicsStepSizeMs);
- this.internalUpdateShake(now, physicsStepSizeMs);
- this.internalUpdateKeyboardForce(now, physicsStepSizeMs);
- }
- this.clampZoomLevel();
- }
-
- /**
- * Prepares a context to transform it
- * @param {CanvasRenderingContext2D} context
- */
- transform(context) {
- if (G_IS_DEV && globalConfig.debug.testCulling) {
- context.transform(1, 0, 0, 1, 100, 100);
- return;
- }
-
- this.clampZoomLevel();
- const zoom = this.zoomLevel;
-
- context.transform(
- // Scale, skew, rotate
- zoom,
- 0,
- 0,
- zoom,
-
- // Translate
- -zoom * this.getViewportLeft(),
- -zoom * this.getViewportTop()
- );
- }
-
- /**
- * Internal shake handler
- * @param {number} now Time now in seconds
- * @param {number} dt Delta time
- */
- internalUpdateShake(now, dt) {
- this.currentShake = this.currentShake.multiplyScalar(0.92);
- }
-
- /**
- * Internal pan handler
- * @param {number} now Time now in seconds
- * @param {number} dt Delta time
- */
- internalUpdatePanning(now, dt) {
- const baseStrength = velocityStrength * this.root.app.platformWrapper.getTouchPanStrength();
-
- this.touchPostMoveVelocity = this.touchPostMoveVelocity.multiplyScalar(velocityFade);
-
- // Check if the camera is being dragged but standing still: if not, zero out `touchPostMoveVelocity`.
- if (this.currentlyMoving && this.desiredCenter === null) {
- if (
- this.lastMovingPositionLastTick !== null &&
- this.lastMovingPositionLastTick.equalsEpsilon(this.lastMovingPosition)
- ) {
- this.numTicksStandingStill++;
- } else {
- this.numTicksStandingStill = 0;
- }
- this.lastMovingPositionLastTick = this.lastMovingPosition.copy();
-
- if (this.numTicksStandingStill >= ticksBeforeErasingVelocity) {
- this.touchPostMoveVelocity.x = 0;
- this.touchPostMoveVelocity.y = 0;
- }
- }
- // Check influence of past points
- if (!this.currentlyMoving && !this.currentlyPinching) {
- const len = this.touchPostMoveVelocity.length();
- if (len >= velocityMax) {
- this.touchPostMoveVelocity.x = (this.touchPostMoveVelocity.x * velocityMax) / len;
- this.touchPostMoveVelocity.y = (this.touchPostMoveVelocity.y * velocityMax) / len;
- }
-
- this.center = this.center.add(this.touchPostMoveVelocity.multiplyScalar(baseStrength));
-
- // Panning
- this.currentPan = mixVector(this.currentPan, this.desiredPan, 0.06);
- this.center = this.center.add(this.currentPan.multiplyScalar((0.5 * dt) / this.zoomLevel));
- this.clampToBounds();
- }
- }
-
- /**
- * Internal screen panning handler
- * @param {number} now
- * @param {number} dt
- */
- internalUpdateMousePanning(now, dt) {
- if (!this.root.app.focused) {
- return;
- }
-
- if (!this.root.app.settings.getAllSettings().enableMousePan) {
- // Not enabled
- return;
- }
-
- const mousePos = this.root.app.mousePosition;
- if (!mousePos) {
- return;
- }
-
- if (this.root.hud.shouldPauseGame() || this.root.hud.hasBlockingOverlayOpen()) {
- return;
- }
-
- if (this.desiredCenter || this.desiredZoom || this.currentlyMoving || this.currentlyPinching) {
- // Performing another method of movement right now
- return;
- }
-
- if (
- mousePos.x < 0 ||
- mousePos.y < 0 ||
- mousePos.x > this.root.gameWidth ||
- mousePos.y > this.root.gameHeight
- ) {
- // Out of screen
- return;
- }
-
- const panAreaPixels = 2;
-
- const panVelocity = new Vector();
- if (mousePos.x < panAreaPixels) {
- panVelocity.x -= 1;
- }
- if (mousePos.x > this.root.gameWidth - panAreaPixels) {
- panVelocity.x += 1;
- }
-
- if (mousePos.y < panAreaPixels) {
- panVelocity.y -= 1;
- }
- if (mousePos.y > this.root.gameHeight - panAreaPixels) {
- panVelocity.y += 1;
- }
-
- this.center = this.center.add(
- panVelocity.multiplyScalar(
- ((0.5 * dt) / this.zoomLevel) * this.root.app.settings.getMovementSpeed()
- )
- );
-
- this.clampToBounds();
- }
-
- /**
- * Updates the non user interaction zooming
- * @param {number} now Time now in seconds
- * @param {number} dt Delta time
- */
- internalUpdateZooming(now, dt) {
- if (!this.currentlyPinching && this.desiredZoom !== null) {
- const diff = this.zoomLevel - this.desiredZoom;
- if (Math.abs(diff) > 0.0001) {
- let fade = 0.94;
- if (diff > 0) {
- // Zoom out faster than in
- fade = 0.9;
- }
-
- assert(Number.isFinite(this.desiredZoom), "Desired zoom is NaN: " + this.desiredZoom);
- assert(Number.isFinite(fade), "Zoom fade is NaN: " + fade);
- this.zoomLevel = this.zoomLevel * fade + this.desiredZoom * (1 - fade);
- assert(Number.isFinite(this.zoomLevel), "Zoom level is NaN after fade: " + this.zoomLevel);
- } else {
- this.zoomLevel = this.desiredZoom;
- this.desiredZoom = null;
- }
- }
- }
-
- /**
- * Updates the non user interaction centering
- * @param {number} now Time now in seconds
- * @param {number} dt Delta time
- */
- internalUpdateCentering(now, dt) {
- if (!this.currentlyMoving && this.desiredCenter !== null) {
- const diff = this.center.direction(this.desiredCenter);
- const length = diff.length();
- const tolerance = 1 / this.zoomLevel;
- if (length > tolerance) {
- const movement = diff.multiplyScalar(Math.min(1, dt * 0.008));
- this.center.x += movement.x;
- this.center.y += movement.y;
- } else {
- this.desiredCenter = null;
- }
- }
- }
-
- /**
- * Updates the keyboard forces
- * @param {number} now
- * @param {number} dt Delta time
- */
- internalUpdateKeyboardForce(now, dt) {
- if (!this.currentlyMoving && this.desiredCenter == null) {
- const limitingDimension = Math.min(this.root.gameWidth, this.root.gameHeight);
-
- const moveAmount = ((limitingDimension / 2048) * dt) / this.zoomLevel;
-
- let forceX = 0;
- let forceY = 0;
-
- const actionMapper = this.root.keyMapper;
- if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveUp).pressed) {
- forceY -= 1;
- }
-
- if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveDown).pressed) {
- forceY += 1;
- }
-
- if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveLeft).pressed) {
- forceX -= 1;
- }
-
- if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveRight).pressed) {
- forceX += 1;
- }
-
- let movementSpeed =
- this.root.app.settings.getMovementSpeed() *
- (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveFaster).pressed ? 4 : 1);
-
- this.center.x += moveAmount * forceX * movementSpeed;
- this.center.y += moveAmount * forceY * movementSpeed;
-
- this.clampToBounds();
- }
- }
-}
+import { clickDetectorGlobals } from "../core/click_detector";
+import { globalConfig, SUPPORT_TOUCH } from "../core/config";
+import { createLogger } from "../core/logging";
+import { Rectangle } from "../core/rectangle";
+import { Signal, STOP_PROPAGATION } from "../core/signal";
+import { clamp } from "../core/utils";
+import { mixVector, Vector } from "../core/vector";
+import { BasicSerializableObject, types } from "../savegame/serialization";
+import { KEYMAPPINGS } from "./key_action_mapper";
+import { GameRoot } from "./root";
+
+const logger = createLogger("camera");
+
+// @TODO: unused signal
+export const USER_INTERACT_MOVE = "move";
+export const USER_INTERACT_ZOOM = "zoom";
+export const USER_INTERACT_TOUCHEND = "touchend";
+
+const velocitySmoothing = 0.5;
+const velocityFade = 0.98;
+const velocityStrength = 0.4;
+const velocityMax = 20;
+const ticksBeforeErasingVelocity = 10;
+
+/**
+ * @enum {string}
+ */
+export const enumMouseButton = {
+ left: "left",
+ middle: "middle",
+ right: "right",
+};
+
+export class Camera extends BasicSerializableObject {
+ constructor(root) {
+ super();
+
+ /** @type {GameRoot} */
+ this.root = root;
+
+ // Zoom level, 2 means double size
+
+ // Find optimal initial zoom
+
+ this.zoomLevel = this.findInitialZoom();
+ this.clampZoomLevel();
+
+ /** @type {Vector} */
+ this.center = new Vector(0, 0);
+
+ // Input handling
+ this.currentlyMoving = false;
+ this.lastMovingPosition = null;
+ this.lastMovingPositionLastTick = null;
+ this.numTicksStandingStill = null;
+ this.cameraUpdateTimeBucket = 0.0;
+ this.didMoveSinceTouchStart = false;
+ this.currentlyPinching = false;
+ this.lastPinchPositions = null;
+
+ this.keyboardForce = new Vector();
+
+ // Signal which gets emitted once the user changed something
+ /** @type {Signal<[string]>} */
+ this.userInteraction = new Signal();
+
+ /** @type {Vector} */
+ this.currentShake = new Vector(0, 0);
+
+ /** @type {Vector} */
+ this.currentPan = new Vector(0, 0);
+
+ // Set desired pan (camera movement)
+ /** @type {Vector} */
+ this.desiredPan = new Vector(0, 0);
+
+ // Set desired camera center
+ /** @type {Vector} */
+ this.desiredCenter = null;
+
+ // Set desired camera zoom
+ /** @type {number} */
+ this.desiredZoom = null;
+
+ /** @type {Vector} */
+ this.touchPostMoveVelocity = new Vector(0, 0);
+
+ // Handlers
+ this.downPreHandler = /** @type {Signal<[Vector, enumMouseButton]>} */ (new Signal());
+ this.movePreHandler = /** @type {Signal<[Vector]>} */ (new Signal());
+ // this.pinchPreHandler = /** @type {Signal<[Vector]>} */ (new Signal());
+ this.upPostHandler = /** @type {Signal<[Vector]>} */ (new Signal());
+
+ this.internalInitEvents();
+ this.clampZoomLevel();
+ this.bindKeys();
+ if (G_IS_DEV) {
+ window.addEventListener("keydown", ev => {
+ if (ev.key === "i") {
+ this.zoomLevel = 3;
+ }
+ });
+ }
+ }
+
+ // Serialization
+ static getId() {
+ return "Camera";
+ }
+
+ static getSchema() {
+ return {
+ zoomLevel: types.float,
+ center: types.vector,
+ };
+ }
+
+ deserialize(data) {
+ const errorCode = super.deserialize(data);
+ if (errorCode) {
+ return errorCode;
+ }
+
+ // Safety
+ this.clampZoomLevel();
+ }
+
+ // Simple getters & setters
+
+ addScreenShake(amount) {
+ const currentShakeAmount = this.currentShake.length();
+ const scale = 1 / (1 + 3 * currentShakeAmount);
+ this.currentShake.x = this.currentShake.x + 2 * (Math.random() - 0.5) * scale * amount;
+ this.currentShake.y = this.currentShake.y + 2 * (Math.random() - 0.5) * scale * amount;
+ }
+
+ /**
+ * Sets a point in world space to focus on
+ * @param {Vector} center
+ */
+ setDesiredCenter(center) {
+ this.desiredCenter = center.copy();
+ this.currentlyMoving = false;
+ }
+
+ /**
+ * Sets a desired zoom level
+ * @param {number} zoom
+ */
+ setDesiredZoom(zoom) {
+ this.desiredZoom = zoom;
+ }
+
+ /**
+ * Returns if this camera is currently moving by a non-user interaction
+ */
+ isCurrentlyMovingToDesiredCenter() {
+ return this.desiredCenter !== null;
+ }
+
+ /**
+ * Sets the camera pan, every frame the camera will move by this amount
+ * @param {Vector} pan
+ */
+ setPan(pan) {
+ this.desiredPan = pan.copy();
+ }
+
+ /**
+ * Finds a good initial zoom level
+ */
+ findInitialZoom() {
+ let desiredWorldSpaceWidth = 18 * globalConfig.tileSize;
+ if (window.innerWidth < 1000) {
+ desiredWorldSpaceWidth = 12 * globalConfig.tileSize;
+ }
+
+ const zoomLevelX = this.root.gameWidth / desiredWorldSpaceWidth;
+ const zoomLevelY = this.root.gameHeight / desiredWorldSpaceWidth;
+
+ const finalLevel = Math.min(zoomLevelX, zoomLevelY);
+ assert(
+ Number.isFinite(finalLevel) && finalLevel > 0,
+ "Invalid zoom level computed for initial zoom: " + finalLevel
+ );
+ return finalLevel;
+ }
+
+ /**
+ * Clears all animations
+ */
+ clearAnimations() {
+ this.touchPostMoveVelocity.x = 0;
+ this.touchPostMoveVelocity.y = 0;
+ this.desiredCenter = null;
+ this.desiredPan.x = 0;
+ this.desiredPan.y = 0;
+ this.currentPan.x = 0;
+ this.currentPan.y = 0;
+ this.currentlyPinching = false;
+ this.currentlyMoving = false;
+ this.lastMovingPosition = null;
+ this.didMoveSinceTouchStart = false;
+ this.desiredZoom = null;
+ }
+
+ /**
+ * Returns if the user is currently interacting with the camera
+ * @returns {boolean} true if the user interacts
+ */
+ isCurrentlyInteracting() {
+ if (this.currentlyPinching) {
+ return true;
+ }
+ if (this.currentlyMoving) {
+ // Only interacting if moved at least once
+ return this.didMoveSinceTouchStart;
+ }
+ if (this.touchPostMoveVelocity.lengthSquare() > 1) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Returns if in the next frame the viewport will change
+ * @returns {boolean} true if it willchange
+ */
+ viewportWillChange() {
+ return this.desiredCenter !== null || this.desiredZoom !== null || this.isCurrentlyInteracting();
+ }
+
+ /**
+ * Cancels all interactions, that is user interaction and non user interaction
+ */
+ cancelAllInteractions() {
+ this.touchPostMoveVelocity = new Vector(0, 0);
+ this.desiredCenter = null;
+ this.currentlyMoving = false;
+ this.currentlyPinching = false;
+ this.desiredZoom = null;
+ }
+
+ /**
+ * Returns effective viewport width
+ */
+ getViewportWidth() {
+ return this.root.gameWidth / this.zoomLevel;
+ }
+
+ /**
+ * Returns effective viewport height
+ */
+ getViewportHeight() {
+ return this.root.gameHeight / this.zoomLevel;
+ }
+
+ /**
+ * Returns effective world space viewport left
+ */
+ getViewportLeft() {
+ return this.center.x - this.getViewportWidth() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
+ }
+
+ /**
+ * Returns effective world space viewport right
+ */
+ getViewportRight() {
+ return this.center.x + this.getViewportWidth() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
+ }
+
+ /**
+ * Returns effective world space viewport top
+ */
+ getViewportTop() {
+ return this.center.y - this.getViewportHeight() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
+ }
+
+ /**
+ * Returns effective world space viewport bottom
+ */
+ getViewportBottom() {
+ return this.center.y + this.getViewportHeight() / 2 + (this.currentShake.x * 10) / this.zoomLevel;
+ }
+
+ /**
+ * Returns the visible world space rect
+ * @returns {Rectangle}
+ */
+ getVisibleRect() {
+ return Rectangle.fromTRBL(
+ Math.floor(this.getViewportTop()),
+ Math.ceil(this.getViewportRight()),
+ Math.ceil(this.getViewportBottom()),
+ Math.floor(this.getViewportLeft())
+ );
+ }
+
+ getIsMapOverlayActive() {
+ return this.zoomLevel < globalConfig.mapChunkOverviewMinZoom;
+ }
+
+ /**
+ * Attaches all event listeners
+ */
+ internalInitEvents() {
+ this.eventListenerTouchStart = this.onTouchStart.bind(this);
+ this.eventListenerTouchEnd = this.onTouchEnd.bind(this);
+ this.eventListenerTouchMove = this.onTouchMove.bind(this);
+ this.eventListenerMousewheel = this.onMouseWheel.bind(this);
+ this.eventListenerMouseDown = this.onMouseDown.bind(this);
+ this.eventListenerMouseMove = this.onMouseMove.bind(this);
+ this.eventListenerMouseUp = this.onMouseUp.bind(this);
+
+ if (SUPPORT_TOUCH) {
+ this.root.canvas.addEventListener("touchstart", this.eventListenerTouchStart);
+ this.root.canvas.addEventListener("touchend", this.eventListenerTouchEnd);
+ this.root.canvas.addEventListener("touchcancel", this.eventListenerTouchEnd);
+ this.root.canvas.addEventListener("touchmove", this.eventListenerTouchMove);
+ }
+
+ this.root.canvas.addEventListener("wheel", this.eventListenerMousewheel);
+ this.root.canvas.addEventListener("mousedown", this.eventListenerMouseDown);
+ this.root.canvas.addEventListener("mousemove", this.eventListenerMouseMove);
+ window.addEventListener("mouseup", this.eventListenerMouseUp);
+ // this.root.canvas.addEventListener("mouseout", this.eventListenerMouseUp);
+ }
+
+ /**
+ * Cleans up all event listeners
+ */
+ cleanup() {
+ if (SUPPORT_TOUCH) {
+ this.root.canvas.removeEventListener("touchstart", this.eventListenerTouchStart);
+ this.root.canvas.removeEventListener("touchend", this.eventListenerTouchEnd);
+ this.root.canvas.removeEventListener("touchcancel", this.eventListenerTouchEnd);
+ this.root.canvas.removeEventListener("touchmove", this.eventListenerTouchMove);
+ }
+
+ this.root.canvas.removeEventListener("wheel", this.eventListenerMousewheel);
+ this.root.canvas.removeEventListener("mousedown", this.eventListenerMouseDown);
+ this.root.canvas.removeEventListener("mousemove", this.eventListenerMouseMove);
+ window.removeEventListener("mouseup", this.eventListenerMouseUp);
+ // this.root.canvas.removeEventListener("mouseout", this.eventListenerMouseUp);
+ }
+
+ /**
+ * Binds the arrow keys
+ */
+ bindKeys() {
+ const mapper = this.root.keyMapper;
+ mapper.getBinding(KEYMAPPINGS.navigation.mapMoveUp).add(() => (this.keyboardForce.y = -1));
+ mapper.getBinding(KEYMAPPINGS.navigation.mapMoveDown).add(() => (this.keyboardForce.y = 1));
+ mapper.getBinding(KEYMAPPINGS.navigation.mapMoveRight).add(() => (this.keyboardForce.x = 1));
+ mapper.getBinding(KEYMAPPINGS.navigation.mapMoveLeft).add(() => (this.keyboardForce.x = -1));
+
+ mapper
+ .getBinding(KEYMAPPINGS.navigation.mapZoomIn)
+ .add(() => (this.desiredZoom = this.zoomLevel * 1.2));
+ mapper
+ .getBinding(KEYMAPPINGS.navigation.mapZoomOut)
+ .add(() => (this.desiredZoom = this.zoomLevel / 1.2));
+
+ mapper.getBinding(KEYMAPPINGS.navigation.centerMap).add(() => this.centerOnMap());
+ }
+
+ centerOnMap() {
+ this.desiredCenter = new Vector(0, 0);
+ }
+
+ /**
+ * Converts from screen to world space
+ * @param {Vector} screen
+ * @returns {Vector} world space
+ */
+ screenToWorld(screen) {
+ const centerSpace = screen.subScalars(this.root.gameWidth / 2, this.root.gameHeight / 2);
+ return centerSpace.divideScalar(this.zoomLevel).add(this.center);
+ }
+
+ /**
+ * Converts from world to screen space
+ * @param {Vector} world
+ * @returns {Vector} screen space
+ */
+ worldToScreen(world) {
+ const screenSpace = world.sub(this.center).multiplyScalar(this.zoomLevel);
+ return screenSpace.addScalars(this.root.gameWidth / 2, this.root.gameHeight / 2);
+ }
+
+ /**
+ * Returns if a point is on screen
+ * @param {Vector} point
+ * @returns {boolean} true if its on screen
+ */
+ isWorldPointOnScreen(point) {
+ const rect = this.getVisibleRect();
+ return rect.containsPoint(point.x, point.y);
+ }
+
+ getMaximumZoom() {
+ return this.root.gameMode.getMaximumZoom();
+ }
+
+ getMinimumZoom() {
+ return this.root.gameMode.getMinimumZoom();
+ }
+
+ /**
+ * Returns if we can further zoom in
+ * @returns {boolean}
+ */
+ canZoomIn() {
+ return this.zoomLevel <= this.getMaximumZoom() - 0.01;
+ }
+
+ /**
+ * Returns if we can further zoom out
+ * @returns {boolean}
+ */
+ canZoomOut() {
+ return this.zoomLevel >= this.getMinimumZoom() + 0.01;
+ }
+
+ // EVENTS
+
+ /**
+ * Checks if the mouse event is too close after a touch event and thus
+ * should get ignored
+ */
+ checkPreventDoubleMouse() {
+ if (performance.now() - clickDetectorGlobals.lastTouchTime < 1000.0) {
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Mousedown handler
+ * @param {MouseEvent} event
+ */
+ onMouseDown(event) {
+ if (event.cancelable) {
+ event.preventDefault();
+ // event.stopPropagation();
+ }
+
+ if (!this.checkPreventDoubleMouse()) {
+ return;
+ }
+
+ this.touchPostMoveVelocity = new Vector(0, 0);
+ if (event.button === 0) {
+ this.combinedSingleTouchStartHandler(event.clientX, event.clientY);
+ } else if (event.button === 1) {
+ this.downPreHandler.dispatch(new Vector(event.clientX, event.clientY), enumMouseButton.middle);
+ } else if (event.button === 2) {
+ this.downPreHandler.dispatch(new Vector(event.clientX, event.clientY), enumMouseButton.right);
+ }
+ return false;
+ }
+
+ /**
+ * Mousemove handler
+ * @param {MouseEvent} event
+ */
+ onMouseMove(event) {
+ if (event.cancelable) {
+ event.preventDefault();
+ // event.stopPropagation();
+ }
+
+ if (!this.checkPreventDoubleMouse()) {
+ return;
+ }
+
+ if (event.button === 0) {
+ this.combinedSingleTouchMoveHandler(event.clientX, event.clientY);
+ }
+
+ // Clamp everything afterwards
+ this.clampZoomLevel();
+ this.clampToBounds();
+ return false;
+ }
+
+ /**
+ * Mouseup handler
+ * @param {MouseEvent=} event
+ */
+ onMouseUp(event) {
+ if (event) {
+ if (event.cancelable) {
+ event.preventDefault();
+ // event.stopPropagation();
+ }
+ }
+
+ if (!this.checkPreventDoubleMouse()) {
+ return;
+ }
+
+ this.combinedSingleTouchStopHandler(event.clientX, event.clientY);
+ return false;
+ }
+
+ /**
+ * Mousewheel event
+ * @param {WheelEvent} event
+ */
+ onMouseWheel(event) {
+ if (event.cancelable) {
+ event.preventDefault();
+ // event.stopPropagation();
+ }
+ const prevZoom = this.zoomLevel;
+
+ const scale = 1 + 0.15 * this.root.app.settings.getScrollWheelSensitivity();
+ assert(Number.isFinite(scale), "Got invalid scale in mouse wheel event: " + event.deltaY);
+ assert(Number.isFinite(this.zoomLevel), "Got invalid zoom level *before* wheel: " + this.zoomLevel);
+ this.zoomLevel *= event.deltaY < 0 ? scale : 1 / scale;
+ assert(Number.isFinite(this.zoomLevel), "Got invalid zoom level *after* wheel: " + this.zoomLevel);
+
+ this.clampZoomLevel();
+ this.desiredZoom = null;
+
+ let mousePosition = this.root.app.mousePosition;
+ if (!this.root.app.settings.getAllSettings().zoomToCursor) {
+ mousePosition = new Vector(this.root.gameWidth / 2, this.root.gameHeight / 2);
+ }
+
+ if (mousePosition) {
+ const worldPos = this.root.camera.screenToWorld(mousePosition);
+ const worldDelta = worldPos.sub(this.center);
+ const actualDelta = this.zoomLevel / prevZoom - 1;
+ this.center = this.center.add(worldDelta.multiplyScalar(actualDelta));
+ this.desiredCenter = null;
+ }
+
+ return false;
+ }
+
+ /**
+ * Touch start handler
+ * @param {TouchEvent} event
+ */
+ onTouchStart(event) {
+ if (event.cancelable) {
+ event.preventDefault();
+ // event.stopPropagation();
+ }
+
+ clickDetectorGlobals.lastTouchTime = performance.now();
+ this.touchPostMoveVelocity = new Vector(0, 0);
+
+ if (event.touches.length === 1) {
+ const touch = event.touches[0];
+ this.combinedSingleTouchStartHandler(touch.clientX, touch.clientY);
+ } else if (event.touches.length === 2) {
+ // if (this.pinchPreHandler.dispatch() === STOP_PROPAGATION) {
+ // // Something prevented pinching
+ // return false;
+ // }
+
+ const touch1 = event.touches[0];
+ const touch2 = event.touches[1];
+ this.currentlyMoving = false;
+ this.currentlyPinching = true;
+ this.lastPinchPositions = [
+ new Vector(touch1.clientX, touch1.clientY),
+ new Vector(touch2.clientX, touch2.clientY),
+ ];
+ }
+ return false;
+ }
+
+ /**
+ * Touch move handler
+ * @param {TouchEvent} event
+ */
+ onTouchMove(event) {
+ if (event.cancelable) {
+ event.preventDefault();
+ // event.stopPropagation();
+ }
+
+ clickDetectorGlobals.lastTouchTime = performance.now();
+
+ if (event.touches.length === 1) {
+ const touch = event.touches[0];
+ this.combinedSingleTouchMoveHandler(touch.clientX, touch.clientY);
+ } else if (event.touches.length === 2) {
+ if (this.currentlyPinching) {
+ const touch1 = event.touches[0];
+ const touch2 = event.touches[1];
+
+ const newPinchPositions = [
+ new Vector(touch1.clientX, touch1.clientY),
+ new Vector(touch2.clientX, touch2.clientY),
+ ];
+
+ // Get distance of taps last time and now
+ const lastDistance = this.lastPinchPositions[0].distance(this.lastPinchPositions[1]);
+ const thisDistance = newPinchPositions[0].distance(newPinchPositions[1]);
+
+ // IMPORTANT to do math max here to avoid NaN and causing an invalid zoom level
+ const difference = thisDistance / Math.max(0.001, lastDistance);
+
+ // Find old center of zoom
+ let oldCenter = this.lastPinchPositions[0].centerPoint(this.lastPinchPositions[1]);
+
+ // Find new center of zoom
+ let center = newPinchPositions[0].centerPoint(newPinchPositions[1]);
+
+ // Compute movement
+ let movement = oldCenter.sub(center);
+ this.center.x += movement.x / this.zoomLevel;
+ this.center.y += movement.y / this.zoomLevel;
+
+ // Compute zoom
+ center = center.sub(new Vector(this.root.gameWidth / 2, this.root.gameHeight / 2));
+
+ // Apply zoom
+ assert(
+ Number.isFinite(difference),
+ "Invalid pinch difference: " +
+ difference +
+ "(last=" +
+ lastDistance +
+ ", new = " +
+ thisDistance +
+ ")"
+ );
+ this.zoomLevel *= difference;
+
+ // Stick to pivot point
+ const correcture = center.multiplyScalar(difference - 1).divideScalar(this.zoomLevel);
+
+ this.center = this.center.add(correcture);
+ this.lastPinchPositions = newPinchPositions;
+ this.userInteraction.dispatch(USER_INTERACT_MOVE);
+
+ // Since we zoomed, abort any programmed zooming
+ if (this.desiredZoom) {
+ this.desiredZoom = null;
+ }
+ }
+ }
+
+ // Clamp everything afterwards
+ this.clampZoomLevel();
+ return false;
+ }
+
+ /**
+ * Touch end and cancel handler
+ * @param {TouchEvent=} event
+ */
+ onTouchEnd(event) {
+ if (event) {
+ if (event.cancelable) {
+ event.preventDefault();
+ // event.stopPropagation();
+ }
+ }
+
+ clickDetectorGlobals.lastTouchTime = performance.now();
+ if (event.changedTouches.length === 0) {
+ logger.warn("Touch end without changed touches");
+ }
+
+ const touch = event.changedTouches[0];
+ this.combinedSingleTouchStopHandler(touch.clientX, touch.clientY);
+ return false;
+ }
+
+ /**
+ * Internal touch start handler
+ * @param {number} x
+ * @param {number} y
+ */
+ combinedSingleTouchStartHandler(x, y) {
+ const pos = new Vector(x, y);
+ if (this.downPreHandler.dispatch(pos, enumMouseButton.left) === STOP_PROPAGATION) {
+ // Somebody else captured it
+ return;
+ }
+
+ this.touchPostMoveVelocity = new Vector(0, 0);
+ this.currentlyMoving = true;
+ this.lastMovingPosition = pos;
+ this.lastMovingPositionLastTick = null;
+ this.numTicksStandingStill = 0;
+ this.didMoveSinceTouchStart = false;
+ }
+
+ /**
+ * Internal touch move handler
+ * @param {number} x
+ * @param {number} y
+ */
+ combinedSingleTouchMoveHandler(x, y) {
+ const pos = new Vector(x, y);
+ if (this.movePreHandler.dispatch(pos) === STOP_PROPAGATION) {
+ // Somebody else captured it
+ return;
+ }
+
+ if (!this.currentlyMoving) {
+ return false;
+ }
+
+ let delta = this.lastMovingPosition.sub(pos).divideScalar(this.zoomLevel);
+ if (G_IS_DEV && globalConfig.debug.testCulling) {
+ // When testing culling, we see everything from the same distance
+ delta = delta.multiplyScalar(this.zoomLevel * -2);
+ }
+
+ this.didMoveSinceTouchStart = this.didMoveSinceTouchStart || delta.length() > 0;
+ this.center = this.center.add(delta);
+
+ this.touchPostMoveVelocity = this.touchPostMoveVelocity
+ .multiplyScalar(velocitySmoothing)
+ .add(delta.multiplyScalar(1 - velocitySmoothing));
+
+ this.lastMovingPosition = pos;
+ this.userInteraction.dispatch(USER_INTERACT_MOVE);
+
+ // Since we moved, abort any programmed moving
+ if (this.desiredCenter) {
+ this.desiredCenter = null;
+ }
+ }
+
+ /**
+ * Internal touch stop handler
+ */
+ combinedSingleTouchStopHandler(x, y) {
+ if (this.currentlyMoving || this.currentlyPinching) {
+ this.currentlyMoving = false;
+ this.currentlyPinching = false;
+ this.lastMovingPosition = null;
+ this.lastMovingPositionLastTick = null;
+ this.numTicksStandingStill = 0;
+ this.lastPinchPositions = null;
+ this.userInteraction.dispatch(USER_INTERACT_TOUCHEND);
+ this.didMoveSinceTouchStart = false;
+ }
+ this.upPostHandler.dispatch(new Vector(x, y));
+ }
+
+ /**
+ * Clamps the camera zoom level within the allowed range
+ */
+ clampZoomLevel() {
+ if (G_IS_DEV && globalConfig.debug.disableZoomLimits) {
+ return;
+ }
+ assert(Number.isFinite(this.zoomLevel), "Invalid zoom level *before* clamp: " + this.zoomLevel);
+ this.zoomLevel = clamp(this.zoomLevel, this.getMinimumZoom(), this.getMaximumZoom());
+ assert(Number.isFinite(this.zoomLevel), "Invalid zoom level *after* clamp: " + this.zoomLevel);
+
+ if (this.desiredZoom) {
+ this.desiredZoom = clamp(this.desiredZoom, this.getMinimumZoom(), this.getMaximumZoom());
+ }
+ }
+
+ /**
+ * Clamps the center within set boundaries
+ */
+ clampToBounds() {
+ const bounds = this.root.gameMode.getCameraBounds();
+ if (!bounds) {
+ return;
+ }
+
+ const tileScaleBounds = this.root.gameMode.getCameraBounds().allScaled(globalConfig.tileSize);
+ this.center.x = clamp(this.center.x, tileScaleBounds.x, tileScaleBounds.x + tileScaleBounds.w);
+ this.center.y = clamp(this.center.y, tileScaleBounds.y, tileScaleBounds.y + tileScaleBounds.h);
+ }
+
+ /**
+ * Updates the camera
+ * @param {number} dt Delta time in milliseconds
+ */
+ update(dt) {
+ dt = Math.min(dt, 33);
+ this.cameraUpdateTimeBucket += dt;
+
+ // Simulate movement of N FPS
+ const updatesPerFrame = 4;
+ const physicsStepSizeMs = 1000.0 / (60.0 * updatesPerFrame);
+
+ let now = this.root.time.systemNow() - 3 * physicsStepSizeMs;
+
+ while (this.cameraUpdateTimeBucket > physicsStepSizeMs) {
+ now += physicsStepSizeMs;
+ this.cameraUpdateTimeBucket -= physicsStepSizeMs;
+
+ this.internalUpdatePanning(now, physicsStepSizeMs);
+ this.internalUpdateMousePanning(now, physicsStepSizeMs);
+ this.internalUpdateZooming(now, physicsStepSizeMs);
+ this.internalUpdateCentering(now, physicsStepSizeMs);
+ this.internalUpdateShake(now, physicsStepSizeMs);
+ this.internalUpdateKeyboardForce(now, physicsStepSizeMs);
+ }
+ this.clampZoomLevel();
+ }
+
+ /**
+ * Prepares a context to transform it
+ * @param {CanvasRenderingContext2D} context
+ */
+ transform(context) {
+ if (G_IS_DEV && globalConfig.debug.testCulling) {
+ context.transform(1, 0, 0, 1, 100, 100);
+ return;
+ }
+
+ this.clampZoomLevel();
+ const zoom = this.zoomLevel;
+
+ context.transform(
+ // Scale, skew, rotate
+ zoom,
+ 0,
+ 0,
+ zoom,
+
+ // Translate
+ -zoom * this.getViewportLeft(),
+ -zoom * this.getViewportTop()
+ );
+ }
+
+ /**
+ * Internal shake handler
+ * @param {number} now Time now in seconds
+ * @param {number} dt Delta time
+ */
+ internalUpdateShake(now, dt) {
+ this.currentShake = this.currentShake.multiplyScalar(0.92);
+ }
+
+ /**
+ * Internal pan handler
+ * @param {number} now Time now in seconds
+ * @param {number} dt Delta time
+ */
+ internalUpdatePanning(now, dt) {
+ const baseStrength = velocityStrength * this.root.app.platformWrapper.getTouchPanStrength();
+
+ this.touchPostMoveVelocity = this.touchPostMoveVelocity.multiplyScalar(velocityFade);
+
+ // Check if the camera is being dragged but standing still: if not, zero out `touchPostMoveVelocity`.
+ if (this.currentlyMoving && this.desiredCenter === null) {
+ if (
+ this.lastMovingPositionLastTick !== null &&
+ this.lastMovingPositionLastTick.equalsEpsilon(this.lastMovingPosition)
+ ) {
+ this.numTicksStandingStill++;
+ } else {
+ this.numTicksStandingStill = 0;
+ }
+ this.lastMovingPositionLastTick = this.lastMovingPosition.copy();
+
+ if (this.numTicksStandingStill >= ticksBeforeErasingVelocity) {
+ this.touchPostMoveVelocity.x = 0;
+ this.touchPostMoveVelocity.y = 0;
+ }
+ }
+ // Check influence of past points
+ if (!this.currentlyMoving && !this.currentlyPinching) {
+ const len = this.touchPostMoveVelocity.length();
+ if (len >= velocityMax) {
+ this.touchPostMoveVelocity.x = (this.touchPostMoveVelocity.x * velocityMax) / len;
+ this.touchPostMoveVelocity.y = (this.touchPostMoveVelocity.y * velocityMax) / len;
+ }
+
+ this.center = this.center.add(this.touchPostMoveVelocity.multiplyScalar(baseStrength));
+
+ // Panning
+ this.currentPan = mixVector(this.currentPan, this.desiredPan, 0.06);
+ this.center = this.center.add(this.currentPan.multiplyScalar((0.5 * dt) / this.zoomLevel));
+ this.clampToBounds();
+ }
+ }
+
+ /**
+ * Internal screen panning handler
+ * @param {number} now
+ * @param {number} dt
+ */
+ internalUpdateMousePanning(now, dt) {
+ if (!this.root.app.focused) {
+ return;
+ }
+
+ if (!this.root.app.settings.getAllSettings().enableMousePan) {
+ // Not enabled
+ return;
+ }
+
+ const mousePos = this.root.app.mousePosition;
+ if (!mousePos) {
+ return;
+ }
+
+ if (this.root.hud.shouldPauseGame() || this.root.hud.hasBlockingOverlayOpen()) {
+ return;
+ }
+
+ if (this.desiredCenter || this.desiredZoom || this.currentlyMoving || this.currentlyPinching) {
+ // Performing another method of movement right now
+ return;
+ }
+
+ if (
+ mousePos.x < 0 ||
+ mousePos.y < 0 ||
+ mousePos.x > this.root.gameWidth ||
+ mousePos.y > this.root.gameHeight
+ ) {
+ // Out of screen
+ return;
+ }
+
+ const panAreaPixels = 2;
+
+ const panVelocity = new Vector();
+ if (mousePos.x < panAreaPixels) {
+ panVelocity.x -= 1;
+ }
+ if (mousePos.x > this.root.gameWidth - panAreaPixels) {
+ panVelocity.x += 1;
+ }
+
+ if (mousePos.y < panAreaPixels) {
+ panVelocity.y -= 1;
+ }
+ if (mousePos.y > this.root.gameHeight - panAreaPixels) {
+ panVelocity.y += 1;
+ }
+
+ this.center = this.center.add(
+ panVelocity.multiplyScalar(
+ ((0.5 * dt) / this.zoomLevel) * this.root.app.settings.getMovementSpeed()
+ )
+ );
+
+ this.clampToBounds();
+ }
+
+ /**
+ * Updates the non user interaction zooming
+ * @param {number} now Time now in seconds
+ * @param {number} dt Delta time
+ */
+ internalUpdateZooming(now, dt) {
+ if (!this.currentlyPinching && this.desiredZoom !== null) {
+ const diff = this.zoomLevel - this.desiredZoom;
+ if (Math.abs(diff) > 0.0001) {
+ let fade = 0.94;
+ if (diff > 0) {
+ // Zoom out faster than in
+ fade = 0.9;
+ }
+
+ assert(Number.isFinite(this.desiredZoom), "Desired zoom is NaN: " + this.desiredZoom);
+ assert(Number.isFinite(fade), "Zoom fade is NaN: " + fade);
+ this.zoomLevel = this.zoomLevel * fade + this.desiredZoom * (1 - fade);
+ assert(Number.isFinite(this.zoomLevel), "Zoom level is NaN after fade: " + this.zoomLevel);
+ } else {
+ this.zoomLevel = this.desiredZoom;
+ this.desiredZoom = null;
+ }
+ }
+ }
+
+ /**
+ * Updates the non user interaction centering
+ * @param {number} now Time now in seconds
+ * @param {number} dt Delta time
+ */
+ internalUpdateCentering(now, dt) {
+ if (!this.currentlyMoving && this.desiredCenter !== null) {
+ const diff = this.center.direction(this.desiredCenter);
+ const length = diff.length();
+ const tolerance = 1 / this.zoomLevel;
+ if (length > tolerance) {
+ const movement = diff.multiplyScalar(Math.min(1, dt * 0.008));
+ this.center.x += movement.x;
+ this.center.y += movement.y;
+ } else {
+ this.desiredCenter = null;
+ }
+ }
+ }
+
+ /**
+ * Updates the keyboard forces
+ * @param {number} now
+ * @param {number} dt Delta time
+ */
+ internalUpdateKeyboardForce(now, dt) {
+ if (!this.currentlyMoving && this.desiredCenter == null) {
+ const limitingDimension = Math.min(this.root.gameWidth, this.root.gameHeight);
+
+ const moveAmount = ((limitingDimension / 2048) * dt) / this.zoomLevel;
+
+ let forceX = 0;
+ let forceY = 0;
+
+ const actionMapper = this.root.keyMapper;
+ if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveUp).pressed) {
+ forceY -= 1;
+ }
+
+ if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveDown).pressed) {
+ forceY += 1;
+ }
+
+ if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveLeft).pressed) {
+ forceX -= 1;
+ }
+
+ if (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveRight).pressed) {
+ forceX += 1;
+ }
+
+ let movementSpeed =
+ this.root.app.settings.getMovementSpeed() *
+ (actionMapper.getBinding(KEYMAPPINGS.navigation.mapMoveFaster).pressed ? 4 : 1);
+
+ this.center.x += moveAmount * forceX * movementSpeed;
+ this.center.y += moveAmount * forceY * movementSpeed;
+
+ this.clampToBounds();
+ }
+ }
+}
diff --git a/src/js/game/component_registry.js b/src/js/game/component_registry.js
index 1add879e..4146ea45 100644
--- a/src/js/game/component_registry.js
+++ b/src/js/game/component_registry.js
@@ -53,7 +53,7 @@ export function initComponentRegistry() {
assert(
// @ts-ignore
- require.context("./components", false, /.*\.js/i).keys().length ===
+ import.meta.webpackContext("./components", { recursive: false, regExp: /.*\.js/i }).keys().length ===
gComponentRegistry.getNumEntries(),
"Not all components are registered"
);
diff --git a/src/js/game/components/belt_reader.js b/src/js/game/components/belt_reader.js
index 187e53cd..0026f2b8 100644
--- a/src/js/game/components/belt_reader.js
+++ b/src/js/game/components/belt_reader.js
@@ -1,53 +1,53 @@
-import { Component } from "../component";
-import { BaseItem } from "../base_item";
-import { typeItemSingleton } from "../item_resolver";
-import { types } from "../../savegame/serialization";
-
-/** @enum {string} */
-export const enumBeltReaderType = {
- wired: "wired",
- wireless: "wireless",
-};
-
-export class BeltReaderComponent extends Component {
- static getId() {
- return "BeltReader";
- }
-
- static getSchema() {
- return {
- lastItem: types.nullable(typeItemSingleton),
- };
- }
-
- constructor() {
- super();
- this.clear();
- }
-
- clear() {
- /**
- * Which items went through the reader, we only store the time
- * @type {Array}
- */
- this.lastItemTimes = [];
-
- /**
- * Which item passed the reader last
- * @type {BaseItem}
- */
- this.lastItem = null;
-
- /**
- * Stores the last throughput we computed
- * @type {number}
- */
- this.lastThroughput = 0;
-
- /**
- * Stores when we last computed the throughput
- * @type {number}
- */
- this.lastThroughputComputation = 0;
- }
-}
+import { Component } from "../component";
+import { BaseItem } from "../base_item";
+import { typeItemSingleton } from "../item_resolver";
+import { types } from "../../savegame/serialization";
+
+/** @enum {string} */
+export const enumBeltReaderType = {
+ wired: "wired",
+ wireless: "wireless",
+};
+
+export class BeltReaderComponent extends Component {
+ static getId() {
+ return "BeltReader";
+ }
+
+ static getSchema() {
+ return {
+ lastItem: types.nullable(typeItemSingleton),
+ };
+ }
+
+ constructor() {
+ super();
+ this.clear();
+ }
+
+ clear() {
+ /**
+ * Which items went through the reader, we only store the time
+ * @type {Array}
+ */
+ this.lastItemTimes = [];
+
+ /**
+ * Which item passed the reader last
+ * @type {BaseItem}
+ */
+ this.lastItem = null;
+
+ /**
+ * Stores the last throughput we computed
+ * @type {number}
+ */
+ this.lastThroughput = 0;
+
+ /**
+ * Stores when we last computed the throughput
+ * @type {number}
+ */
+ this.lastThroughputComputation = 0;
+ }
+}
diff --git a/src/js/game/components/belt_underlays.js b/src/js/game/components/belt_underlays.js
index 63b265d0..ccce4dd4 100644
--- a/src/js/game/components/belt_underlays.js
+++ b/src/js/game/components/belt_underlays.js
@@ -1,41 +1,41 @@
-import { enumDirection, Vector } from "../../core/vector";
-import { Component } from "../component";
-
-/**
- * Store which type an underlay is, this is cached so we can easily
- * render it.
- *
- * Full: Render underlay at top and bottom of tile
- * Bottom Only: Only render underlay at the bottom half
- * Top Only:
- * @enum {string}
- */
-export const enumClippedBeltUnderlayType = {
- full: "full",
- bottomOnly: "bottomOnly",
- topOnly: "topOnly",
- none: "none",
-};
-
-/**
- * @typedef {{
- * pos: Vector,
- * direction: enumDirection,
- * cachedType?: enumClippedBeltUnderlayType
- * }} BeltUnderlayTile
- */
-
-export class BeltUnderlaysComponent extends Component {
- static getId() {
- return "BeltUnderlays";
- }
-
- /**
- * @param {object} param0
- * @param {Array=} param0.underlays Where to render belt underlays
- */
- constructor({ underlays = [] }) {
- super();
- this.underlays = underlays;
- }
-}
+import { enumDirection, Vector } from "../../core/vector";
+import { Component } from "../component";
+
+/**
+ * Store which type an underlay is, this is cached so we can easily
+ * render it.
+ *
+ * Full: Render underlay at top and bottom of tile
+ * Bottom Only: Only render underlay at the bottom half
+ * Top Only:
+ * @enum {string}
+ */
+export const enumClippedBeltUnderlayType = {
+ full: "full",
+ bottomOnly: "bottomOnly",
+ topOnly: "topOnly",
+ none: "none",
+};
+
+/**
+ * @typedef {{
+ * pos: Vector,
+ * direction: enumDirection,
+ * cachedType?: enumClippedBeltUnderlayType
+ * }} BeltUnderlayTile
+ */
+
+export class BeltUnderlaysComponent extends Component {
+ static getId() {
+ return "BeltUnderlays";
+ }
+
+ /**
+ * @param {object} param0
+ * @param {Array=} param0.underlays Where to render belt underlays
+ */
+ constructor({ underlays = [] }) {
+ super();
+ this.underlays = underlays;
+ }
+}
diff --git a/src/js/game/components/filter.js b/src/js/game/components/filter.js
index 8a22a076..d90e05e9 100644
--- a/src/js/game/components/filter.js
+++ b/src/js/game/components/filter.js
@@ -1,59 +1,59 @@
-import { types } from "../../savegame/serialization";
-import { BaseItem } from "../base_item";
-import { Component } from "../component";
-import { typeItemSingleton } from "../item_resolver";
-
-/**
- * @typedef {{
- * item: BaseItem,
- * progress: number
- * }} PendingFilterItem
- */
-
-export class FilterComponent extends Component {
- static getId() {
- return "Filter";
- }
-
- duplicateWithoutContents() {
- return new FilterComponent();
- }
-
- static getSchema() {
- return {
- pendingItemsToLeaveThrough: types.array(
- types.structured({
- item: typeItemSingleton,
- progress: types.ufloat,
- })
- ),
-
- pendingItemsToReject: types.array(
- types.structured({
- item: typeItemSingleton,
- progress: types.ufloat,
- })
- ),
- };
- }
-
- constructor() {
- super();
-
- this.clear();
- }
-
- clear() {
- /**
- * Items in queue to leave through
- * @type {Array}
- */
- this.pendingItemsToLeaveThrough = [];
-
- /**
- * Items in queue to reject
- * @type {Array}
- */
- this.pendingItemsToReject = [];
- }
-}
+import { types } from "../../savegame/serialization";
+import { BaseItem } from "../base_item";
+import { Component } from "../component";
+import { typeItemSingleton } from "../item_resolver";
+
+/**
+ * @typedef {{
+ * item: BaseItem,
+ * progress: number
+ * }} PendingFilterItem
+ */
+
+export class FilterComponent extends Component {
+ static getId() {
+ return "Filter";
+ }
+
+ duplicateWithoutContents() {
+ return new FilterComponent();
+ }
+
+ static getSchema() {
+ return {
+ pendingItemsToLeaveThrough: types.array(
+ types.structured({
+ item: typeItemSingleton,
+ progress: types.ufloat,
+ })
+ ),
+
+ pendingItemsToReject: types.array(
+ types.structured({
+ item: typeItemSingleton,
+ progress: types.ufloat,
+ })
+ ),
+ };
+ }
+
+ constructor() {
+ super();
+
+ this.clear();
+ }
+
+ clear() {
+ /**
+ * Items in queue to leave through
+ * @type {Array}
+ */
+ this.pendingItemsToLeaveThrough = [];
+
+ /**
+ * Items in queue to reject
+ * @type {Array}
+ */
+ this.pendingItemsToReject = [];
+ }
+}
diff --git a/src/js/game/components/goal_acceptor.js b/src/js/game/components/goal_acceptor.js
index fa5f5908..c5aeb974 100644
--- a/src/js/game/components/goal_acceptor.js
+++ b/src/js/game/components/goal_acceptor.js
@@ -1,67 +1,67 @@
-import { globalConfig } from "../../core/config";
-import { BaseItem } from "../base_item";
-import { Component } from "../component";
-import { typeItemSingleton } from "../item_resolver";
-
-export class GoalAcceptorComponent extends Component {
- static getId() {
- return "GoalAcceptor";
- }
-
- static getSchema() {
- return {
- item: typeItemSingleton,
- };
- }
-
- /**
- * @param {object} param0
- * @param {BaseItem=} param0.item
- * @param {number=} param0.rate
- */
- constructor({ item = null, rate = null }) {
- super();
-
- // ths item to produce
- /** @type {BaseItem | undefined} */
- this.item = item;
-
- this.clear();
- }
-
- clear() {
- /**
- * The last item we delivered
- * @type {{ item: BaseItem; time: number; } | null} */
- this.lastDelivery = null;
-
- // The amount of items we delivered so far
- this.currentDeliveredItems = 0;
-
- // Used for animations
- this.displayPercentage = 0;
- }
-
- /**
- * Clears items but doesn't instantly reset the progress bar
- */
- clearItems() {
- this.lastDelivery = null;
- this.currentDeliveredItems = 0;
- }
-
- getRequiredSecondsPerItem() {
- return (
- globalConfig.goalAcceptorsPerProducer /
- (globalConfig.puzzleModeSpeed * globalConfig.beltSpeedItemsPerSecond)
- );
- }
-
- /**
- * Copy the current state to another component
- * @param {GoalAcceptorComponent} otherComponent
- */
- copyAdditionalStateTo(otherComponent) {
- otherComponent.item = this.item;
- }
-}
+import { globalConfig } from "../../core/config";
+import { BaseItem } from "../base_item";
+import { Component } from "../component";
+import { typeItemSingleton } from "../item_resolver";
+
+export class GoalAcceptorComponent extends Component {
+ static getId() {
+ return "GoalAcceptor";
+ }
+
+ static getSchema() {
+ return {
+ item: typeItemSingleton,
+ };
+ }
+
+ /**
+ * @param {object} param0
+ * @param {BaseItem=} param0.item
+ * @param {number=} param0.rate
+ */
+ constructor({ item = null, rate = null }) {
+ super();
+
+ // ths item to produce
+ /** @type {BaseItem | undefined} */
+ this.item = item;
+
+ this.clear();
+ }
+
+ clear() {
+ /**
+ * The last item we delivered
+ * @type {{ item: BaseItem; time: number; } | null} */
+ this.lastDelivery = null;
+
+ // The amount of items we delivered so far
+ this.currentDeliveredItems = 0;
+
+ // Used for animations
+ this.displayPercentage = 0;
+ }
+
+ /**
+ * Clears items but doesn't instantly reset the progress bar
+ */
+ clearItems() {
+ this.lastDelivery = null;
+ this.currentDeliveredItems = 0;
+ }
+
+ getRequiredSecondsPerItem() {
+ return (
+ globalConfig.goalAcceptorsPerProducer /
+ (globalConfig.puzzleModeSpeed * globalConfig.beltSpeedItemsPerSecond)
+ );
+ }
+
+ /**
+ * Copy the current state to another component
+ * @param {GoalAcceptorComponent} otherComponent
+ */
+ copyAdditionalStateTo(otherComponent) {
+ otherComponent.item = this.item;
+ }
+}
diff --git a/src/js/game/components/item_acceptor.js b/src/js/game/components/item_acceptor.js
index d3df3763..e984fefb 100644
--- a/src/js/game/components/item_acceptor.js
+++ b/src/js/game/components/item_acceptor.js
@@ -1,136 +1,136 @@
-import { enumDirection, enumInvertedDirections, Vector } from "../../core/vector";
-import { types } from "../../savegame/serialization";
-import { BaseItem } from "../base_item";
-import { Component } from "../component";
-
-/**
- * @typedef {{
- * pos: Vector,
- * direction: enumDirection,
- * filter?: ItemType
- * }} ItemAcceptorSlot */
-
-/**
- * Contains information about a slot plus its location
- * @typedef {{
- * slot: ItemAcceptorSlot,
- * index: number,
- * }} ItemAcceptorLocatedSlot */
-
-/**
- * @typedef {{
- * pos: Vector,
- * direction: enumDirection,
- * filter?: ItemType
- * }} ItemAcceptorSlotConfig */
-
-export class ItemAcceptorComponent extends Component {
- static getId() {
- return "ItemAcceptor";
- }
-
- /**
- *
- * @param {object} param0
- * @param {Array} param0.slots The slots from which we accept items
- */
- constructor({ slots = [] }) {
- super();
-
- this.setSlots(slots);
- this.clear();
- }
-
- clear() {
- /**
- * Fixes belt animations
- * @type {Array<{
- * item: BaseItem,
- * slotIndex: number,
- * animProgress: number,
- * direction: enumDirection
- * }>}
- */
- this.itemConsumptionAnimations = [];
- }
-
- /**
- *
- * @param {Array} slots
- */
- setSlots(slots) {
- /** @type {Array} */
- this.slots = [];
- for (let i = 0; i < slots.length; ++i) {
- const slot = slots[i];
- this.slots.push({
- pos: slot.pos,
- direction: slot.direction,
-
- // Which type of item to accept (shape | color | all) @see ItemType
- filter: slot.filter,
- });
- }
- }
-
- /**
- * Returns if this acceptor can accept a new item at slot N
- *
- * NOTICE: The belt path ignores this for performance reasons and does his own check
- * @param {number} slotIndex
- * @param {BaseItem=} item
- */
- canAcceptItem(slotIndex, item) {
- const slot = this.slots[slotIndex];
- return !slot.filter || slot.filter === item.getItemType();
- }
-
- /**
- * Called when an item has been accepted so that
- * @param {number} slotIndex
- * @param {enumDirection} direction
- * @param {BaseItem} item
- * @param {number} remainingProgress World space remaining progress, can be set to set the start position of the item
- */
- onItemAccepted(slotIndex, direction, item, remainingProgress = 0.0) {
- this.itemConsumptionAnimations.push({
- item,
- slotIndex,
- direction,
- animProgress: Math.min(1, remainingProgress * 2),
- });
- }
-
- /**
- * Tries to find a slot which accepts the current item
- * @param {Vector} targetLocalTile
- * @param {enumDirection} fromLocalDirection
- * @returns {ItemAcceptorLocatedSlot|null}
- */
- findMatchingSlot(targetLocalTile, fromLocalDirection) {
- // We need to invert our direction since the acceptor specifies *from* which direction
- // it accepts items, but the ejector specifies *into* which direction it ejects items.
- // E.g.: Ejector ejects into "right" direction but acceptor accepts from "left" direction.
- const desiredDirection = enumInvertedDirections[fromLocalDirection];
-
- // Go over all slots and try to find a target slot
- for (let slotIndex = 0; slotIndex < this.slots.length; ++slotIndex) {
- const slot = this.slots[slotIndex];
-
- // Make sure the acceptor slot is on the right position
- if (!slot.pos.equals(targetLocalTile)) {
- continue;
- }
-
- // Check if the acceptor slot accepts items from our direction
- if (desiredDirection === slot.direction) {
- return {
- slot,
- index: slotIndex,
- };
- }
- }
-
- return null;
- }
-}
+import { enumDirection, enumInvertedDirections, Vector } from "../../core/vector";
+import { types } from "../../savegame/serialization";
+import { BaseItem } from "../base_item";
+import { Component } from "../component";
+
+/**
+ * @typedef {{
+ * pos: Vector,
+ * direction: enumDirection,
+ * filter?: ItemType
+ * }} ItemAcceptorSlot */
+
+/**
+ * Contains information about a slot plus its location
+ * @typedef {{
+ * slot: ItemAcceptorSlot,
+ * index: number,
+ * }} ItemAcceptorLocatedSlot */
+
+/**
+ * @typedef {{
+ * pos: Vector,
+ * direction: enumDirection,
+ * filter?: ItemType
+ * }} ItemAcceptorSlotConfig */
+
+export class ItemAcceptorComponent extends Component {
+ static getId() {
+ return "ItemAcceptor";
+ }
+
+ /**
+ *
+ * @param {object} param0
+ * @param {Array} param0.slots The slots from which we accept items
+ */
+ constructor({ slots = [] }) {
+ super();
+
+ this.setSlots(slots);
+ this.clear();
+ }
+
+ clear() {
+ /**
+ * Fixes belt animations
+ * @type {Array<{
+ * item: BaseItem,
+ * slotIndex: number,
+ * animProgress: number,
+ * direction: enumDirection
+ * }>}
+ */
+ this.itemConsumptionAnimations = [];
+ }
+
+ /**
+ *
+ * @param {Array} slots
+ */
+ setSlots(slots) {
+ /** @type {Array} */
+ this.slots = [];
+ for (let i = 0; i < slots.length; ++i) {
+ const slot = slots[i];
+ this.slots.push({
+ pos: slot.pos,
+ direction: slot.direction,
+
+ // Which type of item to accept (shape | color | all) @see ItemType
+ filter: slot.filter,
+ });
+ }
+ }
+
+ /**
+ * Returns if this acceptor can accept a new item at slot N
+ *
+ * NOTICE: The belt path ignores this for performance reasons and does his own check
+ * @param {number} slotIndex
+ * @param {BaseItem=} item
+ */
+ canAcceptItem(slotIndex, item) {
+ const slot = this.slots[slotIndex];
+ return !slot.filter || slot.filter === item.getItemType();
+ }
+
+ /**
+ * Called when an item has been accepted so that
+ * @param {number} slotIndex
+ * @param {enumDirection} direction
+ * @param {BaseItem} item
+ * @param {number} remainingProgress World space remaining progress, can be set to set the start position of the item
+ */
+ onItemAccepted(slotIndex, direction, item, remainingProgress = 0.0) {
+ this.itemConsumptionAnimations.push({
+ item,
+ slotIndex,
+ direction,
+ animProgress: Math.min(1, remainingProgress * 2),
+ });
+ }
+
+ /**
+ * Tries to find a slot which accepts the current item
+ * @param {Vector} targetLocalTile
+ * @param {enumDirection} fromLocalDirection
+ * @returns {ItemAcceptorLocatedSlot|null}
+ */
+ findMatchingSlot(targetLocalTile, fromLocalDirection) {
+ // We need to invert our direction since the acceptor specifies *from* which direction
+ // it accepts items, but the ejector specifies *into* which direction it ejects items.
+ // E.g.: Ejector ejects into "right" direction but acceptor accepts from "left" direction.
+ const desiredDirection = enumInvertedDirections[fromLocalDirection];
+
+ // Go over all slots and try to find a target slot
+ for (let slotIndex = 0; slotIndex < this.slots.length; ++slotIndex) {
+ const slot = this.slots[slotIndex];
+
+ // Make sure the acceptor slot is on the right position
+ if (!slot.pos.equals(targetLocalTile)) {
+ continue;
+ }
+
+ // Check if the acceptor slot accepts items from our direction
+ if (desiredDirection === slot.direction) {
+ return {
+ slot,
+ index: slotIndex,
+ };
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src/js/game/components/item_ejector.js b/src/js/game/components/item_ejector.js
index bfc54cd8..c8c4ec94 100644
--- a/src/js/game/components/item_ejector.js
+++ b/src/js/game/components/item_ejector.js
@@ -1,154 +1,154 @@
-import { enumDirection, enumDirectionToVector, Vector } from "../../core/vector";
-import { types } from "../../savegame/serialization";
-import { BaseItem } from "../base_item";
-import { BeltPath } from "../belt_path";
-import { Component } from "../component";
-import { Entity } from "../entity";
-import { typeItemSingleton } from "../item_resolver";
-
-/**
- * @typedef {{
- * pos: Vector,
- * direction: enumDirection,
- * item: BaseItem,
- * lastItem: BaseItem,
- * progress: number?,
- * cachedDestSlot?: import("./item_acceptor").ItemAcceptorLocatedSlot,
- * cachedBeltPath?: BeltPath,
- * cachedTargetEntity?: Entity
- * }} ItemEjectorSlot
- */
-
-export class ItemEjectorComponent extends Component {
- static getId() {
- return "ItemEjector";
- }
-
- static getSchema() {
- // The cachedDestSlot, cachedTargetEntity fields are not serialized.
- return {
- slots: types.fixedSizeArray(
- types.structured({
- item: types.nullable(typeItemSingleton),
- progress: types.float,
- })
- ),
- };
- }
-
- /**
- *
- * @param {object} param0
- * @param {Array<{pos: Vector, direction: enumDirection }>=} param0.slots The slots to eject on
- * @param {boolean=} param0.renderFloatingItems Whether to render items even if they are not connected
- */
- constructor({ slots = [], renderFloatingItems = true }) {
- super();
-
- this.setSlots(slots);
- this.renderFloatingItems = renderFloatingItems;
- }
-
- clear() {
- for (const slot of this.slots) {
- slot.item = null;
- slot.lastItem = null;
- slot.progress = 0;
- }
- }
-
- /**
- * @param {Array<{pos: Vector, direction: enumDirection }>} slots The slots to eject on
- */
- setSlots(slots) {
- /** @type {Array} */
- this.slots = [];
- for (let i = 0; i < slots.length; ++i) {
- const slot = slots[i];
- this.slots.push({
- pos: slot.pos,
- direction: slot.direction,
- item: null,
- lastItem: null,
- progress: 0,
- cachedDestSlot: null,
- cachedTargetEntity: null,
- });
- }
- }
-
- /**
- * Returns where this slot ejects to
- * @param {ItemEjectorSlot} slot
- * @returns {Vector}
- */
- getSlotTargetLocalTile(slot) {
- const directionVector = enumDirectionToVector[slot.direction];
- return slot.pos.add(directionVector);
- }
-
- /**
- * Returns whether any slot ejects to the given local tile
- * @param {Vector} tile
- */
- anySlotEjectsToLocalTile(tile) {
- for (let i = 0; i < this.slots.length; ++i) {
- if (this.getSlotTargetLocalTile(this.slots[i]).equals(tile)) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * Returns if we can eject on a given slot
- * @param {number} slotIndex
- * @returns {boolean}
- */
- canEjectOnSlot(slotIndex) {
- assert(slotIndex >= 0 && slotIndex < this.slots.length, "Invalid ejector slot: " + slotIndex);
- return !this.slots[slotIndex].item;
- }
-
- /**
- * Returns the first free slot on this ejector or null if there is none
- * @returns {number?}
- */
- getFirstFreeSlot() {
- for (let i = 0; i < this.slots.length; ++i) {
- if (this.canEjectOnSlot(i)) {
- return i;
- }
- }
- return null;
- }
-
- /**
- * Tries to eject a given item
- * @param {number} slotIndex
- * @param {BaseItem} item
- * @returns {boolean}
- */
- tryEject(slotIndex, item) {
- if (!this.canEjectOnSlot(slotIndex)) {
- return false;
- }
- this.slots[slotIndex].item = item;
- this.slots[slotIndex].lastItem = item;
- this.slots[slotIndex].progress = 0;
- return true;
- }
-
- /**
- * Clears the given slot and returns the item it had
- * @param {number} slotIndex
- * @returns {BaseItem|null}
- */
- takeSlotItem(slotIndex) {
- const slot = this.slots[slotIndex];
- const item = slot.item;
- slot.item = null;
- slot.progress = 0.0;
- return item;
- }
-}
+import { enumDirection, enumDirectionToVector, Vector } from "../../core/vector";
+import { types } from "../../savegame/serialization";
+import { BaseItem } from "../base_item";
+import { BeltPath } from "../belt_path";
+import { Component } from "../component";
+import { Entity } from "../entity";
+import { typeItemSingleton } from "../item_resolver";
+
+/**
+ * @typedef {{
+ * pos: Vector,
+ * direction: enumDirection,
+ * item: BaseItem,
+ * lastItem: BaseItem,
+ * progress: number?,
+ * cachedDestSlot?: import("./item_acceptor").ItemAcceptorLocatedSlot,
+ * cachedBeltPath?: BeltPath,
+ * cachedTargetEntity?: Entity
+ * }} ItemEjectorSlot
+ */
+
+export class ItemEjectorComponent extends Component {
+ static getId() {
+ return "ItemEjector";
+ }
+
+ static getSchema() {
+ // The cachedDestSlot, cachedTargetEntity fields are not serialized.
+ return {
+ slots: types.fixedSizeArray(
+ types.structured({
+ item: types.nullable(typeItemSingleton),
+ progress: types.float,
+ })
+ ),
+ };
+ }
+
+ /**
+ *
+ * @param {object} param0
+ * @param {Array<{pos: Vector, direction: enumDirection }>=} param0.slots The slots to eject on
+ * @param {boolean=} param0.renderFloatingItems Whether to render items even if they are not connected
+ */
+ constructor({ slots = [], renderFloatingItems = true }) {
+ super();
+
+ this.setSlots(slots);
+ this.renderFloatingItems = renderFloatingItems;
+ }
+
+ clear() {
+ for (const slot of this.slots) {
+ slot.item = null;
+ slot.lastItem = null;
+ slot.progress = 0;
+ }
+ }
+
+ /**
+ * @param {Array<{pos: Vector, direction: enumDirection }>} slots The slots to eject on
+ */
+ setSlots(slots) {
+ /** @type {Array} */
+ this.slots = [];
+ for (let i = 0; i < slots.length; ++i) {
+ const slot = slots[i];
+ this.slots.push({
+ pos: slot.pos,
+ direction: slot.direction,
+ item: null,
+ lastItem: null,
+ progress: 0,
+ cachedDestSlot: null,
+ cachedTargetEntity: null,
+ });
+ }
+ }
+
+ /**
+ * Returns where this slot ejects to
+ * @param {ItemEjectorSlot} slot
+ * @returns {Vector}
+ */
+ getSlotTargetLocalTile(slot) {
+ const directionVector = enumDirectionToVector[slot.direction];
+ return slot.pos.add(directionVector);
+ }
+
+ /**
+ * Returns whether any slot ejects to the given local tile
+ * @param {Vector} tile
+ */
+ anySlotEjectsToLocalTile(tile) {
+ for (let i = 0; i < this.slots.length; ++i) {
+ if (this.getSlotTargetLocalTile(this.slots[i]).equals(tile)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns if we can eject on a given slot
+ * @param {number} slotIndex
+ * @returns {boolean}
+ */
+ canEjectOnSlot(slotIndex) {
+ assert(slotIndex >= 0 && slotIndex < this.slots.length, "Invalid ejector slot: " + slotIndex);
+ return !this.slots[slotIndex].item;
+ }
+
+ /**
+ * Returns the first free slot on this ejector or null if there is none
+ * @returns {number?}
+ */
+ getFirstFreeSlot() {
+ for (let i = 0; i < this.slots.length; ++i) {
+ if (this.canEjectOnSlot(i)) {
+ return i;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Tries to eject a given item
+ * @param {number} slotIndex
+ * @param {BaseItem} item
+ * @returns {boolean}
+ */
+ tryEject(slotIndex, item) {
+ if (!this.canEjectOnSlot(slotIndex)) {
+ return false;
+ }
+ this.slots[slotIndex].item = item;
+ this.slots[slotIndex].lastItem = item;
+ this.slots[slotIndex].progress = 0;
+ return true;
+ }
+
+ /**
+ * Clears the given slot and returns the item it had
+ * @param {number} slotIndex
+ * @returns {BaseItem|null}
+ */
+ takeSlotItem(slotIndex) {
+ const slot = this.slots[slotIndex];
+ const item = slot.item;
+ slot.item = null;
+ slot.progress = 0.0;
+ return item;
+ }
+}
diff --git a/src/js/game/components/item_processor.js b/src/js/game/components/item_processor.js
index be7d1ce4..e512d666 100644
--- a/src/js/game/components/item_processor.js
+++ b/src/js/game/components/item_processor.js
@@ -7,9 +7,9 @@ export const enumItemProcessorTypes = {
balancer: "balancer",
cutter: "cutter",
cutterQuad: "cutterQuad",
- rotater: "rotater",
- rotaterCCW: "rotaterCCW",
- rotater180: "rotater180",
+ rotator: "rotator",
+ rotatorCCW: "rotatorCCW",
+ rotator180: "rotator180",
stacker: "stacker",
trash: "trash",
mixer: "mixer",
diff --git a/src/js/game/components/item_producer.js b/src/js/game/components/item_producer.js
index ef3571e2..3c1ccf0c 100644
--- a/src/js/game/components/item_producer.js
+++ b/src/js/game/components/item_producer.js
@@ -1,7 +1,7 @@
-import { Component } from "../component";
-
-export class ItemProducerComponent extends Component {
- static getId() {
- return "ItemProducer";
- }
-}
+import { Component } from "../component";
+
+export class ItemProducerComponent extends Component {
+ static getId() {
+ return "ItemProducer";
+ }
+}
diff --git a/src/js/game/components/lever.js b/src/js/game/components/lever.js
index 106cbbdd..cdef5a58 100644
--- a/src/js/game/components/lever.js
+++ b/src/js/game/components/lever.js
@@ -1,31 +1,31 @@
-import { Component } from "../component";
-import { types } from "../../savegame/serialization";
-
-export class LeverComponent extends Component {
- static getId() {
- return "Lever";
- }
-
- static getSchema() {
- return {
- toggled: types.bool,
- };
- }
-
- /**
- * Copy the current state to another component
- * @param {LeverComponent} otherComponent
- */
- copyAdditionalStateTo(otherComponent) {
- otherComponent.toggled = this.toggled;
- }
-
- /**
- * @param {object} param0
- * @param {boolean=} param0.toggled
- */
- constructor({ toggled = false }) {
- super();
- this.toggled = toggled;
- }
-}
+import { Component } from "../component";
+import { types } from "../../savegame/serialization";
+
+export class LeverComponent extends Component {
+ static getId() {
+ return "Lever";
+ }
+
+ static getSchema() {
+ return {
+ toggled: types.bool,
+ };
+ }
+
+ /**
+ * Copy the current state to another component
+ * @param {LeverComponent} otherComponent
+ */
+ copyAdditionalStateTo(otherComponent) {
+ otherComponent.toggled = this.toggled;
+ }
+
+ /**
+ * @param {object} param0
+ * @param {boolean=} param0.toggled
+ */
+ constructor({ toggled = false }) {
+ super();
+ this.toggled = toggled;
+ }
+}
diff --git a/src/js/game/components/logic_gate.js b/src/js/game/components/logic_gate.js
index 62cd3365..83611706 100644
--- a/src/js/game/components/logic_gate.js
+++ b/src/js/game/components/logic_gate.js
@@ -1,34 +1,34 @@
-import { Component } from "../component";
-
-/** @enum {string} */
-export const enumLogicGateType = {
- and: "and",
- not: "not",
- xor: "xor",
- or: "or",
- transistor: "transistor",
-
- analyzer: "analyzer",
- rotater: "rotater",
- unstacker: "unstacker",
- cutter: "cutter",
- compare: "compare",
- stacker: "stacker",
- painter: "painter",
-};
-
-export class LogicGateComponent extends Component {
- static getId() {
- return "LogicGate";
- }
-
- /**
- *
- * @param {object} param0
- * @param {enumLogicGateType=} param0.type
- */
- constructor({ type = enumLogicGateType.and }) {
- super();
- this.type = type;
- }
-}
+import { Component } from "../component";
+
+/** @enum {string} */
+export const enumLogicGateType = {
+ and: "and",
+ not: "not",
+ xor: "xor",
+ or: "or",
+ transistor: "transistor",
+
+ analyzer: "analyzer",
+ rotator: "rotator",
+ unstacker: "unstacker",
+ cutter: "cutter",
+ compare: "compare",
+ stacker: "stacker",
+ painter: "painter",
+};
+
+export class LogicGateComponent extends Component {
+ static getId() {
+ return "LogicGate";
+ }
+
+ /**
+ *
+ * @param {object} param0
+ * @param {enumLogicGateType=} param0.type
+ */
+ constructor({ type = enumLogicGateType.and }) {
+ super();
+ this.type = type;
+ }
+}
diff --git a/src/js/game/components/miner.js b/src/js/game/components/miner.js
index 5321ae11..cc2edb2c 100644
--- a/src/js/game/components/miner.js
+++ b/src/js/game/components/miner.js
@@ -1,64 +1,64 @@
-import { types } from "../../savegame/serialization";
-import { BaseItem } from "../base_item";
-import { Component } from "../component";
-import { Entity } from "../entity";
-import { typeItemSingleton } from "../item_resolver";
-
-const chainBufferSize = 6;
-
-export class MinerComponent extends Component {
- static getId() {
- return "Miner";
- }
-
- static getSchema() {
- // cachedMinedItem is not serialized.
- return {
- lastMiningTime: types.ufloat,
- itemChainBuffer: types.array(typeItemSingleton),
- };
- }
-
- constructor({ chainable = false }) {
- super();
- this.lastMiningTime = 0;
- this.chainable = chainable;
-
- /**
- * @type {BaseItem}
- */
- this.cachedMinedItem = null;
-
- /**
- * Which miner this miner ejects to, in case its a chainable one.
- * If the value is false, it means there is no entity, and we don't have to re-check
- * @type {Entity|null|false}
- */
- this.cachedChainedMiner = null;
-
- this.clear();
- }
-
- clear() {
- /**
- * Stores items from other miners which were chained to this
- * miner.
- * @type {Array}
- */
- this.itemChainBuffer = [];
- }
-
- /**
- *
- * @param {BaseItem} item
- */
- tryAcceptChainedItem(item) {
- if (this.itemChainBuffer.length > chainBufferSize) {
- // Well, this one is full
- return false;
- }
-
- this.itemChainBuffer.push(item);
- return true;
- }
-}
+import { types } from "../../savegame/serialization";
+import { BaseItem } from "../base_item";
+import { Component } from "../component";
+import { Entity } from "../entity";
+import { typeItemSingleton } from "../item_resolver";
+
+const chainBufferSize = 6;
+
+export class MinerComponent extends Component {
+ static getId() {
+ return "Miner";
+ }
+
+ static getSchema() {
+ // cachedMinedItem is not serialized.
+ return {
+ lastMiningTime: types.ufloat,
+ itemChainBuffer: types.array(typeItemSingleton),
+ };
+ }
+
+ constructor({ chainable = false }) {
+ super();
+ this.lastMiningTime = 0;
+ this.chainable = chainable;
+
+ /**
+ * @type {BaseItem}
+ */
+ this.cachedMinedItem = null;
+
+ /**
+ * Which miner this miner ejects to, in case its a chainable one.
+ * If the value is false, it means there is no entity, and we don't have to re-check
+ * @type {Entity|null|false}
+ */
+ this.cachedChainedMiner = null;
+
+ this.clear();
+ }
+
+ clear() {
+ /**
+ * Stores items from other miners which were chained to this
+ * miner.
+ * @type {Array}
+ */
+ this.itemChainBuffer = [];
+ }
+
+ /**
+ *
+ * @param {BaseItem} item
+ */
+ tryAcceptChainedItem(item) {
+ if (this.itemChainBuffer.length > chainBufferSize) {
+ // Well, this one is full
+ return false;
+ }
+
+ this.itemChainBuffer.push(item);
+ return true;
+ }
+}
diff --git a/src/js/game/components/static_map_entity.js b/src/js/game/components/static_map_entity.js
index a3d6a8ca..f92fcc48 100644
--- a/src/js/game/components/static_map_entity.js
+++ b/src/js/game/components/static_map_entity.js
@@ -255,8 +255,16 @@ export class StaticMapEntityComponent extends Component {
* @param {AtlasSprite} sprite
* @param {number=} extrudePixels How many pixels to extrude the sprite
* @param {Vector=} overridePosition Whether to drwa the entity at a different location
+ * @param {boolean=} pixelAligned
+ * Whether to round the canvas coordinates, to avoid issues with transparency between tiling images
*/
- drawSpriteOnBoundsClipped(parameters, sprite, extrudePixels = 0, overridePosition = null) {
+ drawSpriteOnBoundsClipped(
+ parameters,
+ sprite,
+ extrudePixels = 0,
+ overridePosition = null,
+ pixelAligned = false
+ ) {
if (!this.shouldBeDrawn(parameters) && !overridePosition) {
return;
}
@@ -269,31 +277,74 @@ export class StaticMapEntityComponent extends Component {
worldY = overridePosition.y * globalConfig.tileSize;
}
- if (this.rotation === 0) {
- // Early out, is faster
- sprite.drawCached(
- parameters,
- worldX - extrudePixels * size.x,
- worldY - extrudePixels * size.y,
- globalConfig.tileSize * size.x + 2 * extrudePixels * size.x,
- globalConfig.tileSize * size.y + 2 * extrudePixels * size.y
- );
- } else {
- const rotationCenterX = worldX + globalConfig.halfTileSize;
- const rotationCenterY = worldY + globalConfig.halfTileSize;
+ if (!pixelAligned) {
+ if (this.rotation === 0) {
+ // Early out, is faster
+ sprite.drawCached(
+ parameters,
+ worldX - extrudePixels * size.x,
+ worldY - extrudePixels * size.y,
+ globalConfig.tileSize * size.x + 2 * extrudePixels * size.x,
+ globalConfig.tileSize * size.y + 2 * extrudePixels * size.y
+ );
+ } else {
+ const rotationCenterX = worldX + globalConfig.halfTileSize;
+ const rotationCenterY = worldY + globalConfig.halfTileSize;
- parameters.context.translate(rotationCenterX, rotationCenterY);
- parameters.context.rotate(Math.radians(this.rotation));
- sprite.drawCached(
- parameters,
- -globalConfig.halfTileSize - extrudePixels * size.x,
- -globalConfig.halfTileSize - extrudePixels * size.y,
- globalConfig.tileSize * size.x + 2 * extrudePixels * size.x,
- globalConfig.tileSize * size.y + 2 * extrudePixels * size.y,
- false // no clipping possible here
- );
- parameters.context.rotate(-Math.radians(this.rotation));
- parameters.context.translate(-rotationCenterX, -rotationCenterY);
+ parameters.context.translate(rotationCenterX, rotationCenterY);
+ parameters.context.rotate(Math.radians(this.rotation));
+ sprite.drawCached(
+ parameters,
+ -globalConfig.halfTileSize - extrudePixels * size.x,
+ -globalConfig.halfTileSize - extrudePixels * size.y,
+ globalConfig.tileSize * size.x + 2 * extrudePixels * size.x,
+ globalConfig.tileSize * size.y + 2 * extrudePixels * size.y,
+ false // no clipping possible here
+ );
+ parameters.context.rotate(-Math.radians(this.rotation));
+ parameters.context.translate(-rotationCenterX, -rotationCenterY);
+ }
+ return;
}
+
+ const tileCenter = new Vector(globalConfig.halfTileSize, globalConfig.halfTileSize);
+ const rotatedTileCenter = tileCenter.rotateFastMultipleOf90(this.rotation);
+ const cornerX = worldX + tileCenter.x - rotatedTileCenter.x;
+ const cornerY = worldY + tileCenter.y - rotatedTileCenter.y;
+ const offset = size.rotateFastMultipleOf90(this.rotation);
+
+ const transform = parameters.context.getTransform();
+ const matrix = new DOMMatrix().rotate(0, 0, -this.rotation).multiplySelf(transform);
+ let { x: x1, y: y1 } = matrix.transformPoint(
+ new DOMPoint(cornerX - extrudePixels * offset.x, cornerY - extrudePixels * offset.y)
+ );
+ let { x: x2, y: y2 } = matrix.transformPoint(
+ new DOMPoint(
+ cornerX + globalConfig.tileSize * offset.x + extrudePixels * offset.x,
+ cornerY + globalConfig.tileSize * offset.y + extrudePixels * offset.y
+ )
+ );
+ if (x1 > x2) {
+ [x1, x2] = [x2, x1];
+ }
+ if (y1 > y2) {
+ [y1, y2] = [y2, y1];
+ }
+ // Even though drawCached may scale the coordinates,
+ // that scaling is for sprites that don't take up their full tile space,
+ // so they should be interpolated exactly between the rounded tile coordinates.
+ // E.g. rounding in drawCached causes curved belts to look misaligned.
+ x1 = Math.round(x1);
+ y1 = Math.round(y1);
+ x2 = Math.round(x2);
+ y2 = Math.round(y2);
+ if (x2 - x1 == 0 || y2 - y1 == 0) {
+ return;
+ }
+
+ parameters.context.resetTransform();
+ parameters.context.rotate(Math.radians(this.rotation));
+ sprite.drawCached(parameters, x1, y1, x2 - x1, y2 - y1, false);
+ parameters.context.setTransform(transform);
}
}
diff --git a/src/js/game/components/underground_belt.js b/src/js/game/components/underground_belt.js
index 2b744edd..fe465350 100644
--- a/src/js/game/components/underground_belt.js
+++ b/src/js/game/components/underground_belt.js
@@ -57,7 +57,7 @@ export class UndergroundBeltComponent extends Component {
/**
* Used on both receiver and sender.
- * Reciever: Used to store the next item to transfer, and to block input while doing this
+ * Receiver: Used to store the next item to transfer, and to block input while doing this
* Sender: Used to store which items are currently "travelling"
* @type {Array<[BaseItem, number]>} Format is [Item, ingame time to eject the item]
*/
diff --git a/src/js/game/core.js b/src/js/game/core.js
index 7283710e..e349f5b2 100644
--- a/src/js/game/core.js
+++ b/src/js/game/core.js
@@ -1,576 +1,523 @@
-/* typehints:start */
-import { Application } from "../application";
-/* typehints:end */
-import { BufferMaintainer } from "../core/buffer_maintainer";
-import {
- disableImageSmoothing,
- enableImageSmoothing,
- getBufferStats,
- registerCanvas,
-} from "../core/buffer_utils";
-import { globalConfig } from "../core/config";
-import { getDeviceDPI, resizeHighDPICanvas } from "../core/dpi_manager";
-import { DrawParameters } from "../core/draw_parameters";
-import { gMetaBuildingRegistry } from "../core/global_registries";
-import { createLogger } from "../core/logging";
-import { Rectangle } from "../core/rectangle";
-import { ORIGINAL_SPRITE_SCALE } from "../core/sprites";
-import { lerp, randomInt, round2Digits } from "../core/utils";
-import { Vector } from "../core/vector";
-import { Savegame } from "../savegame/savegame";
-import { SavegameSerializer } from "../savegame/savegame_serializer";
-import { AutomaticSave } from "./automatic_save";
-import { MetaHubBuilding } from "./buildings/hub";
-import { Camera } from "./camera";
-import { DynamicTickrate } from "./dynamic_tickrate";
-import { EntityManager } from "./entity_manager";
-import { GameSystemManager } from "./game_system_manager";
-import { HubGoals } from "./hub_goals";
-import { GameHUD } from "./hud/hud";
-import { KeyActionMapper } from "./key_action_mapper";
-import { GameLogic } from "./logic";
-import { MapView } from "./map_view";
-import { defaultBuildingVariant } from "./meta_building";
-import { GameMode } from "./game_mode";
-import { ProductionAnalytics } from "./production_analytics";
-import { GameRoot } from "./root";
-import { ShapeDefinitionManager } from "./shape_definition_manager";
-import { AchievementProxy } from "./achievement_proxy";
-import { SoundProxy } from "./sound_proxy";
-import { GameTime } from "./time/game_time";
-import { MOD_SIGNALS } from "../mods/mod_signals";
-
-const logger = createLogger("ingame/core");
-
-// Store the canvas so we can reuse it later
-/** @type {HTMLCanvasElement} */
-let lastCanvas = null;
-/** @type {CanvasRenderingContext2D} */
-let lastContext = null;
-
-/**
- * The core manages the root and represents the whole game. It wraps the root, since
- * the root class is just a data holder.
- */
-export class GameCore {
- /** @param {Application} app */
- constructor(app) {
- this.app = app;
-
- /** @type {GameRoot} */
- this.root = null;
-
- /**
- * Set to true at the beginning of a logic update and cleared when its finished.
- * This is to prevent doing a recursive logic update which can lead to unexpected
- * behaviour.
- */
- this.duringLogicUpdate = false;
-
- // Cached
- this.boundInternalTick = this.updateLogic.bind(this);
-
- /**
- * Opacity of the overview alpha
- * @TODO Doesn't belong here
- */
- this.overlayAlpha = 0;
- }
-
- /**
- * Initializes the root object which stores all game related data. The state
- * is required as a back reference (used sometimes)
- * @param {import("../states/ingame").InGameState} parentState
- * @param {Savegame} savegame
- */
- initializeRoot(parentState, savegame, gameModeId) {
- logger.log("initializing root");
-
- // Construct the root element, this is the data representation of the game
- this.root = new GameRoot(this.app);
- this.root.gameState = parentState;
- this.root.keyMapper = parentState.keyActionMapper;
- this.root.savegame = savegame;
- this.root.gameWidth = this.app.screenWidth;
- this.root.gameHeight = this.app.screenHeight;
-
- // Initialize canvas element & context
- this.internalInitCanvas();
-
- // Members
- const root = this.root;
-
- // This isn't nice, but we need it right here
- root.keyMapper = new KeyActionMapper(root, this.root.gameState.inputReciever);
-
- // Init game mode
- root.gameMode = GameMode.create(root, gameModeId, parentState.creationPayload.gameModeParameters);
-
- // Needs to come first
- root.dynamicTickrate = new DynamicTickrate(root);
-
- // Init classes
- root.camera = new Camera(root);
- root.map = new MapView(root);
- root.logic = new GameLogic(root);
- root.hud = new GameHUD(root);
- root.time = new GameTime(root);
- root.achievementProxy = new AchievementProxy(root);
- root.automaticSave = new AutomaticSave(root);
- root.soundProxy = new SoundProxy(root);
-
- // Init managers
- root.entityMgr = new EntityManager(root);
- root.systemMgr = new GameSystemManager(root);
- root.shapeDefinitionMgr = new ShapeDefinitionManager(root);
- root.hubGoals = new HubGoals(root);
- root.productionAnalytics = new ProductionAnalytics(root);
- root.buffers = new BufferMaintainer(root);
-
- // Initialize the hud once everything is loaded
- this.root.hud.initialize();
-
- // Initial resize event, it might be possible that the screen
- // resized later during init tho, which is why will emit it later
- // again anyways
- this.resize(this.app.screenWidth, this.app.screenHeight);
-
- if (G_IS_DEV) {
- // @ts-ignore
- window.globalRoot = root;
- }
-
- // @todo Find better place
- if (G_IS_DEV && globalConfig.debug.manualTickOnly) {
- this.root.gameState.inputReciever.keydown.add(key => {
- if (key.keyCode === 84) {
- // 'T'
-
- // Extract current real time
- this.root.time.updateRealtimeNow();
-
- // Perform logic ticks
- this.root.time.performTicks(this.root.dynamicTickrate.deltaMs, this.boundInternalTick);
-
- // Update analytics
- root.productionAnalytics.update();
-
- // Check achievements
- root.achievementProxy.update();
- }
- });
- }
-
- logger.log("root initialized");
- MOD_SIGNALS.gameInitialized.dispatch(root);
- }
-
- /**
- * Initializes a new game, this means creating a new map and centering on the
- * playerbase
- * */
- initNewGame() {
- logger.log("Initializing new game");
- this.root.gameIsFresh = true;
- this.root.map.seed = randomInt(0, 100000);
-
- if (!this.root.gameMode.hasHub()) {
- return;
- }
-
- // Place the hub
- const hub = gMetaBuildingRegistry.findByClass(MetaHubBuilding).createEntity({
- root: this.root,
- origin: new Vector(-2, -2),
- rotation: 0,
- originalRotation: 0,
- rotationVariant: 0,
- variant: defaultBuildingVariant,
- });
- this.root.map.placeStaticEntity(hub);
- this.root.entityMgr.registerEntity(hub);
- this.root.camera.center = new Vector(-5, 2).multiplyScalar(globalConfig.tileSize);
- }
-
- /**
- * Inits an existing game by loading the raw savegame data and deserializing it.
- * Also runs basic validity checks.
- */
- initExistingGame() {
- logger.log("Initializing existing game");
- const serializer = new SavegameSerializer();
-
- try {
- const status = serializer.deserialize(this.root.savegame.getCurrentDump(), this.root);
- if (!status.isGood()) {
- logger.error("savegame-deserialize-failed:" + status.reason);
- return false;
- }
- } catch (ex) {
- logger.error("Exception during deserialization:", ex);
- return false;
- }
- this.root.gameIsFresh = false;
- return true;
- }
-
- /**
- * Initializes the render canvas
- */
- internalInitCanvas() {
- let canvas, context;
- if (!lastCanvas) {
- logger.log("Creating new canvas");
- canvas = document.createElement("canvas");
- canvas.id = "ingame_Canvas";
- canvas.setAttribute("opaque", "true");
- canvas.setAttribute("webkitOpaque", "true");
- canvas.setAttribute("mozOpaque", "true");
- this.root.gameState.getDivElement().appendChild(canvas);
- context = canvas.getContext("2d", { alpha: false });
-
- lastCanvas = canvas;
- lastContext = context;
- } else {
- logger.log("Reusing canvas");
- if (lastCanvas.parentElement) {
- lastCanvas.parentElement.removeChild(lastCanvas);
- }
- this.root.gameState.getDivElement().appendChild(lastCanvas);
-
- canvas = lastCanvas;
- context = lastContext;
-
- lastContext.clearRect(0, 0, lastCanvas.width, lastCanvas.height);
- }
-
- canvas.classList.toggle("smoothed", globalConfig.smoothing.smoothMainCanvas);
-
- // Oof, use :not() instead
- canvas.classList.toggle("unsmoothed", !globalConfig.smoothing.smoothMainCanvas);
-
- if (globalConfig.smoothing.smoothMainCanvas) {
- enableImageSmoothing(context);
- } else {
- disableImageSmoothing(context);
- }
-
- this.root.canvas = canvas;
- this.root.context = context;
-
- registerCanvas(canvas, context);
- }
-
- /**
- * Destructs the root, freeing all resources
- */
- destruct() {
- if (lastCanvas && lastCanvas.parentElement) {
- lastCanvas.parentElement.removeChild(lastCanvas);
- }
-
- this.root.destruct();
- delete this.root;
- this.root = null;
- this.app = null;
- }
-
- tick(deltaMs) {
- const root = this.root;
-
- // Extract current real time
- root.time.updateRealtimeNow();
-
- // Camera is always updated, no matter what
- root.camera.update(deltaMs);
-
- if (!(G_IS_DEV && globalConfig.debug.manualTickOnly)) {
- // Perform logic ticks
- this.root.time.performTicks(deltaMs, this.boundInternalTick);
-
- // Update analytics
- root.productionAnalytics.update();
-
- // Check achievements
- root.achievementProxy.update();
- }
-
- // Update automatic save after everything finished
- root.automaticSave.update();
-
- return true;
- }
-
- shouldRender() {
- if (this.root.queue.requireRedraw) {
- return true;
- }
- if (this.root.hud.shouldPauseRendering()) {
- return false;
- }
-
- // Do not render
- if (!this.app.isRenderable()) {
- return false;
- }
-
- return true;
- }
-
- updateLogic() {
- const root = this.root;
-
- root.dynamicTickrate.beginTick();
-
- if (G_IS_DEV && globalConfig.debug.disableLogicTicks) {
- root.dynamicTickrate.endTick();
- return true;
- }
-
- this.duringLogicUpdate = true;
-
- // Update entities, this removes destroyed entities
- root.entityMgr.update();
-
- // IMPORTANT: At this point, the game might be game over. Stop if this is the case
- if (!this.root) {
- logger.log("Root destructed, returning false");
- root.dynamicTickrate.endTick();
-
- return false;
- }
-
- root.systemMgr.update();
- // root.particleMgr.update();
-
- this.duringLogicUpdate = false;
- root.dynamicTickrate.endTick();
- return true;
- }
-
- resize(w, h) {
- this.root.gameWidth = w;
- this.root.gameHeight = h;
- resizeHighDPICanvas(this.root.canvas, w, h, globalConfig.smoothing.smoothMainCanvas);
- this.root.signals.resized.dispatch(w, h);
- this.root.queue.requireRedraw = true;
- }
-
- postLoadHook() {
- logger.log("Dispatching post load hook");
- this.root.signals.postLoadHook.dispatch();
-
- if (!this.root.gameIsFresh) {
- // Also dispatch game restored hook on restored savegames
- this.root.signals.gameRestored.dispatch();
- }
-
- this.root.gameInitialized = true;
- }
-
- draw() {
- const root = this.root;
- const systems = root.systemMgr.systems;
-
- this.root.dynamicTickrate.onFrameRendered();
-
- if (!this.shouldRender()) {
- // Always update hud tho
- root.hud.update();
- return;
- }
-
- this.root.signals.gameFrameStarted.dispatch();
-
- root.queue.requireRedraw = false;
-
- // Gather context and save all state
- const context = root.context;
- context.save();
- if (G_IS_DEV) {
- context.fillStyle = "#a10000";
- context.fillRect(0, 0, window.innerWidth * 3, window.innerHeight * 3);
- }
-
- // Compute optimal zoom level and atlas scale
- const zoomLevel = root.camera.zoomLevel;
- const lowQuality = root.app.settings.getAllSettings().lowQualityTextures;
- const effectiveZoomLevel =
- (zoomLevel / globalConfig.assetsDpi) * getDeviceDPI() * globalConfig.assetsSharpness;
-
- let desiredAtlasScale = "0.25";
- if (effectiveZoomLevel > 0.5 && !lowQuality) {
- desiredAtlasScale = ORIGINAL_SPRITE_SCALE;
- } else if (effectiveZoomLevel > 0.35 && !lowQuality) {
- desiredAtlasScale = "0.5";
- }
-
- // Construct parameters required for drawing
- const params = new DrawParameters({
- context: context,
- visibleRect: root.camera.getVisibleRect(),
- desiredAtlasScale,
- zoomLevel,
- root: root,
- });
-
- if (G_IS_DEV && globalConfig.debug.testCulling) {
- context.clearRect(0, 0, root.gameWidth, root.gameHeight);
- }
-
- // Transform to world space
-
- if (G_IS_DEV && globalConfig.debug.testClipping) {
- params.visibleRect = params.visibleRect.expandedInAllDirections(
- -200 / this.root.camera.zoomLevel
- );
- }
-
- root.camera.transform(context);
-
- assert(context.globalAlpha === 1.0, "Global alpha not 1 on frame start");
-
- // Update hud
- root.hud.update();
-
- // Main rendering order
- // -----
-
- const desiredOverlayAlpha = this.root.camera.getIsMapOverlayActive() ? 1 : 0;
- this.overlayAlpha = lerp(this.overlayAlpha, desiredOverlayAlpha, 0.25);
-
- // On low performance, skip the fade
- if (this.root.entityMgr.entities.length > 5000 || this.root.dynamicTickrate.averageFps < 50) {
- this.overlayAlpha = desiredOverlayAlpha;
- }
-
- if (this.overlayAlpha < 0.99) {
- // Background (grid, resources, etc)
- root.map.drawBackground(params);
-
- // Belt items
- systems.belt.drawBeltItems(params);
-
- // Miner & Static map entities etc.
- root.map.drawForeground(params);
-
- // HUB Overlay
- systems.hub.draw(params);
-
- // Green wires overlay
- if (root.hud.parts.wiresOverlay) {
- root.hud.parts.wiresOverlay.draw(params);
- }
-
- if (this.root.currentLayer === "wires") {
- // Static map entities
- root.map.drawWiresForegroundLayer(params);
- }
- }
-
- if (this.overlayAlpha > 0.01) {
- // Map overview
- context.globalAlpha = this.overlayAlpha;
- root.map.drawOverlay(params);
- context.globalAlpha = 1;
- }
-
- if (G_IS_DEV) {
- root.map.drawStaticEntityDebugOverlays(params);
- }
-
- if (G_IS_DEV && globalConfig.debug.renderBeltPaths) {
- systems.belt.drawBeltPathDebug(params);
- }
-
- // END OF GAME CONTENT
- // -----
-
- // Finally, draw the hud. Nothing should come after that
- root.hud.draw(params);
-
- assert(context.globalAlpha === 1.0, "Global alpha not 1 on frame end before restore");
-
- // Restore to screen space
- context.restore();
-
- // Restore parameters
- params.zoomLevel = 1;
- params.desiredAtlasScale = ORIGINAL_SPRITE_SCALE;
- params.visibleRect = new Rectangle(0, 0, this.root.gameWidth, this.root.gameHeight);
- if (G_IS_DEV && globalConfig.debug.testClipping) {
- params.visibleRect = params.visibleRect.expandedInAllDirections(-200);
- }
-
- // Draw overlays, those are screen space
- root.hud.drawOverlays(params);
-
- assert(context.globalAlpha === 1.0, "context.globalAlpha not 1 on frame end");
-
- if (G_IS_DEV && globalConfig.debug.simulateSlowRendering) {
- let sum = 0;
- for (let i = 0; i < 1e8; ++i) {
- sum += i;
- }
- if (Math.random() > 0.95) {
- console.log(sum);
- }
- }
-
- if (G_IS_DEV && globalConfig.debug.showAtlasInfo) {
- context.font = "13px GameFont";
- context.fillStyle = "blue";
- context.fillText(
- "Atlas: " +
- desiredAtlasScale +
- " / Zoom: " +
- round2Digits(zoomLevel) +
- " / Effective Zoom: " +
- round2Digits(effectiveZoomLevel),
- 20,
- 600
- );
-
- const stats = this.root.buffers.getStats();
-
- context.fillText(
- "Maintained Buffers: " +
- stats.rootKeys +
- " root keys / " +
- stats.subKeys +
- " buffers / VRAM: " +
- round2Digits(stats.vramBytes / (1024 * 1024)) +
- " MB",
- 20,
- 620
- );
- const internalStats = getBufferStats();
- context.fillText(
- "Total Buffers: " +
- internalStats.bufferCount +
- " buffers / " +
- internalStats.backlogSize +
- " backlog / " +
- internalStats.backlogKeys +
- " keys in backlog / VRAM " +
- round2Digits(internalStats.vramUsage / (1024 * 1024)) +
- " MB / Backlog " +
- round2Digits(internalStats.backlogVramUsage / (1024 * 1024)) +
- " MB / Created " +
- internalStats.numCreated +
- " / Reused " +
- internalStats.numReused,
- 20,
- 640
- );
- }
-
- if (G_IS_DEV && globalConfig.debug.testClipping) {
- context.strokeStyle = "red";
- context.lineWidth = 1;
- context.beginPath();
- context.rect(200, 200, this.root.gameWidth - 400, this.root.gameHeight - 400);
- context.stroke();
- }
- }
-}
+/* typehints:start */
+import { Application } from "../application";
+/* typehints:end */
+import { BufferMaintainer } from "../core/buffer_maintainer";
+import { getBufferStats } from "../core/buffer_utils";
+import { globalConfig } from "../core/config";
+import { getDeviceDPI, resizeHighDPICanvas } from "../core/dpi_manager";
+import { DrawParameters } from "../core/draw_parameters";
+import { gMetaBuildingRegistry } from "../core/global_registries";
+import { createLogger } from "../core/logging";
+import { Rectangle } from "../core/rectangle";
+import { ORIGINAL_SPRITE_SCALE } from "../core/sprites";
+import { lerp, randomInt, round2Digits } from "../core/utils";
+import { Vector } from "../core/vector";
+import { MOD_SIGNALS } from "../mods/mod_signals";
+import { Savegame } from "../savegame/savegame";
+import { SavegameSerializer } from "../savegame/savegame_serializer";
+import { AutomaticSave } from "./automatic_save";
+import { MetaHubBuilding } from "./buildings/hub";
+import { Camera } from "./camera";
+import { DynamicTickrate } from "./dynamic_tickrate";
+import { EntityManager } from "./entity_manager";
+import { GameMode } from "./game_mode";
+import { GameSystemManager } from "./game_system_manager";
+import { HubGoals } from "./hub_goals";
+import { GameHUD } from "./hud/hud";
+import { KeyActionMapper } from "./key_action_mapper";
+import { GameLogic } from "./logic";
+import { MapView } from "./map_view";
+import { defaultBuildingVariant } from "./meta_building";
+import { ProductionAnalytics } from "./production_analytics";
+import { GameRoot } from "./root";
+import { ShapeDefinitionManager } from "./shape_definition_manager";
+import { SoundProxy } from "./sound_proxy";
+import { GameTime } from "./time/game_time";
+
+const logger = createLogger("ingame/core");
+
+/**
+ * The core manages the root and represents the whole game. It wraps the root, since
+ * the root class is just a data holder.
+ */
+export class GameCore {
+ /** @param {Application} app */
+ constructor(app) {
+ this.app = app;
+
+ /** @type {GameRoot} */
+ this.root = null;
+
+ /**
+ * Set to true at the beginning of a logic update and cleared when its finished.
+ * This is to prevent doing a recursive logic update which can lead to unexpected
+ * behaviour.
+ */
+ this.duringLogicUpdate = false;
+
+ // Cached
+ this.boundInternalTick = this.updateLogic.bind(this);
+
+ /**
+ * Opacity of the overview alpha
+ * @TODO Doesn't belong here
+ */
+ this.overlayAlpha = 0;
+ }
+
+ /**
+ * Initializes the root object which stores all game related data. The state
+ * is required as a back reference (used sometimes)
+ * @param {import("../states/ingame").InGameState} parentState
+ * @param {Savegame} savegame
+ */
+ initializeRoot(parentState, savegame, gameModeId) {
+ logger.log("initializing root");
+
+ // Construct the root element, this is the data representation of the game
+ this.root = new GameRoot(this.app);
+ this.root.gameState = parentState;
+ this.root.keyMapper = parentState.keyActionMapper;
+ this.root.savegame = savegame;
+ this.root.gameWidth = this.app.screenWidth;
+ this.root.gameHeight = this.app.screenHeight;
+
+ // Initialize canvas element & context
+ this.internalInitCanvas();
+
+ // Members
+ const root = this.root;
+
+ // This isn't nice, but we need it right here
+ root.keyMapper = new KeyActionMapper(root, this.root.gameState.inputReceiver);
+
+ // Init game mode
+ root.gameMode = GameMode.create(root, gameModeId, parentState.creationPayload.gameModeParameters);
+
+ // Needs to come first
+ root.dynamicTickrate = new DynamicTickrate(root);
+
+ // Init classes
+ root.camera = new Camera(root);
+ root.map = new MapView(root);
+ root.logic = new GameLogic(root);
+ root.hud = new GameHUD(root);
+ root.time = new GameTime(root);
+ root.automaticSave = new AutomaticSave(root);
+ root.soundProxy = new SoundProxy(root);
+
+ // Init managers
+ root.entityMgr = new EntityManager(root);
+ root.systemMgr = new GameSystemManager(root);
+ root.shapeDefinitionMgr = new ShapeDefinitionManager(root);
+ root.hubGoals = new HubGoals(root);
+ root.productionAnalytics = new ProductionAnalytics(root);
+ root.buffers = new BufferMaintainer(root);
+
+ // Initialize the hud once everything is loaded
+ this.root.hud.initialize();
+
+ // Initial resize event, it might be possible that the screen
+ // resized later during init tho, which is why will emit it later
+ // again anyways
+ this.resize(this.app.screenWidth, this.app.screenHeight);
+
+ if (G_IS_DEV) {
+ // @ts-ignore
+ window.globalRoot = root;
+ }
+
+ // @todo Find better place
+ if (G_IS_DEV && globalConfig.debug.manualTickOnly) {
+ this.root.gameState.inputReceiver.keydown.add(key => {
+ if (key.keyCode === 84) {
+ // 'T'
+
+ // Extract current real time
+ this.root.time.updateRealtimeNow();
+
+ // Perform logic ticks
+ this.root.time.performTicks(this.root.dynamicTickrate.deltaMs, this.boundInternalTick);
+
+ // Update analytics
+ root.productionAnalytics.update();
+ }
+ });
+ }
+
+ logger.log("root initialized");
+ MOD_SIGNALS.gameInitialized.dispatch(root);
+ }
+
+ /**
+ * Initializes a new game, this means creating a new map and centering on the
+ * playerbase
+ * */
+ initNewGame() {
+ logger.log("Initializing new game");
+ this.root.gameIsFresh = true;
+ this.root.map.seed = randomInt(0, 100000);
+
+ if (!this.root.gameMode.hasHub()) {
+ return;
+ }
+
+ // Place the hub
+ const hub = gMetaBuildingRegistry.findByClass(MetaHubBuilding).createEntity({
+ root: this.root,
+ origin: new Vector(-2, -2),
+ rotation: 0,
+ originalRotation: 0,
+ rotationVariant: 0,
+ variant: defaultBuildingVariant,
+ });
+ this.root.map.placeStaticEntity(hub);
+ this.root.entityMgr.registerEntity(hub);
+ this.root.camera.center = new Vector(-5, 2).multiplyScalar(globalConfig.tileSize);
+ }
+
+ /**
+ * Inits an existing game by loading the raw savegame data and deserializing it.
+ * Also runs basic validity checks.
+ */
+ initExistingGame() {
+ logger.log("Initializing existing game");
+ const serializer = new SavegameSerializer();
+
+ try {
+ const status = serializer.deserialize(this.root.savegame.getCurrentDump(), this.root);
+ if (!status.isGood()) {
+ logger.error("savegame-deserialize-failed:" + status.reason);
+ return false;
+ }
+ } catch (ex) {
+ logger.error("Exception during deserialization:", ex);
+ return false;
+ }
+ this.root.gameIsFresh = false;
+ return true;
+ }
+
+ /**
+ * Initializes the render canvas
+ */
+ internalInitCanvas() {
+ logger.log("Creating new canvas");
+ const canvas = document.createElement("canvas");
+ canvas.id = "ingame_Canvas";
+ this.root.gameState.getDivElement().appendChild(canvas);
+ const context = canvas.getContext("2d", { alpha: false });
+
+ context.imageSmoothingEnabled = globalConfig.smoothing.smoothMainCanvas;
+ context.imageSmoothingQuality = globalConfig.smoothing.quality;
+
+ this.root.canvas = canvas;
+ this.root.context = context;
+ }
+
+ /**
+ * Destructs the root, freeing all resources
+ */
+ destruct() {
+ this.root.destruct();
+ delete this.root;
+ this.root = null;
+ this.app = null;
+ }
+
+ tick(deltaMs) {
+ const root = this.root;
+
+ // Extract current real time
+ root.time.updateRealtimeNow();
+
+ // Camera is always updated, no matter what
+ root.camera.update(deltaMs);
+
+ if (!(G_IS_DEV && globalConfig.debug.manualTickOnly)) {
+ // Perform logic ticks
+ this.root.time.performTicks(deltaMs, this.boundInternalTick);
+
+ // Update analytics
+ root.productionAnalytics.update();
+ }
+
+ // Update automatic save after everything finished
+ root.automaticSave.update();
+
+ return true;
+ }
+
+ shouldRender() {
+ if (this.root.queue.requireRedraw) {
+ return true;
+ }
+ if (this.root.hud.shouldPauseRendering()) {
+ return false;
+ }
+
+ // Do not render
+ if (!this.app.isRenderable()) {
+ return false;
+ }
+
+ return true;
+ }
+
+ updateLogic() {
+ const root = this.root;
+
+ root.dynamicTickrate.beginTick();
+
+ if (G_IS_DEV && globalConfig.debug.disableLogicTicks) {
+ root.dynamicTickrate.endTick();
+ return true;
+ }
+
+ this.duringLogicUpdate = true;
+
+ // Update entities, this removes destroyed entities
+ root.entityMgr.update();
+
+ // IMPORTANT: At this point, the game might be game over. Stop if this is the case
+ if (!this.root) {
+ logger.log("Root destructed, returning false");
+ root.dynamicTickrate.endTick();
+
+ return false;
+ }
+
+ root.systemMgr.update();
+ // root.particleMgr.update();
+
+ this.duringLogicUpdate = false;
+ root.dynamicTickrate.endTick();
+ return true;
+ }
+
+ resize(w, h) {
+ this.root.gameWidth = w;
+ this.root.gameHeight = h;
+ resizeHighDPICanvas(this.root.canvas, w, h, globalConfig.smoothing.smoothMainCanvas);
+ this.root.signals.resized.dispatch(w, h);
+ this.root.queue.requireRedraw = true;
+ }
+
+ postLoadHook() {
+ logger.log("Dispatching post load hook");
+ this.root.signals.postLoadHook.dispatch();
+
+ if (!this.root.gameIsFresh) {
+ // Also dispatch game restored hook on restored savegames
+ this.root.signals.gameRestored.dispatch();
+ }
+
+ this.root.gameInitialized = true;
+ }
+
+ draw() {
+ const root = this.root;
+ const systems = root.systemMgr.systems;
+
+ this.root.dynamicTickrate.onFrameRendered();
+
+ if (!this.shouldRender()) {
+ // Always update hud tho
+ root.hud.update();
+ return;
+ }
+
+ this.root.signals.gameFrameStarted.dispatch();
+
+ root.queue.requireRedraw = false;
+
+ // Gather context and save all state
+ const context = root.context;
+ context.save();
+ if (G_IS_DEV) {
+ context.fillStyle = "#a10000";
+ context.fillRect(0, 0, window.innerWidth * 3, window.innerHeight * 3);
+ }
+
+ // Compute optimal zoom level and atlas scale
+ const zoomLevel = root.camera.zoomLevel;
+ const lowQuality = root.app.settings.getAllSettings().lowQualityTextures;
+ const effectiveZoomLevel =
+ (zoomLevel / globalConfig.assetsDpi) * getDeviceDPI() * globalConfig.assetsSharpness;
+
+ let desiredAtlasScale = "0.25";
+ if (effectiveZoomLevel > 0.5 && !lowQuality) {
+ desiredAtlasScale = ORIGINAL_SPRITE_SCALE;
+ } else if (effectiveZoomLevel > 0.35 && !lowQuality) {
+ desiredAtlasScale = "0.5";
+ }
+
+ // Construct parameters required for drawing
+ const params = new DrawParameters({
+ context: context,
+ visibleRect: root.camera.getVisibleRect(),
+ desiredAtlasScale,
+ zoomLevel,
+ root: root,
+ });
+
+ if (G_IS_DEV && globalConfig.debug.testCulling) {
+ context.clearRect(0, 0, root.gameWidth, root.gameHeight);
+ }
+
+ // Transform to world space
+
+ if (G_IS_DEV && globalConfig.debug.testClipping) {
+ params.visibleRect = params.visibleRect.expandedInAllDirections(
+ -200 / this.root.camera.zoomLevel
+ );
+ }
+
+ root.camera.transform(context);
+
+ assert(context.globalAlpha === 1.0, "Global alpha not 1 on frame start");
+
+ // Update hud
+ root.hud.update();
+
+ // Main rendering order
+ // -----
+
+ const desiredOverlayAlpha = this.root.camera.getIsMapOverlayActive() ? 1 : 0;
+ this.overlayAlpha = lerp(this.overlayAlpha, desiredOverlayAlpha, 0.25);
+
+ // On low performance, skip the fade
+ if (this.root.entityMgr.entities.size > 5000 || this.root.dynamicTickrate.averageFps < 50) {
+ this.overlayAlpha = desiredOverlayAlpha;
+ }
+
+ if (this.overlayAlpha < 0.99) {
+ // Background (grid, resources, etc)
+ root.map.drawBackground(params);
+
+ // Belt items
+ systems.belt.drawBeltItems(params);
+
+ // Miner & Static map entities etc.
+ root.map.drawForeground(params);
+
+ // HUB Overlay
+ systems.hub.draw(params);
+
+ // Green wires overlay
+ if (root.hud.parts.wiresOverlay) {
+ root.hud.parts.wiresOverlay.draw(params);
+ }
+
+ if (this.root.currentLayer === "wires") {
+ // Static map entities
+ root.map.drawWiresForegroundLayer(params);
+ }
+ }
+
+ if (this.overlayAlpha > 0.01) {
+ // Map overview
+ context.globalAlpha = this.overlayAlpha;
+ root.map.drawOverlay(params);
+ context.globalAlpha = 1;
+ }
+
+ if (G_IS_DEV) {
+ root.map.drawStaticEntityDebugOverlays(params);
+ }
+
+ if (G_IS_DEV && globalConfig.debug.renderBeltPaths) {
+ systems.belt.drawBeltPathDebug(params);
+ }
+
+ // END OF GAME CONTENT
+ // -----
+
+ // Finally, draw the hud. Nothing should come after that
+ root.hud.draw(params);
+
+ assert(context.globalAlpha === 1.0, "Global alpha not 1 on frame end before restore");
+
+ // Restore to screen space
+ context.restore();
+
+ // Restore parameters
+ params.zoomLevel = 1;
+ params.desiredAtlasScale = ORIGINAL_SPRITE_SCALE;
+ params.visibleRect = new Rectangle(0, 0, this.root.gameWidth, this.root.gameHeight);
+ if (G_IS_DEV && globalConfig.debug.testClipping) {
+ params.visibleRect = params.visibleRect.expandedInAllDirections(-200);
+ }
+
+ // Draw overlays, those are screen space
+ root.hud.drawOverlays(params);
+
+ assert(context.globalAlpha === 1.0, "context.globalAlpha not 1 on frame end");
+
+ if (G_IS_DEV && globalConfig.debug.simulateSlowRendering) {
+ let sum = 0;
+ for (let i = 0; i < 1e8; ++i) {
+ sum += i;
+ }
+ if (Math.random() > 0.95) {
+ console.log(sum);
+ }
+ }
+
+ if (G_IS_DEV && globalConfig.debug.showAtlasInfo) {
+ context.font = "13px GameFont";
+ context.fillStyle = "blue";
+ context.fillText(
+ "Atlas: " +
+ desiredAtlasScale +
+ " / Zoom: " +
+ round2Digits(zoomLevel) +
+ " / Effective Zoom: " +
+ round2Digits(effectiveZoomLevel),
+ 20,
+ 600
+ );
+
+ const stats = this.root.buffers.getStats();
+
+ context.fillText(
+ "Maintained Buffers: " +
+ stats.rootKeys +
+ " root keys / " +
+ stats.subKeys +
+ " buffers / VRAM: " +
+ round2Digits(stats.vramBytes / (1024 * 1024)) +
+ " MB",
+ 20,
+ 620
+ );
+ const internalStats = getBufferStats();
+ context.fillText(
+ "Total Buffers: " +
+ internalStats.bufferCount +
+ " buffers / " +
+ internalStats.backlogSize +
+ " backlog / " +
+ internalStats.backlogKeys +
+ " keys in backlog / VRAM " +
+ round2Digits(internalStats.vramUsage / (1024 * 1024)) +
+ " MB / Backlog " +
+ round2Digits(internalStats.backlogVramUsage / (1024 * 1024)) +
+ " MB / Created " +
+ internalStats.numCreated +
+ " / Reused " +
+ internalStats.numReused,
+ 20,
+ 640
+ );
+ }
+
+ if (G_IS_DEV && globalConfig.debug.testClipping) {
+ context.strokeStyle = "red";
+ context.lineWidth = 1;
+ context.beginPath();
+ context.rect(200, 200, this.root.gameWidth - 400, this.root.gameHeight - 400);
+ context.stroke();
+ }
+ }
+}
diff --git a/src/js/game/dynamic_tickrate.js b/src/js/game/dynamic_tickrate.js
index c76fa2e1..c68a3ec9 100644
--- a/src/js/game/dynamic_tickrate.js
+++ b/src/js/game/dynamic_tickrate.js
@@ -1,129 +1,116 @@
-import { GameRoot } from "./root";
-import { createLogger } from "../core/logging";
-import { globalConfig } from "../core/config";
-
-const logger = createLogger("dynamic_tickrate");
-
-const fpsAccumulationTime = 1000;
-
-export class DynamicTickrate {
- /**
- *
- * @param {GameRoot} root
- */
- constructor(root) {
- this.root = root;
-
- this.currentTickStart = null;
- this.capturedTicks = [];
- this.averageTickDuration = 0;
-
- this.accumulatedFps = 0;
- this.accumulatedFpsLastUpdate = 0;
-
- this.averageFps = 60;
-
- const fixedRate = this.root.gameMode.getFixedTickrate();
- if (fixedRate) {
- logger.log("Setting fixed tickrate of", fixedRate);
- this.setTickRate(fixedRate);
- } else {
- this.setTickRate(this.root.app.settings.getDesiredFps());
-
- if (G_IS_DEV && globalConfig.debug.renderForTrailer) {
- this.setTickRate(300);
- }
- }
- }
-
- onFrameRendered() {
- ++this.accumulatedFps;
-
- const now = performance.now();
- const timeDuration = now - this.accumulatedFpsLastUpdate;
- if (timeDuration > fpsAccumulationTime) {
- const avgFps = (this.accumulatedFps / fpsAccumulationTime) * 1000;
- this.averageFps = avgFps;
- this.accumulatedFps = 0;
- this.accumulatedFpsLastUpdate = now;
- }
- }
-
- /**
- * Sets the tick rate to N updates per second
- * @param {number} rate
- */
- setTickRate(rate) {
- logger.log("Applying tick-rate of", rate);
- this.currentTickRate = rate;
- this.deltaMs = 1000.0 / this.currentTickRate;
- this.deltaSeconds = 1.0 / this.currentTickRate;
- }
-
- /**
- * Increases the tick rate marginally
- */
- increaseTickRate() {
- if (G_IS_DEV && globalConfig.debug.renderForTrailer) {
- return;
- }
-
- const desiredFps = this.root.app.settings.getDesiredFps();
- this.setTickRate(Math.round(Math.min(desiredFps, this.currentTickRate * 1.2)));
- }
-
- /**
- * Decreases the tick rate marginally
- */
- decreaseTickRate() {
- if (G_IS_DEV && globalConfig.debug.renderForTrailer) {
- return;
- }
-
- const desiredFps = this.root.app.settings.getDesiredFps();
- this.setTickRate(Math.round(Math.max(desiredFps / 2, this.currentTickRate * 0.8)));
- }
-
- /**
- * Call whenever a tick began
- */
- beginTick() {
- assert(this.currentTickStart === null, "BeginTick called twice");
- this.currentTickStart = performance.now();
-
- if (this.capturedTicks.length > this.currentTickRate * 2) {
- // Take only a portion of the ticks
- this.capturedTicks.sort();
- this.capturedTicks.splice(0, 10);
- this.capturedTicks.splice(this.capturedTicks.length - 11, 10);
-
- let average = 0;
- for (let i = 0; i < this.capturedTicks.length; ++i) {
- average += this.capturedTicks[i];
- }
- average /= this.capturedTicks.length;
-
- this.averageTickDuration = average;
-
- // Disabled for now: Dynamically adjusting tick rate
- // if (this.averageFps > desiredFps * 0.9) {
- // // if (average < maxTickDuration) {
- // this.increaseTickRate();
- // } else if (this.averageFps < desiredFps * 0.7) {
- // this.decreaseTickRate();
- // }
-
- this.capturedTicks = [];
- }
- }
-
- /**
- * Call whenever a tick ended
- */
- endTick() {
- assert(this.currentTickStart !== null, "EndTick called without BeginTick");
- const duration = performance.now() - this.currentTickStart;
- this.capturedTicks.push(duration);
- this.currentTickStart = null;
- }
-}
+import { createLogger } from "../core/logging";
+import { GameRoot } from "./root";
+
+const logger = createLogger("dynamic_tickrate");
+
+const fpsAccumulationTime = 1000;
+
+export class DynamicTickrate {
+ /**
+ *
+ * @param {GameRoot} root
+ */
+ constructor(root) {
+ this.root = root;
+
+ this.currentTickStart = null;
+ this.capturedTicks = [];
+ this.averageTickDuration = 0;
+
+ this.accumulatedFps = 0;
+ this.accumulatedFpsLastUpdate = 0;
+
+ this.averageFps = 60;
+
+ const fixedRate = this.root.gameMode.getFixedTickrate();
+ if (fixedRate) {
+ logger.log("Setting fixed tickrate of", fixedRate);
+ this.setTickRate(fixedRate);
+ } else {
+ this.setTickRate(this.root.app.settings.getDesiredFps());
+ }
+ }
+
+ onFrameRendered() {
+ ++this.accumulatedFps;
+
+ const now = performance.now();
+ const timeDuration = now - this.accumulatedFpsLastUpdate;
+ if (timeDuration > fpsAccumulationTime) {
+ const avgFps = (this.accumulatedFps / fpsAccumulationTime) * 1000;
+ this.averageFps = avgFps;
+ this.accumulatedFps = 0;
+ this.accumulatedFpsLastUpdate = now;
+ }
+ }
+
+ /**
+ * Sets the tick rate to N updates per second
+ * @param {number} rate
+ */
+ setTickRate(rate) {
+ logger.log("Applying tick-rate of", rate);
+ this.currentTickRate = rate;
+ this.deltaMs = 1000.0 / this.currentTickRate;
+ this.deltaSeconds = 1.0 / this.currentTickRate;
+ }
+
+ /**
+ * Increases the tick rate marginally
+ */
+ increaseTickRate() {
+ const desiredFps = this.root.app.settings.getDesiredFps();
+ this.setTickRate(Math.round(Math.min(desiredFps, this.currentTickRate * 1.2)));
+ }
+
+ /**
+ * Decreases the tick rate marginally
+ */
+ decreaseTickRate() {
+ const desiredFps = this.root.app.settings.getDesiredFps();
+ this.setTickRate(Math.round(Math.max(desiredFps / 2, this.currentTickRate * 0.8)));
+ }
+
+ /**
+ * Call whenever a tick began
+ */
+ beginTick() {
+ assert(this.currentTickStart === null, "BeginTick called twice");
+ this.currentTickStart = performance.now();
+
+ if (this.capturedTicks.length > this.currentTickRate * 2) {
+ // Take only a portion of the ticks
+ this.capturedTicks.sort();
+ this.capturedTicks.splice(0, 10);
+ this.capturedTicks.splice(this.capturedTicks.length - 11, 10);
+
+ let average = 0;
+ for (let i = 0; i < this.capturedTicks.length; ++i) {
+ average += this.capturedTicks[i];
+ }
+ average /= this.capturedTicks.length;
+
+ this.averageTickDuration = average;
+
+ // Disabled for now: Dynamically adjusting tick rate
+ // if (this.averageFps > desiredFps * 0.9) {
+ // // if (average < maxTickDuration) {
+ // this.increaseTickRate();
+ // } else if (this.averageFps < desiredFps * 0.7) {
+ // this.decreaseTickRate();
+ // }
+
+ this.capturedTicks = [];
+ }
+ }
+
+ /**
+ * Call whenever a tick ended
+ */
+ endTick() {
+ assert(this.currentTickStart !== null, "EndTick called without BeginTick");
+ const duration = performance.now() - this.currentTickStart;
+ this.capturedTicks.push(duration);
+ this.currentTickStart = null;
+ }
+}
diff --git a/src/js/game/entity.js b/src/js/game/entity.js
index 9acaf26b..e9373918 100644
--- a/src/js/game/entity.js
+++ b/src/js/game/entity.js
@@ -1,232 +1,232 @@
-/* typehints:start */
-import { DrawParameters } from "../core/draw_parameters";
-import { Component } from "./component";
-/* typehints:end */
-
-import { GameRoot } from "./root";
-import { globalConfig } from "../core/config";
-import { enumDirectionToVector, enumDirectionToAngle } from "../core/vector";
-import { BasicSerializableObject, types } from "../savegame/serialization";
-import { EntityComponentStorage } from "./entity_components";
-import { Loader } from "../core/loader";
-import { drawRotatedSprite } from "../core/draw_utils";
-import { gComponentRegistry } from "../core/global_registries";
-import { getBuildingDataFromCode } from "./building_codes";
-
-export class Entity extends BasicSerializableObject {
- /**
- * @param {GameRoot} root
- */
- constructor(root) {
- super();
-
- /**
- * Handle to the global game root
- */
- this.root = root;
-
- /**
- * The components of the entity
- */
- this.components = new EntityComponentStorage();
-
- /**
- * Whether this entity was registered on the @see EntityManager so far
- */
- this.registered = false;
-
- /**
- * On which layer this entity is
- * @type {Layer}
- */
- this.layer = "regular";
-
- /**
- * Internal entity unique id, set by the @see EntityManager
- */
- this.uid = 0;
-
- /* typehints:start */
-
- /**
- * Stores if this entity is destroyed, set by the @see EntityManager
- * @type {boolean} */
- this.destroyed;
-
- /**
- * Stores if this entity is queued to get destroyed in the next tick
- * of the @see EntityManager
- * @type {boolean} */
- this.queuedForDestroy;
-
- /**
- * Stores the reason why this entity was destroyed
- * @type {string} */
- this.destroyReason;
-
- /* typehints:end */
- }
-
- static getId() {
- return "Entity";
- }
-
- /**
- * @see BasicSerializableObject.getSchema
- * @returns {import("../savegame/serialization").Schema}
- */
- static getSchema() {
- return {
- uid: types.uint,
- components: types.keyValueMap(types.objData(gComponentRegistry), false),
- };
- }
-
- /**
- * Returns a clone of this entity
- */
- clone() {
- const staticComp = this.components.StaticMapEntity;
- const buildingData = getBuildingDataFromCode(staticComp.code);
-
- const clone = buildingData.metaInstance.createEntity({
- root: this.root,
- origin: staticComp.origin,
- originalRotation: staticComp.originalRotation,
- rotation: staticComp.rotation,
- rotationVariant: buildingData.rotationVariant,
- variant: buildingData.variant,
- });
-
- for (const key in this.components) {
- /** @type {Component} */ (this.components[key]).copyAdditionalStateTo(clone.components[key]);
- }
-
- return clone;
- }
-
- /**
- * Adds a new component, only possible until the entity is registered on the entity manager,
- * after that use @see EntityManager.addDynamicComponent
- * @param {Component} componentInstance
- * @param {boolean} force Used by the entity manager. Internal parameter, do not change
- */
- addComponent(componentInstance, force = false) {
- if (!force && this.registered) {
- this.root.entityMgr.attachDynamicComponent(this, componentInstance);
- return;
- }
- assert(force || !this.registered, "Entity already registered, use EntityManager.addDynamicComponent");
- const id = /** @type {typeof Component} */ (componentInstance.constructor).getId();
- assert(!this.components[id], "Component already present");
- this.components[id] = componentInstance;
- }
-
- /**
- * Removes a given component, only possible until the entity is registered on the entity manager,
- * after that use @see EntityManager.removeDynamicComponent
- * @param {typeof Component} componentClass
- * @param {boolean} force
- */
- removeComponent(componentClass, force = false) {
- if (!force && this.registered) {
- this.root.entityMgr.removeDynamicComponent(this, componentClass);
- return;
- }
- assert(
- force || !this.registered,
- "Entity already registered, use EntityManager.removeDynamicComponent"
- );
- const id = componentClass.getId();
- assert(this.components[id], "Component does not exist on entity");
- delete this.components[id];
- }
-
- /**
- * Draws the entity, to override use @see Entity.drawImpl
- * @param {DrawParameters} parameters
- */
- drawDebugOverlays(parameters) {
- const context = parameters.context;
- const staticComp = this.components.StaticMapEntity;
-
- if (G_IS_DEV && staticComp && globalConfig.debug.showEntityBounds) {
- if (staticComp) {
- const transformed = staticComp.getTileSpaceBounds();
- context.strokeStyle = "rgba(255, 0, 0, 0.5)";
- context.lineWidth = 2;
- // const boundsSize = 20;
- context.beginPath();
- context.rect(
- transformed.x * globalConfig.tileSize,
- transformed.y * globalConfig.tileSize,
- transformed.w * globalConfig.tileSize,
- transformed.h * globalConfig.tileSize
- );
- context.stroke();
- }
- }
-
- if (G_IS_DEV && staticComp && globalConfig.debug.showAcceptorEjectors) {
- const ejectorComp = this.components.ItemEjector;
-
- if (ejectorComp) {
- const ejectorSprite = Loader.getSprite("sprites/debug/ejector_slot.png");
- for (let i = 0; i < ejectorComp.slots.length; ++i) {
- const slot = ejectorComp.slots[i];
- const slotTile = staticComp.localTileToWorld(slot.pos);
- const direction = staticComp.localDirectionToWorld(slot.direction);
- const directionVector = enumDirectionToVector[direction];
- const angle = Math.radians(enumDirectionToAngle[direction]);
-
- context.globalAlpha = slot.item ? 1 : 0.2;
- drawRotatedSprite({
- parameters,
- sprite: ejectorSprite,
- x: (slotTile.x + 0.5 + directionVector.x * 0.37) * globalConfig.tileSize,
- y: (slotTile.y + 0.5 + directionVector.y * 0.37) * globalConfig.tileSize,
- angle,
- size: globalConfig.tileSize * 0.25,
- });
- }
- }
- const acceptorComp = this.components.ItemAcceptor;
-
- if (acceptorComp) {
- const acceptorSprite = Loader.getSprite("sprites/misc/acceptor_slot.png");
- for (let i = 0; i < acceptorComp.slots.length; ++i) {
- const slot = acceptorComp.slots[i];
- const slotTile = staticComp.localTileToWorld(slot.pos);
- const direction = staticComp.localDirectionToWorld(slot.direction);
- const directionVector = enumDirectionToVector[direction];
- const angle = Math.radians(enumDirectionToAngle[direction] + 180);
- context.globalAlpha = 0.4;
- drawRotatedSprite({
- parameters,
- sprite: acceptorSprite,
- x: (slotTile.x + 0.5 + directionVector.x * 0.37) * globalConfig.tileSize,
- y: (slotTile.y + 0.5 + directionVector.y * 0.37) * globalConfig.tileSize,
- angle,
- size: globalConfig.tileSize * 0.25,
- });
- }
- }
-
- context.globalAlpha = 1;
- }
- // this.drawImpl(parameters);
- }
-
- ///// Helper interfaces
-
- ///// Interface to override by subclasses
-
- /**
- * override, should draw the entity
- * @param {DrawParameters} parameters
- * @abstract
- */
- drawImpl(parameters) {
- abstract;
- }
-}
+/* typehints:start */
+import { DrawParameters } from "../core/draw_parameters";
+import { Component } from "./component";
+/* typehints:end */
+
+import { GameRoot } from "./root";
+import { globalConfig } from "../core/config";
+import { enumDirectionToVector, enumDirectionToAngle } from "../core/vector";
+import { BasicSerializableObject, types } from "../savegame/serialization";
+import { Loader } from "../core/loader";
+import { drawRotatedSprite } from "../core/draw_utils";
+import { gComponentRegistry } from "../core/global_registries";
+import { getBuildingDataFromCode } from "./building_codes";
+
+export class Entity extends BasicSerializableObject {
+ /**
+ * @param {GameRoot} root
+ */
+ constructor(root) {
+ super();
+
+ /**
+ * Handle to the global game root
+ */
+ this.root = root;
+
+ /**
+ * The components of the entity
+ * @type {import("./entity_components").EntityComponentStorage}
+ */
+ this.components = {};
+
+ /**
+ * Whether this entity was registered on the @see EntityManager so far
+ */
+ this.registered = false;
+
+ /**
+ * On which layer this entity is
+ * @type {Layer}
+ */
+ this.layer = "regular";
+
+ /**
+ * Internal entity unique id, set by the @see EntityManager
+ */
+ this.uid = 0;
+
+ /* typehints:start */
+
+ /**
+ * Stores if this entity is destroyed, set by the @see EntityManager
+ * @type {boolean} */
+ this.destroyed;
+
+ /**
+ * Stores if this entity is queued to get destroyed in the next tick
+ * of the @see EntityManager
+ * @type {boolean} */
+ this.queuedForDestroy;
+
+ /**
+ * Stores the reason why this entity was destroyed
+ * @type {string} */
+ this.destroyReason;
+
+ /* typehints:end */
+ }
+
+ static getId() {
+ return "Entity";
+ }
+
+ /**
+ * @see BasicSerializableObject.getSchema
+ * @returns {import("../savegame/serialization").Schema}
+ */
+ static getSchema() {
+ return {
+ uid: types.uint,
+ components: types.keyValueMap(types.objData(gComponentRegistry), false),
+ };
+ }
+
+ /**
+ * Returns a clone of this entity
+ */
+ clone() {
+ const staticComp = this.components.StaticMapEntity;
+ const buildingData = getBuildingDataFromCode(staticComp.code);
+
+ const clone = buildingData.metaInstance.createEntity({
+ root: this.root,
+ origin: staticComp.origin,
+ originalRotation: staticComp.originalRotation,
+ rotation: staticComp.rotation,
+ rotationVariant: buildingData.rotationVariant,
+ variant: buildingData.variant,
+ });
+
+ for (const key in this.components) {
+ this.components[key].copyAdditionalStateTo(clone.components[key]);
+ }
+
+ return clone;
+ }
+
+ /**
+ * Adds a new component, only possible until the entity is registered on the entity manager,
+ * after that use @see EntityManager.addDynamicComponent
+ * @param {Component} componentInstance
+ * @param {boolean} force Used by the entity manager. Internal parameter, do not change
+ */
+ addComponent(componentInstance, force = false) {
+ if (!force && this.registered) {
+ this.root.entityMgr.attachDynamicComponent(this, componentInstance);
+ return;
+ }
+ assert(force || !this.registered, "Entity already registered, use EntityManager.addDynamicComponent");
+ const id = /** @type {typeof Component} */ (componentInstance.constructor).getId();
+ assert(!this.components[id], "Component already present");
+ this.components[id] = componentInstance;
+ }
+
+ /**
+ * Removes a given component, only possible until the entity is registered on the entity manager,
+ * after that use @see EntityManager.removeDynamicComponent
+ * @param {typeof Component} componentClass
+ * @param {boolean} force
+ */
+ removeComponent(componentClass, force = false) {
+ if (!force && this.registered) {
+ this.root.entityMgr.removeDynamicComponent(this, componentClass);
+ return;
+ }
+ assert(
+ force || !this.registered,
+ "Entity already registered, use EntityManager.removeDynamicComponent"
+ );
+ const id = componentClass.getId();
+ assert(this.components[id], "Component does not exist on entity");
+ delete this.components[id];
+ }
+
+ /**
+ * Draws the entity, to override use @see Entity.drawImpl
+ * @param {DrawParameters} parameters
+ */
+ drawDebugOverlays(parameters) {
+ const context = parameters.context;
+ const staticComp = this.components.StaticMapEntity;
+
+ if (G_IS_DEV && staticComp && globalConfig.debug.showEntityBounds) {
+ if (staticComp) {
+ const transformed = staticComp.getTileSpaceBounds();
+ context.strokeStyle = "rgba(255, 0, 0, 0.5)";
+ context.lineWidth = 2;
+ // const boundsSize = 20;
+ context.beginPath();
+ context.rect(
+ transformed.x * globalConfig.tileSize,
+ transformed.y * globalConfig.tileSize,
+ transformed.w * globalConfig.tileSize,
+ transformed.h * globalConfig.tileSize
+ );
+ context.stroke();
+ }
+ }
+
+ if (G_IS_DEV && staticComp && globalConfig.debug.showAcceptorEjectors) {
+ const ejectorComp = this.components.ItemEjector;
+
+ if (ejectorComp) {
+ const ejectorSprite = Loader.getSprite("sprites/debug/ejector_slot.png");
+ for (let i = 0; i < ejectorComp.slots.length; ++i) {
+ const slot = ejectorComp.slots[i];
+ const slotTile = staticComp.localTileToWorld(slot.pos);
+ const direction = staticComp.localDirectionToWorld(slot.direction);
+ const directionVector = enumDirectionToVector[direction];
+ const angle = Math.radians(enumDirectionToAngle[direction]);
+
+ context.globalAlpha = slot.item ? 1 : 0.2;
+ drawRotatedSprite({
+ parameters,
+ sprite: ejectorSprite,
+ x: (slotTile.x + 0.5 + directionVector.x * 0.37) * globalConfig.tileSize,
+ y: (slotTile.y + 0.5 + directionVector.y * 0.37) * globalConfig.tileSize,
+ angle,
+ size: globalConfig.tileSize * 0.25,
+ });
+ }
+ }
+ const acceptorComp = this.components.ItemAcceptor;
+
+ if (acceptorComp) {
+ const acceptorSprite = Loader.getSprite("sprites/misc/acceptor_slot.png");
+ for (let i = 0; i < acceptorComp.slots.length; ++i) {
+ const slot = acceptorComp.slots[i];
+ const slotTile = staticComp.localTileToWorld(slot.pos);
+ const direction = staticComp.localDirectionToWorld(slot.direction);
+ const directionVector = enumDirectionToVector[direction];
+ const angle = Math.radians(enumDirectionToAngle[direction] + 180);
+ context.globalAlpha = 0.4;
+ drawRotatedSprite({
+ parameters,
+ sprite: acceptorSprite,
+ x: (slotTile.x + 0.5 + directionVector.x * 0.37) * globalConfig.tileSize,
+ y: (slotTile.y + 0.5 + directionVector.y * 0.37) * globalConfig.tileSize,
+ angle,
+ size: globalConfig.tileSize * 0.25,
+ });
+ }
+ }
+
+ context.globalAlpha = 1;
+ }
+ // this.drawImpl(parameters);
+ }
+
+ ///// Helper interfaces
+
+ ///// Interface to override by subclasses
+
+ /**
+ * override, should draw the entity
+ * @param {DrawParameters} parameters
+ * @abstract
+ */
+ drawImpl(parameters) {
+ abstract;
+ }
+}
diff --git a/src/js/game/entity_components.js b/src/js/game/entity_components.js
deleted file mode 100644
index 163be9f9..00000000
--- a/src/js/game/entity_components.js
+++ /dev/null
@@ -1,98 +0,0 @@
-/* typehints:start */
-import { BeltComponent } from "./components/belt";
-import { BeltUnderlaysComponent } from "./components/belt_underlays";
-import { HubComponent } from "./components/hub";
-import { ItemAcceptorComponent } from "./components/item_acceptor";
-import { ItemEjectorComponent } from "./components/item_ejector";
-import { ItemProcessorComponent } from "./components/item_processor";
-import { MinerComponent } from "./components/miner";
-import { StaticMapEntityComponent } from "./components/static_map_entity";
-import { StorageComponent } from "./components/storage";
-import { UndergroundBeltComponent } from "./components/underground_belt";
-import { WiredPinsComponent } from "./components/wired_pins";
-import { WireComponent } from "./components/wire";
-import { ConstantSignalComponent } from "./components/constant_signal";
-import { LogicGateComponent } from "./components/logic_gate";
-import { LeverComponent } from "./components/lever";
-import { WireTunnelComponent } from "./components/wire_tunnel";
-import { DisplayComponent } from "./components/display";
-import { BeltReaderComponent } from "./components/belt_reader";
-import { FilterComponent } from "./components/filter";
-import { ItemProducerComponent } from "./components/item_producer";
-import { GoalAcceptorComponent } from "./components/goal_acceptor";
-/* typehints:end */
-
-/**
- * Typedefs for all entity components. These are not actually present on the entity,
- * thus they are undefined by default
- */
-export class EntityComponentStorage {
- constructor() {
- /* typehints:start */
-
- /** @type {StaticMapEntityComponent} */
- this.StaticMapEntity;
-
- /** @type {BeltComponent} */
- this.Belt;
-
- /** @type {ItemEjectorComponent} */
- this.ItemEjector;
-
- /** @type {ItemAcceptorComponent} */
- this.ItemAcceptor;
-
- /** @type {MinerComponent} */
- this.Miner;
-
- /** @type {ItemProcessorComponent} */
- this.ItemProcessor;
-
- /** @type {UndergroundBeltComponent} */
- this.UndergroundBelt;
-
- /** @type {HubComponent} */
- this.Hub;
-
- /** @type {StorageComponent} */
- this.Storage;
-
- /** @type {WiredPinsComponent} */
- this.WiredPins;
-
- /** @type {BeltUnderlaysComponent} */
- this.BeltUnderlays;
-
- /** @type {WireComponent} */
- this.Wire;
-
- /** @type {ConstantSignalComponent} */
- this.ConstantSignal;
-
- /** @type {LogicGateComponent} */
- this.LogicGate;
-
- /** @type {LeverComponent} */
- this.Lever;
-
- /** @type {WireTunnelComponent} */
- this.WireTunnel;
-
- /** @type {DisplayComponent} */
- this.Display;
-
- /** @type {BeltReaderComponent} */
- this.BeltReader;
-
- /** @type {FilterComponent} */
- this.Filter;
-
- /** @type {ItemProducerComponent} */
- this.ItemProducer;
-
- /** @type {GoalAcceptorComponent} */
- this.GoalAcceptor;
-
- /* typehints:end */
- }
-}
diff --git a/src/js/game/entity_components.ts b/src/js/game/entity_components.ts
new file mode 100644
index 00000000..e057dcf4
--- /dev/null
+++ b/src/js/game/entity_components.ts
@@ -0,0 +1,51 @@
+import type { BeltComponent } from "./components/belt";
+import type { BeltUnderlaysComponent } from "./components/belt_underlays";
+import type { HubComponent } from "./components/hub";
+import type { ItemAcceptorComponent } from "./components/item_acceptor";
+import type { ItemEjectorComponent } from "./components/item_ejector";
+import type { ItemProcessorComponent } from "./components/item_processor";
+import type { MinerComponent } from "./components/miner";
+import type { StaticMapEntityComponent } from "./components/static_map_entity";
+import type { StorageComponent } from "./components/storage";
+import type { UndergroundBeltComponent } from "./components/underground_belt";
+import type { WiredPinsComponent } from "./components/wired_pins";
+import type { WireComponent } from "./components/wire";
+import type { ConstantSignalComponent } from "./components/constant_signal";
+import type { LogicGateComponent } from "./components/logic_gate";
+import type { LeverComponent } from "./components/lever";
+import type { WireTunnelComponent } from "./components/wire_tunnel";
+import type { DisplayComponent } from "./components/display";
+import type { BeltReaderComponent } from "./components/belt_reader";
+import type { FilterComponent } from "./components/filter";
+import type { ItemProducerComponent } from "./components/item_producer";
+import type { GoalAcceptorComponent } from "./components/goal_acceptor";
+import type { Component } from "./component";
+
+/**
+ * Typedefs for all entity components.
+ */
+export interface EntityComponentStorage {
+ StaticMapEntity?: StaticMapEntityComponent;
+ Belt?: BeltComponent;
+ ItemEjector?: ItemEjectorComponent;
+ ItemAcceptor?: ItemAcceptorComponent;
+ Miner?: MinerComponent;
+ ItemProcessor?: ItemProcessorComponent;
+ UndergroundBelt?: UndergroundBeltComponent;
+ Hub?: HubComponent;
+ Storage?: StorageComponent;
+ WiredPins?: WiredPinsComponent;
+ BeltUnderlays?: BeltUnderlaysComponent;
+ Wire?: WireComponent;
+ ConstantSignal?: ConstantSignalComponent;
+ LogicGate?: LogicGateComponent;
+ Lever?: LeverComponent;
+ WireTunnel?: WireTunnelComponent;
+ Display?: DisplayComponent;
+ BeltReader?: BeltReaderComponent;
+ Filter?: FilterComponent;
+ ItemProducer?: ItemProducerComponent;
+ GoalAcceptor?: GoalAcceptorComponent;
+
+ [k: string]: Component;
+}
diff --git a/src/js/game/entity_manager.js b/src/js/game/entity_manager.ts
similarity index 50%
rename from src/js/game/entity_manager.js
rename to src/js/game/entity_manager.ts
index b4101fc8..756f5bce 100644
--- a/src/js/game/entity_manager.js
+++ b/src/js/game/entity_manager.ts
@@ -1,241 +1,218 @@
-import { arrayDeleteValue, newEmptyMap, fastArrayDeleteValue } from "../core/utils";
-import { Component } from "./component";
-import { GameRoot } from "./root";
-import { Entity } from "./entity";
-import { BasicSerializableObject, types } from "../savegame/serialization";
-import { createLogger } from "../core/logging";
-import { globalConfig } from "../core/config";
-
-const logger = createLogger("entity_manager");
-
-// Manages all entities
-
-// NOTICE: We use arrayDeleteValue instead of fastArrayDeleteValue since that does not preserve the order
-// This is slower but we need it for the street path generation
-
-export class EntityManager extends BasicSerializableObject {
- constructor(root) {
- super();
-
- /** @type {GameRoot} */
- this.root = root;
-
- /** @type {Array} */
- this.entities = [];
-
- // We store a separate list with entities to destroy, since we don't destroy
- // them instantly
- /** @type {Array} */
- this.destroyList = [];
-
- // Store a map from componentid to entities - This is used by the game system
- // for faster processing
- /** @type {Object.>} */
- this.componentToEntity = newEmptyMap();
-
- // Store the next uid to use
- this.nextUid = 10000;
- }
-
- static getId() {
- return "EntityManager";
- }
-
- static getSchema() {
- return {
- nextUid: types.uint,
- };
- }
-
- getStatsText() {
- return this.entities.length + " entities [" + this.destroyList.length + " to kill]";
- }
-
- // Main update
- update() {
- this.processDestroyList();
- }
-
- /**
- * Registers a new entity
- * @param {Entity} entity
- * @param {number=} uid Optional predefined uid
- */
- registerEntity(entity, uid = null) {
- if (G_IS_DEV && !globalConfig.debug.disableSlowAsserts) {
- assert(this.entities.indexOf(entity) < 0, `RegisterEntity() called twice for entity ${entity}`);
- }
- assert(!entity.destroyed, `Attempting to register destroyed entity ${entity}`);
-
- if (G_IS_DEV && !globalConfig.debug.disableSlowAsserts && uid !== null) {
- assert(!this.findByUid(uid, false), "Entity uid already taken: " + uid);
- assert(uid >= 0 && uid < Number.MAX_SAFE_INTEGER, "Invalid uid passed: " + uid);
- }
-
- this.entities.push(entity);
-
- // Register into the componentToEntity map
- for (const componentId in entity.components) {
- if (entity.components[componentId]) {
- if (this.componentToEntity[componentId]) {
- this.componentToEntity[componentId].push(entity);
- } else {
- this.componentToEntity[componentId] = [entity];
- }
- }
- }
-
- // Give each entity a unique id
- entity.uid = uid ? uid : this.generateUid();
- entity.registered = true;
-
- this.root.signals.entityAdded.dispatch(entity);
- }
-
- /**
- * Generates a new uid
- * @returns {number}
- */
- generateUid() {
- return this.nextUid++;
- }
-
- /**
- * Call to attach a new component after the creation of the entity
- * @param {Entity} entity
- * @param {Component} component
- */
- attachDynamicComponent(entity, component) {
- entity.addComponent(component, true);
- const componentId = /** @type {typeof Component} */ (component.constructor).getId();
- if (this.componentToEntity[componentId]) {
- this.componentToEntity[componentId].push(entity);
- } else {
- this.componentToEntity[componentId] = [entity];
- }
- this.root.signals.entityGotNewComponent.dispatch(entity);
- }
-
- /**
- * Call to remove a component after the creation of the entity
- * @param {Entity} entity
- * @param {typeof Component} component
- */
- removeDynamicComponent(entity, component) {
- entity.removeComponent(component, true);
- const componentId = /** @type {typeof Component} */ (component.constructor).getId();
-
- fastArrayDeleteValue(this.componentToEntity[componentId], entity);
- this.root.signals.entityComponentRemoved.dispatch(entity);
- }
-
- /**
- * Finds an entity buy its uid, kinda slow since it loops over all entities
- * @param {number} uid
- * @param {boolean=} errorWhenNotFound
- * @returns {Entity}
- */
- findByUid(uid, errorWhenNotFound = true) {
- const arr = this.entities;
- for (let i = 0, len = arr.length; i < len; ++i) {
- const entity = arr[i];
- if (entity.uid === uid) {
- if (entity.queuedForDestroy || entity.destroyed) {
- if (errorWhenNotFound) {
- logger.warn("Entity with UID", uid, "not found (destroyed)");
- }
- return null;
- }
- return entity;
- }
- }
- if (errorWhenNotFound) {
- logger.warn("Entity with UID", uid, "not found");
- }
- return null;
- }
-
- /**
- * Returns a map which gives a mapping from UID to Entity.
- * This map is not updated.
- *
- * @returns {Map}
- */
- getFrozenUidSearchMap() {
- const result = new Map();
- const array = this.entities;
- for (let i = 0, len = array.length; i < len; ++i) {
- const entity = array[i];
- if (!entity.queuedForDestroy && !entity.destroyed) {
- result.set(entity.uid, entity);
- }
- }
- return result;
- }
-
- /**
- * Returns all entities having the given component
- * @param {typeof Component} componentHandle
- * @returns {Array} entities
- */
- getAllWithComponent(componentHandle) {
- return this.componentToEntity[componentHandle.getId()] || [];
- }
-
- /**
- * Unregisters all components of an entity from the component to entity mapping
- * @param {Entity} entity
- */
- unregisterEntityComponents(entity) {
- for (const componentId in entity.components) {
- if (entity.components[componentId]) {
- arrayDeleteValue(this.componentToEntity[componentId], entity);
- }
- }
- }
-
- // Processes the entities to destroy and actually destroys them
- /* eslint-disable max-statements */
- processDestroyList() {
- for (let i = 0; i < this.destroyList.length; ++i) {
- const entity = this.destroyList[i];
-
- // Remove from entities list
- arrayDeleteValue(this.entities, entity);
-
- // Remove from componentToEntity list
- this.unregisterEntityComponents(entity);
-
- entity.registered = false;
- entity.destroyed = true;
-
- this.root.signals.entityDestroyed.dispatch(entity);
- }
-
- this.destroyList = [];
- }
-
- /**
- * Queues an entity for destruction
- * @param {Entity} entity
- */
- destroyEntity(entity) {
- if (entity.destroyed) {
- logger.error("Tried to destroy already destroyed entity:", entity.uid);
- return;
- }
-
- if (entity.queuedForDestroy) {
- logger.error("Trying to destroy entity which is already queued for destroy!", entity.uid);
- return;
- }
-
- if (this.destroyList.indexOf(entity) < 0) {
- this.destroyList.push(entity);
- entity.queuedForDestroy = true;
- this.root.signals.entityQueuedForDestroy.dispatch(entity);
- } else {
- assert(false, "Trying to destroy entity twice");
- }
- }
-}
+import { globalConfig } from "../core/config";
+import { createLogger } from "../core/logging";
+import { newEmptyMap } from "../core/utils";
+import { BasicSerializableObject, types } from "../savegame/serialization";
+import { Component } from "./component";
+import { Entity } from "./entity";
+import { GameRoot } from "./root";
+
+const logger = createLogger("entity_manager");
+
+// Manages all entities
+
+// NOTICE: We use arrayDeleteValue instead of fastArrayDeleteValue since that does not preserve the order
+// This is slower but we need it for the street path generation
+
+export class EntityManager extends BasicSerializableObject {
+ readonly root: GameRoot;
+ readonly entities = new Map();
+
+ // We store a separate list with entities to destroy, since we don't destroy
+ // them instantly
+ private destroyList: Entity[] = [];
+
+ // Store a map from componentid to entities - This is used by the game system
+ // for faster processing
+ private readonly componentToEntity: Record> = newEmptyMap();
+
+ // Store the next uid to use
+ private nextUid = 10000;
+
+ constructor(root: GameRoot) {
+ super();
+ this.root = root;
+ }
+
+ static getId() {
+ return "EntityManager";
+ }
+
+ static getSchema() {
+ return {
+ nextUid: types.uint,
+ };
+ }
+
+ getStatsText() {
+ return this.entities.size + " entities [" + this.destroyList.length + " to kill]";
+ }
+
+ // Main update
+ update() {
+ this.processDestroyList();
+ }
+
+ /**
+ * Registers a new entity
+ * @param uid Optional predefined uid
+ */
+ registerEntity(entity: Entity, uid = this.generateUid()) {
+ if (G_IS_DEV && !globalConfig.debug.disableSlowAsserts) {
+ assert(
+ this.entities.get(entity.uid) !== entity,
+ `RegisterEntity() called twice for entity ${entity}`
+ );
+ }
+ assert(!entity.destroyed, `Attempting to register destroyed entity ${entity}`);
+
+ if (G_IS_DEV && !globalConfig.debug.disableSlowAsserts) {
+ assert(!this.findByUid(uid, false), "Entity uid already taken: " + uid);
+ assert(uid >= 0 && uid < Number.MAX_SAFE_INTEGER, "Invalid uid passed: " + uid);
+ }
+
+ // Give each entity a unique id
+ entity.uid = uid;
+ entity.registered = true;
+
+ this.entities.set(entity.uid, entity);
+
+ // Register into the componentToEntity map
+ for (const componentId in entity.components) {
+ if (entity.components[componentId]) {
+ const set = (this.componentToEntity[componentId] ??= new Set());
+ set.add(entity);
+ }
+ }
+
+ this.root.signals.entityAdded.dispatch(entity);
+ }
+
+ /**
+ * Generates a new uid
+ */
+ generateUid(): number {
+ return this.nextUid++;
+ }
+
+ /**
+ * Call to attach a new component after the creation of the entity
+ */
+ attachDynamicComponent(entity: Entity, component: Component) {
+ entity.addComponent(component, true);
+ const componentId = /** @type {typeof Component} */ component.constructor.getId();
+ const set = (this.componentToEntity[componentId] ??= new Set());
+ set.add(entity);
+ this.root.signals.entityGotNewComponent.dispatch(entity);
+ }
+
+ /**
+ * Call to remove a component after the creation of the entity
+ */
+ removeDynamicComponent(entity: Entity, component: typeof Component) {
+ entity.removeComponent(component, true);
+ const componentId = /** @type {typeof Component} */ component.constructor.getId();
+
+ this.componentToEntity[componentId].delete(entity);
+ this.root.signals.entityComponentRemoved.dispatch(entity);
+ }
+
+ /**
+ * Finds an entity by its uid
+ */
+ findByUid(uid: number, errorWhenNotFound = true): Entity {
+ const entity = this.entities.get(uid);
+
+ if (entity === undefined || entity.queuedForDestroy || entity.destroyed) {
+ if (errorWhenNotFound) {
+ logger.warn("Entity with UID", uid, "not found (destroyed)");
+ }
+
+ return null;
+ }
+
+ return entity;
+ }
+
+ /**
+ * Returns a map which gives a mapping from UID to Entity.
+ * This map is not updated.
+ */
+ getFrozenUidSearchMap(): Map {
+ const result = new Map();
+ for (const [uid, entity] of this.entities) {
+ if (!entity.queuedForDestroy && !entity.destroyed) {
+ result.set(uid, entity);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Returns all entities having the given component
+ * @deprecated use {@link getEntitiesWithComponent} instead
+ */
+ getAllWithComponent(componentHandle: typeof Component): Entity[] {
+ return [...(this.componentToEntity[componentHandle.getId()] ?? new Set())];
+ }
+
+ /**
+ * A version of {@link getAllWithComponent} that returns a Set
+ */
+ getEntitiesWithComponent(componentHandle: typeof Component): Set {
+ return new Set(this.componentToEntity[componentHandle.getId()] ?? []);
+ }
+
+ /**
+ * Unregisters all components of an entity from the component to entity mapping
+ */
+ unregisterEntityComponents(entity: Entity) {
+ for (const componentId in entity.components) {
+ if (entity.components[componentId]) {
+ this.componentToEntity[componentId].delete(entity);
+ }
+ }
+ }
+
+ // Processes the entities to destroy and actually destroys them
+ processDestroyList() {
+ for (let i = 0; i < this.destroyList.length; ++i) {
+ const entity = this.destroyList[i];
+
+ // Remove from entities list
+ this.entities.delete(entity.uid);
+
+ // Remove from componentToEntity list
+ this.unregisterEntityComponents(entity);
+
+ entity.registered = false;
+ entity.destroyed = true;
+
+ this.root.signals.entityDestroyed.dispatch(entity);
+ }
+
+ this.destroyList = [];
+ }
+
+ /**
+ * Queues an entity for destruction
+ */
+ destroyEntity(entity: Entity) {
+ if (entity.destroyed) {
+ logger.error("Tried to destroy already destroyed entity:", entity.uid);
+ return;
+ }
+
+ if (entity.queuedForDestroy) {
+ logger.error("Trying to destroy entity which is already queued for destroy!", entity.uid);
+ return;
+ }
+
+ if (this.destroyList.indexOf(entity) < 0) {
+ this.destroyList.push(entity);
+ entity.queuedForDestroy = true;
+ this.root.signals.entityQueuedForDestroy.dispatch(entity);
+ } else {
+ assert(false, "Trying to destroy entity twice");
+ }
+ }
+}
diff --git a/src/js/game/game_mode.js b/src/js/game/game_mode.js
index 2c4527e3..a49d94f3 100644
--- a/src/js/game/game_mode.js
+++ b/src/js/game/game_mode.js
@@ -1,198 +1,193 @@
-/* typehints:start */
-import { GameRoot } from "./root";
-/* typehints:end */
-
-import { Rectangle } from "../core/rectangle";
-import { gGameModeRegistry } from "../core/global_registries";
-import { types, BasicSerializableObject } from "../savegame/serialization";
-import { MetaBuilding } from "./meta_building";
-import { MetaItemProducerBuilding } from "./buildings/item_producer";
-import { BaseHUDPart } from "./hud/base_hud_part";
-
-/** @enum {string} */
-export const enumGameModeIds = {
- puzzleEdit: "puzzleEditMode",
- puzzlePlay: "puzzlePlayMode",
- regular: "regularMode",
-};
-
-/** @enum {string} */
-export const enumGameModeTypes = {
- default: "defaultModeType",
- puzzle: "puzzleModeType",
-};
-
-export class GameMode extends BasicSerializableObject {
- /** @returns {string} */
- static getId() {
- abstract;
- return "unknownMode";
- }
-
- /** @returns {string} */
- static getType() {
- abstract;
- return "unknownType";
- }
- /**
- * @param {GameRoot} root
- * @param {string} [id=Regular]
- * @param {object|undefined} payload
- */
- static create(root, id = enumGameModeIds.regular, payload = undefined) {
- return new (gGameModeRegistry.findById(id))(root, payload);
- }
-
- /**
- * @param {GameRoot} root
- */
- constructor(root) {
- super();
- this.root = root;
-
- /**
- * @type {Record}
- */
- this.additionalHudParts = {};
-
- /** @type {typeof MetaBuilding[]} */
- this.hiddenBuildings = [MetaItemProducerBuilding];
- }
-
- /** @returns {object} */
- serialize() {
- return {
- $: this.getId(),
- data: super.serialize(),
- };
- }
-
- /** @param {object} savedata */
- deserialize({ data }) {
- super.deserialize(data, this.root);
- }
-
- /** @returns {string} */
- getId() {
- // @ts-ignore
- return this.constructor.getId();
- }
-
- /** @returns {string} */
- getType() {
- // @ts-ignore
- return this.constructor.getType();
- }
-
- /**
- * @param {typeof MetaBuilding} building - Class name of building
- * @returns {boolean}
- */
- isBuildingExcluded(building) {
- return this.hiddenBuildings.indexOf(building) >= 0;
- }
-
- /** @returns {undefined|Rectangle[]} */
- getBuildableZones() {
- return;
- }
-
- /** @returns {Rectangle|undefined} */
- getCameraBounds() {
- return;
- }
-
- /** @returns {boolean} */
- hasHub() {
- return true;
- }
-
- /** @returns {boolean} */
- hasResources() {
- return true;
- }
-
- /** @returns {boolean} */
- hasAchievements() {
- return false;
- }
-
- /** @returns {number} */
- getMinimumZoom() {
- return 0.06;
- }
-
- /** @returns {number} */
- getMaximumZoom() {
- return 3.5;
- }
-
- /** @returns {Object} */
- getUpgrades() {
- return {
- belt: [],
- miner: [],
- processors: [],
- painting: [],
- };
- }
-
- throughputDoesNotMatter() {
- return false;
- }
-
- /**
- * @param {number} w
- * @param {number} h
- * @abstract
- */
- adjustZone(w = 0, h = 0) {
- abstract;
- return;
- }
-
- /** @returns {array} */
- getLevelDefinitions() {
- return [];
- }
-
- /** @returns {boolean} */
- getIsFreeplayAvailable() {
- return false;
- }
-
- /** @returns {boolean} */
- getIsSaveable() {
- return true;
- }
-
- /** @returns {boolean} */
- getHasFreeCopyPaste() {
- return false;
- }
-
- /** @returns {boolean} */
- getSupportsWires() {
- return true;
- }
-
- /** @returns {boolean} */
- getIsEditor() {
- return false;
- }
-
- /** @returns {boolean} */
- getIsDeterministic() {
- return false;
- }
-
- /** @returns {number | undefined} */
- getFixedTickrate() {
- return;
- }
-
- /** @returns {string} */
- getBlueprintShapeKey() {
- return "CbCbCbRb:CwCwCwCw";
- }
-}
+/* typehints:start */
+import { GameRoot } from "./root";
+/* typehints:end */
+
+import { gGameModeRegistry } from "../core/global_registries";
+import { Rectangle } from "../core/rectangle";
+import { BasicSerializableObject } from "../savegame/serialization";
+import { MetaItemProducerBuilding } from "./buildings/item_producer";
+import { BaseHUDPart } from "./hud/base_hud_part";
+import { MetaBuilding } from "./meta_building";
+
+/** @enum {string} */
+export const enumGameModeIds = {
+ puzzleEdit: "puzzleEditMode",
+ puzzlePlay: "puzzlePlayMode",
+ regular: "regularMode",
+};
+
+/** @enum {string} */
+export const enumGameModeTypes = {
+ default: "defaultModeType",
+ puzzle: "puzzleModeType",
+};
+
+export class GameMode extends BasicSerializableObject {
+ /** @returns {string} */
+ static getId() {
+ abstract;
+ return "unknownMode";
+ }
+
+ /** @returns {string} */
+ static getType() {
+ abstract;
+ return "unknownType";
+ }
+ /**
+ * @param {GameRoot} root
+ * @param {string} [id=Regular]
+ * @param {object|undefined} payload
+ */
+ static create(root, id = enumGameModeIds.regular, payload = undefined) {
+ return new (gGameModeRegistry.findById(id))(root, payload);
+ }
+
+ /**
+ * @param {GameRoot} root
+ */
+ constructor(root) {
+ super();
+ this.root = root;
+
+ /**
+ * @type {Record}
+ */
+ this.additionalHudParts = {};
+
+ /** @type {typeof MetaBuilding[]} */
+ this.hiddenBuildings = [MetaItemProducerBuilding];
+ }
+
+ /** @returns {object} */
+ serialize() {
+ return {
+ $: this.getId(),
+ data: super.serialize(),
+ };
+ }
+
+ /** @param {object} savedata */
+ deserialize({ data }) {
+ super.deserialize(data, this.root);
+ }
+
+ /** @returns {string} */
+ getId() {
+ // @ts-ignore
+ return this.constructor.getId();
+ }
+
+ /** @returns {string} */
+ getType() {
+ // @ts-ignore
+ return this.constructor.getType();
+ }
+
+ /**
+ * @param {typeof MetaBuilding} building - Class name of building
+ * @returns {boolean}
+ */
+ isBuildingExcluded(building) {
+ return this.hiddenBuildings.indexOf(building) >= 0;
+ }
+
+ /** @returns {undefined|Rectangle[]} */
+ getBuildableZones() {
+ return;
+ }
+
+ /** @returns {Rectangle|undefined} */
+ getCameraBounds() {
+ return;
+ }
+
+ /** @returns {boolean} */
+ hasHub() {
+ return true;
+ }
+
+ /** @returns {boolean} */
+ hasResources() {
+ return true;
+ }
+
+ /** @returns {number} */
+ getMinimumZoom() {
+ return 0.06;
+ }
+
+ /** @returns {number} */
+ getMaximumZoom() {
+ return 3.5;
+ }
+
+ /** @returns {Object
-
-We are currently working on a successor to shapez, with 3D Graphics, Exploration, Layers, Mass transport, New Shape Mechanics, Research and a lot more! Be sure to check it out:
+**shapez Community Edition** (abbreviated as **CE**) is a community-maintained version of [shapez](https://store.steampowered.com/app/1318690/shapez/)!
-
- 
-
-
-
-
+If you are not a collaborator and want to submit a change,
+you can fork our repo and make a pull request.
+Note that because of plans to overhaul many parts of the game,
+unless you are improving translations, you should probably communicate with us on Discord!
+
+> [!TIP]
+> Be aware that [pull requests to the official shapez repository](https://github.com/tobspr-games/shapez.io/pulls) are unlikely to get merged in the near future. Instead, submit them to CE!
+> In fact, because the game is licensed under the [GNU GPL v3.0](https://www.gnu.org/licenses/gpl-3.0.html),
+> existing pull requests can be resubmitted to CE even if you aren't the author! **This is not legal advice.**
### Code
-The game is based on a custom engine which itself is based on the YORG.io 3 game engine (Actually it shares almost the same core).
+The game uses a custom engine originally based on the YORG.io 3 game engine.
The code within the engine is relatively clean with some code for the actual game on top being hacky.
-This project is based on ES5 (If I would develop it again, I would definitely use TypeScript). Some ES2015 features are used but most of them are too slow, especially when polyfilled. For example, `Array.prototype.forEach` is only used within non-critical loops since its slower than a plain for loop.
+We are in the process of migrating to TypeScript and JSX/TSX.
+New changes should be implemented in TypeScript if possible,
+but because we are planning on overhauling many parts of the game,
+there is no need to convert existing code to TypeScript.
-### Assets
+This project is fine with using cutting-edge and bleeding-edge features
+and does not intend to provide compatibility for older clients.
-You can find most assets here.
+## Building
-All assets will be automatically rebuilt into the atlas once changed (Thanks to dengr1065!)
+### Prerequisites
-
+- [Node.js](https://nodejs.org)
+- [ffmpeg](https://www.ffmpeg.org/download.html) for audio transcoding
+- [Java](https://www.oracle.com/java/technologies/downloads/) (or [OpenJDK](https://openjdk.org/)) to run the texture packer
-
-
+### Release
+
+- Run `npm i` in the root folder and in `electron/`.
+- In the root folder, run `npm run package-$PLATFORM-$ARCH` where:
+ - `$PLATFORM` is `win32`, `linux` or `darwin` depending on your system.
+ - `$ARCH` is the target system architecture (`x64` or `arm64`)
+- The build will be found under `build_output/standalone` as `shapez-...`.
+
+## Credits
+
+Thanks to [tobspr](https://tobspr.io) for creating this project!
+
+[
-