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.

main menu refactoring

nesbox 617e5b5f 40d0ff68

+219 -189
+1
src/defines.h
··· 40 40 #define SCOPE(...) for(int MACROVAR(_i_) = 0; !MACROVAR(_i_); ++MACROVAR(_i_), __VA_ARGS__) 41 41 #define FOR(type,it,list) for(type it = list, *MACROVAR(_end_) = it + COUNT_OF(list); it != MACROVAR(_end_); ++it) 42 42 #define RFOR(type,it,list) for(type it = list + (COUNT_OF(list) - 1), *MACROVAR(_end_) = list; it >= MACROVAR(_end_); --it) 43 + #define NEW(o) (o*)malloc(sizeof(o)) 43 44 #define FREE(ptr) do { if(ptr) free(ptr); } while (0) 44 45 45 46 #define BITSET(a,b) ((a) | (1ULL<<(b)))
+3 -3
src/studio/screens/console.c
··· 589 589 590 590 static void onExitCommand(Console* console) 591 591 { 592 - exitStudio(NULL); 592 + exitStudio(); 593 593 commandDone(console); 594 594 } 595 595 ··· 2341 2341 { 2342 2342 commandDone(console); 2343 2343 2344 - resumeGame(NULL); 2344 + resumeGame(); 2345 2345 } 2346 2346 2347 2347 static void onEvalCommand(Console* console) ··· 3796 3796 console->commands.current++; 3797 3797 } 3798 3798 else if(getConfig()->cli) 3799 - exitStudio(NULL); 3799 + exitStudio(); 3800 3800 } 3801 3801 } 3802 3802
+176 -114
src/studio/screens/main_menu.c
··· 20 20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 21 // SOFTWARE. 22 22 23 - #include "studio/studio.h" 24 23 #include "studio/studio_impl.h" 25 - #include "menu.h" 26 24 #include "main_menu.h" 27 25 28 - static struct MenuImpl 26 + struct StudioMainMenu 29 27 { 30 - Menu* menu; 28 + tic_mem* tic; 29 + Menu* menu; 31 30 32 - struct 33 - { 34 - MenuItem* items; 35 - s32 count; 36 - }* gameMenu; 31 + MenuItem* items; 32 + s32 count; 37 33 38 - Gamepads* gamepads; 39 - Config* config; 40 - tic_mem* mem; 41 - } menu_impl; 34 + Gamepads gamepads; 35 + struct StudioOptions* options; 36 + }; 42 37 43 38 #define OPTION_VALUES(...) \ 44 39 .values = (const char*[])__VA_ARGS__, \ 45 40 .count = COUNT_OF(((const char*[])__VA_ARGS__)) 46 41 47 - // TODO: do we need to lock this down further? 48 - static StudioConfig* rwConfig() 42 + static void showMainMenu(void* data, s32 pos); 43 + 44 + StudioMainMenu* studio_mainmenu_init(Menu *menu, Config *config) 49 45 { 50 - return &menu_impl.config->data; 46 + StudioMainMenu* main = NEW(StudioMainMenu); 47 + 48 + *main = (StudioMainMenu) 49 + { 50 + .menu = menu, 51 + .options = &config->data.options, 52 + .tic = config->tic, 53 + .gamepads.key = -1, 54 + }; 55 + 56 + showMainMenu(main, 0); 57 + 58 + return main; 51 59 } 52 60 53 - void initMainMenu(Menu *menu, void *gameMenu, Config *config, tic_mem *mem, Gamepads *gamepads) 61 + static void initGamepadMenu(StudioMainMenu* menu); 62 + 63 + bool studio_mainmenu_keyboard(StudioMainMenu* main) 54 64 { 55 - menu_impl = (struct MenuImpl) 65 + if(main && main->gamepads.key >= 0) 56 66 { 57 - .menu = menu, 58 - .gameMenu = gameMenu, 59 - .config = config, 60 - .mem = mem, 61 - .gamepads = gamepads 62 - }; 67 + tic_key key = *main->tic->ram.input.keyboard.keys; 68 + if(key > tic_key_unknown) 69 + { 70 + main->gamepads.mapping.data[main->gamepads.index * TIC_BUTTONS + main->gamepads.key] = key; 71 + initGamepadMenu(main); 72 + } 73 + 74 + return true; 75 + } 76 + 77 + return false; 63 78 } 64 79 65 - static s32 optionFullscreenGet() 80 + static s32 optionFullscreenGet(void* data) 66 81 { 67 82 return tic_sys_fullscreen_get() ? 1 : 0; 68 83 } 69 84 70 - static void optionFullscreenSet(s32 pos) 85 + static void optionFullscreenSet(void* data, s32 pos) 71 86 { 72 - tic_sys_fullscreen_set(rwConfig()->options.fullscreen = (pos == 1)); 87 + StudioMainMenu* main = data; 88 + tic_sys_fullscreen_set(main->options->fullscreen = (pos == 1)); 73 89 } 74 90 75 91 static const char OffValue[] = "OFF"; ··· 83 99 }; 84 100 85 101 #if defined(CRT_SHADER_SUPPORT) 86 - static s32 optionCrtMonitorGet() 102 + static s32 optionCrtMonitorGet(void* data) 87 103 { 88 - return getConfig()->options.crt ? 1 : 0; 104 + StudioMainMenu* main = data; 105 + return main->options->crt ? 1 : 0; 89 106 } 90 107 91 - static void optionCrtMonitorSet(s32 pos) 108 + static void optionCrtMonitorSet(void* data, s32 pos) 92 109 { 93 - rwConfig()->options.crt = pos == 1; 110 + StudioMainMenu* main = data; 111 + main->options->crt = pos == 1; 94 112 } 95 113 96 114 static MenuOption CrtMonitorOption = ··· 102 120 103 121 #endif 104 122 105 - static s32 optionVSyncGet() 123 + static s32 optionVSyncGet(void* data) 106 124 { 107 - return getConfig()->options.vsync ? 1 : 0; 125 + StudioMainMenu* main = data; 126 + return main->options->vsync ? 1 : 0; 108 127 } 109 128 110 - static void optionVSyncSet(s32 pos) 129 + static void optionVSyncSet(void* data, s32 pos) 111 130 { 112 - rwConfig()->options.vsync = pos == 1; 131 + StudioMainMenu* main = data; 132 + main->options->vsync = pos == 1; 113 133 } 114 134 115 135 static MenuOption VSyncOption = ··· 119 139 optionVSyncSet, 120 140 }; 121 141 122 - static s32 optionVolumeGet() 142 + static s32 optionVolumeGet(void* data) 123 143 { 124 - return getConfig()->options.volume; 144 + StudioMainMenu* main = data; 145 + return main->options->volume; 125 146 } 126 147 127 - static void optionVolumeSet(s32 pos) 148 + static void optionVolumeSet(void* data, s32 pos) 128 149 { 129 - rwConfig()->options.volume = pos; 150 + StudioMainMenu* main = data; 151 + main->options->volume = pos; 130 152 } 131 153 132 154 static MenuOption VolumeOption = ··· 144 166 145 167 #if defined(BUILD_EDITORS) 146 168 147 - static s32 optionDevModeGet() 169 + static s32 optionDevModeGet(void* data) 148 170 { 149 - return getConfig()->options.devmode ? 1 : 0; 171 + StudioMainMenu* main = data; 172 + return main->options->devmode ? 1 : 0; 150 173 } 151 174 152 - static void optionDevModeSet(s32 pos) 175 + static void optionDevModeSet(void* data, s32 pos) 153 176 { 154 - rwConfig()->options.devmode = pos == 1; 177 + StudioMainMenu* main = data; 178 + main->options->devmode = pos == 1; 155 179 } 156 180 157 181 static MenuOption DevModeOption = ··· 163 187 164 188 #endif 165 189 190 + static void showGamepadMenu(void* data, s32 pos) 191 + { 192 + StudioMainMenu* main = data; 193 + main->gamepads.index = 0; 194 + main->gamepads.mapping = main->options->mapping; 195 + 196 + initGamepadMenu(main); 197 + } 198 + 166 199 static const MenuItem OptionMenu[] = 167 200 { 168 201 #if defined(CRT_SHADER_SUPPORT) ··· 179 212 {"BACK", showMainMenu, .back = true}, 180 213 }; 181 214 182 - static void showOptionsMenu(void* data); 183 - static void gameMenuHandler(void* data) 215 + static void showOptionsMenu(void* data, s32 pos); 216 + static void gameMenuHandler(void* data, s32 pos) 184 217 { 185 - tic_mem* tic = menu_impl.mem; 186 - tic_core_script_config(tic)->callback.gamemenu(tic, *(s32*)data, NULL); 187 - resumeGame(NULL); 218 + StudioMainMenu* main = data; 219 + tic_mem* tic = main->tic; 220 + tic_core_script_config(tic)->callback.gamemenu(tic, pos, NULL); 221 + resumeGame(); 188 222 } 189 223 190 - void freeGameMenu() 224 + static void freeItems(StudioMainMenu* menu) 191 225 { 192 - // we may never have opened the menu 193 - if (!menu_impl.gameMenu) return; 194 - 195 - if(menu_impl.gameMenu->items) 226 + if(menu && menu->items) 196 227 { 197 - for(MenuItem *it = menu_impl.gameMenu->items, *end = it + menu_impl.gameMenu->count; it != end; ++it) 228 + for(MenuItem *it = menu->items, *end = it + menu->count; it != end; ++it) 198 229 free((void*)it->label); 199 230 200 - free(menu_impl.gameMenu->items); 201 - menu_impl.gameMenu->count = 0; 202 - menu_impl.gameMenu->items = NULL; 231 + free(menu->items); 232 + menu->count = 0; 233 + menu->items = NULL; 203 234 } 204 235 } 205 236 206 - void initGameMenu() 237 + void studio_mainmenu_free(StudioMainMenu* menu) 207 238 { 208 - tic_mem* tic = menu_impl.mem; 239 + freeItems(menu); 240 + FREE(menu); 241 + } 209 242 210 - freeGameMenu(); 243 + static void initGameMenu(StudioMainMenu* main) 244 + { 245 + tic_mem* tic = main->tic; 246 + 247 + freeItems(main); 211 248 212 249 char* menu = tic_tool_metatag(tic->cart.code.data, "menu", tic_core_script_config(tic)->singleComment); 213 250 ··· 230 267 items[count - 2] = (MenuItem){strdup("")}; 231 268 items[count - 1] = (MenuItem){strdup("BACK"), showMainMenu, .back = true}; 232 269 233 - menu_impl.gameMenu->items = items; 234 - menu_impl.gameMenu->count = count; 270 + main->items = items; 271 + main->count = count; 235 272 } 236 273 } 237 274 238 - void showGameMenu(void* data) 275 + static void showGameMenu(void* data, s32 pos) 276 + { 277 + StudioMainMenu* main = data; 278 + studio_menu_init(main->menu, main->items, main->count, 0, 0, showMainMenu, main); 279 + } 280 + 281 + static inline s32 mainMenuStart(StudioMainMenu* menu) 282 + { 283 + return menu->count ? 0 : 1; 284 + } 285 + 286 + static void onResumeGame(void* data, s32 pos) 287 + { 288 + resumeGame(); 289 + } 290 + 291 + static void onResetGame(void* data, s32 pos) 292 + { 293 + StudioMainMenu* main = data; 294 + tic_api_reset(main->tic); 295 + setStudioMode(TIC_RUN_MODE); 296 + } 297 + 298 + static void onExitStudio(void* data, s32 pos) 239 299 { 240 - studio_menu_init(menu_impl.menu, menu_impl.gameMenu->items, menu_impl.gameMenu->count, 0, 0, showMainMenu, NULL); 300 + exitStudio(); 241 301 } 242 302 243 - static inline s32 mainMenuStart() 303 + static void onExitGame(void* data, s32 pos) 244 304 { 245 - return menu_impl.gameMenu->count ? 0 : 1; 305 + exitGame(); 246 306 } 247 307 248 308 static const MenuItem MainMenu[] = 249 309 { 250 310 {"GAME MENU", showGameMenu}, 251 - {"RESUME GAME", resumeGame}, 252 - {"RESET GAME", resetGame}, 311 + {"RESUME GAME", onResumeGame}, 312 + {"RESET GAME", onResetGame}, 253 313 #if defined(BUILD_EDITORS) 254 - {"CLOSE GAME", exitGame}, 314 + {"CLOSE GAME", onExitGame}, 255 315 #endif 256 316 {"OPTIONS", showOptionsMenu}, 257 317 {""}, 258 - {"QUIT TIC-80", exitStudio}, 318 + {"QUIT TIC-80", onExitStudio}, 259 319 }; 260 320 261 - void showMainMenu(void* data) 321 + static void showMainMenu(void* data, s32 pos) 262 322 { 263 - initGameMenu(); 323 + StudioMainMenu* main = data; 324 + initGameMenu(main); 264 325 265 - s32 start = mainMenuStart(); 326 + s32 start = mainMenuStart(main); 266 327 267 - studio_menu_init(menu_impl.menu, MainMenu + start, COUNT_OF(MainMenu) - start, 0, 0, resumeGame, NULL); 328 + studio_menu_init(main->menu, MainMenu + start, COUNT_OF(MainMenu) - start, 0, 0, onResumeGame, main); 268 329 } 269 330 270 - static void showOptionsMenuPos(s32 pos) 331 + static void showOptionsMenuPos(void* data, s32 pos) 271 332 { 272 - studio_menu_init(menu_impl.menu, OptionMenu, 273 - COUNT_OF(OptionMenu), pos, COUNT_OF(MainMenu) - 3 - mainMenuStart(), showMainMenu, NULL); 333 + StudioMainMenu* main = data; 334 + 335 + studio_menu_init(main->menu, OptionMenu, 336 + COUNT_OF(OptionMenu), pos, COUNT_OF(MainMenu) - 3 - mainMenuStart(main), showMainMenu, main); 274 337 } 275 338 276 - static void showOptionsMenu(void* data) 339 + static void showOptionsMenu(void* data, s32 pos) 277 340 { 278 - showOptionsMenuPos(COUNT_OF(OptionMenu) - 4); 341 + showOptionsMenuPos(data, COUNT_OF(OptionMenu) - 4); 279 342 } 280 343 281 - static void saveGamepadMenu(void* data) 344 + static void saveGamepadMenu(void* data, s32 pos) 282 345 { 283 - rwConfig()->options.mapping = menu_impl.gamepads->mapping; 284 - showOptionsMenuPos(COUNT_OF(OptionMenu) - 3); 346 + StudioMainMenu* main = data; 347 + 348 + main->options->mapping = main->gamepads.mapping; 349 + showOptionsMenuPos(data, COUNT_OF(OptionMenu) - 3); 285 350 } 286 351 287 - static void resetGamepadMenu(void* data); 352 + static void resetGamepadMenu(void* data, s32 pos); 288 353 289 354 static char MappingItems[TIC_BUTTONS][sizeof "RIGHT - RIGHT"]; 290 355 ··· 302 367 303 368 enum{KeyMappingStart = 2}; 304 369 305 - static void assignMapping(void* data) 370 + static void assignMapping(void* data, s32 pos) 306 371 { 307 - menu_impl.gamepads->key = *(s32*)data - KeyMappingStart; 372 + StudioMainMenu* main = data; 373 + 374 + main->gamepads.key = pos - KeyMappingStart; 308 375 309 376 static const char Fmt[] = "to assign to (%s) button..."; 310 377 static char str[sizeof Fmt + STRLEN("RIGHT")]; ··· 315 382 {str}, 316 383 }; 317 384 318 - sprintf(str, Fmt, ButtonLabels[menu_impl.gamepads->key]); 385 + sprintf(str, Fmt, ButtonLabels[main->gamepads.key]); 319 386 320 - studio_menu_init(menu_impl.menu, AssignKeyMenu, COUNT_OF(AssignKeyMenu), 1, 0, NULL, NULL); 387 + studio_menu_init(main->menu, AssignKeyMenu, COUNT_OF(AssignKeyMenu), 1, 0, NULL, main); 321 388 } 322 389 323 - static void initGamepadButtons() 390 + static void initGamepadButtons(StudioMainMenu* menu) 324 391 { 325 392 static const char* const KeysList[] = 326 393 { ··· 337 404 "F7", "F8", "F9", "F10", "F11", "F12", 338 405 }; 339 406 340 - for(s32 i = 0, index = menu_impl.gamepads->index * TIC_BUTTONS; i != TIC_BUTTONS; ++i) 341 - sprintf(MappingItems[i], "%-5s - %-5s", ButtonLabels[i], KeysList[menu_impl.gamepads->mapping.data[index++]]); 407 + for(s32 i = 0, index = menu->gamepads.index * TIC_BUTTONS; i != TIC_BUTTONS; ++i) 408 + sprintf(MappingItems[i], "%-5s - %-5s", ButtonLabels[i], KeysList[menu->gamepads.mapping.data[index++]]); 342 409 } 343 410 344 - static s32 optionGamepadGet() 411 + static s32 optionGamepadGet(void* data) 345 412 { 346 - return menu_impl.gamepads->index; 413 + StudioMainMenu* main = data; 414 + return main->gamepads.index; 347 415 } 348 416 349 - static void optionGamepadSet(s32 pos) 417 + static void optionGamepadSet(void* data, s32 pos) 350 418 { 351 - menu_impl.gamepads->index = pos; 352 - initGamepadButtons(); 419 + StudioMainMenu* main = data; 420 + main->gamepads.index = pos; 421 + initGamepadButtons(main); 353 422 } 354 423 355 424 static MenuOption GamepadOption = ··· 359 428 optionGamepadSet, 360 429 }; 361 430 362 - void initGamepadMenu() 431 + static void initGamepadMenu(StudioMainMenu* main) 363 432 { 364 433 static const MenuItem GamepadMenu[] = 365 434 { ··· 381 450 {"BACK", showOptionsMenu, .back = true}, 382 451 }; 383 452 384 - initGamepadButtons(); 453 + initGamepadButtons(main); 385 454 386 - studio_menu_init(menu_impl.menu, GamepadMenu, COUNT_OF(GamepadMenu), 387 - menu_impl.gamepads->key < 0 ? KeyMappingStart : menu_impl.gamepads->key + KeyMappingStart, 388 - COUNT_OF(OptionMenu) - 3, showOptionsMenu, NULL); 455 + studio_menu_init(main->menu, GamepadMenu, COUNT_OF(GamepadMenu), 456 + main->gamepads.key < 0 ? KeyMappingStart : main->gamepads.key + KeyMappingStart, 457 + COUNT_OF(OptionMenu) - 3, showOptionsMenu, main); 389 458 390 - menu_impl.gamepads->key = -1; 459 + main->gamepads.key = -1; 391 460 } 392 461 393 - static void resetGamepadMenu(void* data) 462 + static void resetGamepadMenu(void* data, s32 pos) 394 463 { 395 - menu_impl.gamepads->index = 0; 396 - ZEROMEM(menu_impl.gamepads->mapping); 397 - tic_sys_default_mapping(&menu_impl.gamepads->mapping); 398 - initGamepadMenu(); 464 + StudioMainMenu* main = data; 465 + main->gamepads.index = 0; 466 + ZEROMEM(main->gamepads.mapping); 467 + tic_sys_default_mapping(&main->gamepads.mapping); 468 + initGamepadMenu(main); 399 469 } 400 - 401 - void showGamepadMenu(void* data) 402 - { 403 - menu_impl.gamepads->index = 0; 404 - menu_impl.gamepads->mapping = getConfig()->options.mapping; 405 - 406 - initGamepadMenu(); 407 - }
+5 -5
src/studio/screens/main_menu.h
··· 22 22 23 23 #pragma once 24 24 25 - void showGamepadMenu(void* data); 26 - void showMainMenu(void* data); 27 - void freeGameMenu(); 28 - void initGamepadMenu(); 29 - void initMainMenu(Menu *menu, void *gameMenu, Config *config, tic_mem* mem, Gamepads *gamepads); 25 + typedef struct StudioMainMenu StudioMainMenu; 26 + 27 + StudioMainMenu* studio_mainmenu_init(Menu *menu, Config *config); 28 + bool studio_mainmenu_keyboard(StudioMainMenu* menu); 29 + void studio_mainmenu_free(StudioMainMenu* menu);
+13 -13
src/studio/screens/menu.c
··· 49 49 s32 backPos; 50 50 51 51 void* data; 52 - void(*back)(void*); 52 + MenuItemHandler back; 53 53 54 54 struct 55 55 { ··· 110 110 { 111 111 Menu *menu = data; 112 112 menu->anim.movie = resetMovie(&menu->anim.idle); 113 - menu->items[menu->pos].handler(menu->data ? menu->data : &menu->pos); 113 + menu->items[menu->pos].handler(menu->data, menu->pos); 114 114 } 115 115 116 116 static void backDone(void* data) ··· 118 118 Menu *menu = data; 119 119 menu->anim.movie = resetMovie(&menu->anim.idle); 120 120 s32 pos = menu->backPos; 121 - menu->back(menu->data); 121 + menu->back(menu->data, 0); 122 122 menu->pos = pos; 123 123 } 124 124 ··· 169 169 } 170 170 } 171 171 172 - static void updateOption(MenuOption* option, s32 val) 172 + static void updateOption(MenuOption* option, s32 val, void* data) 173 173 { 174 174 option->pos = (option->pos + option->count + val) % option->count; 175 - option->set(option->pos); 176 - option->pos = option->get(); 175 + option->set(data, option->pos); 176 + option->pos = option->get(data); 177 177 } 178 178 179 179 static void onMenuItem(Menu* menu, const MenuItem* item) ··· 196 196 if(checkMouseClick(&left, tic_mouse_left)) 197 197 { 198 198 playSystemSfx(2); 199 - updateOption(option, delta); 199 + updateOption(option, delta, menu->data); 200 200 } 201 201 } 202 202 ··· 242 242 || tic_api_keyp(tic, tic_key_left, Hold, Period)) 243 243 { 244 244 playSystemSfx(2); 245 - updateOption(option, -1); 245 + updateOption(option, -1, menu->data); 246 246 } 247 247 248 248 if(tic_api_btnp(menu->tic, Right, Hold, Period) 249 249 || tic_api_keyp(tic, tic_key_right, Hold, Period)) 250 250 { 251 251 playSystemSfx(2); 252 - updateOption(option, +1); 252 + updateOption(option, +1, menu->data); 253 253 } 254 254 } 255 255 ··· 259 259 if(option) 260 260 { 261 261 playSystemSfx(2); 262 - updateOption(option, +1); 262 + updateOption(option, +1, menu->data); 263 263 } 264 264 else if(menu->items[menu->pos].handler) 265 265 onMenuItem(menu, item); ··· 420 420 { 421 421 MenuOption* option = menu->items[menu->pos].option; 422 422 if(option) 423 - updateOption(option, input->mouse.scrolly < 0 ? -1 : +1); 423 + updateOption(option, input->mouse.scrolly < 0 ? -1 : +1, menu->data); 424 424 } 425 425 else 426 426 { ··· 449 449 menu->ticks++; 450 450 } 451 451 452 - void studio_menu_init(Menu* menu, const MenuItem* items, s32 rows, s32 pos, s32 backPos, void(*back)(void*), void* data) 452 + void studio_menu_init(Menu* menu, const MenuItem* items, s32 rows, s32 pos, s32 backPos, MenuItemHandler back, void* data) 453 453 { 454 454 const s32 size = sizeof menu->items[0] * rows; 455 455 ··· 486 486 menu->maxwidth.option = len; 487 487 } 488 488 489 - it->option->pos = it->option->get(); 489 + it->option->pos = it->option->get(menu->data); 490 490 } 491 491 } 492 492
+6 -3
src/studio/screens/menu.h
··· 30 30 Menu* studio_menu_create(struct tic_mem* tic); 31 31 void studio_menu_tick(Menu* menu); 32 32 33 + typedef s32(*MenuOptionGetHandler)(void*); 34 + typedef void(*MenuOptionSetHandler)(void*, s32); 35 + 33 36 typedef struct 34 37 { 35 38 const char** values; 36 39 s32 count; 37 - s32(*get)(); 38 - void(*set)(s32); 40 + MenuOptionGetHandler get; 41 + MenuOptionSetHandler set; 39 42 s32 width; 40 43 s32 pos; 41 44 } MenuOption; 42 45 43 - typedef void(*MenuItemHandler)(void*); 46 + typedef void(*MenuItemHandler)(void*, s32); 44 47 45 48 typedef struct 46 49 {
+10 -37
src/studio/studio.c
··· 115 115 .frames = 0, 116 116 }, 117 117 #endif 118 - 119 - .gamepads = 120 - { 121 - .key = -1, 122 - }, 123 118 }; 124 119 125 120 void fadePalette(tic_palette* pal, s32 value) ··· 1001 996 impl.studio.quit = yes; 1002 997 } 1003 998 1004 - void exitStudio(void* data) 999 + void exitStudio() 1005 1000 { 1006 1001 #if defined(BUILD_EDITORS) 1007 1002 if(impl.mode != TIC_START_MODE && studioCartChanged()) ··· 1142 1137 } 1143 1138 #endif 1144 1139 1145 - void resetGame(void* data) 1146 - { 1147 - tic_api_reset(impl.studio.tic); 1148 - setStudioMode(TIC_RUN_MODE); 1149 - } 1150 - 1151 - void resumeGame(void* data) 1140 + void resumeGame() 1152 1141 { 1153 1142 tic_core_resume(impl.studio.tic); 1154 1143 impl.mode = TIC_RUN_MODE; ··· 1222 1211 } 1223 1212 } 1224 1213 1225 - static void confirmNo(void* data) 1214 + static void confirmNo(void* data, s32 pos) 1226 1215 { 1227 1216 confirmHandler(false, data); 1228 1217 } 1229 1218 1230 - static void confirmYes(void* data) 1219 + static void confirmYes(void* data, s32 pos) 1231 1220 { 1232 1221 confirmHandler(true, data); 1233 1222 } ··· 1551 1540 impl.mode = TIC_MENU_MODE; 1552 1541 } 1553 1542 1554 - initMainMenu(impl.menu, &impl.gameMenu, impl.config, impl.studio.tic, &impl.gamepads); 1555 - showMainMenu(NULL); 1543 + impl.mainmenu = studio_mainmenu_init(impl.menu, impl.config); 1556 1544 } 1557 1545 1558 - static void processStudioShortcuts() 1546 + static void processShortcuts() 1559 1547 { 1560 1548 tic_mem* tic = impl.studio.tic; 1561 1549 ··· 1565 1553 if(impl.mode == TIC_CONSOLE_MODE && !impl.console->active) return; 1566 1554 #endif 1567 1555 1556 + if(studio_mainmenu_keyboard(impl.mainmenu)) return; 1557 + 1568 1558 bool alt = tic_api_key(tic, tic_key_alt); 1569 1559 bool ctrl = tic_api_key(tic, tic_key_ctrl); 1570 1560 ··· 1660 1650 } 1661 1651 } 1662 1652 #endif 1663 - } 1664 - } 1665 - 1666 - static void processShortcuts() 1667 - { 1668 - tic_mem* tic = impl.studio.tic; 1669 - 1670 - if(impl.gamepads.key < 0) 1671 - processStudioShortcuts(); 1672 - else 1673 - { 1674 - tic_key key = *tic->ram.input.keyboard.keys; 1675 - if(key > tic_key_unknown) 1676 - { 1677 - impl.gamepads.mapping.data[impl.gamepads.index * TIC_BUTTONS + impl.gamepads.key] = key; 1678 - initGamepadMenu(); 1679 - } 1680 1653 } 1681 1654 } 1682 1655 ··· 2079 2052 #endif 2080 2053 } 2081 2054 2082 - void exitGame(void* data) 2055 + void exitGame() 2083 2056 { 2084 2057 if(impl.prevMode == TIC_SURF_MODE) 2085 2058 { ··· 2117 2090 freeRun (impl.run); 2118 2091 freeConfig (impl.config); 2119 2092 2120 - freeGameMenu(); 2093 + studio_mainmenu_free(impl.mainmenu); 2121 2094 studio_menu_free(impl.menu); 2122 2095 } 2123 2096
+3 -3
src/studio/studio.h
··· 189 189 190 190 void setStudioMode(EditorMode mode); 191 191 EditorMode getStudioMode(); 192 - void exitStudio(void* data); 192 + void exitStudio(); 193 193 194 194 void toClipboard(const void* data, s32 size, bool flip); 195 195 bool fromClipboard(void* data, s32 size, bool flip, bool remove_white_spaces); ··· 230 230 void gotoSurf(); 231 231 232 232 void runGame(); 233 - void exitGame(void* data); 234 - void resumeGame(void* data); 233 + void exitGame(); 234 + void resumeGame(); 235 235 236 236 tic_tiles* getBankTiles(); 237 237 tic_palette* getBankPalette(bool bank);
+1 -10
src/studio/studio_impl.h
··· 191 191 tic_net* net; 192 192 #endif 193 193 194 - Gamepads gamepads; 195 - 196 194 Start* start; 197 195 Run* run; 198 196 Menu* menu; 199 197 Config* config; 200 198 201 - struct 202 - { 203 - MenuItem* items; 204 - s32 count; 205 - } gameMenu; 199 + struct StudioMainMenu* mainmenu; 206 200 207 201 tic_fs* fs; 208 202 ··· 211 205 tic_font systemFont; 212 206 213 207 } StudioImplementation; 214 - 215 - void resetGame(void* data); 216 - void resumeGame(void* data);
+1 -1
src/studio/system.h
··· 116 116 } shader; 117 117 #endif 118 118 119 - struct 119 + struct StudioOptions 120 120 { 121 121 #if defined(CRT_SHADER_SUPPORT) 122 122 bool crt;