src/sdl/main.c

   1 /* Copyright (C) 2020 SovietPony
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, version 3 of the License ONLY.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  */
  15
  16 #ifdef __EMSCRIPTEN__
  17 #  include <emscripten.h>
  18 #endif
  19
  20 #include <SDL/SDL.h>
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include <stdlib.h> // srand exit
  24 #include <assert.h>
  25 #include "system.h"
  26 #include "input.h"
  27
  28 #include "my.h" // fexists
  29 #include "player.h" // pl1 pl2
  30 #include "menu.h" // G_keyf
  31 #include "error.h" // logo
  32 #include "monster.h" // nomon
  33
  34 #include "files.h" // F_startup F_addwad F_initwads F_allocres
  35 #include "config.h" // CFG_args CFG_load CFG_save
  36 #include "args.h" // ARG_parse
  37 #include "memory.h" // M_startup
  38 #include "game.h" // G_init G_act
  39 #include "sound.h" // S_init S_done
  40 #include "music.h" // S_initmusic S_updatemusic S_donemusic
  41 #include "render.h" // R_init R_draw R_done
  42
  43 #define MODE_NONE 0
  44 #define MODE_OPENGL 1
  45 #define MODE_SOFTWARE 2
  46
  47 static Uint32 ticks;
  48 static int quit = 0;
  49 static SDL_Surface *surf = NULL;
  50 static int mode = MODE_NONE;
  51 static int text_input;
  52 static videomode_t vlist;
  53
  54 static const cfg_t arg[] = {
  55   {"file", NULL, Y_FILES},
  56   {"cheat", &cheat, Y_SW_ON},
  57 //  {"vga", &shot_vga, Y_SW_ON},
  58 //  {"musvol", &mus_vol, Y_WORD},
  59   {"mon", &nomon, Y_SW_OFF},
  60   {"warp", &_warp, Y_BYTE},
  61 //  {"config", NULL, cfg_file, Y_STRING},
  62   {NULL, NULL, 0} // end
  63 };
  64
  65 static const cfg_t cfg[] = {
  66 //  {"screenshot", &shot_vga, Y_SW_ON},
  67 //  {"music_volume", &mus_vol, Y_WORD},
  68 //  {"music_random", &music_random, Y_SW_ON},
  69 //  {"music_time", &music_time, Y_DWORD},
  70 //  {"music_fade", &music_fade, Y_DWORD},
  71   {"pl1_left", &pl1.kl, Y_KEY},
  72   {"pl1_right",&pl1.kr, Y_KEY},
  73   {"pl1_up", &pl1.ku, Y_KEY},
  74   {"pl1_down", &pl1.kd, Y_KEY},
  75   {"pl1_jump", &pl1.kj, Y_KEY},
  76   {"pl1_fire", &pl1.kf, Y_KEY},
  77   {"pl1_next", &pl1.kwr, Y_KEY},
  78   {"pl1_prev", &pl1.kwl, Y_KEY},
  79   {"pl1_use", &pl1.kp, Y_KEY},
  80   {"pl2_left", &pl2.kl, Y_KEY},
  81   {"pl2_right", &pl2.kr, Y_KEY},
  82   {"pl2_up", &pl2.ku, Y_KEY},
  83   {"pl2_down", &pl2.kd, Y_KEY},
  84   {"pl2_jump", &pl2.kj, Y_KEY},
  85   {"pl2_fire", &pl2.kf, Y_KEY},
  86   {"pl2_next", &pl2.kwr, Y_KEY},
  87   {"pl2_prev", &pl2.kwl, Y_KEY},
  88   {"pl2_use", &pl2.kp, Y_KEY},
  89   {NULL, NULL, 0} // end
  90 };
  91
  92 static void CFG_args (int argc, char **argv) {
  93   const cfg_t *list[] = { arg, R_args(), S_args(), MUS_args() };
  94   ARG_parse(argc, argv, 4, list);
  95 }
  96
  97 static void CFG_load (void) {
  98   const cfg_t *list[] = { cfg, R_conf(), S_conf(), MUS_conf() };
  99   CFG_read_config("default.cfg", 4, list);
 100   CFG_read_config("doom2d.cfg", 4, list);
 101 }
 102
 103 static void CFG_save (void) {
 104   const cfg_t *list[] = { cfg, R_conf(), S_conf(), MUS_conf() };
 105   CFG_update_config("doom2d.cfg", "doom2d.cfg", 4, list, "generated by doom2d, do not modify");
 106 }
 107
 108 /* --- error.h --- */
 109
 110 void logo (const char *s, ...) {
 111   va_list ap;
 112   va_start(ap, s);
 113   vprintf(s, ap);
 114   va_end(ap);
 115   fflush(stdout);
 116 }
 117
 118 void logo_gas (int cur, int all) {
 119   // stub
 120 }
 121
 122 void ERR_failinit (char *s, ...) {
 123   va_list ap;
 124   va_start(ap, s);
 125   vprintf(s, ap);
 126   va_end(ap);
 127   puts("");
 128   exit(1);
 129 }
 130
 131 void ERR_fatal (char *s, ...) {
 132   va_list ap;
 133   R_done();
 134   MUS_done();
 135   S_done();
 136   M_shutdown();
 137   SDL_Quit();
 138   puts("\nКРИТИЧЕСКАЯ ОШИБКА:");
 139   va_start(ap, s);
 140   vprintf(s, ap);
 141   va_end(ap);
 142   puts("");
 143   exit(1);
 144 }
 145
 146 void ERR_quit (void) {
 147   quit = 1;
 148 }
 149
 150 /* --- system.h --- */
 151
 152 int Y_set_videomode_opengl (int w, int h, int fullscreen) {
 153   assert(w > 0);
 154   assert(h > 0);
 155   Uint32 flags;
 156   SDL_Surface *s;
 157   if (mode == MODE_OPENGL && surf->w == w && surf->h == h && Y_get_fullscreen() == fullscreen) {
 158     s = surf;
 159   } else {
 160     flags = SDL_DOUBLEBUF | SDL_OPENGL;
 161     if (fullscreen) {
 162       flags = flags | SDL_FULLSCREEN;
 163     }
 164 #   ifdef WIN32
 165       flags = flags | SDL_RESIZABLE;
 166 #   endif
 167     s = SDL_SetVideoMode(w, h, 0, flags);
 168     if (s != NULL) {
 169       mode = MODE_OPENGL;
 170       surf = s;
 171     } else {
 172       logo("Y_set_videomode_opengl: error: %s\n", SDL_GetError());
 173     }
 174   }
 175   return s != NULL;
 176 }
 177
 178 int Y_set_videomode_software (int w, int h, int fullscreen) {
 179   assert(w > 0);
 180   assert(h > 0);
 181   Uint32 flags;
 182   SDL_Surface *s;
 183   if (mode == MODE_OPENGL && surf->w == w && surf->h == h && Y_get_fullscreen() == fullscreen) {
 184     s = surf;
 185   } else {
 186     flags = SDL_DOUBLEBUF | SDL_SWSURFACE | SDL_HWPALETTE;
 187     if (fullscreen) {
 188       flags = flags | SDL_FULLSCREEN;
 189     }
 190 #   ifdef WIN32
 191       flags = flags | SDL_RESIZABLE;
 192 #   endif
 193     s = SDL_SetVideoMode(w, h, 8, flags);
 194     if (s != NULL) {
 195       mode = MODE_SOFTWARE;
 196       surf = s;
 197     }
 198   }
 199   return s != NULL;
 200 }
 201
 202 static void init_videomode_list (Uint32 flags) {
 203   int i, n;
 204   SDL_Rect **r;
 205   if (vlist.modes != NULL) {
 206     free(vlist.modes);
 207     vlist.modes = NULL;
 208     vlist.n = 0;
 209   }
 210   r = SDL_ListModes(NULL, flags);
 211   if (r == (SDL_Rect **)-1) {
 212     if ((flags & SDL_FULLSCREEN) == 0) {
 213       init_videomode_list(flags | SDL_FULLSCREEN);
 214     }
 215   } else if (r != (SDL_Rect**)0) {
 216     n = 0;
 217     while (r[n] != NULL) {
 218       n++;
 219     }
 220     vlist.modes = malloc(n * sizeof(videomode_size_t));
 221     if (vlist.modes != NULL) {
 222       vlist.n = n;
 223       for (i = 0; i < n; i++) {
 224         vlist.modes[i] = (videomode_size_t) {
 225           .w = r[i]->w,
 226           .h = r[i]->h
 227         };
 228       }
 229     }
 230   }
 231 }
 232
 233 const videomode_t *Y_get_videomode_list_opengl (int fullscreen) {
 234   init_videomode_list(SDL_OPENGL | (fullscreen ? SDL_FULLSCREEN : 0));
 235   return &vlist;
 236 }
 237
 238 const videomode_t *Y_get_videomode_list_software (int fullscreen) {
 239   init_videomode_list(SDL_SWSURFACE | SDL_HWPALETTE | (fullscreen ? SDL_FULLSCREEN : 0));
 240   return &vlist;
 241 }
 242
 243 void Y_get_videomode (int *w, int *h) {
 244   if (mode != MODE_NONE) {
 245     *w = surf->w;
 246     *h = surf->h;
 247   } else {
 248     *w = 0;
 249     *h = 0;
 250   }
 251 }
 252
 253 int Y_videomode_setted (void) {
 254   return mode != MODE_NONE;
 255 }
 256
 257 void Y_unset_videomode (void) {
 258   surf = NULL;
 259   mode = MODE_NONE;
 260 #ifndef __EMSCRIPTEN__
 261   SDL_QuitSubSystem(SDL_INIT_VIDEO);
 262   SDL_InitSubSystem(SDL_INIT_VIDEO);
 263 #endif
 264 }
 265
 266 void Y_set_fullscreen (int fullscreen) {
 267   int fs = Y_get_fullscreen();
 268   if (mode != MODE_NONE && fs != fullscreen) {
 269     if (SDL_WM_ToggleFullScreen(surf) == 0) {
 270       switch (mode) {
 271         case MODE_OPENGL:
 272           Y_set_videomode_opengl(surf->w, surf->h, fullscreen);
 273           break;
 274         case MODE_SOFTWARE:
 275           Y_set_videomode_software(surf->w, surf->h, fullscreen);
 276           break;
 277       }
 278     }
 279   }
 280 }
 281
 282 int Y_get_fullscreen (void) {
 283   return (mode != MODE_NONE) && ((surf->flags & SDL_FULLSCREEN) != 0);
 284 }
 285
 286 void Y_swap_buffers (void) {
 287   assert(mode == MODE_OPENGL);
 288   SDL_GL_SwapBuffers();
 289 }
 290
 291 void Y_get_buffer (byte **buf, int *w, int *h, int *pitch) {
 292   assert(mode == MODE_SOFTWARE);
 293   *buf = surf->pixels;
 294   *w = surf->w;
 295   *h = surf->h;
 296   *pitch = surf->pitch;
 297 }
 298
 299 void Y_set_vga_palette (byte *vgapal) {
 300   int i;
 301   byte *p = vgapal;
 302   assert(vgapal != NULL);
 303   assert(mode == MODE_SOFTWARE);
 304   SDL_Color colors[256];
 305   for (i = 0; i < 256; i++) {
 306     colors[i] = (SDL_Color) {
 307       .r = p[0] * 255 / 63,
 308       .g = p[1] * 255 / 63,
 309       .b = p[2] * 255 / 63
 310     };
 311     p += 3;
 312   }
 313   SDL_SetColors(surf, colors, 0, 256);
 314 }
 315
 316 void Y_repaint_rect (int x, int y, int w, int h) {
 317   assert(mode == MODE_SOFTWARE);
 318   SDL_UpdateRect(surf, x, y, w, h);
 319 }
 320
 321 void Y_repaint (void) {
 322   assert(mode == MODE_SOFTWARE);
 323   SDL_Flip(surf);
 324 }
 325
 326 void Y_enable_text_input (void) {
 327   text_input = 1;
 328 }
 329
 330 void Y_disable_text_input (void) {
 331   text_input = 0;
 332 }
 333
 334 /* --- main --- */
 335
 336 static int sdl_to_key (int code) {
 337   switch (code) {
 338     case SDLK_0: return KEY_0;
 339     case SDLK_1: return KEY_1;
 340     case SDLK_2: return KEY_2;
 341     case SDLK_3: return KEY_3;
 342     case SDLK_4: return KEY_4;
 343     case SDLK_5: return KEY_5;
 344     case SDLK_6: return KEY_6;
 345     case SDLK_7: return KEY_7;
 346     case SDLK_8: return KEY_8;
 347     case SDLK_9: return KEY_9;
 348     case SDLK_a: return KEY_A;
 349     case SDLK_b: return KEY_B;
 350     case SDLK_c: return KEY_C;
 351     case SDLK_d: return KEY_D;
 352     case SDLK_e: return KEY_E;
 353     case SDLK_f: return KEY_F;
 354     case SDLK_g: return KEY_G;
 355     case SDLK_h: return KEY_H;
 356     case SDLK_i: return KEY_I;
 357     case SDLK_j: return KEY_J;
 358     case SDLK_k: return KEY_K;
 359     case SDLK_l: return KEY_L;
 360     case SDLK_m: return KEY_M;
 361     case SDLK_n: return KEY_N;
 362     case SDLK_o: return KEY_O;
 363     case SDLK_p: return KEY_P;
 364     case SDLK_q: return KEY_Q;
 365     case SDLK_r: return KEY_R;
 366     case SDLK_s: return KEY_S;
 367     case SDLK_t: return KEY_T;
 368     case SDLK_u: return KEY_U;
 369     case SDLK_v: return KEY_V;
 370     case SDLK_w: return KEY_W;
 371     case SDLK_x: return KEY_X;
 372     case SDLK_y: return KEY_Y;
 373     case SDLK_z: return KEY_Z;
 374     case SDLK_RETURN: return KEY_RETURN;
 375     case SDLK_ESCAPE: return KEY_ESCAPE;
 376     case SDLK_BACKSPACE: return KEY_BACKSPACE;
 377     case SDLK_TAB: return KEY_TAB;
 378     case SDLK_SPACE: return KEY_SPACE;
 379     case SDLK_MINUS: return KEY_MINUS;
 380     case SDLK_EQUALS: return KEY_EQUALS;
 381     case SDLK_LEFTBRACKET: return KEY_LEFTBRACKET;
 382     case SDLK_RIGHTBRACKET: return KEY_RIGHTBRACKET;
 383     case SDLK_BACKSLASH: return KEY_BACKSLASH;
 384     case SDLK_SEMICOLON: return KEY_SEMICOLON;
 385     case SDLK_QUOTE: return KEY_APOSTROPHE;
 386     case SDLK_BACKQUOTE: return KEY_GRAVE;
 387     case SDLK_COMMA: return KEY_COMMA;
 388     case SDLK_PERIOD: return KEY_PERIOD;
 389     case SDLK_SLASH: return KEY_SLASH;
 390     case SDLK_CAPSLOCK: return KEY_CAPSLOCK;
 391     case SDLK_F1: return KEY_F1;
 392     case SDLK_F2: return KEY_F2;
 393     case SDLK_F3: return KEY_F3;
 394     case SDLK_F4: return KEY_F4;
 395     case SDLK_F5: return KEY_F5;
 396     case SDLK_F6: return KEY_F6;
 397     case SDLK_F7: return KEY_F7;
 398     case SDLK_F8: return KEY_F8;
 399     case SDLK_F9: return KEY_F9;
 400     case SDLK_F10: return KEY_F10;
 401     case SDLK_F11: return KEY_F11;
 402     case SDLK_F12: return KEY_F12;
 403     case SDLK_PRINT: return KEY_PRINTSCREEN;
 404     case SDLK_SCROLLOCK: return KEY_SCROLLLOCK;
 405     case SDLK_PAUSE: return KEY_PAUSE;
 406     case SDLK_INSERT: return KEY_INSERT;
 407     case SDLK_HOME: return KEY_HOME;
 408     case SDLK_PAGEUP: return KEY_PAGEUP;
 409     case SDLK_DELETE: return KEY_DELETE;
 410     case SDLK_END: return KEY_END;
 411     case SDLK_PAGEDOWN: return KEY_PAGEDOWN;
 412     case SDLK_RIGHT: return KEY_RIGHT;
 413     case SDLK_LEFT: return KEY_LEFT;
 414     case SDLK_DOWN: return KEY_DOWN;
 415     case SDLK_UP: return KEY_UP;
 416     case SDLK_NUMLOCK: return KEY_NUMLOCK;
 417     case SDLK_KP_DIVIDE: return KEY_KP_DIVIDE;
 418     case SDLK_KP_MULTIPLY: return KEY_KP_MULTIPLY;
 419     case SDLK_KP_MINUS: return KEY_KP_MINUS;
 420     case SDLK_KP_PLUS: return KEY_KP_PLUS;
 421     case SDLK_KP_ENTER: return KEY_KP_ENTER;
 422     case SDLK_KP0: return KEY_KP_0;
 423     case SDLK_KP1: return KEY_KP_1;
 424     case SDLK_KP2: return KEY_KP_2;
 425     case SDLK_KP3: return KEY_KP_3;
 426     case SDLK_KP4: return KEY_KP_4;
 427     case SDLK_KP5: return KEY_KP_5;
 428     case SDLK_KP6: return KEY_KP_6;
 429     case SDLK_KP7: return KEY_KP_7;
 430     case SDLK_KP8: return KEY_KP_8;
 431     case SDLK_KP9: return KEY_KP_9;
 432     case SDLK_KP_PERIOD: return KEY_KP_PERIOD;
 433     case SDLK_SYSREQ: return KEY_SYSREQ;
 434     case SDLK_LCTRL: return KEY_LCTRL;
 435     case SDLK_LSHIFT: return KEY_LSHIFT;
 436     case SDLK_LALT: return KEY_LALT;
 437     case SDLK_LSUPER: return KEY_LSUPER;
 438     case SDLK_RCTRL: return KEY_RCTRL;
 439     case SDLK_RSHIFT: return KEY_RSHIFT;
 440     case SDLK_RALT: return KEY_RALT;
 441     case SDLK_RSUPER: return KEY_RSUPER;
 442     default: return KEY_UNKNOWN;
 443   }
 444 }
 445
 446 static void poll_events (void) {
 447   int key, sym, down;
 448   SDL_Event ev;
 449   while (SDL_PollEvent(&ev)) {
 450     switch (ev.type) {
 451       case SDL_QUIT:
 452         ERR_quit();
 453         break;
 454       case SDL_VIDEORESIZE:
 455         R_set_videomode(ev.resize.w, ev.resize.h, Y_get_fullscreen());
 456         break;
 457       case SDL_KEYDOWN:
 458       case SDL_KEYUP:
 459         sym = ev.key.keysym.sym;
 460         down = ev.type == SDL_KEYDOWN;
 461         key = sdl_to_key(sym);
 462         I_press(key, down);
 463         GM_key(key, down);
 464         if (down && text_input && sym >= 0x20 && sym <= 0x7e) {
 465           // TODO fix this
 466           GM_input(sym);
 467         }
 468         break;
 469     }
 470   }
 471 }
 472
 473 static void step (void) {
 474   poll_events();
 475   MUS_update();
 476   Uint32 t = SDL_GetTicks();
 477   if (t - ticks > DELAY) {
 478     ticks = t;
 479     G_act();
 480   }
 481   R_draw();
 482 }
 483
 484 int main (int argc, char *argv[]) {
 485   char *pw;
 486   logo("main: initialize SDL\n");
 487   if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) == -1) {
 488     logo("main: failed to init SDL: %s\n", SDL_GetError());
 489     return 1;
 490   }
 491   SDL_WM_SetCaption("Doom 2D (SDL)", "Doom 2D");
 492   // Player 1 defaults
 493   pl1.ku = KEY_KP_8;
 494   pl1.kd = KEY_KP_5;
 495   pl1.kl = KEY_KP_4;
 496   pl1.kr = KEY_KP_6;
 497   pl1.kf = KEY_PAGEDOWN;
 498   pl1.kj = KEY_DELETE;
 499   pl1.kwl = KEY_HOME;
 500   pl1.kwr = KEY_END;
 501   pl1.kp = KEY_KP_8;
 502   // Player 2 defaults
 503   pl2.ku = KEY_E;
 504   pl2.kd = KEY_D;
 505   pl2.kl = KEY_S;
 506   pl2.kr = KEY_F;
 507   pl2.kf = KEY_A;
 508   pl2.kj = KEY_Q;
 509   pl2.kwl = KEY_1;
 510   pl2.kwr = KEY_2;
 511   pl2.kp = KEY_E;
 512   srand(SDL_GetTicks());
 513   F_startup();
 514 #ifndef WIN32
 515   pw = "/usr/share/doom2d-rembo/doom2d.wad";
 516 #else
 517   pw = "doom2d.wad";
 518 #endif
 519   if (fexists(pw)) {
 520     F_addwad(pw);
 521   } else {
 522     F_addwad("doom2d.wad");
 523   }
 524   CFG_args(argc, argv);
 525   CFG_load();
 526   F_initwads();
 527   M_startup();
 528   F_allocres();
 529   S_init();
 530   MUS_init();
 531   R_init();
 532   G_init();
 533   ticks = SDL_GetTicks();
 534 #ifdef __EMSCRIPTEN__
 535   emscripten_set_main_loop(step, 0, 1);
 536 #else
 537   while (!quit) {
 538     step();
 539   }
 540 #endif
 541   CFG_save();
 542   R_done();
 543   MUS_done();
 544   S_done();
 545   M_shutdown();
 546   SDL_Quit();
 547   return 0;
 548 }