src/sdl/main.c

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