Mascali
/
shapez.io
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Get rid of 'builtins' file since its useless and causes performance issues

This commit is contained in:
tobspr 2020-06-27 10:51:52 +02:00
parent 14246929b3
commit 2e266f5f21
60 changed files with 256 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
gulp/webpack.production.config.js
View File

@ -105,6 +105,8 @@ module.exports = ({
passes: 2,
module: true,
pure_funcs: [
"Math.radians",
"Math.degrees",
"Math.round",
"Math.ceil",
"Math.floor",
@ -119,21 +121,6 @@ module.exports = ({
"Math.sign",
"Math.pow",
"Math.atan2",
"Math_round",
"Math_ceil",
"Math_floor",
"Math_sqrt",
"Math_hypot",
"Math_abs",
"Math_max",
"Math_min",
"Math_sin",
"Math_cos",
"Math_tan",
"Math_sign",
"Math_pow",
"Math_atan2",
],
toplevel: true,
unsafe_math: true,

3
src/js/application.js
View File

@ -1,6 +1,5 @@
import { AnimationFrame } from "./core/animation_frame";
import { BackgroundResourcesLoader } from "./core/background_resources_loader";
import { performanceNow } from "./core/builtins";
import { IS_MOBILE } from "./core/config";
import { GameState } from "./core/game_state";
import { GLOBAL_APP, setGlobalApp } from "./core/globals";
@ -356,7 +355,7 @@ export class Application {
return;
}
const time = performanceNow();
const time = performance.now();
// Periodically check for resizes, this is expensive (takes 2-3ms so only do it once in a while!)
if (!this.lastResizeCheck || time - this.lastResizeCheck > 1000) {

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

@ -4,8 +4,6 @@ import { Signal } from "./signal";
import BackgroundAnimationFrameEmitterWorker from "../webworkers/background_animation_frame_emittter.worker";
import { createLogger } from "./logging";
import { performanceNow } from "./builtins";
const logger = createLogger("animation_frame");
const maxDtMs = 1000;
@ -34,7 +32,7 @@ export class AnimationFrame {
* @param {MessageEvent} event
*/
handleBackgroundTick(event) {
const time = performanceNow();
const time = performance.now();
if (!this.bgLastTime) {
// First update, first delta is always 16ms
this.bgFrameEmitted.dispatch(1000 / 60);

6
src/js/core/async_compression.js
View File

@ -2,8 +2,6 @@
import CompressionWorker from "../webworkers/compression.worker";
import { createLogger } from "./logging";
import { compressX64 } from "./lzstring";
import { performanceNow, JSON_stringify } from "./builtins";
const logger = createLogger("async_compression");
export let compressionPrefix = String.fromCodePoint(1);
@ -53,7 +51,7 @@ class AsynCompression {
return;
}
const duration = performanceNow() - jobData.startTime;
const duration = performance.now() - jobData.startTime;
// log(this, "Got response from worker within", duration.toFixed(2), "ms");
const resolver = jobData.resolver;
delete this.currentJobs[jobId];
@ -100,7 +98,7 @@ class AsynCompression {
this.currentJobs[jobId] = {
errorHandler,
resolver: resolve,
startTime: performanceNow(),
startTime: performance.now(),
};
this.worker.postMessage({ jobId, job, data });
});

11
src/js/core/buffer_utils.js
View File

@ -1,5 +1,4 @@
import { globalConfig } from "./config";
import { Math_max, Math_floor, Math_abs } from "./builtins";
import { fastArrayDelete } from "./utils";
import { createLogger } from "./logging";
@ -70,8 +69,8 @@ export function makeOffscreenBuffer(w, h, { smooth = true, reusable = true, labe
}
if (w < 1 || h < 1) {
logger.error("Offscreen buffer size < 0:", w, "x", h);
w = Math_max(1, w);
h = Math_max(1, h);
w = Math.max(1, w);
h = Math.max(1, h);
}
const recommendedSize = 1024 * 1024;
@ -79,8 +78,8 @@ export function makeOffscreenBuffer(w, h, { smooth = true, reusable = true, labe
logger.warn("Creating huge buffer:", w, "x", h, "with label", label);
}
w = Math_floor(w);
h = Math_floor(h);
w = Math.floor(w);
h = Math.floor(h);
let canvas = null;
let context = null;
@ -103,7 +102,7 @@ export function makeOffscreenBuffer(w, h, { smooth = true, reusable = true, labe
}
const otherPixels = useableCanvas.width * useableCanvas.height;
const diff = Math_abs(otherPixels - currentPixels);
const diff = Math.abs(otherPixels - currentPixels);
if (diff < bestMatchingPixelsDiff) {
bestMatchingPixelsDiff = diff;
bestMatchingOne = {

34
src/js/core/builtins.js
View File

@ -1,34 +0,0 @@
// Store the original version of all builtins to prevent modification
export const JSON_stringify = JSON.stringify.bind(JSON);
export const JSON_parse = JSON.parse.bind(JSON);
export function Math_radians(degrees) {
return (degrees * Math_PI) / 180.0;
}
export function Math_degrees(radians) {
return (radians * 180.0) / Math_PI;
}
export const performanceNow = performance.now.bind(performance);
export const Math_abs = Math.abs.bind(Math);
export const Math_ceil = Math.ceil.bind(Math);
export const Math_floor = Math.floor.bind(Math);
export const Math_round = Math.round.bind(Math);
export const Math_sign = Math.sign.bind(Math);
export const Math_sqrt = Math.sqrt.bind(Math);
export const Math_min = Math.min.bind(Math);
export const Math_max = Math.max.bind(Math);
export const Math_sin = Math.sin.bind(Math);
export const Math_cos = Math.cos.bind(Math);
export const Math_tan = Math.tan.bind(Math);
export const Math_hypot = Math.hypot.bind(Math);
export const Math_atan2 = Math.atan2.bind(Math);
export const Math_pow = Math.pow.bind(Math);
export const Math_random = Math.random.bind(Math);
export const Math_exp = Math.exp.bind(Math);
export const Math_log10 = Math.log10.bind(Math);
export const Math_PI = 3.1415926;

7
src/js/core/click_detector.js
View File

@ -1,4 +1,3 @@
import { performanceNow } from "../core/builtins";
import { createLogger } from "../core/logging";
import { Signal } from "../core/signal";
import { fastArrayDelete, fastArrayDeleteValueIfContained } from "./utils";
@ -246,7 +245,7 @@ export class ClickDetector {
}
if (window.TouchEvent && event instanceof TouchEvent) {
clickDetectorGlobals.lastTouchTime = performanceNow();
clickDetectorGlobals.lastTouchTime = performance.now();
// console.log("Got touches", event.targetTouches.length, "vs", expectedRemainingTouches);
if (event.targetTouches.length !== expectedRemainingTouches) {
@ -255,7 +254,7 @@ export class ClickDetector {
}
if (event instanceof MouseEvent) {
if (performanceNow() - clickDetectorGlobals.lastTouchTime < 1000.0) {
if (performance.now() - clickDetectorGlobals.lastTouchTime < 1000.0) {
return false;
}
}
@ -340,7 +339,7 @@ export class ClickDetector {
// Store where the touch started
this.clickDownPosition = position;
this.clickStartTime = performanceNow();
this.clickStartTime = performance.now();
this.touchstartSimple.dispatch(this.clickDownPosition.x, this.clickDownPosition.y);
// If we are not currently within a click, register it

19
src/js/core/dpi_manager.js
View File

@ -1,5 +1,4 @@
import { globalConfig } from "../core/config";
import { Math_ceil, Math_floor, Math_round } from "./builtins";
import { round1Digit, round2Digits } from "./utils";
/**
@ -23,7 +22,7 @@ export function smoothenDpi(dpi) {
} else if (dpi < 1) {
return round1Digit(dpi);
} else {
return round1Digit(Math_round(dpi / 0.5) * 0.5);
return round1Digit(Math.round(dpi / 0.5) * 0.5);
}
}
@ -59,11 +58,11 @@ export function prepareHighDPIContext(context, smooth = true) {
export function resizeHighDPICanvas(canvas, w, h, smooth = true) {
const dpi = getDeviceDPI();
const wNumber = Math_floor(w);
const hNumber = Math_floor(h);
const wNumber = Math.floor(w);
const hNumber = Math.floor(h);
const targetW = Math_floor(wNumber * dpi);
const targetH = Math_floor(hNumber * dpi);
const targetW = Math.floor(wNumber * dpi);
const targetH = Math.floor(hNumber * dpi);
if (targetW !== canvas.width || targetH !== canvas.height) {
// console.log("Resize Canvas from", canvas.width, canvas.height, "to", targetW, targetH)
@ -82,8 +81,8 @@ export function resizeHighDPICanvas(canvas, w, h, smooth = true) {
* @param {number} h
*/
export function resizeCanvas(canvas, w, h, setStyle = true) {
const actualW = Math_ceil(w);
const actualH = Math_ceil(h);
const actualW = Math.ceil(w);
const actualH = Math.ceil(h);
if (actualW !== canvas.width || actualH !== canvas.height) {
canvas.width = actualW;
canvas.height = actualH;
@ -103,8 +102,8 @@ export function resizeCanvas(canvas, w, h, setStyle = true) {
* @param {number} h
*/
export function resizeCanvasAndClear(canvas, context, w, h) {
const actualW = Math_ceil(w);
const actualH = Math_ceil(h);
const actualW = Math.ceil(w);
const actualH = Math.ceil(h);
if (actualW !== canvas.width || actualH !== canvas.height) {
canvas.width = actualW;
canvas.height = actualH;

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

@ -3,7 +3,6 @@ import { AtlasSprite } from "./sprites";
import { DrawParameters } from "./draw_parameters";
/* typehints:end */
import { Math_PI, Math_round, Math_atan2, Math_hypot, Math_floor } from "./builtins";
import { Vector } from "./vector";
import { Rectangle } from "./rectangle";
import { createLogger } from "./logging";
@ -40,7 +39,7 @@ export function initDrawUtils() {
return;
}
this.beginPath();
this.arc(x, y, r, 0, 2.0 * Math_PI);
this.arc(x, y, r, 0, 2.0 * Math.PI);
};
}
@ -68,8 +67,8 @@ export function drawLineFast(context, { x1, x2, y1, y2, color = null, lineSize =
const dX = x2 - x1;
const dY = y2 - y1;
const angle = Math_atan2(dY, dX) + 0.0 * Math_PI;
const len = Math_hypot(dX, dY);
const angle = Math.atan2(dY, dX) + 0.0 * Math.PI;
const len = Math.hypot(dX, dY);
context.translate(x1, y1);
context.rotate(angle);
@ -247,7 +246,7 @@ export function hslToRgb(h, s, l) {
b = hue2rgb(p, q, h - 1 / 3);
}
return [Math_round(r * 255), Math_round(g * 255), Math_round(b * 255)];
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
}
export function wrapText(context, text, x, y, maxWidth, lineHeight, stroke = false) {
@ -306,7 +305,7 @@ export function rotateTrapezRightFaced(x, y, w, h, leftHeight, angle) {
*/
export function mapClampedColorValueToHex(value) {
const hex = "0123456789abcdef";
return hex[Math_floor(value / 16)] + hex[value % 16];
return hex[Math.floor(value / 16)] + hex[value % 16];
}
/**

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

@ -1,6 +1,4 @@
import { globalConfig } from "../core/config";
import { Math_floor, performanceNow } from "./builtins";
const circularJson = require("circular-json");
/*
@ -231,7 +229,7 @@ function logInternal(handle, consoleMethod, args) {
const labelColor = handle && handle.LOG_LABEL_COLOR ? handle.LOG_LABEL_COLOR : "#aaa";
if (G_IS_DEV && globalConfig.debug.logTimestamps) {
const timestamp = "⏱ %c" + (Math_floor(performanceNow()) + "").padEnd(6, " ") + "";
const timestamp = "⏱ %c" + (Math.floor(performance.now()) + "").padEnd(6, " ") + "";
consoleMethod.call(
console,
timestamp + " %c" + context,

6
src/js/core/polyfills.js
View File

@ -1,12 +1,12 @@
function mathPolyfills() {
// Converts from degrees to radians.
Math.radians = function (degrees) {
return (degrees * Math_PI) / 180.0;
return (degrees * Math.PI) / 180.0;
};
// Converts from radians to degrees.
Math.degrees = function (radians) {
return (radians * 180.0) / Math_PI;
return (radians * 180.0) / Math.PI;
};
}
@ -98,8 +98,6 @@ function initExtensions() {
// Fetch polyfill
import "whatwg-fetch";
import { Math_PI } from "./builtins";
// Other polyfills
initPolyfills();
initExtensions();

9
src/js/core/read_write_proxy.js
View File

@ -7,7 +7,6 @@ import { createLogger } from "./logging";
import { FILE_NOT_FOUND } from "../platform/storage";
import { accessNestedPropertyReverse } from "./utils";
import { IS_DEBUG, globalConfig } from "./config";
import { JSON_stringify, JSON_parse } from "./builtins";
import { ExplainedResult } from "./explained_result";
import { decompressX64, compressX64 } from ".//lzstring";
import { asyncCompressor, compressionPrefix } from "./async_compression";
@ -84,7 +83,7 @@ export class ReadWriteProxy {
* @param {object} obj
*/
static serializeObject(obj) {
const jsonString = JSON_stringify(compressObject(obj));
const jsonString = JSON.stringify(compressObject(obj));
const checksum = sha1(jsonString + salt);
return compressionPrefix + compressX64(checksum + jsonString);
}
@ -129,7 +128,7 @@ export class ReadWriteProxy {
logger.error("Tried to write invalid data to", this.filename, "reason:", verifyResult.reason);
return Promise.reject(verifyResult.reason);
}
const jsonString = JSON_stringify(compressObject(this.currentData));
const jsonString = JSON.stringify(compressObject(this.currentData));
// if (!this.app.pageVisible || this.app.unloaded) {
// logger.log("Saving file sync because in unload handler");
@ -189,7 +188,7 @@ export class ReadWriteProxy {
.then(rawData => {
if (rawData == null) {
// So, the file has not been found, use default data
return JSON_stringify(compressObject(this.getDefaultData()));
return JSON.stringify(compressObject(this.getDefaultData()));
}
if (rawData.startsWith(compressionPrefix)) {
@ -223,7 +222,7 @@ export class ReadWriteProxy {
// Parse JSON, this could throw but thats fine
.then(res => {
try {
return JSON_parse(res);
return JSON.parse(res);
} catch (ex) {
logger.error(
"Failed to parse file content of",

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

@ -1,5 +1,4 @@
import { globalConfig } from "./config";
import { Math_ceil, Math_floor, Math_max, Math_min } from "./builtins";
import { clamp, epsilonCompare, round2Digits } from "./utils";
import { Vector } from "./vector";
@ -38,10 +37,10 @@ export class Rectangle {
* @param {Vector} p2
*/
static fromTwoPoints(p1, p2) {
const left = Math_min(p1.x, p2.x);
const top = Math_min(p1.y, p2.y);
const right = Math_max(p1.x, p2.x);
const bottom = Math_max(p1.y, p2.y);
const left = Math.min(p1.x, p2.x);
const top = Math.min(p1.y, p2.y);
const right = Math.max(p1.x, p2.x);
const bottom = Math.max(p1.y, p2.y);
return new Rectangle(left, top, right - left, bottom - top);
}
@ -67,10 +66,10 @@ export class Rectangle {
let maxY = -1e10;
for (let i = 0; i < points.length; ++i) {
const rotated = points[i].rotated(angle);
minX = Math_min(minX, rotated.x);
minY = Math_min(minY, rotated.y);
maxX = Math_max(maxX, rotated.x);
maxY = Math_max(maxY, rotated.y);
minX = Math.min(minX, rotated.x);
minY = Math.min(minY, rotated.y);
maxX = Math.max(maxX, rotated.x);
maxY = Math.max(maxY, rotated.y);
}
return new Rectangle(minX, minY, maxX - minX, maxY - minY);
}
@ -98,10 +97,10 @@ export class Rectangle {
this.w = halfWidth * 2;
this.h = halfHeight * 2;
} else {
this.setLeft(Math_min(this.x, centerX - halfWidth));
this.setRight(Math_max(this.right(), centerX + halfWidth));
this.setTop(Math_min(this.y, centerY - halfHeight));
this.setBottom(Math_max(this.bottom(), centerY + halfHeight));
this.setLeft(Math.min(this.x, centerX - halfWidth));
this.setRight(Math.max(this.right(), centerX + halfWidth));
this.setTop(Math.min(this.y, centerY - halfHeight));
this.setBottom(Math.max(this.bottom(), centerY + halfHeight));
}
}
@ -326,11 +325,11 @@ export class Rectangle {
* @returns {Rectangle|null}
*/
getIntersection(rect) {
const left = Math_max(this.x, rect.x);
const top = Math_max(this.y, rect.y);
const left = Math.max(this.x, rect.x);
const top = Math.max(this.y, rect.y);
const right = Math_min(this.x + this.w, rect.x + rect.w);
const bottom = Math_min(this.y + this.h, rect.y + rect.h);
const right = Math.min(this.x + this.w, rect.x + rect.w);
const bottom = Math.min(this.y + this.h, rect.y + rect.h);
if (right <= left || bottom <= top) {
return null;
@ -354,10 +353,10 @@ export class Rectangle {
}
// Find contained area
const left = Math_min(this.x, rect.x);
const top = Math_min(this.y, rect.y);
const right = Math_max(this.right(), rect.right());
const bottom = Math_max(this.bottom(), rect.bottom());
const left = Math.min(this.x, rect.x);
const top = Math.min(this.y, rect.y);
const right = Math.max(this.right(), rect.right());
const bottom = Math.max(this.bottom(), rect.bottom());
return Rectangle.fromTRBL(top, right, bottom, left);
}
@ -388,10 +387,10 @@ export class Rectangle {
if (includeHalfTiles) {
// Increase rectangle size
scaled = Rectangle.fromTRBL(
Math_floor(scaled.y),
Math_ceil(scaled.right()),
Math_ceil(scaled.bottom()),
Math_floor(scaled.x)
Math.floor(scaled.y),
Math.ceil(scaled.right()),
Math.ceil(scaled.bottom()),
Math.floor(scaled.x)
);
}

6
src/js/core/rng.js
View File

@ -1,5 +1,3 @@
import { Math_random } from "./builtins";
// ALEA RNG
function Mash() {
@ -72,7 +70,7 @@ export class RandomNumberGenerator {
* @param {number|string=} seed
*/
constructor(seed) {
this.internalRng = makeNewRng(seed || Math_random());
this.internalRng = makeNewRng(seed || Math.random());
}
/**
@ -80,7 +78,7 @@ export class RandomNumberGenerator {
* @param {number|string} seed
*/
reseed(seed) {
this.internalRng = makeNewRng(seed || Math_random());
this.internalRng = makeNewRng(seed || Math.random());
}
/**

17
src/js/core/sprites.js
View File

@ -1,5 +1,4 @@
import { DrawParameters } from "./draw_parameters";
import { Math_floor } from "./builtins";
import { Rectangle } from "./rectangle";
import { epsilonCompare, round3Digits } from "./utils";
@ -195,20 +194,20 @@ export class AtlasSprite extends BaseSprite {
link.atlas,
// atlas src pos
Math_floor(srcX),
Math_floor(srcY),
Math.floor(srcX),
Math.floor(srcY),
// atlas src size
Math_floor(srcW),
Math_floor(srcH),
Math.floor(srcW),
Math.floor(srcH),
// dest pos
Math_floor(destX),
Math_floor(destY),
Math.floor(destX),
Math.floor(destY),
// dest size
Math_floor(destW),
Math_floor(destH)
Math.floor(destW),
Math.floor(destH)
);
} else {
parameters.context.drawImage(

91
src/js/core/utils.js
View File

@ -1,19 +1,4 @@
import { globalConfig, IS_DEBUG } from "./config";
import {
Math_abs,
Math_atan2,
Math_ceil,
Math_floor,
Math_log10,
Math_max,
Math_min,
Math_PI,
Math_pow,
Math_random,
Math_round,
Math_sin,
performanceNow,
} from "./builtins";
import { Vector } from "./vector";
import { T } from "../translations";
@ -212,7 +197,7 @@ export function newEmptyMap() {
* @param {number} end
*/
export function randomInt(start, end) {
return start + Math_round(Math_random() * (end - start));
return start + Math.round(Math.random() * (end - start));
}
/**
@ -233,7 +218,7 @@ export function accessNestedPropertyReverse(obj, keys) {
* @param {Array | string} arr
*/
export function randomChoice(arr) {
return arr[Math_floor(Math_random() * arr.length)];
return arr[Math.floor(Math.random() * arr.length)];
}
/**
@ -327,12 +312,12 @@ export function arrayDeleteValue(array, value) {
* @returns {number} in range [0, 7]
*/
export function angleToSpriteIndex(offset, inverse = false) {
const twoPi = 2.0 * Math_PI;
const twoPi = 2.0 * Math.PI;
const factor = inverse ? -1 : 1;
const offs = inverse ? 2.5 : 3.5;
const angle = (factor * Math_atan2(offset.y, offset.x) + offs * Math_PI) % twoPi;
const angle = (factor * Math.atan2(offset.y, offset.x) + offs * Math.PI) % twoPi;
const index = Math_round((angle / twoPi) * 8) % 8;
const index = Math.round((angle / twoPi) * 8) % 8;
return index;
}
@ -343,7 +328,7 @@ export function angleToSpriteIndex(offset, inverse = false) {
* @returns {boolean}
*/
export function epsilonCompare(a, b, epsilon = 1e-5) {
return Math_abs(a - b) < epsilon;
return Math.abs(a - b) < epsilon;
}
/**
@ -394,15 +379,15 @@ export function findNiceValue(num) {
roundAmount = 5;
}
const niceValue = Math_floor(num / roundAmount) * roundAmount;
const niceValue = Math.floor(num / roundAmount) * roundAmount;
if (num >= 10) {
return Math_round(niceValue);
return Math.round(niceValue);
}
if (num >= 1) {
return Math_round(niceValue * 10) / 10;
return Math.round(niceValue * 10) / 10;
}
return Math_round(niceValue * 100) / 100;
return Math.round(niceValue * 100) / 100;
}
/**
@ -411,7 +396,7 @@ export function findNiceValue(num) {
* @param {number} num
*/
export function findNiceIntegerValue(num) {
return Math_ceil(findNiceValue(num));
return Math.ceil(findNiceValue(num));
}
/**
@ -422,7 +407,7 @@ function roundSmart(n) {
if (n < 100) {
return n.toFixed(1);
}
return Math_round(n);
return Math.round(n);
}
/**
@ -433,7 +418,7 @@ function roundSmart(n) {
*/
export function formatBigNumber(num, divider = ".") {
const sign = num < 0 ? "-" : "";
num = Math_abs(num);
num = Math.abs(num);
if (num > 1e54) {
return sign + T.global.infinite;
@ -445,7 +430,7 @@ export function formatBigNumber(num, divider = ".") {
if (num < 50 && !Number.isInteger(num)) {
return sign + num.toFixed(1);
}
num = Math_floor(num);
num = Math.floor(num);
if (num < 1000) {
return sign + "" + num;
@ -482,7 +467,7 @@ export function formatBigNumberFull(num, divider = T.global.thousandsDivider) {
let out = "";
while (rest >= 1000) {
out = (rest % 1000).toString().padStart(3, "0") + divider + out;
rest = Math_floor(rest / 1000);
rest = Math.floor(rest / 1000);
}
out = rest + divider + out;
@ -500,11 +485,11 @@ export function artificialDelayedPromise(promise, minTimeMs = 500) {
return promise;
}
const startTime = performanceNow();
const startTime = performance.now();
return promise.then(
result => {
const timeTaken = performanceNow() - startTime;
const waitTime = Math_floor(minTimeMs - timeTaken);
const timeTaken = performance.now() - startTime;
const waitTime = Math.floor(minTimeMs - timeTaken);
if (waitTime > 0) {
return new Promise(resolve => {
setTimeout(() => {
@ -516,8 +501,8 @@ export function artificialDelayedPromise(promise, minTimeMs = 500) {
}
},
error => {
const timeTaken = performanceNow() - startTime;
const waitTime = Math_floor(minTimeMs - timeTaken);
const timeTaken = performance.now() - startTime;
const waitTime = Math.floor(minTimeMs - timeTaken);
if (waitTime > 0) {
// @ts-ignore
return new Promise((resolve, reject) => {
@ -539,7 +524,7 @@ export function artificialDelayedPromise(promise, minTimeMs = 500) {
* @param {number} seed Seed to offset the animation
*/
export function pulseAnimation(time, duration = 1.0, seed = 0.0) {
return Math_sin((time * Math_PI * 2.0) / duration + seed * 5642.86729349) * 0.5 + 0.5;
return Math.sin((time * Math.PI * 2.0) / duration + seed * 5642.86729349) * 0.5 + 0.5;
}
/**
@ -549,7 +534,7 @@ export function pulseAnimation(time, duration = 1.0, seed = 0.0) {
* @returns {number} 0 .. 2 PI
*/
export function smallestAngle(a, b) {
return safeMod(a - b + Math_PI, 2.0 * Math_PI) - Math_PI;
return safeMod(a - b + Math.PI, 2.0 * Math.PI) - Math.PI;
}
/**
@ -566,7 +551,7 @@ export function safeMod(n, m) {
* @param {number} angle
*/
export function wrapAngle(angle) {
return safeMod(angle, 2.0 * Math_PI);
return safeMod(angle, 2.0 * Math.PI);
}
/**
@ -589,7 +574,7 @@ export function waitNextFrame() {
* @returns {number}
*/
export function round1Digit(n) {
return Math_floor(n * 10.0) / 10.0;
return Math.floor(n * 10.0) / 10.0;
}
/**
@ -598,7 +583,7 @@ export function round1Digit(n) {
* @returns {number}
*/
export function round2Digits(n) {
return Math_floor(n * 100.0) / 100.0;
return Math.floor(n * 100.0) / 100.0;
}
/**
@ -607,7 +592,7 @@ export function round2Digits(n) {
* @returns {number}
*/
export function round3Digits(n) {
return Math_floor(n * 1000.0) / 1000.0;
return Math.floor(n * 1000.0) / 1000.0;
}
/**
@ -616,7 +601,7 @@ export function round3Digits(n) {
* @returns {number}
*/
export function round4Digits(n) {
return Math_floor(n * 10000.0) / 10000.0;
return Math.floor(n * 10000.0) / 10000.0;
}
/**
@ -626,7 +611,7 @@ export function round4Digits(n) {
* @param {number=} maximum Default 1
*/
export function clamp(v, minimum = 0, maximum = 1) {
return Math_max(minimum, Math_min(maximum, v));
return Math.max(minimum, Math.min(maximum, v));
}
/**
@ -635,11 +620,11 @@ export function clamp(v, minimum = 0, maximum = 1) {
* @param {function():void} target
*/
export function measure(name, target) {
const now = performanceNow();
const now = performance.now();
for (let i = 0; i < 25; ++i) {
target();
}
const dur = (performanceNow() - now) / 25.0;
const dur = (performance.now() - now) / 25.0;
console.warn("->", name, "took", dur.toFixed(2), "ms");
}
@ -889,10 +874,10 @@ export function fastRotateMultipleOf90(x, y, deg) {
* @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);
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) {
@ -924,18 +909,18 @@ export function formatSecondsToTimeAgo(secs) {
*/
export function formatSeconds(secs) {
const trans = T.global.time;
secs = Math_ceil(secs);
secs = Math.ceil(secs);
if (secs < 60) {
return trans.secondsShort.replace("<seconds>", "" + secs);
} else if (secs < 60 * 60) {
const minutes = Math_floor(secs / 60);
const minutes = Math.floor(secs / 60);
const seconds = secs % 60;
return trans.minutesAndSecondsShort
.replace("<seconds>", "" + seconds)
.replace("<minutes>", "" + minutes);
} else {
const hours = Math_floor(secs / 3600);
const minutes = Math_floor(secs / 60) % 60;
const hours = Math.floor(secs / 3600);
const minutes = Math.floor(secs / 60) % 60;
return trans.hoursAndMinutesShort.replace("<minutes>", "" + minutes).replace("<hours>", "" + hours);
}
}

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

@ -1,17 +1,4 @@
import { globalConfig } from "./config";
import {
Math_abs,
Math_floor,
Math_PI,
Math_max,
Math_min,
Math_round,
Math_hypot,
Math_atan2,
Math_sin,
Math_cos,
Math_ceil,
} from "./builtins";
const tileSize = globalConfig.tileSize;
const halfTileSize = globalConfig.halfTileSize;
@ -158,7 +145,7 @@ export class Vector {
* @returns {number}
*/
length() {
return Math_hypot(this.x, this.y);
return Math.hypot(this.x, this.y);
}
/**
@ -226,7 +213,7 @@ export class Vector {
* @returns {Vector}
*/
maxScalar(f) {
return new Vector(Math_max(f, this.x), Math_max(f, this.y));
return new Vector(Math.max(f, this.x), Math.max(f, this.y));
}
/**
@ -244,7 +231,7 @@ export class Vector {
* @returns {Vector}
*/
min(v) {
return new Vector(Math_min(v.x, this.x), Math_min(v.y, this.y));
return new Vector(Math.min(v.x, this.x), Math.min(v.y, this.y));
}
/**
@ -253,14 +240,14 @@ export class Vector {
* @returns {Vector}
*/
max(v) {
return new Vector(Math_max(v.x, this.x), Math_max(v.y, this.y));
return new Vector(Math.max(v.x, this.x), Math.max(v.y, this.y));
}
/**
* Computes the component wise absolute
* @returns {Vector}
*/
abs() {
return new Vector(Math_abs(this.x), Math_abs(this.y));
return new Vector(Math.abs(this.x), Math.abs(this.y));
}
/**
@ -278,7 +265,7 @@ export class Vector {
* @returns {number}
*/
distance(v) {
return Math_hypot(this.x - v.x, this.y - v.y);
return Math.hypot(this.x - v.x, this.y - v.y);
}
/**
@ -308,7 +295,7 @@ export class Vector {
* @returns {Vector}
*/
floor() {
return new Vector(Math_floor(this.x), Math_floor(this.y));
return new Vector(Math.floor(this.x), Math.floor(this.y));
}
/**
@ -316,7 +303,7 @@ export class Vector {
* @returns {Vector}
*/
ceil() {
return new Vector(Math_ceil(this.x), Math_ceil(this.y));
return new Vector(Math.ceil(this.x), Math.ceil(this.y));
}
/**
@ -324,7 +311,7 @@ export class Vector {
* @returns {Vector}
*/
round() {
return new Vector(Math_round(this.x), Math_round(this.y));
return new Vector(Math.round(this.x), Math.round(this.y));
}
/**
@ -332,7 +319,7 @@ export class Vector {
* @returns {Vector}
*/
toTileSpace() {
return new Vector(Math_floor(this.x / tileSize), Math_floor(this.y / tileSize));
return new Vector(Math.floor(this.x / tileSize), Math.floor(this.y / tileSize));
}
/**
@ -340,7 +327,7 @@ export class Vector {
* @returns {Vector}
*/
toStreetSpace() {
return new Vector(Math_floor(this.x / halfTileSize + 0.25), Math_floor(this.y / halfTileSize + 0.25));
return new Vector(Math.floor(this.x / halfTileSize + 0.25), Math.floor(this.y / halfTileSize + 0.25));
}
/**
@ -364,7 +351,7 @@ export class Vector {
* @returns {Vector}
*/
snapWorldToTile() {
return new Vector(Math_floor(this.x / tileSize) * tileSize, Math_floor(this.y / tileSize) * tileSize);
return new Vector(Math.floor(this.x / tileSize) * tileSize, Math.floor(this.y / tileSize) * tileSize);
}
/**
@ -372,7 +359,7 @@ export class Vector {
* @returns {Vector}
*/
normalize() {
const len = Math_max(1e-5, Math_hypot(this.x, this.y));
const len = Math.max(1e-5, Math.hypot(this.x, this.y));
return new Vector(this.x / len, this.y / len);
}
@ -381,7 +368,7 @@ export class Vector {
* @returns {Vector}
*/
normalizeIfGreaterOne() {
const len = Math_max(1, Math_hypot(this.x, this.y));
const len = Math.max(1, Math.hypot(this.x, this.y));
return new Vector(this.x / len, this.y / len);
}
@ -393,7 +380,7 @@ export class Vector {
normalizedDirection(v) {
const dx = v.x - this.x;
const dy = v.y - this.y;
const len = Math_max(1e-5, Math_hypot(dx, dy));
const len = Math.max(1e-5, Math.hypot(dx, dy));
return new Vector(dx / len, dy / len);
}
@ -437,8 +424,8 @@ export class Vector {
* @returns {Vector} new vector
*/
rotated(angle) {
const sin = Math_sin(angle);
const cos = Math_cos(angle);
const sin = Math.sin(angle);
const cos = Math.cos(angle);
return new Vector(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
}
@ -448,8 +435,8 @@ export class Vector {
* @returns {Vector} this vector
*/
rotateInplaceFastMultipleOf90(angle) {
// const sin = Math_sin(angle);
// const cos = Math_cos(angle);
// const sin = Math.sin(angle);
// const cos = Math.cos(angle);
// let sin = 0, cos = 1;
assert(angle >= 0 && angle <= 360, "Invalid angle, please clamp first: " + angle);
@ -598,7 +585,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) < 1e-5 && Math.abs(this.y - v.y) < epsilon;
}
/**
@ -606,7 +593,7 @@ export class Vector {
* @returns {number} 0 .. 2 PI
*/
angle() {
return Math_atan2(this.y, this.x) + Math_PI / 2;
return Math.atan2(this.y, this.x) + Math.PI / 2;
}
/**
@ -638,7 +625,7 @@ export class Vector {
*/
static deserializeTileFromInt(i) {
const x = i % 256;
const y = Math_floor(i / 256);
const y = Math.floor(i / 256);
return new Vector(x, y);
}

5
src/js/game/automatic_save.js
View File

@ -1,6 +1,5 @@
import { GameRoot } from "./root";
import { globalConfig, IS_DEBUG } from "../core/config";
import { Math_max } from "../core/builtins";
import { createLogger } from "../core/logging";
// How important it is that a savegame is created
@ -29,7 +28,7 @@ export class AutomaticSave {
}
setSaveImportance(importance) {
this.saveImportance = Math_max(this.saveImportance, importance);
this.saveImportance = Math.max(this.saveImportance, importance);
}
doSave() {
@ -54,7 +53,7 @@ export class AutomaticSave {
}
// 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 lastSaveTime = Math.max(this.lastSaveAttempt, this.root.savegame.getRealLastUpdate());
const secondsSinceLastSave = (Date.now() - lastSaveTime) / 1000.0;
let shouldSave = false;

9
src/js/game/belt_path.js
View File

@ -1,4 +1,3 @@
import { Math_min, Math_max } from "../core/builtins";
import { globalConfig } from "../core/config";
import { DrawParameters } from "../core/draw_parameters";
import { createLogger } from "../core/logging";
@ -538,7 +537,7 @@ export class BeltPath extends BasicSerializableObject {
} 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;
const clampedDistanceToNext = Math.min(itemPos + distanceToNext, firstPathLength) - itemPos;
if (clampedDistanceToNext < distanceToNext) {
DEBUG &&
logger.log(
@ -938,9 +937,9 @@ export class BeltPath extends BasicSerializableObject {
const nextDistanceAndItem = this.items[i];
const minimumSpacing = minimumDistance;
const takeAway = Math_max(
const takeAway = Math.max(
0,
Math_min(remainingAmount, nextDistanceAndItem[_nextDistance] - minimumSpacing)
Math.min(remainingAmount, nextDistanceAndItem[_nextDistance] - minimumSpacing)
);
remainingAmount -= takeAway;
@ -984,7 +983,7 @@ export class BeltPath extends BasicSerializableObject {
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);
const localProgress = Math.min(1.0, progress - currentLength);
assert(localProgress >= 0.0, "Invalid local progress: " + localProgress);
const localSpace = beltComp.transformBeltToLocalSpace(localProgress);

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

@ -5,7 +5,6 @@ import { Vector } from "../core/vector";
import { Entity } from "./entity";
import { GameRoot } from "./root";
import { findNiceIntegerValue } from "../core/utils";
import { Math_pow } from "../core/builtins";
import { blueprintShape } from "./upgrades";
import { globalConfig } from "../core/config";
@ -58,7 +57,7 @@ export class Blueprint {
if (G_IS_DEV && globalConfig.debug.blueprintsNoCost) {
return 0;
}
return findNiceIntegerValue(4 * Math_pow(this.entities.length, 1.1));
return findNiceIntegerValue(4 * Math.pow(this.entities.length, 1.1));
}
/**

41
src/js/game/camera.js
View File

@ -1,12 +1,3 @@
import {
Math_abs,
Math_ceil,
Math_floor,
Math_max,
Math_min,
Math_random,
performanceNow,
} from "../core/builtins";
import { clickDetectorGlobals } from "../core/click_detector";
import { globalConfig, SUPPORT_TOUCH } from "../core/config";
import { createLogger } from "../core/logging";
@ -137,8 +128,8 @@ export class Camera extends BasicSerializableObject {
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;
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;
}
/**
@ -181,7 +172,7 @@ export class Camera extends BasicSerializableObject {
const zoomLevelX = this.root.gameWidth / desiredWorldSpaceWidth;
const zoomLevelY = this.root.gameHeight / desiredWorldSpaceWidth;
const finalLevel = Math_min(zoomLevelX, zoomLevelY);
const finalLevel = Math.min(zoomLevelX, zoomLevelY);
assert(
Number.isFinite(finalLevel) && finalLevel > 0,
"Invalid zoom level computed for initial zoom: " + finalLevel
@ -292,10 +283,10 @@ export class Camera extends BasicSerializableObject {
*/
getVisibleRect() {
return Rectangle.fromTRBL(
Math_floor(this.getViewportTop()),
Math_ceil(this.getViewportRight()),
Math_ceil(this.getViewportBottom()),
Math_floor(this.getViewportLeft())
Math.floor(this.getViewportTop()),
Math.ceil(this.getViewportRight()),
Math.ceil(this.getViewportBottom()),
Math.floor(this.getViewportLeft())
);
}
@ -426,7 +417,7 @@ export class Camera extends BasicSerializableObject {
* should get ignored
*/
checkPreventDoubleMouse() {
if (performanceNow() - clickDetectorGlobals.lastTouchTime < 1000.0) {
if (performance.now() - clickDetectorGlobals.lastTouchTime < 1000.0) {
return false;
}
return true;
@ -531,7 +522,7 @@ export class Camera extends BasicSerializableObject {
// event.stopPropagation();
}
clickDetectorGlobals.lastTouchTime = performanceNow();
clickDetectorGlobals.lastTouchTime = performance.now();
this.touchPostMoveVelocity = new Vector(0, 0);
if (event.touches.length === 1) {
@ -565,7 +556,7 @@ export class Camera extends BasicSerializableObject {
// event.stopPropagation();
}
clickDetectorGlobals.lastTouchTime = performanceNow();
clickDetectorGlobals.lastTouchTime = performance.now();
if (event.touches.length === 1) {
const touch = event.touches[0];
@ -585,7 +576,7 @@ export class Camera extends BasicSerializableObject {
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);
const difference = thisDistance / Math.max(0.001, lastDistance);
// Find old center of zoom
let oldCenter = this.lastPinchPositions[0].centerPoint(this.lastPinchPositions[1]);
@ -645,7 +636,7 @@ export class Camera extends BasicSerializableObject {
}
}
clickDetectorGlobals.lastTouchTime = performanceNow();
clickDetectorGlobals.lastTouchTime = performance.now();
if (event.changedTouches.length === 0) {
logger.warn("Touch end without changed touches");
}
@ -753,7 +744,7 @@ export class Camera extends BasicSerializableObject {
* @param {number} dt Delta time in milliseconds
*/
update(dt) {
dt = Math_min(dt, 33);
dt = Math.min(dt, 33);
this.cameraUpdateTimeBucket += dt;
// Simulate movement of N FPS
@ -861,7 +852,7 @@ export class Camera extends BasicSerializableObject {
internalUpdateZooming(now, dt) {
if (!this.currentlyPinching && this.desiredZoom !== null) {
const diff = this.zoomLevel - this.desiredZoom;
if (Math_abs(diff) > 0.0001) {
if (Math.abs(diff) > 0.0001) {
let fade = 0.94;
if (diff > 0) {
// Zoom out faster than in
@ -889,7 +880,7 @@ export class Camera extends BasicSerializableObject {
const length = diff.length();
const tolerance = 1 / this.zoomLevel;
if (length > tolerance) {
const movement = diff.multiplyScalar(Math_min(1, dt * 0.008));
const movement = diff.multiplyScalar(Math.min(1, dt * 0.008));
this.center.x += movement.x;
this.center.y += movement.y;
} else {
@ -905,7 +896,7 @@ export class Camera extends BasicSerializableObject {
*/
internalUpdateKeyboardForce(now, dt) {
if (!this.currentlyMoving && this.desiredCenter == null) {
const limitingDimension = Math_min(this.root.gameWidth, this.root.gameHeight);
const limitingDimension = Math.min(this.root.gameWidth, this.root.gameHeight);
const moveAmount = ((limitingDimension / 2048) * dt) / this.zoomLevel;

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

@ -1,11 +1,10 @@
import { Math_cos, Math_PI, Math_sin } from "../../core/builtins";
import { enumDirection, Vector } from "../../core/vector";
import { types } from "../../savegame/serialization";
import { BeltPath } from "../belt_path";
import { Component } from "../component";
import { Entity } from "../entity";
export const curvedBeltLength = /* Math_PI / 4 */ 0.78;
export const curvedBeltLength = /* Math.PI / 4 */ 0.78;
export class BeltComponent extends Component {
static getId() {
@ -65,13 +64,13 @@ export class BeltComponent extends Component {
case enumDirection.right: {
assert(progress <= curvedBeltLength + 0.02, "Invalid progress 2: " + progress);
const arcProgress = (progress / curvedBeltLength) * 0.5 * Math_PI;
return new Vector(0.5 - 0.5 * Math_cos(arcProgress), 0.5 - 0.5 * Math_sin(arcProgress));
const arcProgress = (progress / curvedBeltLength) * 0.5 * Math.PI;
return new Vector(0.5 - 0.5 * Math.cos(arcProgress), 0.5 - 0.5 * Math.sin(arcProgress));
}
case enumDirection.left: {
assert(progress <= curvedBeltLength + 0.02, "Invalid progress 3: " + progress);
const arcProgress = (progress / curvedBeltLength) * 0.5 * Math_PI;
return new Vector(-0.5 + 0.5 * Math_cos(arcProgress), 0.5 - 0.5 * Math_sin(arcProgress));
const arcProgress = (progress / curvedBeltLength) * 0.5 * Math.PI;
return new Vector(-0.5 + 0.5 * Math.cos(arcProgress), 0.5 - 0.5 * Math.sin(arcProgress));
}
default:
assertAlways(false, "Invalid belt direction: " + this.direction);

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

@ -1,4 +1,3 @@
import { Math_radians } from "../../core/builtins";
import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters";
import { Rectangle } from "../../core/rectangle";
@ -253,7 +252,7 @@ export class StaticMapEntityComponent extends Component {
const rotationCenterY = worldY + globalConfig.halfTileSize;
parameters.context.translate(rotationCenterX, rotationCenterY);
parameters.context.rotate(Math_radians(this.rotation));
parameters.context.rotate(Math.radians(this.rotation));
sprite.drawCached(
parameters,
@ -264,7 +263,7 @@ export class StaticMapEntityComponent extends Component {
false
);
parameters.context.rotate(-Math_radians(this.rotation));
parameters.context.rotate(-Math.radians(this.rotation));
parameters.context.translate(-rotationCenterX, -rotationCenterY);
}
}

3
src/js/game/core.js
View File

@ -5,7 +5,6 @@ import { Application } from "../application";
import { BufferMaintainer } from "../core/buffer_maintainer";
import { disableImageSmoothing, enableImageSmoothing, registerCanvas } from "../core/buffer_utils";
import { Math_random } from "../core/builtins";
import { globalConfig } from "../core/config";
import { getDeviceDPI, resizeHighDPICanvas } from "../core/dpi_manager";
import { DrawParameters } from "../core/draw_parameters";
@ -443,7 +442,7 @@ export class GameCore {
for (let i = 0; i < 1e8; ++i) {
sum += i;
}
if (Math_random() > 0.95) {
if (Math.random() > 0.95) {
console.log(sum);
}
}

11
src/js/game/dynamic_tickrate.js
View File

@ -1,7 +1,6 @@
import { GameRoot } from "./root";
import { createLogger } from "../core/logging";
import { globalConfig } from "../core/config";
import { performanceNow, Math_min, Math_round, Math_max } from "../core/builtins";
import { round3Digits } from "../core/utils";
const logger = createLogger("dynamic_tickrate");
@ -35,7 +34,7 @@ export class DynamicTickrate {
onFrameRendered() {
++this.accumulatedFps;
const now = performanceNow();
const now = performance.now();
const timeDuration = now - this.accumulatedFpsLastUpdate;
if (timeDuration > fpsAccumulationTime) {
const avgFps = (this.accumulatedFps / fpsAccumulationTime) * 1000;
@ -65,7 +64,7 @@ export class DynamicTickrate {
}
const desiredFps = this.root.app.settings.getDesiredFps();
this.setTickRate(Math_round(Math_min(desiredFps, this.currentTickRate * 1.2)));
this.setTickRate(Math.round(Math.min(desiredFps, this.currentTickRate * 1.2)));
}
/**
@ -77,7 +76,7 @@ export class DynamicTickrate {
}
const desiredFps = this.root.app.settings.getDesiredFps();
this.setTickRate(Math_round(Math_max(desiredFps / 2, this.currentTickRate * 0.8)));
this.setTickRate(Math.round(Math.max(desiredFps / 2, this.currentTickRate * 0.8)));
}
/**
@ -85,7 +84,7 @@ export class DynamicTickrate {
*/
beginTick() {
assert(this.currentTickStart === null, "BeginTick called twice");
this.currentTickStart = performanceNow();
this.currentTickStart = performance.now();
if (this.capturedTicks.length > this.currentTickRate * 2) {
// Take only a portion of the ticks
@ -119,7 +118,7 @@ export class DynamicTickrate {
*/
endTick() {
assert(this.currentTickStart !== null, "EndTick called without BeginTick");
const duration = performanceNow() - this.currentTickStart;
const duration = performance.now() - this.currentTickStart;
this.capturedTicks.push(duration);
this.currentTickStart = null;
}

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

@ -10,7 +10,6 @@ import { BasicSerializableObject, types } from "../savegame/serialization";
import { EntityComponentStorage } from "./entity_components";
import { Loader } from "../core/loader";
import { drawRotatedSprite } from "../core/draw_utils";
import { Math_radians } from "../core/builtins";
import { gComponentRegistry } from "../core/global_registries";
export class Entity extends BasicSerializableObject {
@ -166,7 +165,7 @@ export class Entity extends BasicSerializableObject {
const slotTile = staticComp.localTileToWorld(slot.pos);
const direction = staticComp.localDirectionToWorld(slot.direction);
const directionVector = enumDirectionToVector[direction];
const angle = Math_radians(enumDirectionToAngle[direction]);
const angle = Math.radians(enumDirectionToAngle[direction]);
context.globalAlpha = slot.item ? 1 : 0.2;
drawRotatedSprite({
@ -189,7 +188,7 @@ export class Entity extends BasicSerializableObject {
for (let k = 0; k < slot.directions.length; ++k) {
const direction = staticComp.localDirectionToWorld(slot.directions[k]);
const directionVector = enumDirectionToVector[direction];
const angle = Math_radians(enumDirectionToAngle[direction] + 180);
const angle = Math.radians(enumDirectionToAngle[direction] + 180);
context.globalAlpha = 0.4;
drawRotatedSprite({
parameters,

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

@ -8,8 +8,6 @@ import { GameSystem } from "./game_system";
import { arrayDelete, arrayDeleteValue } from "../core/utils";
import { DrawParameters } from "../core/draw_parameters";
import { globalConfig } from "../core/config";
import { Math_floor, Math_ceil } from "../core/builtins";
export class GameSystemWithFilter extends GameSystem {
/**
* Constructs a new game system with the given component filter. It will process
@ -71,11 +69,11 @@ export class GameSystemWithFilter extends GameSystem {
let seenUids = new Set();
const chunkStartX = Math_floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math_floor(minY / globalConfig.mapChunkSize);
const chunkStartX = Math.floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math.floor(minY / globalConfig.mapChunkSize);
const chunkEndX = Math_ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math_ceil(maxY / globalConfig.mapChunkSize);
const chunkEndX = Math.ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math.ceil(maxY / globalConfig.mapChunkSize);
const requiredComponents = this.requiredComponentIds;

5
src/js/game/hub_goals.js
View File

@ -1,4 +1,3 @@
import { Math_random } from "../core/builtins";
import { globalConfig } from "../core/config";
import { queryParamOptions } from "../core/query_parameters";
import { clamp, findNiceIntegerValue, randomChoice, randomInt } from "../core/utils";
@ -336,14 +335,14 @@ export class HubGoals extends BasicSerializableObject {
}
// Sometimes shapes are missing
if (Math_random() > 0.85) {
if (Math.random() > 0.85) {
layer[randomInt(0, 3)] = null;
}
// Sometimes they actually are missing *two* ones!
// Make sure at max only one layer is missing it though, otherwise we could
// create an uncreateable shape
if (Math_random() > 0.95 && !anyIsMissingTwo) {
if (Math.random() > 0.95 && !anyIsMissingTwo) {
layer[randomInt(0, 3)] = null;
anyIsMissingTwo = true;
}

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

@ -1,4 +1,3 @@
import { Math_radians } from "../../../core/builtins";
import { globalConfig } from "../../../core/config";
import { DrawParameters } from "../../../core/draw_parameters";
import { drawRotatedSprite } from "../../../core/draw_utils";
@ -368,7 +367,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
sprite: this.lockIndicatorSprite,
x: worldPos.x,
y: worldPos.y,
angle: Math_radians(rotation),
angle: Math.radians(rotation),
size: 12,
offsetY:
-globalConfig.halfTileSize -
@ -432,7 +431,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
sprite,
x: acceptorSlotWsPos.x,
y: acceptorSlotWsPos.y,
angle: Math_radians(enumDirectionToAngle[enumInvertedDirections[worldDirection]]),
angle: Math.radians(enumDirectionToAngle[enumInvertedDirections[worldDirection]]),
size: 13,
offsetY: offsetShift + 13,
});
@ -478,7 +477,7 @@ export class HUDBuildingPlacer extends HUDBuildingPlacerLogic {
sprite,
x: ejectorSLotWsPos.x,
y: ejectorSLotWsPos.y,
angle: Math_radians(enumDirectionToAngle[ejectorSlotWsDirection]),
angle: Math.radians(enumDirectionToAngle[ejectorSlotWsDirection]),
size: 13,
offsetY: offsetShift,
});

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

@ -1,4 +1,3 @@
import { Math_abs, Math_degrees, Math_round } from "../../../core/builtins";
import { globalConfig } from "../../../core/config";
import { gMetaBuildingRegistry } from "../../../core/global_registries";
import { Signal, STOP_PROPAGATION } from "../../../core/signal";
@ -565,10 +564,10 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
// Place from start to corner
const pathToCorner = this.currentDirectionLockCorner.sub(startTile);
const deltaToCorner = pathToCorner.normalize().round();
const lengthToCorner = Math_round(pathToCorner.length());
const lengthToCorner = Math.round(pathToCorner.length());
let currentPos = startTile.copy();
let rotation = (Math.round(Math_degrees(deltaToCorner.angle()) / 90) * 90 + 360) % 360;
let rotation = (Math.round(Math.degrees(deltaToCorner.angle()) / 90) * 90 + 360) % 360;
if (lengthToCorner > 0) {
for (let i = 0; i < lengthToCorner; ++i) {
@ -583,10 +582,10 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
// Place from corner to end
const pathFromCorner = mouseTile.sub(this.currentDirectionLockCorner);
const deltaFromCorner = pathFromCorner.normalize().round();
const lengthFromCorner = Math_round(pathFromCorner.length());
const lengthFromCorner = Math.round(pathFromCorner.length());
if (lengthFromCorner > 0) {
rotation = (Math.round(Math_degrees(deltaFromCorner.angle()) / 90) * 90 + 360) % 360;
rotation = (Math.round(Math.degrees(deltaFromCorner.angle()) / 90) * 90 + 360) % 360;
for (let i = 0; i < lengthFromCorner + 1; ++i) {
result.push({
tile: currentPos.copy(),
@ -722,7 +721,7 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
).pressed
) {
const delta = newPos.sub(oldPos);
const angleDeg = Math_degrees(delta.angle());
const angleDeg = Math.degrees(delta.angle());
this.currentBaseRotation = (Math.round(angleDeg / 90) * 90 + 360) % 360;
// Holding alt inverts the placement
@ -737,8 +736,8 @@ export class HUDBuildingPlacerLogic extends BaseHUDPart {
let x1 = newPos.x;
let y1 = newPos.y;
var dx = Math_abs(x1 - x0);
var dy = Math_abs(y1 - y0);
var dx = Math.abs(x1 - x0);
var dy = Math.abs(y1 - y0);
var sx = x0 < x1 ? 1 : -1;
var sy = y0 < y1 ? 1 : -1;
var err = dx - dy;

3
src/js/game/hud/parts/debug_info.js
View File

@ -1,6 +1,5 @@
import { BaseHUDPart } from "../base_hud_part";
import { makeDiv, round3Digits, round2Digits } from "../../../core/utils";
import { Math_round } from "../../../core/builtins";
import { DynamicDomAttach } from "../dynamic_dom_attach";
import { KEYMAPPINGS } from "../../key_action_mapper";
@ -34,7 +33,7 @@ export class HUDDebugInfo extends BaseHUDPart {
this.tickRateElement.innerText = "Tickrate: " + this.root.dynamicTickrate.currentTickRate;
this.fpsElement.innerText =
"FPS: " +
Math_round(this.root.dynamicTickrate.averageFps) +
Math.round(this.root.dynamicTickrate.averageFps) +
" (" +
round2Digits(1000 / this.root.dynamicTickrate.averageFps) +
" ms)";

1
src/js/game/hud/parts/pinned_shapes.js
View File

@ -1,4 +1,3 @@
import { Math_max } from "../../../core/builtins";
import { ClickDetector } from "../../../core/click_detector";
import { formatBigNumber, makeDiv, arrayDelete, arrayDeleteValue } from "../../../core/utils";
import { ShapeDefinition } from "../../shape_definition";

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

@ -1,6 +1,5 @@
import { DynamicDomAttach } from "../dynamic_dom_attach";
import { BaseHUDPart } from "../base_hud_part";
import { performanceNow } from "../../../core/builtins";
import { makeDiv } from "../../../core/utils";
import { Signal } from "../../../core/signal";
import { InputReceiver } from "../../../core/input_receiver";
@ -62,15 +61,15 @@ export class HUDProcessingOverlay extends BaseHUDPart {
}
processSync() {
const now = performanceNow();
const now = performance.now();
while (this.tasks.length > 0) {
const workload = this.tasks[0];
workload.call();
this.tasks.shift();
}
const duration = performanceNow() - now;
const duration = performance.now() - now;
if (duration > 100) {
logger.log("Tasks done slow (SYNC!) within", (performanceNow() - now).toFixed(2), "ms");
logger.log("Tasks done slow (SYNC!) within", (performance.now() - now).toFixed(2), "ms");
}
}
@ -89,15 +88,15 @@ export class HUDProcessingOverlay extends BaseHUDPart {
}
this.computeTimeout = setTimeout(() => {
const now = performanceNow();
const now = performance.now();
while (this.tasks.length > 0) {
const workload = this.tasks[0];
workload.call();
this.tasks.shift();
}
const duration = performanceNow() - now;
const duration = performance.now() - now;
if (duration > 100) {
logger.log("Tasks done slow within", (performanceNow() - now).toFixed(2), "ms");
logger.log("Tasks done slow within", (performance.now() - now).toFixed(2), "ms");
}
this.domWatcher.update(false);

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

@ -5,7 +5,6 @@ import { T } from "../../../translations";
import { createLogger } from "../../../core/logging";
import { StaticMapEntityComponent } from "../../components/static_map_entity";
import { Vector } from "../../../core/vector";
import { Math_max, Math_min, Math_floor } from "../../../core/builtins";
import { makeOffscreenBuffer } from "../../../core/buffer_utils";
import { DrawParameters } from "../../../core/draw_parameters";
import { Rectangle } from "../../../core/rectangle";
@ -43,11 +42,11 @@ export class HUDScreenshotExporter extends BaseHUDPart {
const maxTile = new Vector(0, 0);
for (let i = 0; i < staticEntities.length; ++i) {
const bounds = staticEntities[i].components.StaticMapEntity.getTileSpaceBounds();
minTile.x = Math_min(minTile.x, bounds.x);
minTile.y = Math_min(minTile.y, bounds.y);
minTile.x = Math.min(minTile.x, bounds.x);
minTile.y = Math.min(minTile.y, bounds.y);
maxTile.x = Math_max(maxTile.x, bounds.x + bounds.w);
maxTile.y = Math_max(maxTile.y, bounds.y + bounds.h);
maxTile.x = Math.max(maxTile.x, bounds.x + bounds.w);
maxTile.y = Math.max(maxTile.y, bounds.y + bounds.h);
}
const minChunk = minTile.divideScalar(globalConfig.mapChunkSize).floor();
@ -57,10 +56,10 @@ export class HUDScreenshotExporter extends BaseHUDPart {
logger.log("Dimensions:", dimensions);
let chunkSizePixels = 128;
const maxDimensions = Math_max(dimensions.x, dimensions.y);
const maxDimensions = Math.max(dimensions.x, dimensions.y);
if (maxDimensions > 128) {
chunkSizePixels = Math_max(1, Math_floor(128 * (128 / maxDimensions)));
chunkSizePixels = Math.max(1, Math.floor(128 * (128 / maxDimensions)));
}
logger.log("ChunkSizePixels:", chunkSizePixels);

3
src/js/game/hud/parts/shop.js
View File

@ -1,4 +1,3 @@
import { Math_min } from "../../../core/builtins";
import { ClickDetector } from "../../../core/click_detector";
import { InputReceiver } from "../../../core/input_receiver";
import { formatBigNumber, makeDiv } from "../../../core/utils";
@ -178,7 +177,7 @@ export class HUDShop extends BaseHUDPart {
const { progressLabel, progressBar, definition, required } = handle.requireIndexToElement[i];
const haveAmount = this.root.hubGoals.getShapesStored(definition);
const progress = Math_min(haveAmount / required, 1.0);
const progress = Math.min(haveAmount / required, 1.0);
progressLabel.innerText = formatBigNumber(haveAmount) + " / " + formatBigNumber(required);
progressBar.style.width = progress * 100.0 + "%";

3
src/js/game/hud/parts/statistics.js
View File

@ -1,4 +1,3 @@
import { Math_min } from "../../../core/builtins";
import { InputReceiver } from "../../../core/input_receiver";
import { makeButton, makeDiv, removeAllChildren, capitalizeFirstLetter } from "../../../core/utils";
import { KeyActionMapper, KEYMAPPINGS } from "../../key_action_mapper";
@ -179,7 +178,7 @@ export class HUDStatistics extends BaseHUDPart {
let rendered = new Set();
for (let i = 0; i < Math_min(entries.length, 200); ++i) {
for (let i = 0; i < Math.min(entries.length, 200); ++i) {
const entry = entries[i];
const shapeKey = entry[0];

5
src/js/game/hud/parts/waypoints.js
View File

@ -1,5 +1,4 @@
import { makeOffscreenBuffer } from "../../../core/buffer_utils";
import { Math_max, Math_PI, Math_radians } from "../../../core/builtins";
import { globalConfig, IS_DEMO } from "../../../core/config";
import { DrawParameters } from "../../../core/draw_parameters";
import { Loader } from "../../../core/loader";
@ -270,7 +269,7 @@ export class HUDWaypoints extends BaseHUDPart {
center: { x: position.x, y: position.y },
// Make sure the zoom is *just* a bit above the zoom level where the map overview
// starts, so you always see all buildings
zoomLevel: Math_max(this.root.camera.zoomLevel, globalConfig.mapChunkOverviewMinZoom + 0.05),
zoomLevel: Math.max(this.root.camera.zoomLevel, globalConfig.mapChunkOverviewMinZoom + 0.05),
});
// Sort waypoints by name
@ -419,7 +418,7 @@ export class HUDWaypoints extends BaseHUDPart {
if (this.currentCompassOpacity > 0.01) {
context.globalAlpha = this.currentCompassOpacity;
const angle = cameraPos.angle() + Math_radians(45) + Math_PI / 2;
const angle = cameraPos.angle() + Math.radians(45) + Math.PI / 2;
context.translate(dims / 2, dims / 2);
context.rotate(angle);
this.directionIndicatorSprite.drawCentered(context, 0, 0, indicatorSize);

5
src/js/game/hud/trailer_maker.js
View File

@ -1,7 +1,6 @@
import { GameRoot } from "../root";
import { globalConfig } from "../../core/config";
import { Vector, mixVector } from "../../core/vector";
import { performanceNow } from "../../core/builtins";
import { lerp } from "../../core/utils";
/* dev:start */
@ -87,7 +86,7 @@ export class TrailerMaker {
if (!nextMarker.startTime) {
console.log("Starting to approach", nextMarker.pos);
nextMarker.startTime = performanceNow() / 1000.0;
nextMarker.startTime = performance.now() / 1000.0;
}
const speed =
@ -98,7 +97,7 @@ export class TrailerMaker {
// this.currentPlaybackOrigin.distance(Vector.fromSerializedObject(nextMarker.pos)) / speed;
const time = nextMarker.time;
const progress = (performanceNow() / 1000.0 - nextMarker.startTime) / time;
const progress = (performance.now() / 1000.0 - nextMarker.startTime) / time;
if (progress > 1.0) {
if (nextMarker.wait > 0) {

4
src/js/game/key_action_mapper.js
View File

@ -7,8 +7,6 @@ import { Application } from "../application";
import { Signal, STOP_PROPAGATION } from "../core/signal";
import { IS_MOBILE } from "../core/config";
import { T } from "../translations";
import { JSON_stringify } from "../core/builtins";
function key(str) {
return str.toUpperCase().charCodeAt(0);
}
@ -446,7 +444,7 @@ export class KeyActionMapper {
getBinding(binding) {
// @ts-ignore
const id = binding.id;
assert(id, "Not a valid keybinding: " + JSON_stringify(binding));
assert(id, "Not a valid keybinding: " + JSON.stringify(binding));
assert(this.keybindings[id], "Keybinding " + id + " not known!");
return this.keybindings[id];
}

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

@ -3,7 +3,6 @@ import { Entity } from "./entity";
import { Vector, enumDirectionToVector, enumDirection } from "../core/vector";
import { MetaBuilding } from "./meta_building";
import { StaticMapEntityComponent } from "./components/static_map_entity";
import { Math_abs, performanceNow } from "../core/builtins";
import { createLogger } from "../core/logging";
import { MetaBeltBaseBuilding, arrayBeltVariantToRotation } from "./buildings/belt_base";
import { SOUNDS } from "../platform/sound";
@ -199,9 +198,9 @@ export class GameLogic {
logger.warn("Running bulk operation ...");
assert(!this.root.bulkOperationRunning, "Can not run two bulk operations twice");
this.root.bulkOperationRunning = true;
const now = performanceNow();
const now = performance.now();
const returnValue = operation();
const duration = performanceNow() - now;
const duration = performance.now() - now;
logger.log("Done in", round2Digits(duration), "ms");
assert(this.root.bulkOperationRunning, "Bulk operation = false while bulk operation was running");
this.root.bulkOperationRunning = false;
@ -244,7 +243,7 @@ export class GameLogic {
for (let dx = -1; dx <= 1; ++dx) {
for (let dy = -1; dy <= 1; ++dy) {
if (Math_abs(dx) + Math_abs(dy) !== 1) {
if (Math.abs(dx) + Math.abs(dy) !== 1) {
continue;
}

9
src/js/game/map.js
View File

@ -5,7 +5,6 @@ import { GameRoot } from "./root";
import { globalConfig } from "../core/config";
import { Vector } from "../core/vector";
import { Entity } from "./entity";
import { Math_floor } from "../core/builtins";
import { createLogger } from "../core/logging";
import { BaseItem } from "./base_item";
import { MapChunkView } from "./map_chunk_view";
@ -71,8 +70,8 @@ export class BaseMap extends BasicSerializableObject {
* @returns {MapChunkView}
*/
getOrCreateChunkAtTile(tileX, tileY) {
const chunkX = Math_floor(tileX / globalConfig.mapChunkSize);
const chunkY = Math_floor(tileY / globalConfig.mapChunkSize);
const chunkX = Math.floor(tileX / globalConfig.mapChunkSize);
const chunkY = Math.floor(tileY / globalConfig.mapChunkSize);
return this.getChunk(chunkX, chunkY, true);
}
@ -83,8 +82,8 @@ export class BaseMap extends BasicSerializableObject {
* @returns {MapChunkView?}
*/
getChunkAtTileOrNull(tileX, tileY) {
const chunkX = Math_floor(tileX / globalConfig.mapChunkSize);
const chunkY = Math_floor(tileY / globalConfig.mapChunkSize);
const chunkX = Math.floor(tileX / globalConfig.mapChunkSize);
const chunkY = Math.floor(tileY / globalConfig.mapChunkSize);
return this.getChunk(chunkX, chunkY, false);
}

21
src/js/game/map_chunk.js
View File

@ -2,7 +2,6 @@
import { GameRoot } from "./root";
/* typehints:end */
import { Math_ceil, Math_max, Math_min, Math_round } from "../core/builtins";
import { globalConfig } from "../core/config";
import { createLogger } from "../core/logging";
import { clamp, fastArrayDeleteValueIfContained, make2DUndefinedArray } from "../core/utils";
@ -66,7 +65,7 @@ export class MapChunk {
* @param {number=} overrideY Override the Y position of the patch
*/
internalGeneratePatch(rng, patchSize, item, overrideX = null, overrideY = null) {
const border = Math_ceil(patchSize / 2 + 3);
const border = Math.ceil(patchSize / 2 + 3);
// Find a position within the chunk which is not blocked
let patchX = rng.nextIntRange(border, globalConfig.mapChunkSize - border - 1);
@ -88,7 +87,7 @@ export class MapChunk {
for (let i = 0; i <= numCircles; ++i) {
// Determine circle parameters
const circleRadius = Math_min(1 + i, patchSize);
const circleRadius = Math.min(1 + i, patchSize);
const circleRadiusSquare = circleRadius * circleRadius;
const circleOffsetRadius = (numCircles - i) / 2 + 2;
@ -101,8 +100,8 @@ export class MapChunk {
for (let dx = -circleRadius * circleScaleX - 2; dx <= circleRadius * circleScaleX + 2; ++dx) {
for (let dy = -circleRadius * circleScaleY - 2; dy <= circleRadius * circleScaleY + 2; ++dy) {
const x = Math_round(circleX + dx);
const y = Math_round(circleY + dy);
const x = Math.round(circleX + dx);
const y = Math.round(circleY + dy);
if (x >= 0 && x < globalConfig.mapChunkSize && y >= 0 && y <= globalConfig.mapChunkSize) {
const originalDx = dx / circleScaleX;
const originalDy = dy / circleScaleY;
@ -158,9 +157,9 @@ export class MapChunk {
// Later there is a mix of everything
weights = {
[enumSubShape.rect]: 100,
[enumSubShape.circle]: Math_round(50 + clamp(distanceToOriginInChunks * 2, 0, 50)),
[enumSubShape.star]: Math_round(20 + clamp(distanceToOriginInChunks, 0, 30)),
[enumSubShape.windmill]: Math_round(6 + clamp(distanceToOriginInChunks / 2, 0, 20)),
[enumSubShape.circle]: Math.round(50 + clamp(distanceToOriginInChunks * 2, 0, 50)),
[enumSubShape.star]: Math.round(20 + clamp(distanceToOriginInChunks, 0, 30)),
[enumSubShape.windmill]: Math.round(6 + clamp(distanceToOriginInChunks / 2, 0, 20)),
};
if (distanceToOriginInChunks < 7) {
@ -239,20 +238,20 @@ export class MapChunk {
}
const chunkCenter = new Vector(this.x, this.y).addScalar(0.5);
const distanceToOriginInChunks = Math_round(chunkCenter.length());
const distanceToOriginInChunks = Math.round(chunkCenter.length());
// Determine how likely it is that there is a color patch
const colorPatchChance = 0.9 - clamp(distanceToOriginInChunks / 25, 0, 1) * 0.5;
if (rng.next() < colorPatchChance / 4) {
const colorPatchSize = Math_max(2, Math_round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
const colorPatchSize = Math.max(2, Math.round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
this.internalGenerateColorPatch(rng, colorPatchSize, distanceToOriginInChunks);
}
// Determine how likely it is that there is a shape patch
const shapePatchChance = 0.9 - clamp(distanceToOriginInChunks / 25, 0, 1) * 0.5;
if (rng.next() < shapePatchChance / 4) {
const shapePatchSize = Math_max(2, Math_round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
const shapePatchSize = Math.max(2, Math.round(1 + clamp(distanceToOriginInChunks / 8, 0, 4)));
this.internalGenerateShapePatch(rng, shapePatchSize, distanceToOriginInChunks);
}
}

1
src/js/game/map_chunk_view.js
View File

@ -3,7 +3,6 @@ import { GameRoot } from "./root";
import { globalConfig } from "../core/config";
import { DrawParameters } from "../core/draw_parameters";
import { round1Digit } from "../core/utils";
import { Math_max, Math_round } from "../core/builtins";
import { Rectangle } from "../core/rectangle";
import { createLogger } from "../core/logging";
import { smoothenDpi } from "../core/dpi_manager";

25
src/js/game/map_view.js
View File

@ -1,4 +1,3 @@
import { Math_max, Math_min, Math_floor, Math_ceil } from "../core/builtins";
import { globalConfig } from "../core/config";
import { DrawParameters } from "../core/draw_parameters";
import { BaseMap } from "./map";
@ -142,11 +141,11 @@ export class MapView extends BaseMap {
const minX = left - border;
const maxX = right + border - 1;
const chunkStartX = Math_floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math_floor(minY / globalConfig.mapChunkSize);
const chunkStartX = Math.floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math.floor(minY / globalConfig.mapChunkSize);
const chunkEndX = Math_ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math_ceil(maxY / globalConfig.mapChunkSize);
const chunkEndX = Math.ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math.ceil(maxY / globalConfig.mapChunkSize);
// Render y from top down for proper blending
for (let chunkX = chunkStartX; chunkX <= chunkEndX; ++chunkX) {
@ -196,11 +195,11 @@ export class MapView extends BaseMap {
const minX = left - border;
const maxX = right + border - 1;
const chunkStartX = Math_floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math_floor(minY / globalConfig.mapChunkSize);
const chunkStartX = Math.floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math.floor(minY / globalConfig.mapChunkSize);
const chunkEndX = Math_ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math_ceil(maxY / globalConfig.mapChunkSize);
const chunkEndX = Math.ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math.ceil(maxY / globalConfig.mapChunkSize);
// Render y from top down for proper blending
for (let chunkX = chunkStartX; chunkX <= chunkEndX; ++chunkX) {
@ -223,11 +222,11 @@ export class MapView extends BaseMap {
const minX = left - border;
const maxX = right + border - 1;
const chunkStartX = Math_floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math_floor(minY / globalConfig.mapChunkSize);
const chunkStartX = Math.floor(minX / globalConfig.mapChunkSize);
const chunkStartY = Math.floor(minY / globalConfig.mapChunkSize);
const chunkEndX = Math_ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math_ceil(maxY / globalConfig.mapChunkSize);
const chunkEndX = Math.ceil(maxX / globalConfig.mapChunkSize);
const chunkEndY = Math.ceil(maxY / globalConfig.mapChunkSize);
// Render y from top down for proper blending
for (let chunkX = chunkStartX; chunkX <= chunkEndX; ++chunkX) {

9
src/js/game/shape_definition.js
View File

@ -1,5 +1,4 @@
import { makeOffscreenBuffer } from "../core/buffer_utils";
import { JSON_parse, JSON_stringify, Math_max, Math_PI, Math_radians } from "../core/builtins";
import { globalConfig } from "../core/config";
import { smoothenDpi } from "../core/dpi_manager";
import { DrawParameters } from "../core/draw_parameters";
@ -235,7 +234,7 @@ export class ShapeDefinition extends BasicSerializableObject {
* @returns {Array<ShapeLayer>}
*/
internalCloneLayers() {
return JSON_parse(JSON_stringify(this.layers));
return JSON.parse(JSON.stringify(this.layers));
}
/**
@ -340,7 +339,7 @@ export class ShapeDefinition extends BasicSerializableObject {
for (let layerIndex = 0; layerIndex < this.layers.length; ++layerIndex) {
const quadrants = this.layers[layerIndex];
const layerScale = Math_max(0.1, 0.9 - layerIndex * 0.22);
const layerScale = Math.max(0.1, 0.9 - layerIndex * 0.22);
for (let quadrantIndex = 0; quadrantIndex < 4; ++quadrantIndex) {
if (!quadrants[quadrantIndex]) {
@ -352,7 +351,7 @@ export class ShapeDefinition extends BasicSerializableObject {
const centerQuadrantX = quadrantPos.x * quadrantHalfSize;
const centerQuadrantY = quadrantPos.y * quadrantHalfSize;
const rotation = Math_radians(quadrantIndex * 90);
const rotation = Math.radians(quadrantIndex * 90);
context.translate(centerQuadrantX, centerQuadrantY);
context.rotate(rotation);
@ -414,7 +413,7 @@ export class ShapeDefinition extends BasicSerializableObject {
insetPadding + -quadrantHalfSize,
-insetPadding + quadrantHalfSize,
quadrantSize * layerScale,
-Math_PI * 0.5,
-Math.PI * 0.5,
0
);
context.closePath();

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

@ -1,4 +1,3 @@
import { Math_min } from "../../core/builtins";
import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters";
import { gMetaBuildingRegistry } from "../../core/global_registries";
@ -482,7 +481,7 @@ export class BeltSystem extends GameSystemWithFilter {
}
// Limit speed to avoid belts going backwards
const speedMultiplier = Math_min(this.root.hubGoals.getBeltBaseSpeed(), 10);
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(), 10);
// SYNC with systems/item_acceptor.js:drawEntityUnderlays!
// 126 / 42 is the exact animation speed of the png animation

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

@ -6,7 +6,6 @@ import { enumDirectionToVector, enumDirectionToAngle } from "../../core/vector";
import { ItemAcceptorComponent } from "../components/item_acceptor";
import { Loader } from "../../core/loader";
import { drawRotatedSprite } from "../../core/draw_utils";
import { Math_radians, Math_min } from "../../core/builtins";
import { BELT_ANIM_COUNT } from "./belt";
export class ItemAcceptorSystem extends GameSystemWithFilter {
@ -98,7 +97,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
}
// Limit speed to avoid belts going backwards
const speedMultiplier = Math_min(this.root.hubGoals.getBeltBaseSpeed(), 10);
const speedMultiplier = Math.min(this.root.hubGoals.getBeltBaseSpeed(), 10);
const underlays = acceptorComp.beltUnderlays;
for (let i = 0; i < underlays.length; ++i) {
@ -118,7 +117,7 @@ export class ItemAcceptorSystem extends GameSystemWithFilter {
sprite: this.underlayBeltSprites[animationIndex % this.underlayBeltSprites.length],
x: (transformedPos.x + 0.5) * globalConfig.tileSize,
y: (transformedPos.y + 0.5) * globalConfig.tileSize,
angle: Math_radians(angle),
angle: Math.radians(angle),
size: globalConfig.tileSize,
});
}

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

@ -1,4 +1,3 @@
import { Math_min } from "../../core/builtins";
import { globalConfig } from "../../core/config";
import { DrawParameters } from "../../core/draw_parameters";
import { createLogger } from "../../core/logging";
@ -207,7 +206,7 @@ export class ItemEjectorSystem extends GameSystemWithFilter {
const targetEntity = sourceSlot.cachedTargetEntity;
// Advance items on the slot
sourceSlot.progress = Math_min(1, sourceSlot.progress + progressGrowth);
sourceSlot.progress = Math.min(1, sourceSlot.progress + progressGrowth);
// Check if we are still in the process of ejecting, can't proceed then
if (sourceSlot.progress < 1.0) {

3
src/js/game/systems/item_processor.js
View File

@ -1,4 +1,3 @@
import { Math_max } from "../../core/builtins";
import { globalConfig } from "../../core/config";
import { BaseItem } from "../base_item";
import { enumColorMixingResults } from "../colors";
@ -21,7 +20,7 @@ export class ItemProcessorSystem extends GameSystemWithFilter {
const ejectorComp = entity.components.ItemEjector;
// First of all, process the current recipe
processorComp.secondsUntilEject = Math_max(
processorComp.secondsUntilEject = Math.max(
0,
processorComp.secondsUntilEject - this.root.dynamicTickrate.deltaSeconds
);

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

@ -1,4 +1,3 @@
import { Math_max } from "../../core/builtins";
import { globalConfig } from "../../core/config";
import { Loader } from "../../core/loader";
import {
@ -40,7 +39,7 @@ export class UndergroundBeltSystem extends GameSystemWithFilter {
// Decrease remaining time of all items in belt
for (let k = 0; k < pendingItems.length; ++k) {
const item = pendingItems[k];
item[1] = Math_max(0, item[1] - delta);
item[1] = Math.max(0, item[1] - delta);
if (G_IS_DEV && globalConfig.debug.instantBelts) {
item[1] = 0;
}

7
src/js/game/time/game_time.js
View File

@ -6,7 +6,6 @@ import { types, BasicSerializableObject } from "../../savegame/serialization";
import { RegularGameSpeed } from "./regular_game_speed";
import { BaseGameSpeed } from "./base_game_speed";
import { PausedGameSpeed } from "./paused_game_speed";
import { performanceNow, Math_max } from "../../core/builtins";
import { FastForwardGameSpeed } from "./fast_forward_game_speed";
import { gGameSpeedRegistry } from "../../core/global_registries";
import { globalConfig } from "../../core/config";
@ -55,7 +54,7 @@ export class GameTime extends BasicSerializableObject {
* Fetches the new "real" time, called from the core once per frame, since performance now() is kinda slow
*/
updateRealtimeNow() {
this.realtimeSeconds = performanceNow() / 1000.0 + this.realtimeAdjust;
this.realtimeSeconds = performance.now() / 1000.0 + this.realtimeAdjust;
}
/**
@ -104,7 +103,7 @@ export class GameTime extends BasicSerializableObject {
}
// Check for too big pile of updates -> reduce it to 1
let maxLogicSteps = Math_max(
let maxLogicSteps = Math.max(
3,
(this.speed.getMaxLogicStepsInQueue() * this.root.dynamicTickrate.currentTickRate) / 60
);
@ -209,7 +208,7 @@ export class GameTime extends BasicSerializableObject {
}
// Adjust realtime now difference so they match
this.realtimeAdjust = this.realtimeSeconds - performanceNow() / 1000.0;
this.realtimeAdjust = this.realtimeSeconds - performance.now() / 1000.0;
this.updateRealtimeNow();
// Make sure we have a quantizied time

7
src/js/platform/ad_providers/adinplay.js
View File

@ -5,7 +5,6 @@ import { Application } from "../../application";
import { AdProviderInterface } from "../ad_provider";
import { createLogger } from "../../core/logging";
import { ClickDetector } from "../../core/click_detector";
import { performanceNow } from "../../core/builtins";
import { clamp } from "../../core/utils";
import { T } from "../../translations";
@ -52,7 +51,7 @@ export class AdinplayAdProvider extends AdProviderInterface {
return (
this.getHasAds() &&
!this.videoAdResolveFunction &&
performanceNow() - this.lastVideoAdShowTime > minimumTimeBetweenVideoAdsMs
performance.now() - this.lastVideoAdShowTime > minimumTimeBetweenVideoAdsMs
);
}
@ -141,7 +140,7 @@ export class AdinplayAdProvider extends AdProviderInterface {
showVideoAd() {
assert(this.getHasAds(), "Called showVideoAd but ads are not supported!");
assert(!this.videoAdResolveFunction, "Video ad still running, can not show again!");
this.lastVideoAdShowTime = performanceNow();
this.lastVideoAdShowTime = performance.now();
document.body.appendChild(this.adContainerMainElement);
this.adContainerMainElement.classList.add("visible");
this.adContainerMainElement.classList.remove("waitingForFinish");
@ -167,7 +166,7 @@ export class AdinplayAdProvider extends AdProviderInterface {
this.videoAdResolveTimer = null;
// When the ad closed, also set the time
this.lastVideoAdShowTime = performanceNow();
this.lastVideoAdShowTime = performance.now();
resolve();
};

7
src/js/platform/ad_providers/gamedistribution.js
View File

@ -3,7 +3,6 @@ import { Application } from "../../application";
/* typehints:end */
import { AdProviderInterface } from "../ad_provider";
import { performanceNow } from "../../core/builtins";
import { createLogger } from "../../core/logging";
const minimumTimeBetweenVideoAdsMs = G_IS_DEV ? 1 : 5 * 60 * 1000;
@ -45,7 +44,7 @@ export class GamedistributionAdProvider extends AdProviderInterface {
return (
this.getHasAds() &&
!this.videoAdResolveFunction &&
performanceNow() - this.lastVideoAdShowTime > minimumTimeBetweenVideoAdsMs
performance.now() - this.lastVideoAdShowTime > minimumTimeBetweenVideoAdsMs
);
}
@ -84,7 +83,7 @@ export class GamedistributionAdProvider extends AdProviderInterface {
showVideoAd() {
assert(this.getHasAds(), "Called showVideoAd but ads are not supported!");
assert(!this.videoAdResolveFunction, "Video ad still running, can not show again!");
this.lastVideoAdShowTime = performanceNow();
this.lastVideoAdShowTime = performance.now();
console.log("🎬 Gamedistribution: Start ad");
try {
@ -104,7 +103,7 @@ export class GamedistributionAdProvider extends AdProviderInterface {
this.videoAdResolveTimer = null;
// When the ad closed, also set the time
this.lastVideoAdShowTime = performanceNow();
this.lastVideoAdShowTime = performance.now();
resolve();
};

1
src/js/platform/browser/google_analytics.js
View File

@ -1,5 +1,4 @@
import { AnalyticsInterface } from "../analytics";
import { Math_random, performanceNow } from "../../core/builtins";
import { createLogger } from "../../core/logging";
const logger = createLogger("ga");

3
src/js/platform/browser/wrapper.js
View File

@ -1,4 +1,3 @@
import { Math_min } from "../../core/builtins";
import { globalConfig, IS_DEMO, IS_MOBILE } from "../../core/config";
import { createLogger } from "../../core/logging";
import { queryParamOptions } from "../../core/query_parameters";
@ -130,7 +129,7 @@ export class PlatformWrapperImplBrowser extends PlatformWrapperInterface {
return 1;
}
const avgDims = Math_min(this.app.screenWidth, this.app.screenHeight);
const avgDims = Math.min(this.app.screenWidth, this.app.screenHeight);
return clamp((avgDims / 1000.0) * 1.9, 0.1, 10);
}

2
src/js/savegame/savegame.js
View File

@ -209,7 +209,7 @@ export class Savegame extends ReadWriteProxy {
// Construct a new serializer
const serializer = new SavegameSerializer();
// let timer = performanceNow();
// let timer = performance.now();
const dump = serializer.generateDumpFromGameRoot(root);
if (!dump) {
return false;

2
src/js/savegame/savegame_manager.js
View File

@ -3,8 +3,6 @@ import { createLogger } from "../core/logging";
import { ReadWriteProxy } from "../core/read_write_proxy";
import { globalConfig } from "../core/config";
import { Savegame } from "./savegame";
import { Math_floor } from "../core/builtins";
const logger = createLogger("savegame_manager");
const Rusha = require("rusha");

3
src/js/savegame/savegame_serializer.js
View File

@ -3,7 +3,6 @@ import { Component } from "../game/component";
import { GameRoot } from "../game/root";
/* typehints:end */
import { JSON_stringify } from "../core/builtins";
import { ExplainedResult } from "../core/explained_result";
import { createLogger } from "../core/logging";
// import { BuildingComponent } from "../components/impl/building";
@ -88,7 +87,7 @@ export class SavegameSerializer {
// Verify components
if (!entity.components) {
return ExplainedResult.bad(
"Entity is missing key 'components': " + JSON_stringify(entity)
"Entity is missing key 'components': " + JSON.stringify(entity)
);
}
const components = entity.components;

3
src/js/savegame/serialization.js
View File

@ -1,4 +1,3 @@
import { JSON_stringify } from "../core/builtins";
import {
BaseDataType,
TypeArray,
@ -223,7 +222,7 @@ export function serializeSchema(obj, schema, mergeWith = {}) {
);
}
if (!schema[key]) {
assert(false, "Invalid schema (bad key '" + key + "'): " + JSON_stringify(schema));
assert(false, "Invalid schema (bad key '" + key + "'): " + JSON.stringify(schema));
}
if (G_IS_DEV) {

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

@ -5,8 +5,6 @@ import { BasicSerializableObject } from "./serialization";
import { Vector } from "../core/vector";
import { round4Digits, schemaObject, accessNestedPropertyReverse } from "../core/utils";
import { JSON_stringify } from "../core/builtins";
export const globalJsonSchemaDefs = {};
/**
@ -128,7 +126,7 @@ export class BaseDataType {
"serialization verify failed: " +
errorCode +
" [value " +
JSON_stringify(value).substr(0, 100) +
JSON.stringify(value).substr(0, 100) +
"]"
);
}