prosperon/scripts/engine.js

271 lines
6.5 KiB
JavaScript
Raw Normal View History

2023-12-11 16:59:59 -06:00
"use math";
Object.defineProperty(String.prototype, 'rm', {
value: function(index, endidx = index+1) { return this.slice(0,index) + this.slice(endidx); }
});
2024-06-18 16:14:23 -05:00
Object.defineProperty(String.prototype, "tolast", {
value: function (val) {
2024-04-01 17:58:29 -05:00
var idx = this.lastIndexOf(val);
if (idx === -1) return this.slice();
2024-06-18 16:14:23 -05:00
return this.slice(0, idx);
},
2024-04-01 17:58:29 -05:00
});
2024-06-18 16:14:23 -05:00
Object.defineProperty(String.prototype, "dir", {
value: function () {
if (!this.includes("/")) return "";
return this.tolast("/");
},
2024-04-01 17:58:29 -05:00
});
2024-06-18 16:14:23 -05:00
Object.defineProperty(String.prototype, "folder", {
value: function () {
var dir = this.dir();
if (!dir) return "";
else return dir + "/";
2024-06-18 16:14:23 -05:00
},
});
2024-04-01 17:58:29 -05:00
globalThis.Resources = {};
Resources.rm_fn = function(fn, text)
2024-07-25 16:14:37 -05:00
{
var reg = new RegExp(fn.source + "\\s*\\(");
var match;
while (match = text.match(reg)) {
var last = match.index+match[0].length;
var par = 1;
while (par !== 0) {
if (text[last] === '(') par++;
if (text[last] === ')') par--;
last++;
}
text = text.rm(match.index, last);
}
2024-07-25 16:14:37 -05:00
return text;
}
2024-07-25 16:14:37 -05:00
Resources.rm_fn.doc = "Remove calls to a given function from a given text script.";
2024-06-18 16:14:23 -05:00
Resources.replpath = function (str, path) {
2024-04-01 17:58:29 -05:00
if (!str) return str;
2024-06-18 16:14:23 -05:00
if (str[0] === "/") return str.rm(0);
2024-04-01 17:58:29 -05:00
2024-06-18 16:14:23 -05:00
if (str[0] === "@") return os.prefpath() + "/" + str.rm(0);
2024-04-01 17:58:29 -05:00
if (!path) return str;
2024-06-18 16:14:23 -05:00
2024-04-01 17:58:29 -05:00
var stem = path.dir();
while (stem) {
2024-06-18 16:14:23 -05:00
var tr = stem + "/" + str;
2024-04-01 17:58:29 -05:00
if (io.exists(tr)) return tr;
stem = stem.updir();
}
2024-06-18 16:14:23 -05:00
2024-04-01 17:58:29 -05:00
return str;
2024-06-18 16:14:23 -05:00
};
2024-04-01 17:58:29 -05:00
2024-06-18 16:14:23 -05:00
Resources.replstrs = function (path) {
2024-04-01 17:58:29 -05:00
if (!path) return;
var script = io.slurp(path);
var regexp = /"[^"\s]*?\.[^"\s]+?"/g;
var stem = path.dir();
2024-07-25 16:14:37 -05:00
// remove console statements
script = Resources.rm_fn(/console\.(spam|info|warn|error)/, script);
script = Resources.rm_fn(/profile\.(cache|frame|endcache|endframe)/, script);
script = Resources.rm_fn(/assert/, script);
2024-07-25 16:14:37 -05:00
//script = script.replace(/console\.(.*?)\(.*?\)/g, '');
//script = script.replace(/assert\(.*?\)/g, '');
2024-04-01 17:58:29 -05:00
2024-06-18 16:14:23 -05:00
script = script.replace(regexp, function (str) {
2024-04-01 17:58:29 -05:00
var newstr = Resources.replpath(str.trimchr('"'), path);
return `"${newstr}"`;
});
return script;
2024-06-18 16:14:23 -05:00
};
2024-04-01 17:58:29 -05:00
globalThis.json = {};
2024-06-18 16:14:23 -05:00
json.encode = function (value, replacer, space = 1) {
return JSON.stringify(value, replacer, space);
2024-06-18 16:14:23 -05:00
};
2024-06-18 16:14:23 -05:00
json.decode = function (text, reviver) {
if (!text) return undefined;
2024-06-18 16:14:23 -05:00
return JSON.parse(text, reviver);
};
2024-06-18 16:14:23 -05:00
json.readout = function (obj) {
var j = {};
for (var k in obj)
2024-06-18 16:14:23 -05:00
if (typeof obj[k] === "function") j[k] = "function " + obj[k].toString();
else j[k] = obj[k];
return json.encode(j);
2024-06-18 16:14:23 -05:00
};
json.doc = {
doc: "json implementation.",
encode: "Encode a value to json.",
decode: "Decode a json string to a value.",
2024-06-18 16:14:23 -05:00
readout: "Encode an object fully, including function definitions.",
};
Resources.scripts = ["jsoc", "jsc", "jso", "js"];
Resources.images = ["png", "gif", "jpg", "jpeg"];
2024-06-18 16:14:23 -05:00
Resources.sounds = ["wav", "flac", "mp3", "qoa"];
Resources.is_image = function (path) {
var ext = path.ext();
2024-06-18 16:14:23 -05:00
return Resources.images.any((x) => x === ext);
};
2024-06-18 16:14:23 -05:00
function find_ext(file, ext) {
if (io.exists(file)) return file;
for (var e of ext) {
var nf = `${file}.${e}`;
if (io.exists(nf)) return nf;
}
return;
}
2024-06-18 16:14:23 -05:00
Resources.find_image = function (file) {
return find_ext(file, Resources.images);
};
Resources.find_sound = function (file) {
return find_ext(file, Resources.sounds);
};
Resources.find_script = function (file) {
return find_ext(file, Resources.scripts);
};
2024-04-03 17:17:32 -05:00
console.transcript = "";
2024-06-18 16:14:23 -05:00
console.say = function (msg) {
msg += "\n";
2024-04-03 17:17:32 -05:00
console.print(msg);
console.transcript += msg;
};
console.log = console.say;
2024-04-15 07:58:23 -05:00
globalThis.say = console.say;
globalThis.print = console.print;
2024-04-03 17:17:32 -05:00
2024-06-18 16:14:23 -05:00
console.pprint = function (msg, lvl = 0) {
if (typeof msg === "object") msg = JSON.stringify(msg, null, 2);
2024-04-03 17:17:32 -05:00
var file = "nofile";
var line = 0;
2024-06-18 16:14:23 -05:00
console.rec(0, msg, file, line);
var caller = new Error().stack.split("\n")[2];
if (caller) {
2024-04-03 17:17:32 -05:00
var md = caller.match(/\((.*)\:/);
var m = md ? md[1] : "SCRIPT";
if (m) file = m;
md = caller.match(/\:(\d*)\)/);
m = md ? md[1] : 0;
if (m) line = m;
}
2024-06-18 16:14:23 -05:00
2024-04-03 17:17:32 -05:00
console.rec(lvl, msg, file, line);
};
2024-06-18 16:14:23 -05:00
console.spam = function (msg) {
console.pprint(msg, 0);
};
console.debug = function (msg) {
console.pprint(msg, 1);
};
console.info = function (msg) {
console.pprint(msg, 2);
};
console.warn = function (msg) {
console.pprint(msg, 3);
};
console.error = function (msg) {
console.pprint(msg + "\n" + console.stackstr(2), 4);
};
console.panic = function (msg) {
console.pprint(msg + "\n" + console.stackstr(2), 5);
};
console.stackstr = function (skip = 0) {
2024-04-03 17:17:32 -05:00
var err = new Error();
2024-06-18 16:14:23 -05:00
var stack = err.stack.split("\n");
return stack.slice(skip, stack.length).join("\n");
2024-04-03 17:17:32 -05:00
};
2024-06-18 16:14:23 -05:00
console.stack = function (skip = 0) {
console.log(console.stackstr(skip + 1));
};
2024-03-23 09:56:38 -05:00
console.stdout_lvl = 1;
console.trace = console.stack;
console.doc = {
level: "Set level to output logging to console.",
info: "Output info level message.",
warn: "Output warn level message.",
error: "Output error level message, and print stacktrace.",
critical: "Output critical level message, and exit game immediately.",
write: "Write raw text to console.",
say: "Write raw text to console, plus a newline.",
stack: "Output a stacktrace to console.",
console: "Output directly to in game console.",
2024-06-18 16:14:23 -05:00
clear: "Clear console.",
};
2024-02-25 17:31:48 -06:00
globalThis.global = globalThis;
2023-05-24 20:45:50 -05:00
var use_cache = {};
2024-07-24 14:17:32 -05:00
globalThis.use = function(file, env = {}, script) {
file = Resources.find_script(file);
profile.cache("USE", file);
2024-06-18 16:14:23 -05:00
if (use_cache[file]) {
var ret = use_cache[file].call(env);
return;
}
2024-04-01 17:58:29 -05:00
script ??= Resources.replstrs(file);
2024-04-01 17:58:29 -05:00
script = `(function() { var self = this; ${script}; })`;
2024-06-18 16:14:23 -05:00
var fn = os.eval(file, script);
use_cache[file] = fn;
var ret = fn.call(env);
profile.endcache();
return ret;
}
function stripped_use (file, env = {}, script) {
file = Resources.find_script(file);
2024-07-11 16:37:24 -05:00
if (use_cache[file]) {
var ret = use_cache[file].call(env);
return;
2024-07-23 17:21:27 -05:00
}
script ??= Resources.replstrs(file);
2024-07-23 17:21:27 -05:00
script = `(function() { var self = this; ${script}; })`;
var fn = os.eval(file, script);
var ret = fn.call(env);
profile.endcache();
return ret;
2024-07-23 17:21:27 -05:00
}
function bare_use(file)
2024-07-23 17:21:27 -05:00
{
var script = io.slurp(file);
script = `(function() { var self = this; ${script}; })`;
Object.assign(globalThis, os.eval(file, script).call(globalThis));
2024-04-23 15:58:08 -05:00
}
profile.enabled = false;
2023-11-22 03:51:43 -06:00
bare_use("scripts/base.js");
bare_use("scripts/profile.js");
2023-09-08 12:35:06 -05:00
if (!profile.enabled)
use = stripped_use;
Object.assign(globalThis, use("scripts/prosperon.js"));