prosperon/source/engine/script.c

280 lines
5.2 KiB
C
Raw Normal View History

2021-11-30 21:29:18 -06:00
#include "script.h"
2022-08-01 13:32:58 -05:00
#include "stdio.h"
2022-08-03 17:00:00 -05:00
#include "log.h"
2022-06-21 12:48:19 -05:00
2023-01-10 14:02:24 -06:00
#include "ffi.h"
#include "font.h"
2022-06-21 12:48:19 -05:00
#include "ftw.h"
2022-12-19 09:12:34 -06:00
#include "stb_ds.h"
2023-01-13 13:07:44 -06:00
#include "time.h"
#include "sys/stat.h"
#include "sys/types.h"
2023-04-18 14:49:17 -05:00
JSContext *js = NULL;
2021-11-30 21:29:18 -06:00
static int load_prefab(const char *fpath, const struct stat *sb, int typeflag) {
if (typeflag != FTW_F)
return 0;
if (!strcmp(".prefab", strrchr(fpath, '.')))
2023-01-10 14:02:24 -06:00
script_dofile(fpath);
return 0;
}
2022-08-01 13:32:58 -05:00
void script_init() {
2023-04-18 14:49:17 -05:00
js = duk_create_heap_default();
2022-08-03 17:00:00 -05:00
ffi_load();
/* Load all prefabs into memory */
2023-01-10 14:02:24 -06:00
script_dofile("scripts/engine.js");
script_dofile("config.js");
//ftw(".", load_prefab, 10);
2021-11-30 21:29:18 -06:00
}
2022-08-01 13:32:58 -05:00
void script_run(const char *script) {
2023-04-18 14:49:17 -05:00
duk_eval_string(js, script);
2022-02-06 10:14:57 -06:00
}
2022-08-01 13:32:58 -05:00
2023-01-13 13:07:44 -06:00
time_t file_mod_secs(const char *file) {
struct stat attr;
stat(file, &attr);
return attr.st_mtime;
}
2023-01-13 22:08:39 -06:00
void duk_run_err() {
2023-04-18 14:49:17 -05:00
duk_get_prop_string(js, -1, "lineNumber");
duk_get_prop_string(js, -2, "fileName");
duk_get_prop_string(js, -3, "stack");
mYughLog(1, 2, duk_get_int(js, -3), duk_safe_to_string(js, -2), "%s\n%s", duk_safe_to_string(js, -4), duk_safe_to_string(js, -1));
2023-01-13 22:08:39 -06:00
2023-04-18 14:49:17 -05:00
duk_pop_3(js);
2023-01-13 22:08:39 -06:00
}
2022-11-20 15:50:14 -06:00
int script_dofile(const char *file) {
2023-01-10 14:02:24 -06:00
const char *script = slurp_text(file);
if (!script) {
YughError("Can't find file %s.", file);
return 1;
}
2023-04-18 14:49:17 -05:00
duk_push_string(js, script);
2023-01-10 14:02:24 -06:00
free(script);
2023-04-18 14:49:17 -05:00
duk_push_string(js, file);
2023-01-13 22:08:39 -06:00
2023-04-18 14:49:17 -05:00
if (duk_pcompile(js, 0) != 0) {
2023-01-13 22:08:39 -06:00
duk_run_err();
2023-01-10 14:02:24 -06:00
return 1;
}
2023-04-18 14:49:17 -05:00
if (duk_pcall(js, 0))
2023-01-13 22:08:39 -06:00
duk_run_err();
2023-01-10 14:02:24 -06:00
2023-04-18 14:49:17 -05:00
duk_pop(js);
2023-01-13 13:07:44 -06:00
return file_mod_secs(file);
2022-08-03 17:00:00 -05:00
}
/* Call the "update" function in the master game script */
2022-08-07 01:43:45 -05:00
void script_update(double dt) {
2023-01-10 14:02:24 -06:00
2022-08-03 17:00:00 -05:00
}
/* Call the "draw" function in master game script */
2022-08-03 17:00:00 -05:00
void script_draw() {
2023-01-10 14:02:24 -06:00
2022-08-03 20:49:56 -05:00
}
/* Call "editor" function in master game script */
2022-08-03 20:49:56 -05:00
void script_editor() {
2023-01-10 14:02:24 -06:00
2022-08-05 14:23:39 -05:00
}
2023-01-10 14:02:24 -06:00
/* Call the given function name */
2022-08-05 14:23:39 -05:00
void script_call(const char *f) {
2023-01-10 14:02:24 -06:00
//s7_call(s7, s7_name_to_value(s7, f), s7_nil(s7));
2022-08-07 01:43:45 -05:00
}
/* env is an object in the scripting environment;
s is the function to call on that object
*/
2023-01-10 14:02:24 -06:00
void script_eval_w_env(const char *s, void *env) {
2023-04-18 14:49:17 -05:00
duk_push_heapptr(js, env);
duk_push_string(js, s);
2023-01-09 15:35:05 -06:00
2023-04-18 14:49:17 -05:00
if (!duk_has_prop(js, -2)) {
duk_pop(js);
2023-01-10 14:02:24 -06:00
return;
}
2023-04-18 14:49:17 -05:00
duk_push_string(js, s);
if (duk_pcall_prop(js, -2, 0))
2023-01-13 22:08:39 -06:00
duk_run_err();
2023-04-18 14:49:17 -05:00
duk_pop_2(js);
2022-12-19 18:15:38 -06:00
}
int script_eval_setup(const char *s, void *env)
{
2023-04-18 14:49:17 -05:00
duk_push_heapptr(js, env);
2023-04-18 14:49:17 -05:00
if (!duk_has_prop_string(js, -1, s)) {
duk_pop(js);
return 1;
}
2023-04-18 14:49:17 -05:00
duk_push_string(js, s);
return 0;
}
void script_eval_exec(int argc)
{
2023-04-18 14:49:17 -05:00
if (duk_pcall_prop(js, -2 - argc, argc))
duk_run_err();
2023-04-18 14:49:17 -05:00
duk_pop_2(js);
}
2023-01-10 14:02:24 -06:00
void script_call_sym(void *sym)
2022-08-07 01:43:45 -05:00
{
2023-04-18 14:49:17 -05:00
duk_push_heapptr(js, sym);
if (duk_pcall(js, 0))
2023-01-13 22:08:39 -06:00
duk_run_err();
2023-04-18 14:49:17 -05:00
duk_pop(js);
2022-08-07 01:43:45 -05:00
}
2023-01-10 14:02:24 -06:00
void script_call_sym_args(void *sym, void *args)
2022-12-26 20:57:45 -06:00
{
2023-01-10 14:02:24 -06:00
//s7_call(s7, sym, s7_cons(s7, args, s7_nil(s7)));
}
2022-12-19 09:12:34 -06:00
2023-01-11 16:57:34 -06:00
struct callee *updates = NULL;
struct callee *physics = NULL;
struct callee *guis = NULL;
2023-03-17 10:25:35 -05:00
struct callee *debugs = NULL;
2023-01-19 13:06:32 -06:00
struct callee *nk_guis = NULL;
2023-01-11 16:57:34 -06:00
2023-04-18 14:49:17 -05:00
void unregister_obj(JSValue obj)
{
2023-04-18 14:49:17 -05:00
/* for (int i = arrlen(updates)-1; i >= 0; i--)
if (updates[i].obj == obj) arrdel(updates, i);
for (int i = arrlen(physics)-1; i >= 0; i--)
if (physics[i].obj == obj) arrdel(physics,i);
for (int i = arrlen(guis)-1; i >= 0; i--)
if (guis[i].obj == obj) arrdel(guis,i);
for (int i = arrlen(nk_guis)-1; i >= 0; i--)
2023-03-17 10:25:35 -05:00
if (nk_guis[i].obj == obj) arrdel(nk_guis,i);
for (int i = arrlen(debugs)-1; i >= 0; i--)
if (debugs[i].obj == obj) arrdel(debugs,i);
2023-04-18 14:49:17 -05:00
*/
2023-03-17 10:25:35 -05:00
}
void register_debug(struct callee c) {
arrput(debugs, c);
}
void unregister_gui(struct callee c)
{
for (int i = arrlen(guis)-1; i >= 0; i--) {
2023-04-18 14:49:17 -05:00
/*
if (guis[i].obj == c.obj && guis[i].fn == c.fn) {
arrdel(guis, i);
return;
}
2023-04-18 14:49:17 -05:00
*/
}
}
2023-01-11 16:57:34 -06:00
void register_update(struct callee c) {
arrput(updates, c);
}
void register_gui(struct callee c) {
arrput(guis, c);
}
2023-01-19 13:06:32 -06:00
void register_nk_gui(struct callee c) { arrput(nk_guis, c); }
2023-01-11 16:57:34 -06:00
void register_physics(struct callee c) {
arrput(physics, c);
}
void setup_callee(struct callee c)
{
2023-04-18 14:49:17 -05:00
duk_push_heapptr(js, c.fn);
duk_push_heapptr(js, c.obj);
}
2023-01-13 22:08:39 -06:00
void exec_callee(int argc)
{
2023-04-18 14:49:17 -05:00
if (duk_pcall_method(js, argc))
2023-01-13 22:08:39 -06:00
duk_run_err();
2023-04-18 14:49:17 -05:00
duk_pop(js);
2023-01-11 16:57:34 -06:00
}
void call_callee(struct callee *c) {
setup_callee(*c);
exec_callee(0);
}
2023-01-13 22:08:39 -06:00
void callee_dbl(struct callee c, double d)
{
setup_callee(c);
2023-04-18 14:49:17 -05:00
duk_push_number(js, d);
exec_callee(1);
}
2023-01-13 22:08:39 -06:00
2023-02-13 08:30:35 -06:00
void callee_int(struct callee c, int i)
{
setup_callee(c);
2023-04-18 14:49:17 -05:00
duk_push_int(js, i);
2023-02-13 08:30:35 -06:00
exec_callee(1);
}
void callee_vec2(struct callee c, cpVect vec)
{
setup_callee(c);
vect2duk(vec);
exec_callee(1);
2023-01-09 07:21:45 -06:00
}
2022-12-22 16:58:06 -06:00
void call_updates(double dt) {
2023-03-17 10:25:35 -05:00
for (int i = 0; i < arrlen(updates); i++)
2023-01-11 16:57:34 -06:00
callee_dbl(updates[i], dt);
2022-12-20 19:34:22 -06:00
}
void call_gui() {
for (int i = 0; i < arrlen(guis); i++)
2023-01-18 17:15:36 -06:00
call_callee(&guis[i]);
2022-12-20 19:34:22 -06:00
}
2023-03-17 10:25:35 -05:00
void call_debug() {
for (int i = 0; i < arrlen(debugs); i++)
call_callee(&debugs[i]);
}
2023-01-19 13:06:32 -06:00
void call_nk_gui() {
for (int i = 0; i < arrlen(nk_guis); i++)
call_callee(&nk_guis[i]);
}
2022-12-22 16:58:06 -06:00
void call_physics(double dt) {
2023-03-17 10:25:35 -05:00
for (int i = 0; i < arrlen(physics); i++)
callee_dbl(physics[i], dt);
}
void call_debugs()
{
for (int i = 0; i < arrlen(debugs); i++)
call_callee(&debugs[i]);
2023-01-10 15:41:43 -06:00
}