John Alanbrook
a8865594ca
Some checks failed
Build and Deploy / package-dist (push) Blocked by required conditions
Build and Deploy / deploy-itch (push) Blocked by required conditions
Build and Deploy / deploy-gitea (push) Blocked by required conditions
Build and Deploy / build-linux (push) Successful in 1m13s
Build and Deploy / build-windows (CLANG64) (push) Failing after 14m3s
700 lines
16 KiB
JavaScript
700 lines
16 KiB
JavaScript
(function engine() {
|
|
prosperon.DOC = Symbol('+documentation+') // Symbol for documentation references
|
|
|
|
var listeners = new Map()
|
|
|
|
prosperon.on = function(type, callback) {
|
|
if (!listeners.has(type)) listeners.set(type, [])
|
|
listeners.get(type).push(callback)
|
|
|
|
return function() {
|
|
var arr = listeners.get(type)
|
|
if (!arr) return
|
|
var idx = arr.indexOf(callback)
|
|
if (idx >= 0) arr.splice(idx,1)
|
|
}
|
|
}
|
|
|
|
prosperon.dispatch = function(type, data) {
|
|
var arr = listeners.get(type)
|
|
if (!arr) return
|
|
for (var callback of arr) callback(data)
|
|
}
|
|
|
|
var os = use_embed('os')
|
|
var js = use_embed('js')
|
|
|
|
prosperon.on('SIGINT', function() {
|
|
os.exit(1)
|
|
})
|
|
|
|
prosperon.on('SIGABRT', function() {
|
|
console.error(new Error('SIGABRT'))
|
|
os.exit(1)
|
|
})
|
|
|
|
prosperon.on('SIGSEGV', function() {
|
|
console.error(new Error('SIGSEGV'))
|
|
os.exit(1)
|
|
})
|
|
|
|
var use_cache = {}
|
|
|
|
Object.defineProperty(Function.prototype, "hashify", {
|
|
value: function () {
|
|
var hash = new Map()
|
|
var fn = this
|
|
function hashified(...args) {
|
|
var key = args[0]
|
|
if (!hash.has(key)) hash.set(key, fn(...args))
|
|
return hash.get(key)
|
|
}
|
|
return hashified
|
|
},
|
|
})
|
|
|
|
var io = use_embed('io')
|
|
var tracy = use_embed('tracy')
|
|
|
|
var RESPATH = 'scripts/modules/resources.js'
|
|
var canonical = io.realdir(RESPATH) + 'resources.js'
|
|
var content = io.slurp(RESPATH)
|
|
var resources = js.eval(RESPATH, `(function setup_resources(){${content}})`).call({})
|
|
|
|
use_cache[resources.canonical('resources.js')] = resources
|
|
|
|
function print_api(obj) {
|
|
for (var prop in obj) {
|
|
if (!obj.hasOwnProperty(prop)) continue
|
|
var val = obj[prop]
|
|
console.log(prop)
|
|
if (typeof val === 'function') {
|
|
var m = val.toString().match(/\(([^)]*)\)/)
|
|
if (m) console.log(' function: ' + prop + '(' + m[1].trim() + ')')
|
|
}
|
|
}
|
|
}
|
|
|
|
prosperon.PATH = [
|
|
"/",
|
|
"scripts/modules/",
|
|
"scripts/modules/ext/",
|
|
]
|
|
|
|
// path is the path of a module or script to resolve
|
|
var script_fn = function script_fn(path) {
|
|
var parsed = {}
|
|
var file = resources.find_script(path)
|
|
|
|
if (!file) {
|
|
parsed.module_ret = bare_load(path)
|
|
if (!parsed.module_ret) throw new Error(`Module ${path} could not be created`)
|
|
return parsed
|
|
}
|
|
|
|
var content = io.slurp(file)
|
|
var parsed = parse_file(content, file)
|
|
var module_name = file.name()
|
|
parsed.module_ret = bare_load(path)
|
|
parsed.module_ret ??= {}
|
|
|
|
if (parsed.module) {
|
|
var mod_script = `(function setup_${module_name}_module(){ var self = this; var $ = this; var exports = {}; var module = {exports: exports}; var define = undefined; ${parsed.module}})`
|
|
var module_fn = js.eval(file, mod_script)
|
|
parsed.module_ret = module_fn.call(parsed.module_ret)
|
|
if (parsed.module_ret === undefined || parsed.module_ret === null)
|
|
throw new Error(`Module ${module_name} must return a value`)
|
|
parsed.module_fn = module_fn
|
|
}
|
|
|
|
parsed.program ??= ""
|
|
var prog_script = `(function use_${module_name}() { var self = this; var $ = this.__proto__; ${parsed.program}})`
|
|
parsed.prog_fn = js.eval(file, prog_script)
|
|
|
|
return parsed
|
|
}.hashify()
|
|
|
|
function bare_load(file) {
|
|
try {
|
|
return use_embed(file)
|
|
} catch (e) { }
|
|
try {
|
|
return use_dyn(file + so_ext)
|
|
} catch(e) { }
|
|
return undefined
|
|
}
|
|
|
|
var res_cache = {}
|
|
|
|
function console_rec(category, priority, line, file, msg) {
|
|
return `${file}:${line}: [${category} ${priority}]: ${msg}\n`
|
|
}
|
|
|
|
io.mkdir('.prosperon')
|
|
var logfile = io.open('.prosperon/log.txt')
|
|
|
|
function pprint(msg, lvl = 0) {
|
|
if (!logfile) return
|
|
|
|
if (typeof msg === "object") msg = JSON.stringify(msg, null, 2)
|
|
|
|
var file = "nofile"
|
|
var line = 0
|
|
|
|
var caller = new Error().stack.split("\n")[2]
|
|
if (caller) {
|
|
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
|
|
}
|
|
var fmt = console_rec("script", lvl, line, file, msg)
|
|
console.print(fmt)
|
|
|
|
if (logfile)
|
|
logfile.write(fmt)
|
|
|
|
if (tracy) tracy.message(fmt)
|
|
}
|
|
|
|
console.spam = function(msg) {
|
|
pprint(msg, 0)
|
|
}
|
|
console.debug = function(msg) {
|
|
pprint(msg, 1)
|
|
}
|
|
console.info = function(msg) {
|
|
pprint(msg, 2)
|
|
}
|
|
console.warn = function(msg) {
|
|
pprint(msg, 3)
|
|
}
|
|
console.log = function(msg) {
|
|
pprint(msg, 2)
|
|
}
|
|
console.error = function(e) {
|
|
if (!e)
|
|
e = new Error()
|
|
|
|
if (e instanceof Error)
|
|
pprint(`${e.name} : ${e.message}
|
|
${e.stack}`, 4)
|
|
else
|
|
pprint(e,4)
|
|
}
|
|
console.panic = function(e) {
|
|
pprint(e, 5)
|
|
os.quit()
|
|
}
|
|
console.assert = function(op, str = `assertion failed [value '${op}']`) {
|
|
if (!op) console.panic(str)
|
|
}
|
|
|
|
os.on('uncaught_exception', function(e) { console.error(e) })
|
|
|
|
console[prosperon.DOC] = {
|
|
doc: "The console object provides various logging, debugging, and output methods.",
|
|
spam: "Output a spam-level message for very verbose logging.",
|
|
debug: "Output a debug-level message.",
|
|
info: "Output info level message.",
|
|
warn: "Output warn level message.",
|
|
error: "Output error level message, and print stacktrace.",
|
|
panic: "Output a panic-level message and exit the program.",
|
|
assert: "If the condition is false, print an error and panic.",
|
|
critical: "Output critical level message, and exit game immediately.",
|
|
write: "Write raw text to console.",
|
|
say: "Write raw text to console, plus a newline.",
|
|
log: "Output directly to in game console.",
|
|
level: "Set level to output logging to console.",
|
|
stack: "Output a stacktrace to console.",
|
|
clear: "Clear console."
|
|
}
|
|
|
|
var BASEPATH = 'scripts/core/base.js'
|
|
var script = io.slurp(BASEPATH)
|
|
var fnname = "base"
|
|
script = `(function ${fnname}() { ${script}; })`
|
|
js.eval(BASEPATH, script)()
|
|
|
|
function add_timer(obj, fn, seconds) {
|
|
var timers = obj[TIMERS]
|
|
|
|
var stop = function () {
|
|
if (!timer) return
|
|
timers.delete(stop)
|
|
timer.fn = undefined
|
|
timer = undefined
|
|
}
|
|
|
|
function execute() {
|
|
if (fn) timer.remain = fn(stop.seconds)
|
|
if (!timer) return
|
|
if (!timer.remain) stop()
|
|
else stop.seconds = timer.remain
|
|
}
|
|
|
|
var timer = os.make_timer(execute)
|
|
timer.remain = seconds
|
|
|
|
stop.remain = seconds
|
|
stop.seconds = seconds
|
|
|
|
timers.push(stop)
|
|
return stop
|
|
}
|
|
|
|
var DEAD = Symbol()
|
|
var GARBAGE = Symbol()
|
|
var FILE = Symbol()
|
|
var TIMERS = Symbol()
|
|
var REGGIES = Symbol()
|
|
var UNDERLINGS = Symbol()
|
|
var OVERLING = Symbol()
|
|
|
|
var actor = {}
|
|
globalThis.actor = actor
|
|
|
|
var so_ext
|
|
switch(os.platform()) {
|
|
case 'Windows':
|
|
so_ext = '.dll'
|
|
break
|
|
default:
|
|
so_ext = '.so'
|
|
break
|
|
}
|
|
|
|
globalThis.use = function use(file) {
|
|
if (use_cache[file]) return use_cache[file]
|
|
var mod = script_fn(file)
|
|
use_cache[file] = mod.module_ret
|
|
return use_cache[file]
|
|
}
|
|
|
|
globalThis.json = use('json')
|
|
|
|
function parse_file(content, file) {
|
|
if (!content) return {}
|
|
var parts = content.split(/\n\s*---\s*\n/)
|
|
if (parts.length === 1) {
|
|
var part = parts[0]
|
|
if (part.match(/return\s+[^;]+;?\s*$/))
|
|
return { module: part }
|
|
return { program: part }
|
|
}
|
|
var module = parts[0]
|
|
if (!/\breturn\b/.test(module))
|
|
throw new Error(`Malformed file: ${file}. Module section must end with a return statement.`);
|
|
|
|
try {
|
|
new Function(module)()
|
|
} catch (e) {
|
|
throw new Error(`Malformed file: ${file}. Module section must end with a return statement.\n` + e.message);
|
|
}
|
|
|
|
var pad = '\n'.repeat(module.split('\n').length+4)
|
|
return {
|
|
module,
|
|
program: pad+parts[1]
|
|
}
|
|
}
|
|
|
|
globalThis.Register = {
|
|
registries: [],
|
|
|
|
add_cb(name) {
|
|
var n = {}
|
|
var fns = []
|
|
|
|
n.register = function (fn, oname) {
|
|
if (typeof fn !== 'function') return
|
|
|
|
var dofn = function (...args) {
|
|
fn(...args)
|
|
}
|
|
Object.defineProperty(dofn, 'name', {value:`do_${oname}`})
|
|
|
|
var left = 0
|
|
var right = fns.length - 1
|
|
dofn.layer = fn.layer
|
|
dofn.layer ??= 0
|
|
|
|
while (left <= right) {
|
|
var mid = Math.floor((left + right) / 2)
|
|
if (fns[mid] === dofn.layer) {
|
|
left = mid
|
|
break
|
|
} else if (fns[mid].layer < dofn.layer) left = mid + 1
|
|
else right = mid - 1
|
|
}
|
|
|
|
fns.splice(left, 0, dofn)
|
|
return function () {
|
|
fns.delete(dofn)
|
|
}
|
|
}
|
|
|
|
prosperon[name] = function (...args) {
|
|
fns.forEach(fn => {
|
|
fn(...args)
|
|
})
|
|
}
|
|
Object.defineProperty(prosperon[name], 'name', {value:name})
|
|
prosperon[name].fns = fns
|
|
|
|
n.clear = function () {
|
|
fns = []
|
|
}
|
|
|
|
Register[name] = n
|
|
Register.registries[name] = n
|
|
return n
|
|
},
|
|
}
|
|
|
|
Register.pull_registers = function pull_registers(obj) {
|
|
var reggies = []
|
|
for (var reg in Register.registries) {
|
|
if (typeof obj[reg] === "function")
|
|
reggies.push(reg)
|
|
}
|
|
return reggies
|
|
}
|
|
|
|
Register.register_obj = function register_obj(obj, reg) {
|
|
var fn = obj[reg].bind(obj)
|
|
fn.layer = obj[reg].layer
|
|
var name = obj.ur ? obj.ur.name : obj.toString()
|
|
obj[TIMERS].push(Register.registries[reg].register(fn, name))
|
|
if (!obj[reg].name) Object.defineProperty(obj[reg], 'name', {value:`${obj._file}_${reg}`})
|
|
}
|
|
|
|
Register.check_registers = function check_registers(obj) {
|
|
if (obj[REGGIES]) {
|
|
if (obj[REGGIES].length == 0) return
|
|
for (var reg of obj[REGGIES])
|
|
Register.register_obj(obj,reg)
|
|
return
|
|
}
|
|
for (var reg in Register.registries) {
|
|
if (typeof obj[reg] === "function")
|
|
Register.register_obj(obj,reg)
|
|
}
|
|
}
|
|
|
|
Register.add_cb("appupdate")
|
|
Register.add_cb("update").doc = "Called once per frame."
|
|
Register.add_cb("physupdate")
|
|
Register.add_cb("gui")
|
|
Register.add_cb("hud")
|
|
Register.add_cb("draw")
|
|
Register.add_cb("imgui")
|
|
Register.add_cb("app")
|
|
|
|
function cant_kill() {
|
|
throw Error("Can't kill an object in its spawning code. Move the kill command to awake.")
|
|
}
|
|
|
|
actor.toString = function() { return this[FILE] }
|
|
|
|
actor.spawn = function spawn(script, config, callback) {
|
|
if (this[DEAD]) throw new Error("Attempting to spawn on a dead actor")
|
|
var prog
|
|
if (!script) {
|
|
prog = {}
|
|
prog.module_ret = {}
|
|
prog.prog_fn = function() {}
|
|
} else {
|
|
prog = script_fn(script)
|
|
if (!prog.prog_fn) throw new Error(`Script ${script} is not an actor script or has no actor component`)
|
|
}
|
|
|
|
var underling
|
|
prog.module_ret.__proto__ = actor
|
|
underling = Object.create(prog.module_ret)
|
|
underling[OVERLING] = this
|
|
underling[FILE] = script
|
|
underling[TIMERS] = []
|
|
underling[UNDERLINGS] = new Set()
|
|
|
|
Object.defineProperty(underling, 'overling', {
|
|
get() { return this[OVERLING] },
|
|
enumerable:true,
|
|
configurable:false
|
|
})
|
|
|
|
Object.defineProperty(underling, 'underlings', {
|
|
get() { return new Set(this[UNDERLINGS]) },
|
|
enumerable:true,
|
|
configurable:false
|
|
})
|
|
|
|
Object.defineProperty(underling, 'spawn', {
|
|
value: actor.spawn,
|
|
writable:false,
|
|
enumerable:true,
|
|
configurable:false
|
|
})
|
|
|
|
Object.defineProperty(underling, 'kill', {
|
|
value: actor.kill,
|
|
writable:false,
|
|
enumerable:true,
|
|
configurable:false
|
|
})
|
|
|
|
Object.defineProperty(underling, 'delay', {
|
|
value: actor.delay,
|
|
writable:false,
|
|
enumerable:true,
|
|
configurable:false
|
|
})
|
|
|
|
if (callback) callback(underling, { message:"created" })
|
|
|
|
try {
|
|
prog.prog_fn.call(underling)
|
|
} catch(e) { throw e }
|
|
|
|
if (underling[DEAD]) return undefined
|
|
|
|
if (typeof config === 'object') Object.assign(underling, config)
|
|
|
|
if (!underling[REGGIES])
|
|
underling.__proto__[REGGIES] = Register.pull_registers(underling)
|
|
|
|
Register.check_registers(underling)
|
|
if (underling.awake) underling.awake()
|
|
|
|
this[UNDERLINGS].add(underling)
|
|
if (underling.tag) act.tag_add(underling.tag, underling)
|
|
|
|
underling[GARBAGE] = underling.garbage
|
|
return underling
|
|
}
|
|
|
|
actor.clear = function actor_clear() {
|
|
this[UNDERLINGS].forEach(p => {
|
|
p.kill()
|
|
})
|
|
this[UNDERLINGS].clear()
|
|
}
|
|
|
|
var input = use('input')
|
|
|
|
actor.kill = function kill() {
|
|
if (this[DEAD]) return
|
|
this[DEAD] = true
|
|
this[TIMERS].slice().forEach(t => t())
|
|
delete this[TIMERS]
|
|
input.do_uncontrol(this)
|
|
|
|
this.clear()
|
|
this[OVERLING][UNDERLINGS].delete(this)
|
|
delete this[UNDERLINGS]
|
|
|
|
if (typeof this.garbage === "function") this.garbage()
|
|
if (typeof this.then === "function") this.then()
|
|
|
|
act.tag_clear_guid(this)
|
|
}
|
|
actor.kill.doc = `Remove this actor and all its underlings from existence.`
|
|
|
|
actor.delay = function(fn, seconds) {
|
|
if (this[DEAD]) return
|
|
add_timer(this, fn, seconds)
|
|
}
|
|
actor.delay.doc = `Call 'fn' after 'seconds' with 'this' set to the actor.`
|
|
|
|
var act = use('actor')
|
|
actor[UNDERLINGS] = new Set()
|
|
|
|
globalThis.mixin("color")
|
|
|
|
var DOCPATH = 'scripts/core/doc.js'
|
|
var script = io.slurp(DOCPATH)
|
|
var fnname = "doc"
|
|
script = `(function ${fnname}() { ${script}; })`
|
|
js.eval(DOCPATH, script)()
|
|
|
|
var enet = use('enet')
|
|
var util = use('util')
|
|
|
|
var $_ = {}
|
|
|
|
var underlings = new Set()
|
|
var overling = undefined
|
|
|
|
var host = enet.create_host()
|
|
$_.host = host
|
|
|
|
console.log(`made a host with port ${host.port()}`)
|
|
|
|
globalThis.$_ = $_
|
|
|
|
var portal = undefined
|
|
|
|
var receive_fn = undefined;
|
|
|
|
$_.contact = function(callback, record)
|
|
{
|
|
|
|
}
|
|
|
|
$_.connection = function(callback, actor, config) {
|
|
var peer = actor.peer;
|
|
callback({
|
|
latency: peer.rtt,
|
|
bandwidth: {
|
|
incoming: peer.incoming_bandwidth,
|
|
outgoing: peer.outgoing_bandwidth
|
|
},
|
|
activity: {
|
|
last_sent: peer.last_send_time,
|
|
last_received: peer.last_receive_time,
|
|
},
|
|
mtu: peer.mtu,
|
|
data: {
|
|
incoming_total: peer.incoming_data_total,
|
|
outgoing_total: peer.outgoing_data_total,
|
|
reliable_in_transit: peer.reliable_data_in_transit
|
|
},
|
|
latency_variance: peer.rtt_variance,
|
|
packet_loss: peer.packet_loss,
|
|
state: peer.state
|
|
});
|
|
};
|
|
|
|
var portal = undefined
|
|
$_.portal = function(fn, port)
|
|
{
|
|
|
|
}
|
|
|
|
$_.receiver = function(fn)
|
|
{
|
|
receive_fn = fn;
|
|
}
|
|
|
|
var greeters = {}
|
|
|
|
$_.start = function(cb, prg, arg)
|
|
{
|
|
var guid = util.guid()
|
|
greeters[guid] = cb
|
|
os.createprocess(["./prosperon", "spawn", "--program", prg, "--overling", $_.host.port(), "--guid", guid])
|
|
guid2actor.set(guid, {peer:undefined, guid:guid})
|
|
}
|
|
|
|
$_.stop = function(actor)
|
|
{
|
|
if (!actor) {
|
|
os.exit(0)
|
|
}
|
|
|
|
actor.peer.send({
|
|
type:"stop",
|
|
})
|
|
}
|
|
|
|
$_.unneeded = function(fn, seconds)
|
|
{
|
|
|
|
}
|
|
|
|
$_.delay = function(fn, seconds)
|
|
{
|
|
var id = os.addtimer(fn, seconds);
|
|
return function() { os.removetimer(id); }
|
|
}
|
|
|
|
var guid2actor = new Map()
|
|
|
|
var couplings = new Set()
|
|
|
|
$_.couple = function(actor)
|
|
{
|
|
couplings.add(actor)
|
|
}
|
|
|
|
use('cmd')(prosperon.argv)
|
|
|
|
if (prosperon.overling)
|
|
$_.host.connect("localhost", args.overling)
|
|
|
|
if (prosperon.program)
|
|
actor.spawn(prosperon.program)
|
|
|
|
if (!prosperon.guid) prosperon.guid = util.guid()
|
|
|
|
var ar = 60 // seconds before reclamation
|
|
|
|
var unneeded_timer = $_.delay($_.stop, ar)
|
|
|
|
function handle_receive(e)
|
|
{
|
|
var data = e.data
|
|
switch(data.type) {
|
|
case "greet":
|
|
if (greeters[data.guid]) {
|
|
var actor = guid2actor.get(data.guid)
|
|
if (!actor) throw new Error(`No registered actor for guid ${data.guid}`)
|
|
actor.peer = e.peer
|
|
guid2actor.set(e.peer, actor)
|
|
greeters[data.guid]({
|
|
type: "greet",
|
|
data: actor
|
|
})
|
|
greeters[data.guid] = undefined
|
|
}
|
|
break
|
|
case "stop":
|
|
console.log("STOPPING!")
|
|
os.exit(0)
|
|
}
|
|
}
|
|
|
|
function handle_actor_disconnect(actor)
|
|
{
|
|
console.log(`actor ${json.encode(actor)} disconnected`)
|
|
guid2actor.delete(actor.guid)
|
|
guid2actor.delete(actor.peer)
|
|
if (couplings.has(actor)) {
|
|
console.log(`I was connected to it, so I'm dying`)
|
|
$_.stop()
|
|
}
|
|
}
|
|
|
|
var hang = 0.016
|
|
while (1) {
|
|
os.waitevent(e => {
|
|
unneeded_timer()
|
|
unneded_timer = $_.delay($_.stop, ar)
|
|
}, hang)
|
|
host.service(e => {
|
|
unneeded_timer()
|
|
switch(e.type) {
|
|
case "connect":
|
|
console.log(`connected. sending greet with guid ${prosperon.guid} to peer ${e.peer}`)
|
|
e.peer.send({
|
|
type: "greet",
|
|
guid: prosperon.guid
|
|
});
|
|
break;
|
|
|
|
case "receive":
|
|
handle_receive(e);
|
|
break;
|
|
|
|
case "disconnect":
|
|
handle_actor_disconnect(guid2actor.get(e.peer))
|
|
break
|
|
}
|
|
unneeded_timer = $_.delay($_.stop, ar)
|
|
}, hang);
|
|
}
|
|
|
|
})()
|