src/menu.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 #include "glob.h"
  24 #include "files.h"
  25 #include "memory.h"
  26 #include "error.h"
  27 #include "sound.h"
  28 #include "view.h"
  29 #include "player.h"
  30 #include "switch.h"
  31 #include "menu.h"
  32 #include "misc.h"
  33 #include "render.h"
  34 #include "config.h"
  35 #include "game.h"
  36 #include "player.h"
  37 #include "sound.h"
  38 #include "music.h"
  39 #include "input.h"
  40 #include "system.h"
  41
  42 #include "save.h"
  43
  44 #include <stdio.h>
  45 #include <string.h>
  46 #include <stdlib.h>
  47 #include <assert.h>
  48
  49 #define PCOLORN 10
  50 static byte pcolortab[PCOLORN] = {
  51   0x18, 0x20, 0x40, 0x58, 0x60, 0x70, 0x80, 0xB0, 0xC0, 0xD0
  52 };
  53 static int p1color = 5;
  54 static int p2color = 4;
  55
  56 byte _warp;
  57
  58 #define MAX_STACK 8
  59 static struct {
  60   const menu_t *m;
  61 } stack[MAX_STACK];
  62 static int stack_p = -1;
  63
  64 #define GM_MAX_INPUT 24
  65 char ibuf[GM_MAX_INPUT];
  66 byte input;
  67 int icur;
  68 int imax;
  69 static byte cbuf[32];
  70 short lastkey;
  71
  72 #define QSND_NUM 14
  73 static int qsnd[QSND_NUM];
  74 static snd_t *csnd1, *csnd2, *msnd1, *msnd2, *msnd3, *msnd4, *msnd5, *msnd6;
  75 static snd_t *voc;
  76 static int voc_ch;
  77
  78 static void GM_stop (void) {
  79   if (voc != NULL) {
  80     if (voc_ch) {
  81       S_stop(voc_ch);
  82       voc_ch = 0;
  83     }
  84     S_free(voc);
  85     voc = NULL;
  86   }
  87 }
  88
  89 static int GM_say (const char nm[8]) {
  90   snd_t *snd = S_load(nm);
  91   if (snd) {
  92     GM_stop();
  93     voc = S_load(nm);
  94     voc_ch = S_play(voc, 0, 255);
  95   }
  96   return 1;
  97 }
  98
  99 int GM_init_int0 (menu_msg_t *msg, int i, int a, int b, int s) {
 100   assert(msg != NULL);
 101   msg->integer.i = i;
 102   msg->integer.a = a;
 103   msg->integer.b = b;
 104   msg->integer.s = s;
 105   return 1;
 106 }
 107
 108 int GM_init_int (menu_msg_t *msg, int i, int a, int b, int s) {
 109   assert(msg != NULL);
 110   assert(a <= b);
 111   assert(s >= 0);
 112   return GM_init_int0(msg, min(max(i, a), b), a, b, s);
 113 }
 114
 115 int GM_init_str (menu_msg_t *msg, char *str, int maxlen) {
 116   assert(msg != NULL);
 117   assert(str != NULL);
 118   assert(maxlen >= 0);
 119   msg->string.s = str;
 120   msg->string.maxlen = maxlen;
 121   return 1;
 122 }
 123
 124 int basic_menu_handler (menu_msg_t *msg, byte type, char *title, char *say, int n, int *cur) {
 125   assert(msg != NULL);
 126   assert(type == GM_BIG || type == GM_SMALL);
 127   assert(title != NULL);
 128   assert(n >= 0);
 129   assert(cur != NULL);
 130   switch (msg->type) {
 131     case GM_QUERY: return GM_init_int0(msg, *cur, n, n, type);
 132     case GM_GETTITLE: return GM_init_str(msg, title, strlen(title));
 133     case GM_ENTER: return say ? GM_say(say) : 1;
 134     case GM_UP: *cur = GM_CYCLE(*cur - 1, 0, n - 1); return 1;
 135     case GM_DOWN: *cur = GM_CYCLE(*cur + 1, 0, n - 1); return 1;
 136   }
 137   return 0;
 138 }
 139
 140 int simple_menu_handler (menu_msg_t *msg, int i, int n, const simple_menu_t *m, int *cur) {
 141   assert(msg != NULL);
 142   assert(n >= 0);
 143   assert(i >= 0 && i < n);
 144   assert(m != NULL);
 145   assert(cur != NULL);
 146   switch (msg->type) {
 147     case GM_GETENTRY: return GM_init_int0(msg, m->type == GM_SMALL ? GM_SMALL_BUTTON : GM_BUTTON, 0, 0, 0);
 148     case GM_GETCAPTION: return GM_init_str(msg, m->entries[i].caption, strlen(m->entries[i].caption));
 149     case GM_SELECT: return m->entries[i].submenu ? GM_push(m->entries[i].submenu) : 1;
 150   }
 151   return basic_menu_handler(msg, m->type, m->title, m->say, n, cur);
 152 }
 153
 154 static int start_game (int twoplayers, int dm, int level) {
 155   _2pl = twoplayers;
 156   g_dm = dm;
 157   g_map = level ? level : 1;
 158   PL_reset();
 159   pl1.color = pcolortab[p1color];
 160   pl2.color = pcolortab[p2color];
 161   G_start();
 162   return GM_popall();
 163 }
 164
 165 static int new_game_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 166   static int cur;
 167   enum { ONEPLAYER, TWOPLAYERS, DEATHMATCH, __NUM__ };
 168   static const simple_menu_t sm = {
 169     GM_BIG, "New Game", "_NEWGAME",
 170     {
 171       { "One Player", NULL },
 172       { "Two Players", NULL },
 173       { "Deathmatch", NULL },
 174     }
 175   };
 176   if (msg->type == GM_SELECT) {
 177     switch (i) {
 178       case ONEPLAYER: GM_say("_1PLAYER"); return start_game(0, 0, _warp);
 179       case TWOPLAYERS: GM_say("_2PLAYER"); return start_game(1, 0, _warp);
 180       case DEATHMATCH: GM_say("_DM"); return start_game(1, 1, _warp);
 181       // GM_say("_COOP");
 182     }
 183   }
 184   return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
 185 }
 186
 187 static const menu_t new_game_menu = {
 188   NULL, &new_game_menu_handler
 189 };
 190
 191 static int load_game_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 192   static int cur;
 193   const int max_slots = 7;
 194   assert(i >= 0 && i < max_slots);
 195   switch (msg->type) {
 196     case GM_ENTER: F_getsavnames(); break;
 197     case GM_GETENTRY: return GM_init_int0(msg, GM_TEXTFIELD_BUTTON, 0, 0, 0);
 198     case GM_GETSTR: return GM_init_str(msg, (char*)savname[i], 24);
 199     case GM_SELECT:
 200       if (savok[i]) {
 201         load_game(i);
 202         GM_popall();
 203       }
 204       return 1;
 205   }
 206   return basic_menu_handler(msg, GM_BIG, "Load game", "_OLDGAME", max_slots, &cur);
 207 }
 208
 209 static const menu_t load_game_menu = {
 210   NULL, &load_game_menu_handler
 211 };
 212
 213 static int save_game_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 214   static int cur;
 215   const int max_slots = 7;
 216   assert(i >= 0 && i < max_slots);
 217   switch (msg->type) {
 218     case GM_ENTER:
 219       if (g_st == GS_GAME) {
 220         F_getsavnames();
 221         break;
 222       } else {
 223         return GM_pop();
 224       }
 225     case GM_GETENTRY: return GM_init_int0(msg, GM_TEXTFIELD, 0, 0, 0);
 226     case GM_GETSTR: return GM_init_str(msg, (char*)savname[i], 24);
 227     case GM_END:
 228       if (g_st == GS_GAME) {
 229         assert(msg->string.maxlen >= 24);
 230         F_savegame(i, msg->string.s);
 231       }
 232       return GM_popall();
 233   }
 234   return basic_menu_handler(msg, GM_BIG, "Save game", "_SAVGAME", max_slots, &cur);
 235 }
 236
 237 static const menu_t save_game_menu = {
 238   NULL, &save_game_menu_handler
 239 };
 240
 241 static int sound_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 242   static int cur;
 243   enum { VOLUME, __NUM__ };
 244   static const simple_menu_t sm = {
 245     GM_BIG, "Sound", NULL,
 246     {
 247       { "Volume", NULL },
 248     }
 249   };
 250   if (i == VOLUME) {
 251     switch (msg->type) {
 252       case GM_GETENTRY: return GM_init_int0(msg, GM_SCROLLER, 0, 0, 0);
 253       case GM_GETINT: return GM_init_int(msg, snd_vol, 0, 128, 8);
 254       case GM_SETINT: S_volume(msg->integer.i); return 1;
 255     }
 256   }
 257   return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
 258 }
 259
 260 static const menu_t sound_menu = {
 261   NULL, &sound_menu_handler
 262 };
 263
 264 static int music_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 265   static int cur;
 266   enum { VOLUME, MUSIC, __NUM__ };
 267   static const simple_menu_t sm = {
 268     GM_BIG, "Music", NULL,
 269     {
 270       { "Volume", NULL },
 271       { "Music: ", NULL },
 272     }
 273   };
 274   if (i == VOLUME) {
 275     switch (msg->type) {
 276       case GM_GETENTRY: return GM_init_int0(msg, GM_SCROLLER, 0, 0, 0);
 277       case GM_GETINT: return GM_init_int(msg, mus_vol, 0, 128, 8);
 278       case GM_SETINT: S_volumemusic(msg->integer.i); return 1;
 279     }
 280   } else if (i == MUSIC) {
 281     switch (msg->type) {
 282       case GM_GETSTR: return GM_init_str(msg, g_music, strlen(g_music));
 283       case GM_SELECT:
 284         F_freemus();
 285         F_nextmus(g_music);
 286         F_loadmus(g_music);
 287         S_startmusic(music_time * 2); // ???
 288         return 1;
 289     }
 290   }
 291   return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
 292 }
 293
 294 static const menu_t music_menu = {
 295   NULL, &music_menu_handler
 296 };
 297
 298 static int options_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 299   static int cur;
 300   enum { VIDEO, SOUND, MUSIC, __NUM__ };
 301   static const simple_menu_t sm = {
 302     GM_BIG, "Options", NULL,
 303     {
 304       { "Video", NULL },
 305       { "Sound", &sound_menu },
 306       { "Music", &music_menu },
 307     }
 308   };
 309   if (msg->type == GM_SELECT) {
 310     if (i == VIDEO) {
 311       const menu_t *mm = R_menu();
 312       return mm ? GM_push(mm) : 1;
 313     }
 314   }
 315   return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
 316 }
 317
 318 static const menu_t options_menu = {
 319   NULL, &options_menu_handler
 320 };
 321
 322 static int exit_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 323   static int cur;
 324   enum { YES, NO, __NUM__ };
 325   static const simple_menu_t sm = {
 326     GM_SMALL, "You are sure?", NULL,
 327     {
 328       { "Yes", NULL },
 329       { "No", NULL },
 330     }
 331   };
 332   if (msg->type == GM_ENTER) {
 333     return GM_say(rand() & 1 ? "_EXIT1" : "_EXIT2");
 334   } else if (msg->type == GM_SELECT) {
 335     switch (i) {
 336       case YES:
 337         F_freemus();
 338         GM_stop();
 339         Z_sound(S_get(qsnd[myrand(QSND_NUM)]), 255);
 340         S_wait();
 341         ERR_quit();
 342         return 1;
 343       case NO:
 344         return GM_pop();
 345     }
 346   }
 347   return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
 348 }
 349
 350 static const menu_t exit_menu = {
 351   NULL, &exit_menu_handler
 352 };
 353
 354 static int main_menu_handler (menu_msg_t *msg, const menu_t *m, void *data, int i) {
 355   static int cur;
 356   enum { NEWGAME, OLDGAME, SAVEGAME, OPTIONS, EXIT, __NUM__ };
 357   assert(i >= 0 && i < __NUM__);
 358   static const simple_menu_t sm = {
 359     GM_BIG, "Menu", NULL,
 360     {
 361       { "New Game", &new_game_menu },
 362       { "Load Game", &load_game_menu },
 363       { "Save Game", &save_game_menu },
 364       { "Options", &options_menu },
 365       { "Exit", &exit_menu },
 366     }
 367   };
 368   return simple_menu_handler(msg, i, __NUM__, &sm, &cur);
 369 }
 370
 371 static const menu_t main_menu = {
 372   NULL, &main_menu_handler
 373 };
 374
 375 int GM_push (const menu_t *m) {
 376   assert(m != NULL);
 377   assert(stack_p >= -1);
 378   assert(stack_p < MAX_STACK - 1);
 379   menu_msg_t msg;
 380   stack_p += 1;
 381   stack[stack_p].m = m;
 382   msg.type = GM_ENTER;
 383   GM_send_this(m, &msg);
 384   return 1;
 385 }
 386
 387 int GM_pop (void) {
 388   assert(stack_p >= 0);
 389   menu_msg_t msg;
 390   stack_p -= 1;
 391   msg.type = GM_LEAVE;
 392   GM_send_this(stack[stack_p + 1].m, &msg);
 393   return 1;
 394 }
 395
 396 int GM_popall (void) {
 397   int i;
 398   for (i = 0; i >= -1; i--) {
 399     GM_pop();
 400   }
 401   return 1;
 402 }
 403
 404 const menu_t *GM_get (void) {
 405   if (stack_p >= 0) {
 406     return stack[stack_p].m;
 407   } else {
 408     return NULL;
 409   }
 410 }
 411
 412 static void GM_normalize_message (menu_msg_t *msg) {
 413   switch (msg->type) {
 414     case GM_SETINT:
 415       msg->integer.i = min(max(msg->integer.i, msg->integer.a), msg->integer.b);
 416       break;
 417     case GM_SETSTR:
 418       assert(msg->string.maxlen >= 0);
 419       break;
 420   }
 421 }
 422
 423 int GM_send_this (const menu_t *m, menu_msg_t *msg) {
 424   assert(m != NULL);
 425   assert(msg != NULL);
 426   if (m->handler != NULL) {
 427     GM_normalize_message(msg);
 428     return m->handler(msg, m, m->data, 0);
 429   }
 430   return 0;
 431 }
 432
 433 int GM_send (const menu_t *m, int i, menu_msg_t *msg) {
 434   assert(m != NULL);
 435   assert(i >= 0);
 436   assert(msg != NULL);
 437   if (m->handler != NULL) {
 438     GM_normalize_message(msg);
 439     return m->handler(msg, m, m->data, i);
 440   }
 441   return 0;
 442 }
 443
 444 void G_code (void) {
 445   void *s;
 446   s=csnd2;
 447   if(memcmp(cbuf+32-5,"IDDQD",5)==0) {
 448     PL_hit(&pl1,400,0,HIT_SOME);
 449     if(_2pl) PL_hit(&pl2,400,0,HIT_SOME);
 450     s=csnd1;
 451   }else if(memcmp(cbuf+32-4,"TANK",4)==0) {
 452     pl1.life=pl1.armor=200;pl1.drawst|=PL_DRAWARMOR|PL_DRAWLIFE;
 453     if(_2pl) {pl2.life=pl2.armor=200;pl2.drawst|=PL_DRAWARMOR|PL_DRAWLIFE;}
 454   }else if(memcmp(cbuf+32-8,"BULLFROG",8)==0) {
 455     PL_JUMP=(PL_JUMP==10)?20:10;
 456   }else if(memcmp(cbuf+32-8,"FORMULA1",8)==0) {
 457     PL_RUN=(PL_RUN==8)?24:8;
 458   }else if(memcmp(cbuf+32-5,"RAMBO",5)==0) {
 459     pl1.ammo=pl1.shel=pl1.rock=pl1.cell=pl1.fuel=30000;
 460     pl1.wpns=0x7FF;pl1.drawst|=PL_DRAWWPN|PL_DRAWKEYS;
 461     pl1.keys=0x70;
 462     if(_2pl) {
 463       pl2.ammo=pl2.shel=pl2.rock=pl2.cell=pl1.fuel=30000;
 464       pl2.wpns=0x7FF;pl2.drawst|=PL_DRAWWPN|PL_DRAWKEYS;
 465       pl2.keys=0x70;
 466     }
 467   }else if(memcmp(cbuf+32-5,"UJHTW",5)==0) {
 468     p_immortal=!p_immortal;
 469   }else if(memcmp(cbuf+32-9,",TKSQJHTK",9)==0) {
 470     p_fly=!p_fly;
 471   }else if(memcmp(cbuf+32-6,"CBVCBV",6)==0) {
 472     SW_cheat_open();
 473   }else if(memcmp(cbuf+32-7,"GOODBYE",7)==0) {
 474     g_exit=1;
 475   }else if(memcmp(cbuf+32-9,"GJITKYF",7)==0) {
 476     if(cbuf[30]>='0' && cbuf[30]<='9' && cbuf[31]>='0' && cbuf[31]<='9') {
 477       g_map=(cbuf[30]=='0')?0:(cbuf[30]-'0')*10;
 478       g_map+=(cbuf[31]=='0')?0:(cbuf[31]-'0');
 479       G_start();
 480     }
 481   }else return;
 482   memset(cbuf,0,32);
 483   Z_sound(s,128);
 484 }
 485
 486 static int strnlen (const char *s, int len) {
 487   int i = 0;
 488   while (i < len && s[i] != 0) {
 489     i++;
 490   }
 491   return i;
 492 }
 493
 494 static int state_for_anykey (int x) {
 495   return x == GS_TITLE || x == GS_ENDSCR;
 496 }
 497
 498 int GM_act (void) {
 499   menu_msg_t msg;
 500   int n, cur, type;
 501   const menu_t *m = GM_get();
 502   if (m == NULL) {
 503     if (lastkey == KEY_ESCAPE || (state_for_anykey(g_st) && lastkey != KEY_UNKNOWN)) {
 504       GM_push(&main_menu);
 505       Z_sound(msnd3, 128);
 506     }
 507   } else {
 508     msg.type = GM_QUERY;
 509     if (GM_send_this(m, &msg)) {
 510       cur = msg.integer.i;
 511       n = msg.integer.a;
 512       msg.type = GM_GETENTRY;
 513       if (GM_send(m, cur, &msg)) {
 514         type = msg.integer.i;
 515         switch (lastkey) {
 516           case KEY_ESCAPE:
 517             if (type == GM_TEXTFIELD && input) {
 518               input = 0;
 519               Y_disable_text_input();
 520               msg.type = GM_CANCEL;
 521               GM_send(m, cur, &msg);
 522             } else {
 523               GM_pop();
 524               Z_sound(msnd4, 128);
 525             }
 526             break;
 527           case KEY_UP:
 528           case KEY_DOWN:
 529             if (input == 0) {
 530               msg.type = lastkey == KEY_UP ? GM_UP : GM_DOWN;
 531               if (GM_send(m, cur, &msg)) {
 532                 Z_sound(msnd1, 128);
 533               }
 534             }
 535             break;
 536           case KEY_LEFT:
 537           case KEY_RIGHT:
 538             if (type == GM_SCROLLER) {
 539               msg.integer.type = GM_GETINT;
 540               if (GM_send(m, cur, &msg)) {
 541                 msg.integer.type = GM_SETINT;
 542                 msg.integer.i += lastkey == KEY_LEFT ? -msg.integer.s : msg.integer.s;
 543                 msg.integer.i = min(max(msg.integer.i, msg.integer.a), msg.integer.b);
 544                 if (GM_send(m, cur, &msg)) {
 545                   Z_sound(lastkey == KEY_LEFT ? msnd5 : msnd6, 255);
 546                 }
 547               }
 548             } else if (type == GM_TEXTFIELD) {
 549               //if (input) {
 550               //  icur += lastkey == KEY_LEFT ? -1 : +1;
 551               //  icur = min(max(icur, 0), strnlen(ibuf, imax));
 552               //}
 553             }
 554             break;
 555           case KEY_BACKSPACE:
 556             if (type == GM_TEXTFIELD) {
 557               if (input && icur > 0) {
 558                 // FIXIT buffers in strncpy must not overlap
 559                 strncpy(&ibuf[icur - 1], &ibuf[icur], imax - icur);
 560                 ibuf[imax - 1] = 0;
 561                 icur -= 1;
 562               }
 563             }
 564             break;
 565           case KEY_RETURN:
 566             if (type == GM_TEXTFIELD) {
 567               if (input) {
 568                 input = 0;
 569                 Y_disable_text_input();
 570                 msg.type = GM_END;
 571                 msg.string.s = ibuf;
 572                 msg.string.maxlen = imax;
 573                 GM_send(m, cur, &msg);
 574               } else {
 575                 msg.type = GM_GETSTR;
 576                 if (GM_send(m, cur, &msg)) {
 577                   imax = min(msg.string.maxlen, GM_MAX_INPUT);
 578                   strncpy(ibuf, msg.string.s, imax);
 579                   icur = strnlen(ibuf, imax);
 580                 } else {
 581                   memset(ibuf, 0, GM_MAX_INPUT);
 582                   imax = GM_MAX_INPUT;
 583                   icur = 0;
 584                 }
 585                 input = 1;
 586                 Y_enable_text_input();
 587                 msg.type = GM_BEGIN;
 588                 GM_send(m, cur, &msg);
 589               }
 590               Z_sound(msnd2, 128);
 591             } else {
 592               msg.type = GM_SELECT;
 593               if (cur < 0) abort();
 594               if (GM_send(m, cur, &msg)) {
 595                 Z_sound(msnd2, 128);
 596               }
 597             }
 598             break;
 599         }
 600       }
 601     }
 602   }
 603   lastkey = KEY_UNKNOWN;
 604   return m != NULL;
 605 }
 606
 607 void GM_input (int ch) {
 608   if (ch != 0 && input) {
 609     if (icur < imax) {
 610       ibuf[icur] = ch;
 611       icur += 1;
 612       if (icur < imax) {
 613         ibuf[icur] = 0;
 614       }
 615     }
 616   }
 617 }
 618
 619 void GM_key (int key, int down) {
 620   int i;
 621   if (down) {
 622     lastkey = key;
 623     if (!_2pl || cheat) {
 624       for (i = 0; i < 31; i++) {
 625         cbuf[i] = cbuf[i + 1];
 626       }
 627       if (key >= KEY_0 && key <= KEY_9) {
 628         cbuf[31] = key - KEY_0 + '0';
 629       } else if (key >= KEY_A && key <= KEY_Z) {
 630         cbuf[31] = key - KEY_A + 'A';
 631       } else {
 632         cbuf[31] = 0;
 633       }
 634     }
 635   }
 636 }
 637
 638 void GM_init (void) {
 639   int i;
 640   char s[8];
 641   static const char nm[QSND_NUM][6] = {
 642     "CYBSIT", "KNTDTH", "MNPAIN", "PEPAIN", "SLOP", "MANSIT", "BOSPN", "VILACT",
 643     "PLFALL", "BGACT", "BGDTH2", "POPAIN", "SGTATK", "VILDTH"
 644   };
 645   s[0] = 'D';
 646   s[1] = 'S';
 647   for (i = 0; i < QSND_NUM; ++i) {
 648     memcpy(s + 2, nm[i], 6);
 649     qsnd[i] = F_getresid(s);
 650   }
 651   csnd1 = Z_getsnd("HAHA1");
 652   csnd2 = Z_getsnd("RADIO");
 653   msnd1 = Z_getsnd("PSTOP");
 654   msnd2 = Z_getsnd("PISTOL");
 655   msnd3 = Z_getsnd("SWTCHN");
 656   msnd4 = Z_getsnd("SWTCHX");
 657   msnd5 = Z_getsnd("SUDI");
 658   msnd6 = Z_getsnd("TUDI");
 659   F_loadmus("MENU");
 660   S_startmusic(0);
 661 }