src/sdl2/main.c

   1 #ifdef __EMSCRIPTEN__
   2 #  include <emscripten.h>
   3 #endif
   4
   5 #include <SDL2/SDL.h>
   6 #include <stdio.h>
   7 #include <stdarg.h>
   8 #include <stdlib.h> // srand exit
   9 #include <string.h> // strcasecmp
  10 #include <assert.h>
  11 #include "system.h"
  12 #include "input.h"
  13
  14 #include "cp866.h"
  15
  16 #include "my.h" // fexists
  17 #include "player.h" // pl1 pl2
  18 #include "menu.h" // G_keyf
  19 #include "error.h" // logo
  20 #include "monster.h" // nomon
  21
  22 #include "files.h" // F_startup F_addwad F_initwads F_allocres
  23 #include "config.h" // CFG_args CFG_load CFG_save
  24 #include "memory.h" // M_startup
  25 #include "game.h" // G_init G_act
  26 #include "sound.h" // S_init S_done
  27 #include "music.h" // S_initmusic S_updatemusic S_donemusic
  28 #include "render.h" // R_init R_draw R_done
  29
  30 #define TITLE_STR "Doom 2D (SDL2)"
  31
  32 static Uint32 ticks;
  33 static int quit = 0;
  34 static SDL_Window *window;
  35 static SDL_GLContext context;
  36 static SDL_Surface *surf;
  37 static videomode_t vlist;
  38
  39 static const cfg_t arg[] = {
  40   {"file", NULL, Y_FILES},
  41   {"cheat", &cheat, Y_SW_ON},
  42 //  {"vga", &shot_vga, Y_SW_ON},
  43   {"sndvol", &snd_vol, Y_WORD},
  44   {"musvol", &mus_vol, Y_WORD},
  45 //  {"fullscr", &fullscreen, Y_SW_ON},
  46 //  {"window", &fullscreen, Y_SW_OFF},
  47   {"mon", &nomon, Y_SW_OFF},
  48 //  {"gamma", &gammaa, Y_DWORD},
  49   {"warp", &_warp, Y_BYTE},
  50 //  {"width", &SCRW, Y_DWORD},
  51 //  {"height", &SCRH, Y_DWORD},
  52 //  {"config", NULL, cfg_file, Y_STRING},
  53   {NULL, NULL, 0} // end
  54 };
  55
  56 static const cfg_t cfg[] = {
  57 //  {"screenshot", &shot_vga, Y_SW_ON},
  58   {"sound_volume", &snd_vol, Y_WORD},
  59   {"music_volume", &mus_vol, Y_WORD},
  60 //  {"fullscreen", &fullscreen, Y_SW_ON},
  61   {"sky", &w_horiz, Y_SW_ON},
  62 //  {"gamma", &gammaa, Y_DWORD},
  63 //  {"screen_width", &SCRW, Y_DWORD},
  64 //  {"screen_height", &SCRH, Y_DWORD},
  65   {"music_random", &music_random, Y_SW_ON},
  66   {"music_time", &music_time, Y_DWORD},
  67   {"music_fade", &music_fade, Y_DWORD},
  68   {"pl1_left", &pl1.kl, Y_KEY},
  69   {"pl1_right",&pl1.kr, Y_KEY},
  70   {"pl1_up", &pl1.ku, Y_KEY},
  71   {"pl1_down", &pl1.kd, Y_KEY},
  72   {"pl1_jump", &pl1.kj, Y_KEY},
  73   {"pl1_fire", &pl1.kf, Y_KEY},
  74   {"pl1_next", &pl1.kwr, Y_KEY},
  75   {"pl1_prev", &pl1.kwl, Y_KEY},
  76   {"pl1_use", &pl1.kp, Y_KEY},
  77   {"pl2_left", &pl2.kl, Y_KEY},
  78   {"pl2_right", &pl2.kr, Y_KEY},
  79   {"pl2_up", &pl2.ku, Y_KEY},
  80   {"pl2_down", &pl2.kd, Y_KEY},
  81   {"pl2_jump", &pl2.kj, Y_KEY},
  82   {"pl2_fire", &pl2.kf, Y_KEY},
  83   {"pl2_next", &pl2.kwr, Y_KEY},
  84   {"pl2_prev", &pl2.kwl, Y_KEY},
  85   {"pl2_use", &pl2.kp, Y_KEY},
  86   {NULL, NULL, 0} // end
  87 };
  88
  89 static void CFG_args (int argc, char **argv) {
  90   int i;
  91   for (i = 1; i < argc; i++) {
  92     if (argv[i][0] == '-' && argv[i][1] != 0) {
  93       if (i + 1 >= argc) {
  94         ERR_failinit("CFG_args: not enough arguments for parameter %s\n", argv[i]);
  95       } else {
  96         if (CFG_update_key(&argv[i][1], argv[i + 1], arg) != 0) {
  97           ERR_failinit("CFG_args: unknown parameter %s\n", argv[i]);
  98         }
  99         i += 1;
 100       }
 101     } else {
 102       ERR_failinit("CFG_args: something wrong here: %s\n", argv[i]);
 103     }
 104   }
 105 }
 106
 107 static void CFG_load (void) {
 108   CFG_read_config("default.cfg", cfg);
 109   CFG_read_config("doom2d.cfg", cfg);
 110 }
 111
 112 static void CFG_save (void) {
 113   const cfg_t *list[] = { &cfg, NULL };
 114   CFG_update_config("doom2d.cfg", "doom2d.cfg", 1, list, "generated by doom2d, do not modify");
 115   //CFG_update_config("doom2d.cfg", "doom2d.tmp", cfg, "temporary file");
 116   //CFG_update_config("doom2d.tmp", "doom2d.cfg", cfg, "generated by doom2d, do not modify");
 117   //remove("doom2d.tmp");
 118 }
 119
 120 /* --- error.h --- */
 121
 122 void logo (const char *s, ...) {
 123   va_list ap;
 124   va_start(ap, s);
 125   vprintf(s, ap);
 126   va_end(ap);
 127   fflush(stdout);
 128 }
 129
 130 void logo_gas (int cur, int all) {
 131   // stub
 132 }
 133
 134 void ERR_failinit (char *s, ...) {
 135   va_list ap;
 136   va_start(ap, s);
 137   vprintf(s, ap);
 138   va_end(ap);
 139   puts("");
 140   exit(1);
 141 }
 142
 143 void ERR_fatal (char *s, ...) {
 144   va_list ap;
 145   R_done();
 146   S_done();
 147   S_donemusic();
 148   M_shutdown();
 149   SDL_Quit();
 150   puts("\nКРИТИЧЕСКАЯ ОШИБКА:");
 151   va_start(ap, s);
 152   vprintf(s, ap);
 153   va_end(ap);
 154   puts("");
 155   exit(1);
 156 }
 157
 158 void ERR_quit (void) {
 159   quit = 1;
 160 }
 161
 162 /* --- system.h --- */
 163
 164 static int Y_resize_window (int w, int h, int fullscreen) {
 165   assert(w > 0);
 166   assert(h > 0);
 167   assert(window != NULL);
 168   if (surf != NULL) {
 169     if (surf->w != w || surf->h != h) {
 170       SDL_Surface *s = SDL_CreateRGBSurface(0, w, h, 8, 0, 0, 0, 0);
 171       if (s != NULL) {
 172         SDL_SetPaletteColors(s->format->palette, surf->format->palette->colors, 0, surf->format->palette->ncolors);
 173         SDL_FreeSurface(surf);
 174         surf = s;
 175       }
 176     }
 177   }
 178   SDL_SetWindowSize(window, w, h);
 179   Y_set_fullscreen(fullscreen);
 180   return 1;
 181 }
 182
 183 int Y_set_videomode_opengl (int w, int h, int fullscreen) {
 184   assert(w > 0);
 185   assert(h > 0);
 186   Uint32 flags;
 187   SDL_Window *win;
 188   SDL_GLContext ctx;
 189   if (window != NULL && context != NULL) {
 190     Y_resize_window(w, h, fullscreen);
 191     win = window;
 192   } else {
 193     flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL;
 194     if (fullscreen) {
 195       flags = flags | SDL_WINDOW_FULLSCREEN;
 196     }
 197     // TODO set context version and type
 198 #ifdef __EMSCRIPTEN__
 199     SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
 200     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
 201     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
 202 #else
 203     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
 204     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
 205 #endif
 206     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 207     win = SDL_CreateWindow(TITLE_STR, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags);
 208     if (win != NULL) {
 209       ctx = SDL_GL_CreateContext(win);
 210       if (ctx != NULL) {
 211         Y_unset_videomode();
 212         window = win;
 213         context = ctx;
 214         SDL_GL_MakeCurrent(window, context);
 215       } else {
 216         SDL_DestroyWindow(win);
 217         win = NULL;
 218       }
 219     }
 220   }
 221   if (win == NULL) {
 222     logo("Y_set_videomode_opengl: error: %s\n", SDL_GetError());
 223   }
 224   return win != NULL;
 225 }
 226
 227 int Y_set_videomode_software (int w, int h, int fullscreen) {
 228   assert(w > 0);
 229   assert(h > 0);
 230   Uint32 flags;
 231   SDL_Surface *s;
 232   SDL_Window *win;
 233   if (window != NULL && surf != NULL) {
 234     Y_resize_window(w, h, fullscreen);
 235     win = window;
 236   } else {
 237     flags = SDL_WINDOW_RESIZABLE;
 238     if (fullscreen) {
 239       flags = flags | SDL_WINDOW_FULLSCREEN;
 240     }
 241     win = SDL_CreateWindow(TITLE_STR, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags);
 242     if (win != NULL) {
 243       s = SDL_CreateRGBSurface(0, w, h, 8, 0, 0, 0, 0);
 244       if (s != NULL) {
 245         Y_unset_videomode();
 246         window = win;
 247         surf = s;
 248       } else {
 249         SDL_DestroyWindow(win);
 250         win = NULL;
 251       }
 252     }
 253   }
 254   if (win == NULL) {
 255     logo("Y_set_videomode_software: error: %s\n", SDL_GetError());
 256   }
 257   return win != NULL;
 258 }
 259
 260 void Y_get_videomode (int *w, int *h) {
 261   if (window != NULL) {
 262     SDL_GetWindowSize(window, w, h);
 263   } else {
 264     *w = 0;
 265     *h = 0;
 266   }
 267 }
 268
 269 int Y_videomode_setted (void) {
 270   return window != NULL;
 271 }
 272
 273 void Y_unset_videomode (void) {
 274   if (window != NULL) {
 275     if (context != NULL) {
 276       SDL_GL_MakeCurrent(window, NULL);
 277       SDL_GL_DeleteContext(context);
 278       context = NULL;
 279     }
 280     if (surf != NULL) {
 281       SDL_FreeSurface(surf);
 282       surf = NULL;
 283     }
 284     SDL_DestroyWindow(window);
 285     window = NULL;
 286   }
 287 }
 288
 289 static void init_videomode_list (void) {
 290   int i, j, k;
 291   SDL_DisplayMode m;
 292   int n = SDL_GetNumDisplayModes(0);
 293   if (vlist.modes != NULL) {
 294     free(vlist.modes);
 295     vlist.modes = NULL;
 296     vlist.n = 0;
 297   }
 298   if (n > 0) {
 299     vlist.modes = malloc(n * sizeof(videomode_size_t));
 300     if (vlist.modes != NULL) {
 301       j = 0;
 302       for (i = 0; i < n; i++) {
 303         SDL_GetDisplayMode(0, i, &m);
 304         k = 0;
 305         while (k < j && (m.w != vlist.modes[k].w || m.h != vlist.modes[k].h)) {
 306           k++;
 307         }
 308         if (k >= j) {
 309           vlist.modes[j] = (videomode_size_t) {
 310             .w = m.w,
 311             .h = m.h
 312           };
 313           j++;
 314         }
 315       }
 316       vlist.n = j;
 317     }
 318   }
 319 }
 320
 321 const videomode_t *Y_get_videomode_list_opengl (int fullscreen) {
 322   init_videomode_list();
 323   return &vlist;
 324 }
 325
 326 const videomode_t *Y_get_videomode_list_software (int fullscreen) {
 327   init_videomode_list();
 328   return &vlist;
 329 }
 330
 331 void Y_set_fullscreen (int yes) {
 332   if (window != NULL) {
 333     SDL_SetWindowFullscreen(window, yes ? SDL_WINDOW_FULLSCREEN : 0);
 334   }
 335 }
 336
 337 int Y_get_fullscreen (void) {
 338   return (window != NULL) && (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN);
 339 }
 340
 341 void Y_swap_buffers (void) {
 342   assert(window != NULL);
 343   assert(context != NULL);
 344   SDL_GL_SwapWindow(window);
 345 }
 346
 347 void Y_get_buffer (byte **buf, int *w, int *h, int *pitch) {
 348   assert(window != NULL);
 349   assert(surf != NULL);
 350   *buf = surf->pixels;
 351   *w = surf->w;
 352   *h = surf->h;
 353   *pitch = surf->pitch;
 354 }
 355
 356 void Y_set_vga_palette (byte *vgapal) {
 357   assert(window != NULL);
 358   assert(surf != NULL);
 359   int i;
 360   byte *p = vgapal;
 361   SDL_Color colors[256];
 362   for (i = 0; i < 256; i++) {
 363     colors[i] = (SDL_Color) {
 364       .r = p[0] * 255 / 63,
 365       .g = p[1] * 255 / 63,
 366       .b = p[2] * 255 / 63
 367     };
 368     p += 3;
 369   }
 370   SDL_SetPaletteColors(surf->format->palette, colors, 0, 256);
 371 }
 372
 373 void Y_repaint_rect (int x, int y, int w, int h) {
 374   assert(window != NULL);
 375   assert(surf != NULL);
 376   SDL_Surface *s = SDL_GetWindowSurface(window);
 377   SDL_Rect r = (SDL_Rect) {
 378     .x = x,
 379     .y = y,
 380     .w = w,
 381     .h = h
 382   };
 383   SDL_BlitSurface(surf, &r, s, &r);
 384   SDL_UpdateWindowSurfaceRects(window, &r, 1);
 385 }
 386
 387 void Y_repaint (void) {
 388   Y_repaint_rect(0, 0, surf->w, surf->h);
 389 }
 390
 391 void Y_enable_text_input (void) {
 392   SDL_StartTextInput();
 393 }
 394
 395 void Y_disable_text_input (void) {
 396   SDL_StopTextInput();
 397 }
 398
 399 /* --- main --- */
 400
 401 static int sdl_to_key (int code) {
 402   switch (code) {
 403     case SDL_SCANCODE_0: return KEY_0;
 404     case SDL_SCANCODE_1: return KEY_1;
 405     case SDL_SCANCODE_2: return KEY_2;
 406     case SDL_SCANCODE_3: return KEY_3;
 407     case SDL_SCANCODE_4: return KEY_4;
 408     case SDL_SCANCODE_5: return KEY_5;
 409     case SDL_SCANCODE_6: return KEY_6;
 410     case SDL_SCANCODE_7: return KEY_7;
 411     case SDL_SCANCODE_8: return KEY_8;
 412     case SDL_SCANCODE_9: return KEY_9;
 413     case SDL_SCANCODE_A: return KEY_A;
 414     case SDL_SCANCODE_B: return KEY_B;
 415     case SDL_SCANCODE_C: return KEY_C;
 416     case SDL_SCANCODE_D: return KEY_D;
 417     case SDL_SCANCODE_E: return KEY_E;
 418     case SDL_SCANCODE_F: return KEY_F;
 419     case SDL_SCANCODE_G: return KEY_G;
 420     case SDL_SCANCODE_H: return KEY_H;
 421     case SDL_SCANCODE_I: return KEY_I;
 422     case SDL_SCANCODE_J: return KEY_J;
 423     case SDL_SCANCODE_K: return KEY_K;
 424     case SDL_SCANCODE_L: return KEY_L;
 425     case SDL_SCANCODE_M: return KEY_M;
 426     case SDL_SCANCODE_N: return KEY_N;
 427     case SDL_SCANCODE_O: return KEY_O;
 428     case SDL_SCANCODE_P: return KEY_P;
 429     case SDL_SCANCODE_Q: return KEY_Q;
 430     case SDL_SCANCODE_R: return KEY_R;
 431     case SDL_SCANCODE_S: return KEY_S;
 432     case SDL_SCANCODE_T: return KEY_T;
 433     case SDL_SCANCODE_U: return KEY_U;
 434     case SDL_SCANCODE_V: return KEY_V;
 435     case SDL_SCANCODE_W: return KEY_W;
 436     case SDL_SCANCODE_X: return KEY_X;
 437     case SDL_SCANCODE_Y: return KEY_Y;
 438     case SDL_SCANCODE_Z: return KEY_Z;
 439     case SDL_SCANCODE_RETURN: return KEY_RETURN;
 440     case SDL_SCANCODE_ESCAPE: return KEY_ESCAPE;
 441     case SDL_SCANCODE_BACKSPACE: return KEY_BACKSPACE;
 442     case SDL_SCANCODE_TAB: return KEY_TAB;
 443     case SDL_SCANCODE_SPACE: return KEY_SPACE;
 444     case SDL_SCANCODE_MINUS: return KEY_MINUS;
 445     case SDL_SCANCODE_EQUALS: return KEY_EQUALS;
 446     case SDL_SCANCODE_LEFTBRACKET: return KEY_LEFTBRACKET;
 447     case SDL_SCANCODE_RIGHTBRACKET: return KEY_RIGHTBRACKET;
 448     case SDL_SCANCODE_BACKSLASH: return KEY_BACKSLASH;
 449     case SDL_SCANCODE_SEMICOLON: return KEY_SEMICOLON;
 450     case SDL_SCANCODE_APOSTROPHE: return KEY_APOSTROPHE;
 451     case SDL_SCANCODE_GRAVE: return KEY_GRAVE;
 452     case SDL_SCANCODE_COMMA: return KEY_COMMA;
 453     case SDL_SCANCODE_PERIOD: return KEY_PERIOD;
 454     case SDL_SCANCODE_SLASH: return KEY_SLASH;
 455     case SDL_SCANCODE_CAPSLOCK: return KEY_CAPSLOCK;
 456     case SDL_SCANCODE_F1: return KEY_F1;
 457     case SDL_SCANCODE_F2: return KEY_F2;
 458     case SDL_SCANCODE_F3: return KEY_F3;
 459     case SDL_SCANCODE_F4: return KEY_F4;
 460     case SDL_SCANCODE_F5: return KEY_F5;
 461     case SDL_SCANCODE_F6: return KEY_F6;
 462     case SDL_SCANCODE_F7: return KEY_F7;
 463     case SDL_SCANCODE_F8: return KEY_F8;
 464     case SDL_SCANCODE_F9: return KEY_F9;
 465     case SDL_SCANCODE_F10: return KEY_F10;
 466     case SDL_SCANCODE_F11: return KEY_F11;
 467     case SDL_SCANCODE_F12: return KEY_F12;
 468     case SDL_SCANCODE_PRINTSCREEN: return KEY_PRINTSCREEN;
 469     case SDL_SCANCODE_SCROLLLOCK: return KEY_SCROLLLOCK;
 470     case SDL_SCANCODE_PAUSE: return KEY_PAUSE;
 471     case SDL_SCANCODE_INSERT: return KEY_INSERT;
 472     case SDL_SCANCODE_HOME: return KEY_HOME;
 473     case SDL_SCANCODE_PAGEUP: return KEY_PAGEUP;
 474     case SDL_SCANCODE_DELETE: return KEY_DELETE;
 475     case SDL_SCANCODE_END: return KEY_END;
 476     case SDL_SCANCODE_PAGEDOWN: return KEY_PAGEDOWN;
 477     case SDL_SCANCODE_RIGHT: return KEY_RIGHT;
 478     case SDL_SCANCODE_LEFT: return KEY_LEFT;
 479     case SDL_SCANCODE_DOWN: return KEY_DOWN;
 480     case SDL_SCANCODE_UP: return KEY_UP;
 481     case SDL_SCANCODE_NUMLOCKCLEAR: return KEY_NUMLOCK;
 482     case SDL_SCANCODE_KP_DIVIDE: return KEY_KP_DIVIDE;
 483     case SDL_SCANCODE_KP_MULTIPLY: return KEY_KP_MULTIPLY;
 484     case SDL_SCANCODE_KP_MINUS: return KEY_KP_MINUS;
 485     case SDL_SCANCODE_KP_PLUS: return KEY_KP_PLUS;
 486     case SDL_SCANCODE_KP_ENTER: return KEY_KP_ENTER;
 487     case SDL_SCANCODE_KP_0: return KEY_KP_0;
 488     case SDL_SCANCODE_KP_1: return KEY_KP_1;
 489     case SDL_SCANCODE_KP_2: return KEY_KP_2;
 490     case SDL_SCANCODE_KP_3: return KEY_KP_3;
 491     case SDL_SCANCODE_KP_4: return KEY_KP_4;
 492     case SDL_SCANCODE_KP_5: return KEY_KP_5;
 493     case SDL_SCANCODE_KP_6: return KEY_KP_6;
 494     case SDL_SCANCODE_KP_7: return KEY_KP_7;
 495     case SDL_SCANCODE_KP_8: return KEY_KP_8;
 496     case SDL_SCANCODE_KP_9: return KEY_KP_9;
 497     case SDL_SCANCODE_KP_PERIOD: return KEY_KP_PERIOD;
 498     case SDL_SCANCODE_SYSREQ: return KEY_SYSREQ;
 499     case SDL_SCANCODE_LCTRL: return KEY_LCTRL;
 500     case SDL_SCANCODE_LSHIFT: return KEY_LSHIFT;
 501     case SDL_SCANCODE_LALT: return KEY_LALT;
 502     case SDL_SCANCODE_LGUI: return KEY_LSUPER;
 503     case SDL_SCANCODE_RCTRL: return KEY_RCTRL;
 504     case SDL_SCANCODE_RSHIFT: return KEY_RSHIFT;
 505     case SDL_SCANCODE_RALT: return KEY_RALT;
 506     case SDL_SCANCODE_RGUI: return KEY_RSUPER;
 507     default: return KEY_UNKNOWN;
 508   }
 509 }
 510
 511 static void window_event_handler (SDL_WindowEvent *ev) {
 512   switch (ev->event) {
 513     case SDL_WINDOWEVENT_RESIZED:
 514       R_set_videomode(ev->data1, ev->data2, Y_get_fullscreen());
 515       break;
 516     case SDL_WINDOWEVENT_CLOSE:
 517       ERR_quit();
 518       break;
 519   }
 520 }
 521
 522 static int utf8_to_wchar (char *x) {
 523   int i = 0;
 524   byte *s = (byte*)x;
 525   if (s[0] < 0x80) {
 526     return s[0];
 527   } else if (s[0] < 0xE0) {
 528     if (s[0] - 192 >= 0 && s[1] >= 0x80 && s[1] < 0xE0) {
 529       i = (s[0] - 192) * 64 + s[1] - 128;
 530     }
 531   } else if (s[0] < 0xF0) {
 532     if (s[1] >= 0x80 && s[1] < 0xE0 && s[2] >= 0x80 && s[2] < 0xE0) {
 533       i = ((s[0] - 224) * 64 + s[1] - 128) * 64 + s[2] - 128;
 534     }
 535   }
 536   return i;
 537 }
 538
 539 static void poll_events (void) {
 540   int key, down, uch, ch;
 541   SDL_Event ev;
 542   while (SDL_PollEvent(&ev)) {
 543     switch (ev.type) {
 544       case SDL_QUIT:
 545         ERR_quit();
 546         break;
 547       case SDL_WINDOWEVENT:
 548         if (ev.window.windowID == SDL_GetWindowID(window)) {
 549           window_event_handler(&ev.window);
 550         }
 551         break;
 552       case SDL_KEYDOWN:
 553       case SDL_KEYUP:
 554         down = ev.type == SDL_KEYDOWN;
 555         key = sdl_to_key(ev.key.keysym.scancode);
 556         I_press(key, down);
 557         GM_key(key, down);
 558         break;
 559       case SDL_TEXTINPUT:
 560         uch = utf8_to_wchar(ev.text.text);
 561         ch = cp866_utoc(uch);
 562         if (ch >= 0) {
 563           GM_input(ch);
 564         }
 565         break;
 566     }
 567   }
 568 }
 569
 570 static void step (void) {
 571   poll_events();
 572   S_updatemusic();
 573   Uint32 t = SDL_GetTicks();
 574   if (t - ticks > DELAY) {
 575     ticks = t;
 576     G_act();
 577   }
 578   R_draw();
 579 }
 580
 581 int main (int argc, char **argv) {
 582   char *pw;
 583   logo("system: initialize SDL2\n");
 584   if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS) == -1) {
 585     logo("system: failed to init SDL2: %s\n", SDL_GetError());
 586     return 1;
 587   }
 588   // Player 1 defaults
 589   pl1.ku = KEY_KP_8;
 590   pl1.kd = KEY_KP_5;
 591   pl1.kl = KEY_KP_4;
 592   pl1.kr = KEY_KP_6;
 593   pl1.kf = KEY_PAGEDOWN;
 594   pl1.kj = KEY_DELETE;
 595   pl1.kwl = KEY_HOME;
 596   pl1.kwr = KEY_END;
 597   pl1.kp = KEY_KP_8;
 598   // Player 2 defaults
 599   pl2.ku = KEY_E;
 600   pl2.kd = KEY_D;
 601   pl2.kl = KEY_S;
 602   pl2.kr = KEY_F;
 603   pl2.kf = KEY_A;
 604   pl2.kj = KEY_Q;
 605   pl2.kwl = KEY_1;
 606   pl2.kwr = KEY_2;
 607   pl2.kp = KEY_E;
 608   srand(SDL_GetTicks());
 609   F_startup();
 610 #ifndef WIN32
 611   pw = "/usr/share/doom2d-rembo/doom2d.wad";
 612 #else
 613   pw = "doom2d.wad";
 614 #endif
 615   if (fexists(pw)) {
 616     F_addwad(pw);
 617   } else {
 618     F_addwad("doom2d.wad");
 619   }
 620   CFG_args(argc, argv);
 621   CFG_load();
 622   F_initwads();
 623   M_startup();
 624   F_allocres();
 625   S_init();
 626   S_initmusic();
 627   R_init();
 628   G_init();
 629   ticks = SDL_GetTicks();
 630 #ifdef __EMSCRIPTEN__
 631   emscripten_set_main_loop(step, 0, 1);
 632 #else
 633   while (!quit) {
 634     step();
 635   }
 636 #endif
 637   CFG_save();
 638   R_done();
 639   S_donemusic();
 640   S_done();
 641   M_shutdown();
 642   SDL_Quit();
 643   return 0;
 644 }