main.cpp

   1
   2 #include "nx.h"
   3 #include <stdarg.h>
   4 #include <unistd.h>
   5 #include "graphics/safemode.h"
   6 #include "main.fdh"
   7
   8 const char *data_dir = "data";
   9 const char *stage_dir = "data/Stage";
  10 const char *pic_dir = "endpic";
  11 const char *nxdata_dir = ".";
  12
  13 int fps = 0;
  14 static int fps_so_far = 0;
  15 static uint32_t fpstimer = 0;
  16
  17 #define GAME_WAIT                       (1000/GAME_FPS) // sets framerate
  18 #define VISFLAGS                        (SDL_APPACTIVE | SDL_APPINPUTFOCUS)
  19 int framecount = 0;
  20 bool freezeframe = false;
  21 int flipacceltime = 0;
  22
  23 int main(int argc, char *argv[])
  24 {
  25 bool inhibit_loadfade = false;
  26 bool error = false;
  27 bool freshstart;
  28
  29         SetLogFilename("debug.txt");
  30         if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
  31         {
  32                 staterr("ack, sdl_init failed: %s.", SDL_GetError());
  33                 return 1;
  34         }
  35         atexit(SDL_Quit);
  36
  37         // start up inputs first thing because settings_load may remap them
  38         input_init();
  39
  40         // load settings, or at least get the defaults,
  41         // so we know the initial screen resolution.
  42         settings_load();
  43
  44         if (Graphics::init(settings->resolution)) { staterr("Failed to initialize graphics."); return 1; }
  45         if (font_init()) { staterr("Failed to load font."); return 1; }
  46
  47         //speed_test();
  48         //return 1;
  49
  50         #ifdef CONFIG_DATA_EXTRACTOR
  51         if (!settings->files_extracted)
  52         {
  53                 if (extract_main())
  54                 {
  55                         Graphics::close();
  56                         font_close();
  57                         return 0;
  58                 }
  59                 else
  60                 {
  61                         settings->files_extracted = true;
  62                         settings_save();
  63                 }
  64         }
  65         #endif
  66
  67         if (check_data_exists())
  68         {
  69                 return 1;
  70         }
  71
  72         //Graphics::ShowLoadingScreen();
  73         if (sound_init()) { fatal("Failed to initialize sound."); return 1; }
  74         if (trig_init()) { fatal("Failed trig module init."); return 1; }
  75
  76         if (tsc_init()) { fatal("Failed to initialize script engine."); return 1; }
  77         if (textbox.Init()) { fatal("Failed to initialize textboxes."); return 1; }
  78         if (Carets::init()) { fatal("Failed to initialize carets."); return 1; }
  79
  80         if (game.init()) return 1;
  81         game.setmode(GM_NORMAL);
  82         // set null stage just to have something to do while we go to intro
  83         game.switchstage.mapno = 0;
  84
  85         //#define REPLAY
  86         #ifdef REPLAY
  87                 game.switchstage.mapno = START_REPLAY;
  88                 //Replay::set_ffwd(6000);
  89                 //Replay::set_stopat(3500);
  90                 game.switchstage.param = 1;
  91         #else
  92                 //game.switchstage.mapno = LOAD_GAME;
  93                 //game.pause(GP_OPTIONS);
  94
  95                 if (settings->skip_intro && file_exists(GetProfileName(settings->last_save_slot)))
  96                         game.switchstage.mapno = LOAD_GAME;
  97                 else
  98                         game.setmode(GM_INTRO);
  99         #endif
 100
 101         // for debug
 102         if (game.paused) { game.switchstage.mapno = 0; game.switchstage.eventonentry = 0; }
 103         if (game.switchstage.mapno == LOAD_GAME) inhibit_loadfade = true;
 104
 105         game.running = true;
 106         freshstart = true;
 107
 108         stat("Entering main loop...");
 109         #ifdef __SDLSHIM__
 110                 set_console_visible(false);
 111         #endif
 112
 113         //speed_test();
 114         //return 1;
 115
 116         while(game.running)
 117         {
 118                 // SSS/SPS persists across stage transitions until explicitly
 119                 // stopped, or you die & reload. It seems a bit risky to me,
 120                 // but that's the spec.
 121                 if (game.switchstage.mapno >= MAPNO_SPECIALS)
 122                 {
 123                         StopLoopSounds();
 124                 }
 125
 126                 // enter next stage, whatever it may be
 127                 if (game.switchstage.mapno == LOAD_GAME || \
 128                         game.switchstage.mapno == LOAD_GAME_FROM_MENU)
 129                 {
 130                         if (game.switchstage.mapno == LOAD_GAME_FROM_MENU)
 131                                 freshstart = true;
 132
 133                         stat("= Loading game =");
 134                         if (game_load(settings->last_save_slot))
 135                         {
 136                                 fatal("savefile error");
 137                                 goto ingame_error;
 138                         }
 139
 140                         Replay::OnGameStarting();
 141
 142                         if (!inhibit_loadfade) fade.Start(FADE_IN, FADE_CENTER);
 143                         else inhibit_loadfade = false;
 144                 }
 145                 else if (game.switchstage.mapno == START_REPLAY)
 146                 {
 147                         stat(">> beginning replay '%s'", GetReplayName(game.switchstage.param));
 148
 149                         StopScripts();
 150                         if (Replay::begin_playback(GetReplayName(game.switchstage.param)))
 151                         {
 152                                 fatal("error starting playback");
 153                                 goto ingame_error;
 154                         }
 155                 }
 156                 else
 157                 {
 158                         if (game.switchstage.mapno == NEW_GAME || \
 159                                 game.switchstage.mapno == NEW_GAME_FROM_MENU)
 160                         {
 161                                 bool show_intro = (game.switchstage.mapno == NEW_GAME_FROM_MENU);
 162                                 InitNewGame(show_intro);
 163                         }
 164
 165                         // slide weapon bar on first intro to Start Point
 166                         if (game.switchstage.mapno == STAGE_START_POINT && \
 167                                 game.switchstage.eventonentry == 91)
 168                         {
 169                                 freshstart = true;
 170                         }
 171
 172                         // switch maps
 173                         if (load_stage(game.switchstage.mapno)) goto ingame_error;
 174
 175                         player->x = (game.switchstage.playerx * TILE_W) << CSF;
 176                         player->y = (game.switchstage.playery * TILE_H) << CSF;
 177                 }
 178
 179                 // start the level
 180                 if (game.initlevel()) return 1;
 181
 182                 if (freshstart)
 183                         weapon_introslide();
 184
 185                 gameloop();
 186                 game.stageboss.OnMapExit();
 187                 freshstart = false;
 188         }
 189
 190 shutdown: ;
 191         Replay::close();
 192         game.close();
 193         Carets::close();
 194
 195         Graphics::close();
 196         input_close();
 197         font_close();
 198         sound_close();
 199         tsc_close();
 200         textbox.Deinit();
 201         return error;
 202
 203 ingame_error: ;
 204         stat("");
 205         stat(" ************************************************");
 206         stat(" * An in-game error occurred. Game shutting down.");
 207         stat(" ************************************************");
 208         error = true;
 209         goto shutdown;
 210 }
 211
 212
 213 void gameloop(void)
 214 {
 215 int32_t nexttick = 0;
 216
 217         game.switchstage.mapno = -1;
 218
 219         while(game.running && game.switchstage.mapno < 0)
 220         {
 221                 // get time until next tick
 222                 int32_t curtime = SDL_GetTicks();
 223                 int32_t timeRemaining = nexttick - curtime;
 224
 225                 if (timeRemaining <= 0 || game.ffwdtime)
 226                 {
 227                         run_tick();
 228
 229                         // try to "catch up" if something else on the system bogs us down for a moment.
 230                         // but if we get really far behind, it's ok to start dropping frames
 231                         if (game.ffwdtime)
 232                                 game.ffwdtime--;
 233
 234                         nexttick = curtime + GAME_WAIT;
 235
 236                         // pause game if window minimized
 237                         if ((SDL_GetAppState() & VISFLAGS) != VISFLAGS)
 238                         {
 239                                 AppMinimized();
 240                                 nexttick = 0;
 241                         }
 242                 }
 243                 else
 244                 {
 245                         // don't needlessly hog CPU, but don't sleep for entire
 246                         // time left, some CPU's/kernels will fall asleep for
 247                         // too long and cause us to run slower than we should
 248                         timeRemaining /= 2;
 249                         if (timeRemaining)
 250                                 SDL_Delay(timeRemaining);
 251                 }
 252         }
 253 }
 254
 255 static inline void run_tick()
 256 {
 257 static bool can_tick = true;
 258 static bool last_freezekey = false;
 259 static bool last_framekey = false;
 260 static int frameskip = 0;
 261
 262         input_poll();
 263
 264         // input handling for a few global things
 265         if (justpushed(ESCKEY))
 266         {
 267                 if (settings->instant_quit)
 268                 {
 269                         game.running = false;
 270                 }
 271                 else if (!game.paused)          // no pause from Options
 272                 {
 273                         game.pause(GP_PAUSED);
 274                 }
 275         }
 276         else if (justpushed(F3KEY))
 277         {
 278                 game.pause(GP_OPTIONS);
 279         }
 280
 281         // freeze frame
 282         if (settings->enable_debug_keys)
 283         {
 284                 if (inputs[FREEZE_FRAME_KEY] && !last_freezekey)
 285                 {
 286                         can_tick = true;
 287                         freezeframe ^= 1;
 288                         framecount = 0;
 289                 }
 290
 291                 if (inputs[FRAME_ADVANCE_KEY] && !last_framekey)
 292                 {
 293                         can_tick = true;
 294                         if (!freezeframe)
 295                         {
 296                                 freezeframe = 1;
 297                                 framecount = 0;
 298                         }
 299                 }
 300
 301                 last_freezekey = inputs[FREEZE_FRAME_KEY];
 302                 last_framekey = inputs[FRAME_ADVANCE_KEY];
 303         }
 304
 305         // fast-forward key (F5)
 306         if (inputs[FFWDKEY] && (settings->enable_debug_keys || Replay::IsPlaying()))
 307         {
 308                 game.ffwdtime = 2;
 309         }
 310
 311         if (can_tick)
 312         {
 313                 game.tick();
 314
 315                 if (freezeframe)
 316                 {
 317                         char buf[1024];
 318                         sprintf(buf, "[] Tick %d", framecount++);
 319                         font_draw_shaded(4, (SCREEN_HEIGHT-GetFontHeight()-4), buf, 0, &greenfont);
 320                         can_tick = false;
 321                 }
 322                 else
 323                 {
 324                         Replay::DrawStatus();
 325                 }
 326
 327                 if (settings->show_fps)
 328                 {
 329                         update_fps();
 330                 }
 331
 332                 if (!flipacceltime)
 333                 {
 334                         //platform_sync_to_vblank();
 335                         screen->Flip();
 336                 }
 337                 else
 338                 {
 339                         flipacceltime--;
 340                         if (--frameskip < 0)
 341                         {
 342                                 screen->Flip();
 343                                 frameskip = 256;
 344                         }
 345                 }
 346
 347                 memcpy(lastinputs, inputs, sizeof(lastinputs));
 348         }
 349         else
 350         {       // frame is frozen; don't hog CPU
 351                 SDL_Delay(20);
 352         }
 353
 354         // immediately after a game tick is when we have the most amount of time before
 355         // the game needs to run again. so now's as good a time as any for some
 356         // BGM audio processing, wouldn't you say?
 357         org_run();
 358 }
 359
 360 void update_fps()
 361 {
 362         fps_so_far++;
 363
 364         if ((SDL_GetTicks() - fpstimer) >= 500)
 365         {
 366                 fpstimer = SDL_GetTicks();
 367                 fps = (fps_so_far << 1);
 368                 fps_so_far = 0;
 369         }
 370
 371         char fpstext[64];
 372         sprintf(fpstext, "%d fps", fps);
 373
 374         int x = (SCREEN_WIDTH - 4) - GetFontWidth(fpstext, 0, true);
 375         font_draw_shaded(x, 4, fpstext, 0, &greenfont);
 376 }
 377
 378
 379 void InitNewGame(bool with_intro)
 380 {
 381         stat("= Beginning new game =");
 382
 383         memset(game.flags, 0, sizeof(game.flags));
 384         memset(game.skipflags, 0, sizeof(game.skipflags));
 385         textbox.StageSelect.ClearSlots();
 386
 387         game.quaketime = game.megaquaketime = 0;
 388         game.showmapnametime = 0;
 389         game.debug.god = 0;
 390         game.running = true;
 391         game.frozen = false;
 392
 393         // fully re-init the player object
 394         Objects::DestroyAll(true);
 395         game.createplayer();
 396
 397         player->maxHealth = 3;
 398         player->hp = player->maxHealth;
 399
 400         game.switchstage.mapno = STAGE_START_POINT;
 401         game.switchstage.playerx = 10;
 402         game.switchstage.playery = 8;
 403         game.switchstage.eventonentry = (with_intro) ? 200 : 91;
 404
 405         fade.set_full(FADE_OUT);
 406 }
 407
 408
 409 void AppMinimized(void)
 410 {
 411         stat("Game minimized or lost focus--pausing...");
 412         SDL_PauseAudio(1);
 413
 414         for(;;)
 415         {
 416                 if ((SDL_GetAppState() & VISFLAGS) == VISFLAGS)
 417                 {
 418                         break;
 419                 }
 420
 421                 input_poll();
 422                 SDL_Delay(20);
 423         }
 424
 425         SDL_PauseAudio(0);
 426         stat("Focus regained, resuming play...");
 427 }
 428
 429
 430 /*
 431 void c------------------------------() {}
 432 */
 433
 434 static void fatal(const char *str)
 435 {
 436         staterr("fatal: '%s'", str);
 437
 438         if (!safemode::init())
 439         {
 440                 safemode::moveto(SM_UPPER_THIRD);
 441                 safemode::print("Fatal Error");
 442
 443                 safemode::moveto(SM_CENTER);
 444                 safemode::print("%s", str);
 445
 446                 safemode::run_until_key();
 447                 safemode::close();
 448         }
 449 }
 450
 451 static bool check_data_exists()
 452 {
 453 char fname[MAXPATHLEN];
 454
 455         sprintf(fname, "%s/npc.tbl", data_dir);
 456         if (file_exists(fname)) return 0;
 457
 458         if (!safemode::init())
 459         {
 460                 safemode::moveto(SM_UPPER_THIRD);
 461                 safemode::print("Fatal Error");
 462
 463                 safemode::moveto(SM_CENTER);
 464                 safemode::print("Missing \"%s\" directory.", data_dir);
 465                 safemode::print("Please copy it over from a Doukutsu installation.");
 466
 467                 safemode::run_until_key();
 468                 safemode::close();
 469         }
 470
 471         return 1;
 472 }
 473
 474 void visible_warning(const char *fmt, ...)
 475 {
 476 va_list ar;
 477 char buffer[80];
 478
 479         va_start(ar, fmt);
 480         vsnprintf(buffer, sizeof(buffer), fmt, ar);
 481         va_end(ar);
 482
 483         console.Print(buffer);
 484 }
 485
 486 /*
 487 void c------------------------------() {}
 488 */
 489
 490 #ifdef __SDLSHIM__
 491
 492 void speed_test(void)
 493 {
 494         SDL_Rect textrect;
 495
 496         uint32_t end = 0;
 497         fps = 0;
 498
 499         ClearScreen(255, 0, 0);
 500
 501         game.running = true;
 502         while(game.running)
 503         {
 504                 if (SDL_GetTicks() >= end)
 505                 {
 506                         SDLS_VRAMSurface->h = 320;
 507                         SDLS_VRAMSurface->cliprect.h = 320;
 508                         textrect.x = 5;
 509                         textrect.y = 250;
 510                         textrect.w = 100;
 511                         textrect.h = 10;
 512                         SDL_FillRect(SDLS_VRAMSurface, &textrect, 0);
 513
 514                         char buffer[80];
 515                         sprintf(buffer, "%d fps ", fps);
 516                         direct_text_draw(5, 250, buffer);
 517                         SDLS_VRAMSurface->h = 240;
 518                         SDLS_VRAMSurface->cliprect.h = 240;
 519
 520                         input_poll();
 521
 522                         fps = 0;
 523                         end = SDL_GetTicks() + 1000;
 524                 }
 525
 526                 screen->Flip();
 527                 fps++;
 528         }
 529 }
 530
 531 #else
 532
 533 void speed_test(void)
 534 {
 535         SDL_Rect textrect;
 536         SDL_Surface *vram = screen->GetSDLSurface();
 537         int click = 0;
 538
 539         uint32_t end = 0;
 540         fps = 0;
 541
 542         SDL_FillRect(vram, NULL, SDL_MapRGB(vram->format, 255, 0, 0));
 543         int c = 0;
 544
 545         game.running = true;
 546         while(game.running)
 547         {
 548                 //SDL_FillRect(vram, NULL, c ^= 255);
 549
 550                 if (SDL_GetTicks() >= end)
 551                 {
 552                         stat("%d fps", fps);
 553                         fps = 0;
 554                         end = SDL_GetTicks() + 1000;
 555
 556                         if (++click > 3)
 557                                 break;
 558                 }
 559
 560                 screen->Flip();
 561                 fps++;
 562         }
 563 }
 564
 565 #endif
 566
 567
 568
 569 void org_test_miniloop(void)
 570 {
 571 uint32_t start = 0, curtime;
 572 uint32_t counter;
 573
 574         stat("Starting org test");
 575
 576         font_draw(5, 5, "ORG test in progress...", 0, &greenfont);
 577         font_draw(5, 15, "Logging statistics to nx.log", 0, &greenfont);
 578         font_draw(5, 25, "Press any button to quit", 0, &greenfont);
 579         screen->Flip();
 580
 581         music_set_enabled(1);
 582         music(32);
 583
 584         last_sdl_key = -1;
 585
 586         for(;;)
 587         {
 588                 org_run();
 589
 590                 if (++counter > 1024)
 591                 {
 592                         counter = 0;
 593
 594                         curtime = SDL_GetTicks();
 595                         if ((curtime - start) >= 100)
 596                         {
 597                                 start = curtime;
 598                                 input_poll();
 599
 600                                 if (last_sdl_key != -1)
 601                                         return;
 602                         }
 603                 }
 604         }
 605 }
 606
 607 void SDL_Delay(int ms)
 608 {
 609         usleep(ms * 1000);
 610 }