550 lines
12 KiB
JavaScript
550 lines
12 KiB
JavaScript
"use math";
|
|
var files = {};
|
|
function load(file) {
|
|
var modtime = cmd(0, file);
|
|
files[file] = modtime;
|
|
}
|
|
|
|
load("scripts/base.js");
|
|
load("scripts/std.js");
|
|
|
|
function run(file)
|
|
{
|
|
var modtime = cmd(119, file);
|
|
if (modtime === 0) {
|
|
Log.stack();
|
|
return false;
|
|
}
|
|
|
|
files[file] = modtime;
|
|
return cmd(117, file);
|
|
}
|
|
|
|
function run_env(file, env)
|
|
{
|
|
var script = IO.slurp(file);
|
|
return function(){return eval(script);}.call(env);
|
|
}
|
|
|
|
load("scripts/diff.js");
|
|
Log.level = 1;
|
|
|
|
load("scripts/color.js");
|
|
|
|
function bb2wh(bb) {
|
|
return [bb.r-bb.l, bb.t-bb.b];
|
|
};
|
|
|
|
var Device = {
|
|
pc: [1920,1080],
|
|
macbook_m2: [2560,1664, 13.6],
|
|
ds_top: [400,240, 3.53],
|
|
ds_bottom: [320,240, 3.02],
|
|
playdate: [400,240,2.7],
|
|
switch: [1280,720, 6.2],
|
|
switch_lite: [1280,720,5.5],
|
|
switch_oled: [1280,720,7],
|
|
dsi: [256,192,3.268],
|
|
ds: [256,192, 3],
|
|
dsixl: [256,192,4.2],
|
|
ipad_air_m2: [2360,1640, 11.97],
|
|
iphone_se: [1334, 750, 4.7],
|
|
iphone_12_pro: [2532,1170,6.06],
|
|
iphone_15: [2556,1179,6.1],
|
|
gba: [240,160,2.9],
|
|
gameboy: [160,144,2.48],
|
|
gbc: [160,144,2.28],
|
|
steamdeck: [1280,800,7],
|
|
vita: [960,544,5],
|
|
psp: [480,272,4.3],
|
|
imac_m3: [4480,2520,23.5],
|
|
macbook_pro_m3: [3024,1964, 14.2],
|
|
ps1: [320,240,5],
|
|
ps2: [640,480],
|
|
snes: [256,224],
|
|
gamecube: [640,480],
|
|
n64: [320,240],
|
|
c64: [320,200],
|
|
macintosh: [512,342,9],
|
|
gamegear: [160,144,3.2],
|
|
};
|
|
|
|
load("scripts/gui.js");
|
|
|
|
var timer = {
|
|
update(dt) {
|
|
this.remain -= dt;
|
|
if (this.remain <= 0) {
|
|
this.fn();
|
|
this.kill();
|
|
}
|
|
},
|
|
|
|
kill() {
|
|
Register.unregister_obj(this);
|
|
this.fn = undefined;
|
|
},
|
|
|
|
delay(fn, secs) {
|
|
var t = Object.create(this);
|
|
t.time = secs;
|
|
t.remain = secs;
|
|
t.fn = fn;
|
|
Register.update.register(t.update, t);
|
|
return function() { t.kill(); };
|
|
},
|
|
};
|
|
|
|
load("scripts/tween.js");
|
|
|
|
var Render = {
|
|
normal() { cmd(67);},
|
|
wireframe() { cmd(68); },
|
|
|
|
pass() {
|
|
|
|
},
|
|
};
|
|
|
|
Render.doc = {
|
|
doc: "Functions for rendering modes.",
|
|
normal: "Final render with all lighting.",
|
|
wireframe: "Show only wireframes of models."
|
|
};
|
|
|
|
load("scripts/physics.js");
|
|
load("scripts/input.js");
|
|
load("scripts/sound.js");
|
|
load("scripts/ai.js");
|
|
|
|
function screen2world(screenpos) {
|
|
if (Game.camera)
|
|
return Game.camera.view2world(screenpos);
|
|
return screenpos;
|
|
}
|
|
function world2screen(worldpos) { return Game.camera.world2view(worldpos); }
|
|
|
|
var Register = {
|
|
kbm_input(mode, btn, state, ...args) {
|
|
if (state === 'released') {
|
|
btn = btn.split('-').last();
|
|
}
|
|
|
|
switch(mode) {
|
|
case "emacs":
|
|
Player.players[0].raw_input(btn, state, ...args);
|
|
break;
|
|
|
|
case "mouse":
|
|
Player.players[0].mouse_input(btn, state, ...args);
|
|
break;
|
|
|
|
case "char":
|
|
Player.players[0].char_input(btn);
|
|
break;
|
|
};
|
|
},
|
|
|
|
gamepad_playermap: [],
|
|
gamepad_input(pad, btn, state, ...args) {
|
|
var player = this.gamepad_playermap[pad];
|
|
if (!player) return;
|
|
|
|
var statestr = Input.state2str(state);
|
|
|
|
var rawfn = `gamepad_${btn}_${statestr}`;
|
|
player.input(rawfn, ...args);
|
|
|
|
Action.actions.forEach(x => {
|
|
if (x.inputs.includes(btn))
|
|
player.input(`action_${x.name}_${statestr}`, ...args);
|
|
});
|
|
},
|
|
|
|
unregister_obj(obj) {
|
|
Register.registries.forEach(function(x) {
|
|
x.unregister_obj(obj);
|
|
});
|
|
Player.uncontrol(obj);
|
|
},
|
|
|
|
endofloop(fn) {
|
|
if (!this.inloop)
|
|
fn();
|
|
else {
|
|
this.loopcbs.push(fn);
|
|
}
|
|
},
|
|
|
|
clear() {
|
|
Register.registries.forEach(function(n) {
|
|
n.entries = [];
|
|
});
|
|
},
|
|
|
|
registries: [],
|
|
|
|
add_cb(idx, name) {
|
|
var entries = [];
|
|
var n = {};
|
|
n.register = function(fn, obj) {
|
|
if (!obj) {
|
|
Log.error("Refusing to register a function without a destroying object.");
|
|
return;
|
|
}
|
|
entries.push({
|
|
fn: fn,
|
|
obj: obj
|
|
});
|
|
}
|
|
|
|
n.unregister = function(fn) {
|
|
entries = entries.filter(function(e) { return e.fn !== fn; });
|
|
}
|
|
|
|
n.unregister_obj = function(obj) {
|
|
entries = entries.filter(function(e) { return e.obj !== obj; });
|
|
}
|
|
|
|
n.broadcast = function(...args) {
|
|
entries.forEach(x => x.fn.call(x.obj, ...args));
|
|
}
|
|
|
|
n.clear = function() {
|
|
entries = [];
|
|
}
|
|
|
|
register(idx, n.broadcast, n);
|
|
|
|
Register[name] = n;
|
|
Register.registries.push(n);
|
|
|
|
return n;
|
|
},
|
|
};
|
|
|
|
Register.add_cb(0, "update").doc = "Called once per frame.";
|
|
Register.add_cb(11, "appupdate");
|
|
Register.add_cb(1, "physupdate");
|
|
Register.add_cb(2, "gui");
|
|
Register.add_cb(6, "debug");
|
|
register(7, Register.kbm_input, Register);
|
|
Register.add_cb(8, "gamepad_input");
|
|
Register.add_cb(10, "draw");
|
|
|
|
register(9, Log.stack, this);
|
|
|
|
Register.gamepad_playermap[0] = Player.players[0];
|
|
|
|
var Signal = {
|
|
obj_begin(fn, obj, go) {
|
|
register_collide(0, fn, obj, go.body);
|
|
},
|
|
|
|
obj_separate(fn, obj, go) {
|
|
register_collide(3,fn,obj,go.body);
|
|
},
|
|
};
|
|
|
|
var Event = {
|
|
events: {},
|
|
|
|
observe(name, obj, fn) {
|
|
this.events[name] ??= [];
|
|
this.events[name].push([obj, fn]);
|
|
},
|
|
|
|
unobserve(name, obj) {
|
|
this.events[name] = this.events[name].filter(x => x[0] !== obj);
|
|
},
|
|
|
|
rm_obj(obj) {
|
|
Object.keys(this.events).forEach(name => Event.unobserve(name,obj));
|
|
},
|
|
|
|
notify(name) {
|
|
if (!this.events[name]) return;
|
|
this.events[name].forEach(function(x) {
|
|
x[1].call(x[0]);
|
|
});
|
|
},
|
|
};
|
|
|
|
Event.observe('quit', undefined, function() { Primum.kill(); });
|
|
|
|
var Window = {
|
|
fullscreen(f) { cmd(145, f); },
|
|
set width(w) { cmd(125, w); },
|
|
set height(h) { cmd(126, h); },
|
|
get width() { return cmd(48); },
|
|
get height() { return cmd(49); },
|
|
get dimensions() { return [this.width, this.height]; },
|
|
set name(str) { cmd(134, str); },
|
|
boundingbox() {
|
|
return {
|
|
t: Window.height,
|
|
b: 0,
|
|
r: Window.width,
|
|
l: 0
|
|
};
|
|
},
|
|
};
|
|
|
|
Window.icon = function(path) { cmd(90, path); };
|
|
Window.icon.doc = "Set the icon of the window using the PNG image at path.";
|
|
|
|
function reloadfiles() {
|
|
Object.keys(files).forEach(function (x) { load(x); });
|
|
}
|
|
|
|
load("scripts/debug.js");
|
|
|
|
/*
|
|
function Color(from) {
|
|
var color = Object.create(Array);
|
|
Object.defineProperty(color, 'r', setelem(0));
|
|
Object.defineProperty(color, 'g', setelem(1));
|
|
Object.defineProperty(color, 'b', setelem(2));
|
|
Object.defineProperty(color, 'a', setelem(3));
|
|
|
|
color.a = color.g = color.b = color.a = 1;
|
|
Object.assign(color, from);
|
|
|
|
return color;
|
|
};
|
|
*/
|
|
|
|
var Spline = {};
|
|
Spline.sample_angle = function(type, points, angle) {
|
|
return spline_cmd(0, type, points[0].length, points, angle);
|
|
}
|
|
|
|
Spline.bezier_loop = function(cp)
|
|
{
|
|
cp.push(Vector.reflect_point(cp.at(-2),cp.at(-1)));
|
|
cp.push(Vector.reflect_point(cp[1],cp[0]));
|
|
cp.push(cp[0].slice());
|
|
return cp;
|
|
}
|
|
|
|
Spline.bezier_node_count = function(cp)
|
|
{
|
|
if (cp.length === 4) return 2;
|
|
return 2 + (cp.length-4)/3;
|
|
}
|
|
|
|
Spline.is_bezier = function(t) { return t === Spline.type.bezier; }
|
|
Spline.is_catmull = function(t) { return t === Spline.type.catmull; }
|
|
|
|
Spline.bezier2catmull = function(b)
|
|
{
|
|
var c = [];
|
|
for (var i = 0; i < b.length; i += 3)
|
|
c.push(b[i]);
|
|
return c;
|
|
}
|
|
|
|
Spline.catmull2bezier = function(c)
|
|
{
|
|
var b = [];
|
|
for (var i = 1; i < c.length-2; i++) {
|
|
b.push(c[i].slice());
|
|
b.push(c[i+1].sub(c[i-1]).scale(0.25).add(c[i]));
|
|
b.push(c[i].sub(c[i+2]).scale(0.25).add(c[i+1]));
|
|
}
|
|
b.push(c[c.length-2]);
|
|
return b;
|
|
}
|
|
|
|
Spline.catmull_loop = function(cp)
|
|
{
|
|
cp = cp.slice();
|
|
cp.unshift(cp.last());
|
|
cp.push(cp[1]);
|
|
cp.push(cp[2]);
|
|
return cp;
|
|
}
|
|
|
|
Spline.catmull_caps = function(cp)
|
|
{
|
|
cp = cp.slice();
|
|
cp.unshift(cp[0].sub(cp[1]).add(cp[0]));
|
|
cp.push(cp.last().sub(cp.at(-2).add(cp.last())));
|
|
return cp;
|
|
}
|
|
|
|
Spline.catmull2bezier.doc = "Given a set of control points C for a camtull-rom type curve, return a set of cubic bezier points to give the same curve."
|
|
|
|
Spline.type = {
|
|
catmull: 0,
|
|
bezier: 1,
|
|
bspline: 2,
|
|
cubichermite: 3
|
|
};
|
|
|
|
Spline.bezier_tan_partner = function(points, i)
|
|
{
|
|
if (i%3 === 0) return undefined;
|
|
var partner_i = (i%3) === 2 ? i-1 : i+1;
|
|
return points[i];
|
|
}
|
|
|
|
Spline.bezier_cp_mirror = function(points, i)
|
|
{
|
|
if (i%3 === 0) return undefined;
|
|
var partner_i = (i%3) === 2 ? i+2 : i-2;
|
|
var node_i = (i%3) === 2 ? i+1 : i-1;
|
|
if (partner_i >= points.length || node_i >= points.length) return;
|
|
points[partner_i] = points[node_i].sub(points[i]).add(points[node_i]);
|
|
}
|
|
|
|
Spline.bezier_point_handles = function(points, i)
|
|
{
|
|
if (!Spline.bezier_is_node(points,i)) return [];
|
|
var a = i-1;
|
|
var b = i+1;
|
|
var c = []
|
|
if (a > 0)
|
|
c.push(a);
|
|
|
|
if (b < points.length)
|
|
c.push(b);
|
|
|
|
return c;
|
|
}
|
|
|
|
Spline.bezier_nodes = function(points)
|
|
{
|
|
var c = [];
|
|
for (var i = 0; i < points.length; i+=3)
|
|
c.push(points[i].slice());
|
|
|
|
return c;
|
|
}
|
|
|
|
Spline.bezier_is_node = function(points, i) { return i%3 === 0; }
|
|
Spline.bezier_is_handle = function(points, i) { return !Spline.bezier_is_node(points,i); }
|
|
|
|
load("scripts/components.js");
|
|
|
|
var Game = {
|
|
init() {
|
|
if (!Game.edit) {
|
|
load("config.js");
|
|
load("game.js");
|
|
}
|
|
else {
|
|
load("scripts/editor.js");
|
|
load("editorconfig.js");
|
|
editor.enter_editor();
|
|
}
|
|
},
|
|
|
|
native: Device.pc,
|
|
|
|
edit: true,
|
|
|
|
object_count() {
|
|
return cmd(214);
|
|
},
|
|
|
|
all_objects(fn) {
|
|
/* Wind down from Primum */
|
|
},
|
|
|
|
/* Returns a list of objects by name */
|
|
find(name) {
|
|
|
|
},
|
|
|
|
/* Return a list of objects derived from a specific prototype */
|
|
find_proto(proto) {
|
|
|
|
},
|
|
|
|
/* List of all objects spawned that have a specific tag */
|
|
find_tag(tag){
|
|
|
|
},
|
|
|
|
quit() { sys_cmd(0); },
|
|
pause() { sys_cmd(3); },
|
|
stop() { Game.pause(); },
|
|
step() { sys_cmd(4);},
|
|
editor_mode(m) { sys_cmd(10, m); },
|
|
playing() { return sys_cmd(5); },
|
|
paused() { return sys_cmd(6); },
|
|
stepping() { return cmd(79); },
|
|
play() { sys_cmd(1); },
|
|
|
|
wait_fns: [],
|
|
|
|
wait_exec(fn) {
|
|
if (!phys_stepping())
|
|
fn();
|
|
else
|
|
this.wait_fns.push(fn);
|
|
},
|
|
|
|
exec() {
|
|
this.wait_fns.forEach(function(x) { x(); });
|
|
|
|
this.wait_fns = [];
|
|
},
|
|
};
|
|
|
|
Game.doc = {};
|
|
Game.doc.object = "Returns the entity belonging to a given id.";
|
|
Game.doc.quit = "Immediately quit the game.";
|
|
Game.doc.pause = "Pause game simulation.";
|
|
Game.doc.stop = "Stop game simulation. This does the same thing as 'pause', and if the game is a debug build, starts its editor.";
|
|
Game.doc.play = "Resume or start game simulation.";
|
|
Game.doc.editor_mode = "Set to true for the game to only update on input; otherwise the game updates every frame.";
|
|
Game.doc.dt = "Current frame dt.";
|
|
Game.doc.view_camera = "Set the camera for the current view.";
|
|
Game.doc.camera = "Current camera.";
|
|
|
|
Window.doc = {};
|
|
Window.doc.width = "Width of the game window.";
|
|
Window.doc.height = "Height of the game window.";
|
|
Window.doc.dimensions = "Window width and height packaged in an array [width,height]";
|
|
Window.doc.name = "Name in the title bar of the window.";
|
|
Window.doc.boundingbox = "Boundingbox of the window, with top and right being its height and width.";
|
|
|
|
Register.update.register(Game.exec, Game);
|
|
|
|
load("scripts/entity.js");
|
|
|
|
function world_start() {
|
|
globalThis.Primum = Object.create(gameobject);
|
|
Primum.objects = {};
|
|
Primum.check_dirty = function() {};
|
|
Primum.namestr = function(){};
|
|
Primum._ed = {
|
|
selectable:false,
|
|
dirty:false,
|
|
};
|
|
Primum.toString = function() { return "Primum"; };
|
|
Primum.ur = "Primum";
|
|
Primum.kill = function() { this.clear(); };
|
|
Primum.phys = 2;
|
|
gameobject.level = Primum;
|
|
}
|
|
|
|
load("scripts/physics.js");
|
|
|
|
Game.view_camera = function(cam)
|
|
{
|
|
Game.camera = cam;
|
|
cmd(61, Game.camera.body);
|
|
}
|
|
|
|
Window.name = "Primum Machinam (V0.1)";
|
|
Window.width = 1280;
|
|
Window.height = 720;
|
|
|
|
var Asset = {};
|
|
Asset.doc = {
|
|
doc: "Functions to manage the loading and unloading of assets, like sounds and images."
|
|
};
|