Archives/tobspr_shapez.io
1
0
Fork 0
mirror of https://github.com/tobspr/shapez.io.git synced 2026-03-02 03:39:21 +00:00
Code Issues Projects Releases Wiki Activity

Initial support for saving games

Browse Source
This commit is contained in:
tobspr
2020-05-14 21:54:11 +02:00
parent 23874c43dc
commit b01d38e55d
44 changed files with 690 additions and 777 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -84,39 +84,6 @@ class AsynCompression {
});
}
/**
* Compresses regulary
* @param {string} text
*/
compressX64Async(text) {
if (text.length < 1024) {
// Ok so this is not worth it
return Promise.resolve(compressX64(text));
}
return this.internalQueueJob("compressX64", text);
}
/**
* Compresses with checksum
* @param {any} obj
*/
compressWithChecksum(obj) {
const stringified = JSON_stringify(obj);
return this.internalQueueJob("compressWithChecksum", stringified);
}
/**
* Compresses with checksum
* @param {any} data The packets data
* @param {number} packetId The numeric packet id
*/
compressPacket(data, packetId) {
return this.internalQueueJob("compressPacket", {
data,
packetId,
});
}
/**
* Queues a new job
* @param {string} job

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

@@ -73,11 +73,11 @@ export const globalConfig = {
/* dev:start */
// fastGameEnter: true,
noArtificialDelays: true,
disableSavegameWrite: false,
// disableSavegameWrite: true,
showEntityBounds: false,
showAcceptorEjectors: false,
usePlainShapeIds: true,
// disableMusic: true,
disableMusic: true,
doNotRenderStatics: false,
disableZoomLimits: false,
showChunkBorders: false,

175
src/js/core/perlin_noise.js
View File

@@ -1,175 +0,0 @@
import { perlinNoiseData } from "./perlin_noise_data";
import { Math_sqrt } from "./builtins";
class Grad {
constructor(x, y, z) {
this.x = x;
this.y = y;
this.z = z;
}
dot2(x, y) {
return this.x * x + this.y * y;
}
dot3(x, y, z) {
return this.x * x + this.y * y + this.z * z;
}
}
function fade(t) {
return t * t * t * (t * (t * 6 - 15) + 10);
}
function lerp(a, b, t) {
return (1 - t) * a + t * b;
}
const F2 = 0.5 * (Math_sqrt(3) - 1);
const G2 = (3 - Math_sqrt(3)) / 6;
const F3 = 1 / 3;
const G3 = 1 / 6;
export class PerlinNoise {
constructor(seed) {
this.perm = new Array(512);
this.gradP = new Array(512);
this.grad3 = [
new Grad(1, 1, 0),
new Grad(-1, 1, 0),
new Grad(1, -1, 0),
new Grad(-1, -1, 0),
new Grad(1, 0, 1),
new Grad(-1, 0, 1),
new Grad(1, 0, -1),
new Grad(-1, 0, -1),
new Grad(0, 1, 1),
new Grad(0, -1, 1),
new Grad(0, 1, -1),
new Grad(0, -1, -1),
];
this.seed = seed;
this.initializeFromSeed(seed);
}
initializeFromSeed(seed) {
const P = perlinNoiseData;
if (seed > 0 && seed < 1) {
// Scale the seed out
seed *= 65536;
}
seed = Math.floor(seed);
if (seed < 256) {
seed |= seed << 8;
}
for (let i = 0; i < 256; i++) {
let v;
if (i & 1) {
v = P[i] ^ (seed & 255);
} else {
v = P[i] ^ ((seed >> 8) & 255);
}
this.perm[i] = this.perm[i + 256] = v;
this.gradP[i] = this.gradP[i + 256] = this.grad3[v % 12];
}
}
/**
* 2d Perlin Noise
* @param {number} x
* @param {number} y
* @returns {number}
*/
computePerlin2(x, y) {
// Find unit grid cell containing point
let X = Math.floor(x),
Y = Math.floor(y);
// Get relative xy coordinates of point within that cell
x = x - X;
y = y - Y;
// Wrap the integer cells at 255 (smaller integer period can be introduced here)
X = X & 255;
Y = Y & 255;
// Calculate noise contributions from each of the four corners
let n00 = this.gradP[X + this.perm[Y]].dot2(x, y);
let n01 = this.gradP[X + this.perm[Y + 1]].dot2(x, y - 1);
let n10 = this.gradP[X + 1 + this.perm[Y]].dot2(x - 1, y);
let n11 = this.gradP[X + 1 + this.perm[Y + 1]].dot2(x - 1, y - 1);
// Compute the fade curve value for x
let u = fade(x);
// Interpolate the four results
return lerp(lerp(n00, n10, u), lerp(n01, n11, u), fade(y));
}
computeSimplex2(xin, yin) {
var n0, n1, n2; // Noise contributions from the three corners
// Skew the input space to determine which simplex cell we're in
var s = (xin + yin) * F2; // Hairy factor for 2D
var i = Math.floor(xin + s);
var j = Math.floor(yin + s);
var t = (i + j) * G2;
var x0 = xin - i + t; // The x,y distances from the cell origin, unskewed.
var y0 = yin - j + t;
// For the 2D case, the simplex shape is an equilateral triangle.
// Determine which simplex we are in.
var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
if (x0 > y0) {
// lower triangle, XY order: (0,0)->(1,0)->(1,1)
i1 = 1;
j1 = 0;
} else {
// upper triangle, YX order: (0,0)->(0,1)->(1,1)
i1 = 0;
j1 = 1;
}
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
// c = (3-sqrt(3))/6
var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
var y1 = y0 - j1 + G2;
var x2 = x0 - 1 + 2 * G2; // Offsets for last corner in (x,y) unskewed coords
var y2 = y0 - 1 + 2 * G2;
// Work out the hashed gradient indices of the three simplex corners
i &= 255;
j &= 255;
var gi0 = this.gradP[i + this.perm[j]];
var gi1 = this.gradP[i + i1 + this.perm[j + j1]];
var gi2 = this.gradP[i + 1 + this.perm[j + 1]];
// Calculate the contribution from the three corners
var t0 = 0.5 - x0 * x0 - y0 * y0;
if (t0 < 0) {
n0 = 0;
} else {
t0 *= t0;
n0 = t0 * t0 * gi0.dot2(x0, y0); // (x,y) of grad3 used for 2D gradient
}
var t1 = 0.5 - x1 * x1 - y1 * y1;
if (t1 < 0) {
n1 = 0;
} else {
t1 *= t1;
n1 = t1 * t1 * gi1.dot2(x1, y1);
}
var t2 = 0.5 - x2 * x2 - y2 * y2;
if (t2 < 0) {
n2 = 0;
} else {
t2 *= t2;
n2 = t2 * t2 * gi2.dot2(x2, y2);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to return values in the interval [-1,1].
return 70 * (n0 + n1 + n2);
}
}

258
src/js/core/perlin_noise_data.js
View File

@@ -1,258 +0,0 @@
export const perlinNoiseData = [
151,
160,
137,
91,
90,
15,
131,
13,
201,
95,
96,
53,
194,
233,
7,
225,
140,
36,
103,
30,
69,
142,
8,
99,
37,
240,
21,
10,
23,
190,
6,
148,
247,
120,
234,
75,
0,
26,
197,
62,
94,
252,
219,
203,
117,
35,
11,
32,
57,
177,
33,
88,
237,
149,
56,
87,
174,
20,
125,
136,
171,
168,
68,
175,
74,
165,
71,
134,
139,
48,
27,
166,
77,
146,
158,
231,
83,
111,
229,
122,
60,
211,
133,
230,
220,
105,
92,
41,
55,
46,
245,
40,
244,
102,
143,
54,
65,
25,
63,
161,
1,
216,
80,
73,
209,
76,
132,
187,
208,
89,
18,
169,
200,
196,
135,
130,
116,
188,
159,
86,
164,
100,
109,
198,
173,
186,
3,
64,
52,
217,
226,
250,
124,
123,
5,
202,
38,
147,
118,
126,
255,
82,
85,
212,
207,
206,
59,
227,
47,
16,
58,
17,
182,
189,
28,
42,
223,
183,
170,
213,
119,
248,
152,
2,
44,
154,
163,
70,
221,
153,
101,
155,
167,
43,
172,
9,
129,
22,
39,
253,
19,
98,
108,
110,
79,
113,
224,
232,
178,
185,
112,
104,
218,
246,
97,
228,
251,
34,
242,
193,
238,
210,
144,
12,
191,
179,
162,
241,
81,
51,
145,
235,
249,
14,
239,
107,
49,
192,
214,
31,
181,
199,
106,
157,
184,
84,
204,
176,
115,
121,
50,
45,
127,
4,
150,
254,
138,
236,
205,
93,
222,
114,
67,
29,
24,
72,
243,
141,
128,
195,
78,
66,
215,
61,
156,
180,
];

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

@@ -11,6 +11,7 @@ import { JSON_stringify, JSON_parse } from "./builtins";
import { ExplainedResult } from "./explained_result";
import { decompressX64, compressX64 } from ".//lzstring";
import { asyncCompressor, compressionPrefix } from "./async_compression";
import { compressObject, decompressObject } from "../savegame/savegame_compressor";
const logger = createLogger("read_write_proxy");
@@ -89,7 +90,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(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");
@@ -149,7 +150,7 @@ export class ReadWriteProxy {
.then(rawData => {
if (rawData == null) {
// So, the file has not been found, use default data
return JSON_stringify(this.getDefaultData());
return JSON_stringify(compressObject(this.getDefaultData()));
}
if (rawData.startsWith(compressionPrefix)) {
@@ -198,6 +199,9 @@ export class ReadWriteProxy {
}
})
// Decompress
.then(compressed => decompressObject(compressed))
// Verify basic structure
.then(contents => {
const result = this.internalVerifyBasicStructure(contents);

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

@@ -90,6 +90,15 @@ export class RandomNumberGenerator {
return this.internalRng();
}
/**
* Random choice of an array
* @param {array} array
*/
choice(array) {
const index = this.nextIntRange(0, array.length);
return array[index];
}
/**
* @param {number} min
* @param {number} max

43
src/js/core/sensitive_utils.encrypt.js
View File

@@ -17,46 +17,3 @@ export function sha1(str) {
export function getNameOfProvider() {
return window[decodeHashedString("DYewxghgLgliB2Q")][decodeHashedString("BYewzgLgdghgtgUyA")];
}
export function compressWithChecksum(object) {
const stringified = JSON.stringify(object);
const checksum = Rusha.createHash()
.update(stringified + encryptKey)
.digest("hex");
return compressX64(checksum + stringified);
}
export function decompressWithChecksum(binary) {
let decompressed = null;
try {
decompressed = decompressX64(binary);
} catch (err) {
throw new Error("failed-to-decompress");
}
// Split into checksum and content
if (!decompressed || decompressed.length < 41) {
throw new Error("checksum-missing");
}
const checksum = decompressed.substr(0, 40);
const rawData = decompressed.substr(40);
// Validate checksum
const computedChecksum = Rusha.createHash()
.update(rawData + encryptKey)
.digest("hex");
if (computedChecksum !== checksum) {
throw new Error("checksum-mismatch");
}
// Try parsing the JSON
let data = null;
try {
data = JSON.parse(rawData);
} catch (err) {
throw new Error("failed-to-parse");
}
return data;
}

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

@@ -825,3 +825,37 @@ export function fastRotateMultipleOf90(x, y, deg) {
}
}
}
/**
* 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 "one second ago";
}
return seconds + " seconds ago";
} else if (minutes <= 60) {
if (minutes <= 1) {
return "one minute ago";
}
return minutes + " minutes ago";
} else if (hours <= 60) {
if (hours <= 1) {
return "one hour ago";
}
return hours + " hour ago";
} else {
if (days <= 1) {
return "one day ago";
}
return days + " days ago";
}
}