alice.mosphere.at / TIC-80
this repo has no description
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

added BOOT() callback for all the scripts/wasm #1773

nesbox 7e29a1b9 4220da1e

+161 -40
+9 -5
src/api.h
··· 50 50 51 51 typedef struct tic_mem tic_mem; 52 52 typedef void(*tic_tick)(tic_mem* memory); 53 + typedef void(*tic_boot)(tic_mem* memory); 53 54 typedef void(*tic_scanline)(tic_mem* memory, s32 row, void* data); 54 55 typedef void(*tic_border)(tic_mem* memory, s32 row, void* data); 55 56 typedef void(*tic_gamemenu)(tic_mem* memory, s32 index, void* data); ··· 64 65 { 65 66 tic_scanline scanline; 66 67 tic_border border; 67 - tic_gamemenu gamemenu; 68 + tic_gamemenu menu; 68 69 void* data; 69 70 } tic_blit_callback; 70 71 ··· 79 80 void(*close)(tic_mem* memory); 80 81 81 82 tic_tick tick; 83 + tic_boot boot; 82 84 tic_blit_callback callback; 83 85 }; 84 86 ··· 139 141 #undef TIC_SYNC_DEF 140 142 }; 141 143 142 - #define TIC_FN "TIC" 143 - #define SCN_FN "SCN" 144 - #define OVR_FN "OVR" // deprecated since v1.0 145 - #define BDR_FN "BDR" 144 + #define TIC_FN "TIC" 145 + #define BOOT_FN "BOOT" 146 + #define SCN_FN "SCN" 147 + #define OVR_FN "OVR" // deprecated since v1.0 148 + #define BDR_FN "BDR" 146 149 #define MENU_FN "MENU" 147 150 148 151 #define TIC_CALLBACK_LIST(macro) \ 149 152 macro(TIC, TIC_FN "()", "Main function. It's called at " DEF2STR(TIC80_FRAMERATE) \ 150 153 "fps (" DEF2STR(TIC80_FRAMERATE) " times every second).") \ 154 + macro(BOOT, BOOT_FN, "Startup function.") \ 151 155 macro(MENU, MENU_FN "(index)", "Game Menu handler.") \ 152 156 macro(SCN, SCN_FN "(row)", "Allows you to execute code between the drawing of each scanline, " \ 153 157 "for example, to manipulate the palette.") \
+3
src/api/fennel.c
··· 184 184 .init = initFennel, 185 185 .close = closeLua, 186 186 .tick = callLuaTick, 187 + .boot = callLuaBoot, 188 + 187 189 .callback = 188 190 { 189 191 .scanline = callLuaScanline, 190 192 .border = callLuaBorder, 193 + .menu = callLuaMenu, 191 194 }, 192 195 193 196 .getOutline = getFennelOutline,
+17 -2
src/api/js.c
··· 1072 1072 callJavascriptIntCallback(tic, row, data, BDR_FN); 1073 1073 } 1074 1074 1075 - static void callJavascriptGameMenu(tic_mem* tic, s32 index, void* data) 1075 + static void callJavascriptMenu(tic_mem* tic, s32 index, void* data) 1076 1076 { 1077 1077 callJavascriptIntCallback(tic, index, data, MENU_FN); 1078 + } 1079 + 1080 + static void callJavascriptBoot(tic_mem* tic) 1081 + { 1082 + tic_core* core = (tic_core*)tic; 1083 + duk_context* duk = core->currentVM; 1084 + 1085 + if(duk_get_global_string(duk, BOOT_FN)) 1086 + { 1087 + if(duk_pcall(duk, 0) != 0) 1088 + core->data->error(core->data->data, duk_safe_to_stacktrace(duk, -1)); 1089 + } 1090 + 1091 + duk_pop(duk); 1078 1092 } 1079 1093 1080 1094 static const char* const JsKeywords [] = ··· 1160 1174 .init = initJavascript, 1161 1175 .close = closeJavascript, 1162 1176 .tick = callJavascriptTick, 1177 + .boot = callJavascriptBoot, 1163 1178 .callback = 1164 1179 { 1165 1180 .scanline = callJavascriptScanline, 1166 1181 .border = callJavascriptBorder, 1167 - .gamemenu = callJavascriptGameMenu, 1182 + .menu = callJavascriptMenu, 1168 1183 }, 1169 1184 1170 1185 .getOutline = getJsOutline,
+20 -2
src/api/lua.c
··· 1595 1595 callLuaIntCallback(tic, row, data, BDR_FN); 1596 1596 } 1597 1597 1598 - void callLuaGameMenu(tic_mem* tic, s32 index, void* data) 1598 + void callLuaMenu(tic_mem* tic, s32 index, void* data) 1599 1599 { 1600 1600 callLuaIntCallback(tic, index, data, MENU_FN); 1601 + } 1602 + 1603 + void callLuaBoot(tic_mem* tic) 1604 + { 1605 + tic_core* core = (tic_core*)tic; 1606 + lua_State* lua = core->currentVM; 1607 + 1608 + if (lua) 1609 + { 1610 + lua_getglobal(lua, BOOT_FN); 1611 + if(lua_isfunction(lua, -1)) 1612 + { 1613 + if(docall(lua, 0, 0) != LUA_OK) 1614 + core->data->error(core->data->data, lua_tostring(lua, -1)); 1615 + } 1616 + else lua_pop(lua, 1); 1617 + } 1601 1618 } 1602 1619 1603 1620 static const char* const LuaKeywords [] = ··· 1692 1709 .init = initLua, 1693 1710 .close = closeLua, 1694 1711 .tick = callLuaTick, 1712 + .boot = callLuaBoot, 1695 1713 1696 1714 .callback = 1697 1715 { 1698 1716 .scanline = callLuaScanline, 1699 1717 .border = callLuaBorder, 1700 - .gamemenu = callLuaGameMenu, 1718 + .menu = callLuaMenu, 1701 1719 }, 1702 1720 1703 1721 .getOutline = getLuaOutline,
+2
src/api/lua_api.h
··· 33 33 34 34 extern void initLuaAPI(tic_core* core); 35 35 extern void callLuaTick(tic_mem* tic); 36 + extern void callLuaBoot(tic_mem* tic); 36 37 extern void callLuaScanlineName(tic_mem* tic, s32 row, void* data, const char* name); 37 38 extern void callLuaScanline(tic_mem* tic, s32 row, void* data); 38 39 extern void callLuaBorder(tic_mem* tic, s32 row, void* data); 39 40 extern void callLuaOverline(tic_mem* tic, void* data); 41 + extern void callLuaMenu(tic_mem* tic, s32 index, void* data); 40 42 extern void closeLua(tic_mem* tic); 41 43 extern void callLuaTick(tic_mem* tic); 42 44 extern void lua_open_builtins(lua_State *lua);
+3
src/api/moonscript.c
··· 198 198 .init = initMoonscript, 199 199 .close = closeLua, 200 200 .tick = callLuaTick, 201 + .boot = callLuaBoot, 202 + 201 203 .callback = 202 204 { 203 205 .scanline = callLuaScanline, 204 206 .border = callLuaBorder, 207 + .menu = callLuaMenu, 205 208 }, 206 209 207 210 .getOutline = getMoonOutline,
+20 -2
src/api/mruby.c
··· 1092 1092 } 1093 1093 } 1094 1094 1095 + static void callMRubyBoot(tic_mem* tic) 1096 + { 1097 + tic_core* machine = (tic_core*)tic; 1098 + const char* BootFunc = BOOT_FN; 1099 + 1100 + mrb_state* mrb = ((mrbVm*)machine->currentVM)->mrb; 1101 + 1102 + if(mrb) 1103 + { 1104 + if (mrb_respond_to(mrb, mrb_top_self(mrb), mrb_intern_cstr(mrb, BootFunc))) 1105 + { 1106 + mrb_funcall(mrb, mrb_top_self(mrb), BootFunc, 0); 1107 + catcherr(machine); 1108 + } 1109 + } 1110 + } 1111 + 1095 1112 static void callMRubyIntCallback(tic_mem* memory, s32 value, void* data, const char* name) 1096 1113 { 1097 1114 tic_core* machine = (tic_core*)memory; ··· 1116 1133 callMRubyIntCallback(memory, row, data, BDR_FN); 1117 1134 } 1118 1135 1119 - static void callMRubyGameMenu(tic_mem* memory, s32 index, void* data) 1136 + static void callMRubyMenu(tic_mem* memory, s32 index, void* data) 1120 1137 { 1121 1138 callMRubyIntCallback(memory, index, data, MENU_FN); 1122 1139 } ··· 1210 1227 .init = initMRuby, 1211 1228 .close = closeMRuby, 1212 1229 .tick = callMRubyTick, 1230 + .boot = callMRubyBoot, 1213 1231 1214 1232 .callback = 1215 1233 { 1216 1234 .scanline = callMRubyScanline, 1217 1235 .border = callMRubyBorder, 1218 - .gamemenu = callMRubyGameMenu, 1236 + .menu = callMRubyMenu, 1219 1237 }, 1220 1238 1221 1239 .getOutline = getMRubyOutline,
+27 -2
src/api/squirrel.c
··· 1661 1661 } 1662 1662 } 1663 1663 1664 + static void callSquirrelBoot(tic_mem* tic) 1665 + { 1666 + tic_core* core = (tic_core*)tic; 1667 + 1668 + HSQUIRRELVM vm = core->currentVM; 1669 + 1670 + if(vm) 1671 + { 1672 + sq_pushroottable(vm); 1673 + sq_pushstring(vm, BOOT_FN, -1); 1674 + 1675 + if (SQ_SUCCEEDED(sq_get(vm, -2))) 1676 + { 1677 + sq_pushroottable(vm); 1678 + if(SQ_FAILED(sq_call(vm, 1, SQFalse, SQTrue))) 1679 + { 1680 + errorReport(tic); 1681 + return; 1682 + } 1683 + } 1684 + } 1685 + } 1686 + 1664 1687 static void callSquirrelIntCallback(tic_mem* tic, s32 value, void* data, const char* name) 1665 1688 { 1666 1689 tic_core* core = (tic_core*)tic; ··· 1704 1727 callSquirrelIntCallback(tic, row, data, BDR_FN); 1705 1728 } 1706 1729 1707 - static void callSquirrelGameMenu(tic_mem* tic, s32 index, void* data) 1730 + static void callSquirrelMenu(tic_mem* tic, s32 index, void* data) 1708 1731 { 1709 1732 callSquirrelIntCallback(tic, index, data, MENU_FN); 1710 1733 } ··· 1818 1841 .init = initSquirrel, 1819 1842 .close = closeSquirrel, 1820 1843 .tick = callSquirrelTick, 1844 + .boot = callSquirrelBoot, 1845 + 1821 1846 .callback = 1822 1847 { 1823 1848 .scanline = callSquirrelScanline, 1824 1849 .border = callSquirrelBorder, 1825 - .gamemenu = callSquirrelGameMenu, 1850 + .menu = callSquirrelMenu, 1826 1851 }, 1827 1852 1828 1853 .getOutline = getSquirrelOutline,
+32 -19
src/api/wasm.c
··· 42 42 IM3Function BDR_function; 43 43 IM3Function SCN_function; 44 44 IM3Function TIC_function; 45 + IM3Function BOOT_function; 46 + IM3Function MENU_function; 45 47 46 48 #define FATAL(msg, ...) { printf("Error: [Fatal] " msg "\n", ##__VA_ARGS__); goto _onfatal; } 47 49 #define WASM_STACK_SIZE 64*1024 48 - 49 50 50 51 static 51 52 M3Result SuppressLookupFailure (M3Result i_result) ··· 1124 1125 1125 1126 m3_FindFunction (&BDR_function, runtime, BDR_FN); 1126 1127 m3_FindFunction (&SCN_function, runtime, SCN_FN); 1128 + m3_FindFunction (&BOOT_function, runtime, BOOT_FN); 1129 + m3_FindFunction (&MENU_function, runtime, MENU_FN); 1127 1130 result = m3_FindFunction (&TIC_function, runtime, TIC_FN); 1128 1131 1129 1132 if (result) ··· 1148 1151 M3Result res = m3_CallV(TIC_function); 1149 1152 if(res) 1150 1153 { 1151 - core->data->error(core->data->data, res); 1154 + core->data->error(core->data->data, res); 1152 1155 } 1153 1156 } 1154 1157 1155 - static void callWasmScanline(tic_mem* tic, s32 row, void* data) 1158 + static void callWasmBoot(tic_mem* tic) 1156 1159 { 1157 - // ForceExitCounter = 0; 1158 - 1159 1160 tic_core* core = (tic_core*)tic; 1160 1161 1161 1162 IM3Runtime runtime = core->currentVM; 1162 1163 1163 1164 if(!runtime) { return; } 1164 - if (SCN_function == NULL) { return; } 1165 + if (BOOT_function == NULL) { return; } 1165 1166 1166 - M3Result res = m3_CallV(SCN_function, row); 1167 + M3Result res = m3_CallV(BOOT_function); 1167 1168 if(res) 1168 1169 { 1169 - core->data->error(core->data->data, res); 1170 + core->data->error(core->data->data, res); 1170 1171 } 1171 1172 } 1172 1173 1173 - static void callWasmBorder(tic_mem* tic, s32 row, void* data) 1174 + static void callWasmIntFunc(tic_mem* tic, IM3Function func, s32 value, void* data) 1174 1175 { 1175 - // ForceExitCounter = 0; 1176 - 1177 1176 tic_core* core = (tic_core*)tic; 1178 1177 1179 1178 IM3Runtime runtime = core->currentVM; 1180 1179 1181 1180 if(!runtime) { return; } 1182 - if (BDR_function == NULL) { return; } 1181 + if (func == NULL) { return; } 1183 1182 1184 - M3Result res = m3_CallV(BDR_function, row); 1183 + M3Result res = m3_CallV(func, value); 1185 1184 if(res) 1186 1185 { 1187 - core->data->error(core->data->data, res); 1186 + core->data->error(core->data->data, res); 1188 1187 } 1189 1188 } 1190 1189 1191 - // static const char* const WasmKeywords [] = 1192 - // { 1193 - // }; 1190 + static void callWasmScanline(tic_mem* tic, s32 row, void* data) 1191 + { 1192 + callWasmIntFunc(tic, SCN_function, row, data); 1193 + } 1194 + 1195 + static void callWasmBorder(tic_mem* tic, s32 row, void* data) 1196 + { 1197 + callWasmIntFunc(tic, BDR_function, row, data); 1198 + } 1199 + 1200 + static void callWasmMenu(tic_mem* tic, s32 index, void* data) 1201 + { 1202 + callWasmIntFunc(tic, MENU_function, index, data); 1203 + } 1194 1204 1195 1205 static inline bool isalnum_(char c) {return isalnum(c) || c == '_';} 1196 1206 ··· 1266 1276 .init = initWasm, 1267 1277 .close = closeWasm, 1268 1278 .tick = callWasmTick, 1279 + .boot = callWasmBoot, 1280 + 1269 1281 .callback = 1270 1282 { 1271 - .scanline = callWasmScanline, 1272 - .border = callWasmBorder, 1283 + .scanline = callWasmScanline, 1284 + .border = callWasmBorder, 1285 + .menu = callWasmMenu, 1273 1286 }, 1274 1287 1275 1288 .getOutline = getWasmOutline,
+26 -7
src/api/wren.c
··· 35 35 static WrenHandle* game_class = NULL; 36 36 static WrenHandle* new_handle = NULL; 37 37 static WrenHandle* update_handle = NULL; 38 + static WrenHandle* boot_handle = NULL; 38 39 static WrenHandle* scanline_handle = NULL; 39 40 static WrenHandle* border_handle = NULL; 40 - static WrenHandle* gamemenu_handle = NULL; 41 + static WrenHandle* menu_handle = NULL; 41 42 static WrenHandle* overline_handle = NULL; 42 43 43 44 static bool loaded = false; ··· 175 176 }\n\ 176 177 }\n\ 177 178 " TIC_FN "(){}\n\ 179 + " BOOT_FN "(){}\n\ 178 180 " SCN_FN "(row){}\n\ 179 181 " BDR_FN "(row){}\n\ 180 182 " MENU_FN "(index){}\n\ ··· 218 220 { 219 221 wrenReleaseHandle(core->currentVM, new_handle); 220 222 wrenReleaseHandle(core->currentVM, update_handle); 223 + wrenReleaseHandle(core->currentVM, boot_handle); 221 224 wrenReleaseHandle(core->currentVM, scanline_handle); 222 225 wrenReleaseHandle(core->currentVM, border_handle); 223 - wrenReleaseHandle(core->currentVM, gamemenu_handle); 226 + wrenReleaseHandle(core->currentVM, menu_handle); 224 227 wrenReleaseHandle(core->currentVM, overline_handle); 225 228 if (game_class != NULL) 226 229 { ··· 1533 1536 1534 1537 new_handle = wrenMakeCallHandle(vm, "new()"); 1535 1538 update_handle = wrenMakeCallHandle(vm, TIC_FN "()"); 1539 + boot_handle = wrenMakeCallHandle(vm, BOOT_FN "()"); 1536 1540 scanline_handle = wrenMakeCallHandle(vm, SCN_FN "(_)"); 1537 1541 border_handle = wrenMakeCallHandle(vm, BDR_FN "(_)"); 1538 - gamemenu_handle = wrenMakeCallHandle(vm, MENU_FN "(_)"); 1542 + menu_handle = wrenMakeCallHandle(vm, MENU_FN "(_)"); 1539 1543 overline_handle = wrenMakeCallHandle(vm, OVR_FN "()"); 1540 1544 1541 1545 // create game class ··· 1578 1582 { 1579 1583 wrenEnsureSlots(vm, 1); 1580 1584 wrenSetSlotHandle(vm, 0, game_class); 1581 - wrenCall(vm, overline_handle); 1585 + wrenCall(vm, overline_handle); 1582 1586 } 1583 1587 } 1584 1588 } 1585 1589 } 1586 1590 1591 + static void callWrenBoot(tic_mem* tic) 1592 + { 1593 + tic_core* core = (tic_core*)tic; 1594 + WrenVM* vm = core->currentVM; 1595 + 1596 + if(vm && game_class) 1597 + { 1598 + wrenEnsureSlots(vm, 1); 1599 + wrenSetSlotHandle(vm, 0, game_class); 1600 + wrenCall(vm, boot_handle); 1601 + } 1602 + } 1603 + 1587 1604 static void callWrenIntCallback(tic_mem* tic, s32 value, WrenHandle* handle, void* data) 1588 1605 { 1589 1606 tic_core* core = (tic_core*)tic; ··· 1608 1625 callWrenIntCallback(tic, row, border_handle, data); 1609 1626 } 1610 1627 1611 - static void callWrenGameMenu(tic_mem* tic, s32 index, void* data) 1628 + static void callWrenMenu(tic_mem* tic, s32 index, void* data) 1612 1629 { 1613 - callWrenIntCallback(tic, index, gamemenu_handle, data); 1630 + callWrenIntCallback(tic, index, menu_handle, data); 1614 1631 } 1615 1632 1616 1633 static const char* const WrenKeywords [] = ··· 1696 1713 .init = initWren, 1697 1714 .close = closeWren, 1698 1715 .tick = callWrenTick, 1716 + .boot = callWrenBoot, 1717 + 1699 1718 .callback = 1700 1719 { 1701 1720 .scanline = callWrenScanline, 1702 1721 .border = callWrenBorder, 1703 - .gamemenu = callWrenGameMenu, 1722 + .menu = callWrenMenu, 1704 1723 }, 1705 1724 1706 1725 .getOutline = getWrenOutline,
+1
src/core/core.c
··· 469 469 470 470 if (done) 471 471 { 472 + config->boot(tic); 472 473 core->state.tick = config->tick; 473 474 core->state.callback = config->callback; 474 475 core->state.initialized = true;
+1 -1
src/studio/screens/mainmenu.c
··· 228 228 { 229 229 StudioMainMenu* main = data; 230 230 tic_mem* tic = main->tic; 231 - tic_core_script_config(tic)->callback.gamemenu(tic, pos, NULL); 231 + tic_core_script_config(tic)->callback.menu(tic, pos, NULL); 232 232 resumeGame(main->studio); 233 233 } 234 234