apps/plugins/doom/m_menu.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // $Id$
   5 //
   6 // Copyright (C) 1993-1996 by id Software, Inc.
   7 //
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License
  10 // as published by the Free Software Foundation; either version 2
  11 // of the License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // $Log$
  19 // Revision 1.7  2006/12/13 04:44:17  kkurbjun
  20 // Dehacked and BEX support for Doom - currently only supports a DEHACKED file in a WAD (not as a standalone file yet).
  21 //
  22 // Revision 1.6  2006-04-16 23:14:04  kkurbjun
  23 // Fix run so that it stays enabled across level loads.  Removed some unused code and added some back in for hopeful future use.
  24 //
  25 // Revision 1.5  2006-04-04 23:58:37  kkurbjun
  26 // Make savegame strings more informative
  27 //
  28 // Revision 1.4  2006-04-04 23:13:50  kkurbjun
  29 // Fix up configurable keys, edit exit string, more work needs to be done on menu keys
  30 //
  31 // Revision 1.3  2006-04-03 20:03:02  kkurbjun
  32 // Updates doom menu w/ new graphics, now requires rockdoom.wad: http://alamode.mines.edu/~kkurbjun/rockdoom.wad
  33 //
  34 // Revision 1.2  2006-04-03 00:28:13  kkurbjun
  35 // Fixes graphic errors in scaling code, note sure about the fix in hu_lib.c though.  I havn't seen any corrupted text but it may still need a proper fix.
  36 //
  37 // Revision 1.1  2006-03-28 15:44:01  dave
  38 // Patch #2969 - Doom!  Currently only working on the H300.
  39 //
  40 //
  41 // DESCRIPTION:
  42 // DOOM selection menu, options, episode etc.
  43 // Sliders and icons. Kinda widget stuff.
  44 //
  45 //-----------------------------------------------------------------------------
  46
  47 #include "doomdef.h"
  48 #include "dstrings.h"
  49
  50 #include "d_main.h"
  51
  52 #include "i_system.h"
  53 #include "i_video.h"
  54 #include "z_zone.h"
  55 #include "v_video.h"
  56 #include "w_wad.h"
  57
  58 #include "r_main.h"
  59 #include "d_deh.h"
  60 #include "hu_stuff.h"
  61
  62 #include "g_game.h"
  63
  64 #include "m_argv.h"
  65 #include "m_swap.h"
  66 #include "s_sound.h"
  67
  68 #include "doomstat.h"
  69
  70 // Data.
  71 #include "sounds.h"
  72
  73 #include "m_menu.h"
  74 #include "rockmacros.h"
  75
  76
  77 extern patchnum_t  hu_font[HU_FONTSIZE];
  78 extern boolean  message_dontfuckwithme;
  79
  80 extern boolean  chat_on;  // in heads-up code
  81
  82 //
  83 // defaulted values
  84 //
  85 int   mouseSensitivity;       // has default
  86
  87 // Show messages has default, 0 = off, 1 = on
  88 int   showMessages;
  89
  90 // Blocky mode, has default, 0 = high, 1 = normal
  91 int   screenblocks;  // has default
  92
  93 // temp for screenblocks (0-9)
  94 int   screenSize;
  95
  96 // -1 = no quicksave slot picked!
  97 int   quickSaveSlot;
  98
  99 // 1 = message to be printed
 100 int   messageToPrint;
 101 // ...and here is the message string!
 102 const char*   messageString;
 103
 104 // message x & y
 105 int   messx;
 106 int   messy;
 107 int   messageLastMenuActive;
 108
 109 // timed message = no input from user
 110 boolean   messageNeedsInput;
 111
 112 void    (*messageRoutine)(int response);
 113
 114 #define SAVESTRINGSIZE  24
 115
 116 // we are going to be entering a savegame string
 117 int   saveStringEnter;
 118 int              saveSlot; // which slot to save in
 119 int   saveCharIndex; // which char we're editing
 120 // old save description before edit
 121 char   saveOldString[SAVESTRINGSIZE];
 122
 123 boolean   inhelpscreens;
 124 boolean   menuactive;
 125
 126 #define SKULLXOFF  -32
 127 #define LINEHEIGHT  16
 128
 129 extern boolean  sendpause;
 130 char   savegamestrings[10][SAVESTRINGSIZE];
 131
 132 char endstring[170];
 133
 134
 135 //
 136 // MENU TYPEDEFS
 137 //
 138 typedef struct
 139 {
 140    // 0 = no cursor here, 1 = ok, 2 = arrows ok
 141    short status;
 142
 143    char name[10];
 144
 145    // choice = menu item #.
 146    // if status = 2,
 147    //   choice=0:leftarrow,1:rightarrow
 148    void (*routine)(int choice);
 149
 150    // hotkey in menu
 151    char alphaKey;
 152 }
 153 menuitem_t;
 154
 155
 156
 157 typedef struct menu_s
 158 {
 159    short  numitems; // # of menu items
 160    struct menu_s* prevMenu; // previous menu
 161    menuitem_t*  menuitems; // menu items
 162    void  (*routine)(void); // draw routine ROCKBOX
 163    short  x;
 164    short  y;  // x,y of menu
 165    short  lastOn;  // last item user was on in menu
 166 }
 167 menu_t;
 168
 169 short  itemOn;   // menu item skull is on
 170 short  skullAnimCounter; // skull animation counter
 171 short  whichSkull;  // which skull to draw
 172 int systemvol;
 173
 174 // graphic name of skulls
 175 // warning: initializer-string for array of chars is too long
 176 char    skullName[2][/*8*/9] = {"M_SKULL1","M_SKULL2"};
 177
 178 // current menudef
 179 menu_t* currentMenu;
 180
 181 //
 182 // PROTOTYPES
 183 //
 184 void M_NewGame(int choice);
 185 void M_Episode(int choice);
 186 void M_ChooseSkill(int choice);
 187 void M_LoadGame(int choice);
 188 void M_SaveGame(int choice);
 189 void M_Options(int choice);
 190 void M_EndGame(int choice);
 191 void M_ReadThis(int choice);
 192 void M_ReadThis2(int choice);
 193 void M_QuitDOOM(int choice);
 194
 195 void M_ChangeMessages(int choice);
 196 void M_ChangeGamma(int choice);
 197 void M_SfxVol(int choice);
 198 void M_MusicVol(int choice);
 199 void M_SystemVol(int choice);
 200 void M_SizeDisplay(int choice);
 201 void M_StartGame(int choice);
 202 void M_Sound(int choice);
 203
 204 void M_FinishReadThis(int choice);
 205 void M_LoadSelect(int choice);
 206 void M_SaveSelect(int choice);
 207 void M_ReadSaveStrings(void);
 208 void M_QuickSave(void);
 209 void M_QuickLoad(void);
 210
 211 void M_DrawMainMenu(void);
 212 void M_DrawReadThis1(void);
 213 void M_DrawReadThis2(void);
 214 void M_DrawNewGame(void);
 215 void M_DrawEpisode(void);
 216 void M_DrawOptions(void);
 217 void M_DrawSound(void);
 218 void M_DrawLoad(void);
 219 void M_DrawSave(void);
 220
 221 void M_DrawSaveLoadBorder(int x,int y);
 222 void M_SetupNextMenu(menu_t *menudef);
 223 void M_DrawThermo(int x,int y,int thermWidth,int thermDot);
 224 void M_DrawEmptyCell(menu_t *menu,int item);
 225 void M_DrawSelCell(menu_t *menu,int item);
 226 void M_WriteText(int x, int y, char *string);
 227 int M_StringWidth(const char* string);
 228 int M_StringHeight(const char* string);
 229 void M_StartControlPanel(void);
 230 void M_StartMessage(const char *string,void *routine,boolean input);
 231 void M_StopMessage(void);
 232 void M_ClearMenus (void);
 233
 234
 235
 236
 237 //
 238 // DOOM MENU
 239 //
 240 enum
 241 {
 242    newgame = 0,
 243    options,
 244    loadgame,
 245    savegame,
 246    readthis,
 247    quitdoom,
 248    main_end
 249 };
 250 unsigned main_e;
 251
 252 menuitem_t MainMenu[]=
 253    {
 254       {1,"M_NGAME",M_NewGame,'n'},
 255       {1,"M_OPTION",M_Options,'o'},
 256       {1,"M_LOADG",M_LoadGame,'l'},
 257       {1,"M_SAVEG",M_SaveGame,'s'},
 258       // Another hickup with Special edition.
 259       {1,"M_RDTHIS",M_ReadThis,'r'},
 260       {1,"M_QUITG",M_QuitDOOM,'q'}
 261    };
 262
 263 menu_t  MainDef =
 264    {
 265       main_end,
 266       NULL,
 267       MainMenu,
 268       M_DrawMainMenu,
 269       97,64,
 270       0
 271    };
 272
 273
 274 //
 275 // EPISODE SELECT
 276 //
 277 enum
 278 {
 279    ep1,
 280    ep2,
 281    ep3,
 282    ep4,
 283    ep_end
 284 };
 285 unsigned episodes_e;
 286
 287 menuitem_t EpisodeMenu[]=
 288    {
 289       {1,"M_EPI1", M_Episode,'k'},
 290       {1,"M_EPI2", M_Episode,'t'},
 291       {1,"M_EPI3", M_Episode,'i'},
 292       {1,"M_EPI4", M_Episode,'t'}
 293    };
 294
 295 menu_t  EpiDef =
 296    {
 297       ep_end,  // # of menu items
 298       &MainDef,  // previous menu
 299       EpisodeMenu, // menuitem_t ->
 300       M_DrawEpisode, // drawing routine ->
 301       48,63,              // x,y
 302       ep1   // lastOn
 303    };
 304
 305 //
 306 // NEW GAME
 307 //
 308 enum
 309 {
 310    killthings,
 311    toorough,
 312    hurtme,
 313    violence,
 314    nightmare,
 315    newg_end
 316 };
 317 unsigned newgame_e;
 318
 319 menuitem_t NewGameMenu[]=
 320    {
 321       {1,"M_JKILL", M_ChooseSkill, 'i'},
 322       {1,"M_ROUGH", M_ChooseSkill, 'h'},
 323       {1,"M_HURT", M_ChooseSkill, 'h'},
 324       {1,"M_ULTRA", M_ChooseSkill, 'u'},
 325       {1,"M_NMARE", M_ChooseSkill, 'n'}
 326    };
 327
 328 menu_t  NewDef =
 329    {
 330       newg_end,  // # of menu items
 331       &EpiDef,  // previous menu
 332       NewGameMenu, // menuitem_t ->
 333       M_DrawNewGame, // drawing routine ->
 334       48,63,              // x,y
 335       hurtme  // lastOn
 336    };
 337
 338
 339
 340 //
 341 // OPTIONS MENU
 342 //
 343 enum
 344 {
 345    endgame,
 346    messages,
 347    scrnsize,
 348    option_empty1,
 349    gamasens,
 350    option_empty2,
 351    soundvol,
 352    opt_end
 353 };
 354 unsigned options_e;
 355
 356 menuitem_t OptionsMenu[]=
 357    {
 358       {1,"M_ENDGAM", M_EndGame,'e'},
 359       {1,"M_MESSG", M_ChangeMessages,'m'},
 360       {2,"M_SCRNSZ", M_SizeDisplay,'s'},
 361       {-1,"",0,0},
 362       {2,"M_GAMMA", M_ChangeGamma,'m'},
 363       {-1,"",0,0},
 364       {1,"M_SVOL", M_Sound,'s'}
 365    };
 366
 367 menu_t  OptionsDef =
 368    {
 369       opt_end,
 370       &MainDef,
 371       OptionsMenu,
 372       M_DrawOptions,
 373       60,37,
 374       0
 375    };
 376
 377 //
 378 // Read This! MENU 1 & 2
 379 //
 380 enum
 381 {
 382    rdthsempty1,
 383    read1_end
 384 };
 385 unsigned read_e;
 386
 387 menuitem_t ReadMenu1[] =
 388    {
 389       {1,"",M_ReadThis2,0}
 390    };
 391
 392 menu_t  ReadDef1 =
 393    {
 394       read1_end,
 395       &MainDef,
 396       ReadMenu1,
 397       M_DrawReadThis1,
 398       280,185,
 399       0
 400    };
 401
 402 enum
 403 {
 404    rdthsempty2,
 405    read2_end
 406 };
 407 unsigned read_e2;
 408
 409 menuitem_t ReadMenu2[]=
 410    {
 411       {1,"",M_FinishReadThis,0}
 412    };
 413
 414 menu_t  ReadDef2 =
 415    {
 416       read2_end,
 417       &ReadDef1,
 418       ReadMenu2,
 419       M_DrawReadThis2,
 420       330,175,
 421       0
 422    };
 423
 424 //
 425 // SOUND VOLUME MENU
 426 //
 427 enum
 428 {
 429    sfx_vol,
 430    sfx_empty1,
 431    music_vol,
 432    sfx_empty2,
 433    system_vol,
 434    sfx_empty3,
 435    sound_end
 436 };
 437 unsigned sound_e;
 438
 439 menuitem_t SoundMenu[]=
 440    {
 441       {2,"M_SFXVOL",M_SfxVol,'s'},
 442       {-1,"",0,0}, //ROCKBOX
 443       {2,"M_MUSVOL",M_MusicVol,'m'},
 444       {-1,"",0,0}, //ROCKBOX
 445       {2,"M_SYSVOL",M_SystemVol,'z'},
 446       {-1,"",0,0} //ROCKBOX
 447    };
 448
 449 menu_t  SoundDef =
 450    {
 451       sound_end,
 452       &OptionsDef,
 453       SoundMenu,
 454       M_DrawSound,
 455       80,64,
 456       0
 457    };
 458
 459 //
 460 // LOAD GAME MENU
 461 //
 462 enum
 463 {
 464    load1,
 465    load2,
 466    load3,
 467    load4,
 468    load5,
 469    load6,
 470    load_end
 471 };
 472 unsigned load_e;
 473
 474 menuitem_t LoadMenu[]=
 475    {
 476       {1,"", M_LoadSelect,'1'},
 477       {1,"", M_LoadSelect,'2'},
 478       {1,"", M_LoadSelect,'3'},
 479       {1,"", M_LoadSelect,'4'},
 480       {1,"", M_LoadSelect,'5'},
 481       {1,"", M_LoadSelect,'6'}
 482    };
 483
 484 menu_t  LoadDef =
 485    {
 486       load_end,
 487       &MainDef,
 488       LoadMenu,
 489       M_DrawLoad,
 490       80,54,
 491       0
 492    };
 493
 494 //
 495 // SAVE GAME MENU
 496 //
 497 menuitem_t SaveMenu[]=
 498    {
 499       {1,"", M_SaveSelect,'1'},
 500       {1,"", M_SaveSelect,'2'},
 501       {1,"", M_SaveSelect,'3'},
 502       {1,"", M_SaveSelect,'4'},
 503       {1,"", M_SaveSelect,'5'},
 504       {1,"", M_SaveSelect,'6'}
 505    };
 506
 507 menu_t  SaveDef =
 508    {
 509       load_end,
 510       &MainDef,
 511       SaveMenu,
 512       M_DrawSave,
 513       80,54,
 514       0
 515    };
 516
 517
 518 //
 519 // M_ReadSaveStrings
 520 //  read the strings from the savegame files
 521 //
 522 void M_ReadSaveStrings(void)
 523 {
 524    int             handle;
 525    int             count;
 526    int             i;
 527    char    name[256];
 528
 529    for (i = 0;i < load_end;i++)
 530    {
 531       if (M_CheckParm("-cdrom"))
 532          snprintf(name,sizeof(name),"c:\\doomdata\\"SAVEGAMENAME"%d.dsg",i);
 533       else
 534          snprintf(name,sizeof(name),SAVEGAMENAME"%d.dsg",i);
 535
 536       handle = open (name, O_RDONLY | 0);
 537       if (handle == -1)
 538       {
 539          strcpy(&savegamestrings[i][0],EMPTYSTRING);
 540          LoadMenu[i].status = 0;
 541          continue;
 542       }
 543       count = read (handle, &savegamestrings[i], SAVESTRINGSIZE);
 544       close (handle);
 545       LoadMenu[i].status = 1;
 546    }
 547 }
 548
 549 #define LOADGRAPHIC_Y 8
 550 //
 551 // M_LoadGame & Cie.
 552 //
 553 void M_DrawLoad(void)
 554 {
 555    int             i;
 556
 557    V_DrawNamePatch(72 ,LOADGRAPHIC_Y, 0, "M_LOADG", CR_DEFAULT, VPT_STRETCH);
 558    for (i = 0;i < load_end; i++)
 559    {
 560       M_DrawSaveLoadBorder(LoadDef.x,LoadDef.y+LINEHEIGHT*i);
 561       M_WriteText(LoadDef.x,LoadDef.y+LINEHEIGHT*i,savegamestrings[i]);
 562    }
 563 }
 564
 565
 566
 567 //
 568 // Draw border for the savegame description
 569 //
 570 void M_DrawSaveLoadBorder(int x,int y)
 571 {
 572    int             i;
 573
 574    V_DrawNamePatch(x-8, y+7, 0, "M_LSLEFT", CR_DEFAULT, VPT_STRETCH);
 575    for (i = 0;i < 24;i++)
 576    {
 577       V_DrawNamePatch(x, y+7, 0, "M_LSCNTR", CR_DEFAULT, VPT_STRETCH);
 578       x += 8;
 579    }
 580    V_DrawNamePatch(x, y+7, 0, "M_LSRGHT", CR_DEFAULT, VPT_STRETCH);
 581 }
 582
 583
 584
 585 //
 586 // User wants to load this game
 587 //
 588 void M_LoadSelect(int choice)
 589 {
 590    char    name[256];
 591
 592    if (M_CheckParm("-cdrom"))
 593       snprintf(name,sizeof(name),"c:\\doomdata\\"SAVEGAMENAME"%d.dsg",choice);
 594    else
 595       snprintf(name,sizeof(name),SAVEGAMENAME"%d.dsg",choice);
 596    G_LoadGame (choice, false);
 597    M_ClearMenus ();
 598 }
 599
 600 //
 601 // Selected from DOOM menu
 602 //
 603 void M_LoadGame (int choice)
 604 {
 605    (void)choice;
 606    if (netgame)
 607    {
 608       M_StartMessage(LOADNET,NULL,false);
 609       return;
 610    }
 611
 612    M_SetupNextMenu(&LoadDef);
 613    M_ReadSaveStrings();
 614 }
 615
 616
 617 //
 618 //  M_SaveGame & Cie.
 619 //
 620 void M_DrawSave(void)
 621 {
 622    int             i;
 623
 624    V_DrawNamePatch(72, LOADGRAPHIC_Y, 0, "M_SAVEG", CR_DEFAULT, VPT_STRETCH);
 625    for (i = 0;i < load_end; i++)
 626    {
 627       M_DrawSaveLoadBorder(LoadDef.x,LoadDef.y+LINEHEIGHT*i);
 628       M_WriteText(LoadDef.x,LoadDef.y+LINEHEIGHT*i,savegamestrings[i]);
 629    }
 630
 631    if (saveStringEnter)
 632    {
 633       i = M_StringWidth(savegamestrings[saveSlot]);
 634       M_WriteText(LoadDef.x + i,LoadDef.y+LINEHEIGHT*saveSlot,"_");
 635    }
 636 }
 637
 638 //
 639 // M_Responder calls this when user is finished
 640 //
 641 void M_DoSave(int slot)
 642 {
 643    G_SaveGame (slot,savegamestrings[slot]);
 644    M_ClearMenus ();
 645
 646    // PICK QUICKSAVE SLOT YET?
 647    if (quickSaveSlot == -2)
 648       quickSaveSlot = slot;
 649 }
 650
 651 //
 652 // User wants to save. Start string input for M_Responder
 653 //
 654 void M_SaveSelect(int choice)
 655 {
 656    // we are going to be intercepting all chars
 657    saveStringEnter = 1;
 658
 659    saveSlot = choice;
 660    snprintf(savegamestrings[choice], sizeof(savegamestrings[choice]),
 661       (gamemode==shareware||gamemode==registered||gamemode==retail) ?
 662       *mapnames[(gameepisode-1)*9+gamemap-1]  : (gamemission==doom2)     ?
 663       *mapnames2[gamemap-1] : (gamemission==pack_plut) ?
 664       *mapnamesp[gamemap-1] : (gamemission==pack_tnt)  ?
 665       *mapnamest[gamemap-1] : "Unknown Location", choice);
 666    if (!strcmp(savegamestrings[choice],s_EMPTYSTRING))
 667       savegamestrings[choice][0] = 0;
 668    saveCharIndex = strlen(savegamestrings[choice]);
 669 }
 670
 671 //
 672 // Selected from DOOM menu
 673 //
 674 void M_SaveGame (int choice)
 675 {
 676    (void)choice;
 677    if (!usergame)
 678    {
 679       M_StartMessage(s_SAVEDEAD,NULL,false);
 680       return;
 681    }
 682
 683    if (gamestate != GS_LEVEL)
 684       return;
 685
 686    M_SetupNextMenu(&SaveDef);
 687    M_ReadSaveStrings();
 688 }
 689
 690
 691
 692 //
 693 //      M_QuickSave
 694 //
 695 char    tempstring[80];
 696
 697 void M_QuickSaveResponse(int ch)
 698 {
 699    if (ch == 'y')
 700    {
 701       M_DoSave(quickSaveSlot);
 702
 703       S_StartSound(NULL,sfx_swtchx);
 704
 705    }
 706 }
 707
 708 void M_QuickSave(void)
 709 {
 710    if (!usergame)
 711    {
 712       S_StartSound(NULL,sfx_oof);
 713       return;
 714    }
 715
 716    if (gamestate != GS_LEVEL)
 717       return;
 718
 719    if (quickSaveSlot < 0)
 720    {
 721       M_StartControlPanel();
 722       M_ReadSaveStrings();
 723       M_SetupNextMenu(&SaveDef);
 724       quickSaveSlot = -2; // means to pick a slot now
 725       return;
 726    }
 727    snprintf(tempstring,sizeof(tempstring),s_QSPROMPT,savegamestrings[quickSaveSlot]);
 728    M_StartMessage(tempstring,M_QuickSaveResponse,true);
 729 }
 730
 731
 732
 733 //
 734 // M_QuickLoad
 735 //
 736 void M_QuickLoadResponse(int ch)
 737 {
 738    if (ch == 'y')
 739    {
 740       M_LoadSelect(quickSaveSlot);
 741       S_StartSound(NULL,sfx_swtchx);
 742    }
 743 }
 744
 745
 746 void M_QuickLoad(void)
 747 {
 748    if (netgame)
 749    {
 750       M_StartMessage(QLOADNET,NULL,false);
 751       return;
 752    }
 753
 754    if (quickSaveSlot < 0)
 755    {
 756       M_StartMessage(QSAVESPOT,NULL,false);
 757       return;
 758    }
 759    snprintf(tempstring, sizeof(tempstring), QLPROMPT,savegamestrings[quickSaveSlot]);
 760    M_StartMessage(tempstring,M_QuickLoadResponse,true);
 761 }
 762
 763
 764
 765
 766 //
 767 // Read This Menus
 768 // Had a "quick hack to fix romero bug"
 769 //
 770 void M_DrawReadThis1(void)
 771 {
 772    inhelpscreens = true;
 773    switch ( gamemode )
 774    {
 775    case commercial:
 776       V_DrawNamePatch(0, 0, 0, "HELP", CR_DEFAULT, VPT_STRETCH);
 777       break;
 778    case shareware:
 779    case registered:
 780    case retail:
 781       V_DrawNamePatch(0, 0, 0, "HELP1", CR_DEFAULT, VPT_STRETCH);
 782       break;
 783    default:
 784       break;
 785    }
 786    return;
 787 }
 788
 789
 790
 791 //
 792 // Read This Menus - optional second page.
 793 //
 794 void M_DrawReadThis2(void)
 795 {
 796    inhelpscreens = true;
 797    switch ( gamemode )
 798    {
 799    case retail:
 800    case commercial:
 801       // This hack keeps us from having to change menus.
 802       V_DrawNamePatch(0, 0, 0, "CREDIT", CR_DEFAULT, VPT_STRETCH);
 803       break;
 804    case shareware:
 805    case registered:
 806       V_DrawNamePatch(0, 0, 0, "HELP2", CR_DEFAULT, VPT_STRETCH);
 807       break;
 808    default:
 809       break;
 810    }
 811    return;
 812 }
 813
 814
 815 //
 816 // Change Sfx & Music volumes
 817 //
 818 void M_DrawSound(void)
 819 {
 820    int sysmax=(rb->sound_max(SOUND_VOLUME)-rb->sound_min(SOUND_VOLUME));
 821    V_DrawNamePatch(60, 38, 0, "M_SVOL", CR_DEFAULT, VPT_STRETCH);
 822
 823    M_DrawThermo(SoundDef.x,SoundDef.y+LINEHEIGHT*(sfx_vol+1),
 824                 16,snd_SfxVolume);
 825
 826    M_DrawThermo(SoundDef.x,SoundDef.y+LINEHEIGHT*(music_vol+1),
 827                 16,snd_MusicVolume);
 828
 829    M_DrawThermo(SoundDef.x,SoundDef.y+LINEHEIGHT*(system_vol+1),
 830                 16,(sysmax+systemvol)/5);
 831 }
 832
 833 void M_Sound(int choice)
 834 {
 835    (void) choice;
 836    M_SetupNextMenu(&SoundDef);
 837 }
 838
 839 void M_SfxVol(int choice)
 840 {
 841    switch(choice)
 842    {
 843    case 0:
 844       if (snd_SfxVolume)
 845          snd_SfxVolume--;
 846       break;
 847    case 1:
 848       if (snd_SfxVolume < 15)
 849          snd_SfxVolume++;
 850       break;
 851    }
 852
 853    S_SetSfxVolume(snd_SfxVolume /* *8 */);
 854 }
 855
 856 void M_MusicVol(int choice)
 857 {
 858    switch(choice)
 859    {
 860    case 0:
 861       if (snd_MusicVolume)
 862          snd_MusicVolume--;
 863       break;
 864    case 1:
 865       if (snd_MusicVolume < 15)
 866          snd_MusicVolume++;
 867       break;
 868    }
 869
 870    S_SetMusicVolume(snd_MusicVolume /* *8 */);
 871 }
 872
 873 void M_SystemVol(int choice)
 874 {
 875    switch(choice)
 876    {
 877    case 0:
 878       if (systemvol-5>rb->sound_min(SOUND_VOLUME))
 879       {
 880          systemvol-=5;
 881          rb->sound_set(SOUND_VOLUME, systemvol);
 882          rb->global_settings->volume = systemvol;
 883       }
 884       break;
 885    case 1:
 886       if (systemvol+5<rb->sound_max(SOUND_VOLUME))
 887       {
 888          systemvol+=5;
 889          rb->sound_set(SOUND_VOLUME, systemvol);
 890          rb->global_settings->volume = systemvol;
 891       }
 892       break;
 893    }
 894 }
 895
 896 //
 897 // M_DrawMainMenu
 898 //
 899 void M_DrawMainMenu(void)
 900 {
 901    V_DrawNamePatch(94, 2, 0, "M_DOOM", CR_DEFAULT, VPT_STRETCH);
 902 }
 903
 904
 905
 906
 907 //
 908 // M_NewGame
 909 //
 910 void M_DrawNewGame(void)
 911 {
 912    // CPhipps - patch drawing updated
 913    V_DrawNamePatch(96, 14, 0, "M_NEWG", CR_DEFAULT, VPT_STRETCH);
 914    V_DrawNamePatch(54, 38, 0, "M_SKILL",CR_DEFAULT, VPT_STRETCH);
 915 }
 916
 917 void M_NewGame(int choice)
 918 {
 919    (void) choice;
 920    if (netgame && !demoplayback)
 921    {
 922       M_StartMessage(s_NEWGAME,NULL,false);
 923       return;
 924    }
 925
 926    if ( gamemode == commercial )
 927       M_SetupNextMenu(&NewDef);
 928    else
 929       M_SetupNextMenu(&EpiDef);
 930 }
 931
 932
 933 //
 934 //      M_Episode
 935 //
 936 int     epi;
 937
 938 void M_DrawEpisode(void)
 939 {
 940    // CPhipps - patch drawing updated
 941    V_DrawNamePatch(54, 38, 0, "M_EPISOD", CR_DEFAULT, VPT_STRETCH);
 942 }
 943
 944 void M_VerifyNightmare(int ch)
 945 {
 946    if (ch != key_menu_enter)
 947       return;
 948
 949    G_DeferedInitNew(nightmare,epi+1,1);
 950    M_ClearMenus ();
 951 }
 952
 953 void M_ChooseSkill(int choice)
 954 {
 955    if (choice == nightmare)
 956    {
 957       M_StartMessage(s_NIGHTMARE,M_VerifyNightmare,true);
 958       return;
 959    }
 960
 961    //jff 3/24/98 remember last skill selected
 962    // killough 10/98 moved to here
 963    defaultskill = choice+1;
 964
 965    G_DeferedInitNew(choice,epi+1,1);
 966    M_ClearMenus ();
 967 }
 968
 969 void M_Episode(int choice)
 970 {
 971    if ( (gamemode == shareware)
 972          && choice)
 973    {
 974       M_StartMessage(s_SWSTRING,NULL,false); // Ty 03/27/98 - externalized
 975       M_SetupNextMenu(&ReadDef1);
 976       return;
 977    }
 978
 979    // Yet another hack...
 980    if ( (gamemode == registered)
 981          && (choice > 2))
 982    {
 983       /* Digita */
 984       // fprintf( stderr,
 985       //     "M_Episode: 4th episode requires UltimateDOOM\n");
 986       choice = 0;
 987    }
 988
 989    epi = choice;
 990    M_SetupNextMenu(&NewDef);
 991 }
 992
 993
 994
 995 //
 996 // M_Options
 997 //
 998 char    detailNames[2][9] = {"M_GDHIGH","M_GDLOW"};
 999 char msgNames[2][9]  = {"M_MSGOFF","M_MSGON"};
1000
1001
1002 void M_DrawOptions(void)
1003 {
1004    // CPhipps - patch drawing updated
1005    V_DrawNamePatch(108, 15, 0, "M_OPTTTL", CR_DEFAULT, VPT_STRETCH);
1006
1007    V_DrawNamePatch(OptionsDef.x + 120, OptionsDef.y+LINEHEIGHT*messages, 0,
1008                    msgNames[showMessages], CR_DEFAULT, VPT_STRETCH);
1009
1010    M_DrawThermo(OptionsDef.x,OptionsDef.y+LINEHEIGHT*(gamasens+1),
1011                 4,usegamma);
1012
1013    M_DrawThermo(OptionsDef.x,OptionsDef.y+LINEHEIGHT*(scrnsize+1),
1014                 9,screenSize);
1015 }
1016
1017 void M_Options(int choice)
1018 {
1019    (void)choice;
1020    M_SetupNextMenu(&OptionsDef);
1021 }
1022
1023
1024
1025 //
1026 //      Toggle messages on/off
1027 //
1028 void M_ChangeMessages(int choice)
1029 {
1030    // warning: unused parameter `int choice'
1031    choice = 0;
1032    showMessages = 1 - showMessages;
1033
1034    if (!showMessages)
1035       players[consoleplayer].message = s_MSGOFF;
1036    else
1037       players[consoleplayer].message = s_MSGON ;
1038
1039    message_dontfuckwithme = true;
1040 }
1041
1042
1043 //
1044 // M_EndGame
1045 //
1046 void M_EndGameResponse(int ch)
1047 {
1048    if (ch != key_menu_enter)
1049       return;
1050
1051    // killough 5/26/98: make endgame quit if recording or playing back demo
1052    if (demorecording || singledemo)
1053       G_CheckDemoStatus();
1054
1055    currentMenu->lastOn = itemOn;
1056    M_ClearMenus ();
1057    D_StartTitle ();
1058 }
1059
1060 void M_EndGame(int choice)
1061 {
1062    choice = 0;
1063    if (!usergame)
1064    {
1065       S_StartSound(NULL,sfx_oof);
1066       return;
1067    }
1068
1069    if (netgame)
1070    {
1071       M_StartMessage(s_NETEND,NULL,false);
1072       return;
1073    }
1074
1075    M_StartMessage(s_ENDGAME,M_EndGameResponse,true);
1076 }
1077
1078
1079
1080
1081 //
1082 // M_ReadThis
1083 //
1084 void M_ReadThis(int choice)
1085 {
1086    choice = 0;
1087    M_SetupNextMenu(&ReadDef1);
1088 }
1089
1090 void M_ReadThis2(int choice)
1091 {
1092    choice = 0;
1093    M_SetupNextMenu(&ReadDef2);
1094 }
1095
1096 void M_FinishReadThis(int choice)
1097 {
1098    choice = 0;
1099    M_SetupNextMenu(&MainDef);
1100 }
1101
1102
1103
1104
1105 //
1106 // M_QuitDOOM
1107 //
1108 int     quitsounds[8] =
1109    {
1110       sfx_pldeth,
1111       sfx_dmpain,
1112       sfx_popain,
1113       sfx_slop,
1114       sfx_telept,
1115       sfx_posit1,
1116       sfx_posit3,
1117       sfx_sgtatk
1118    };
1119
1120 int     quitsounds2[8] =
1121    {
1122       sfx_vilact,
1123       sfx_getpow,
1124       sfx_boscub,
1125       sfx_slop,
1126       sfx_skeswg,
1127       sfx_kntdth,
1128       sfx_bspact,
1129       sfx_sgtatk
1130    };
1131
1132
1133
1134 void M_QuitResponse(int ch)
1135 {
1136    if (ch != key_menu_enter)
1137       return;
1138    if (!netgame)
1139    {
1140       if (gamemode == commercial)
1141          S_StartSound(NULL,quitsounds2[(gametic>>2)&7]);
1142       else
1143          S_StartSound(NULL,quitsounds[(gametic>>2)&7]);
1144       I_WaitVBL(105);
1145    }
1146    I_Quit ();
1147 }
1148
1149
1150
1151
1152 void M_QuitDOOM(int choice)
1153 {
1154    (void)choice;
1155    // We pick index 0 which is language sensitive,
1156    //  or one at random, between 1 and maximum number.
1157    if (language != english )
1158       snprintf(endstring,sizeof(endstring),"%s\n\n%s",s_DOSY, endmsg[0] );
1159    else
1160       snprintf(endstring,sizeof(endstring),"%s\n\n%s", endmsg[gametic%(NUM_QUITMESSAGES-1)+1], s_DOSY);
1161
1162    M_StartMessage(endstring,M_QuitResponse,true);
1163 }
1164
1165
1166
1167
1168 void M_ChangeGamma(int choice)
1169 {
1170    switch(choice)
1171    {
1172    case 0:
1173       if (usegamma)
1174          usegamma--;
1175       break;
1176    case 1:
1177       if (usegamma < 4)
1178          usegamma++;
1179       break;
1180    }
1181    V_SetPalette (0);
1182 }
1183
1184 void M_SizeDisplay(int choice)
1185 {
1186    switch(choice)
1187    {
1188    case 0:
1189       if (screenSize > 0)
1190       {
1191          screenblocks--;
1192          screenSize--;
1193       }
1194       break;
1195    case 1:
1196       if (screenSize < 8)
1197       {
1198          screenblocks++;
1199          screenSize++;
1200       }
1201       break;
1202    }
1203
1204
1205    R_SetViewSize (screenblocks);
1206 }
1207
1208
1209
1210
1211 //
1212 //      Menu Functions
1213 //
1214 void
1215 M_DrawThermo
1216 ( int x,
1217   int y,
1218   int thermWidth,
1219   int thermDot )
1220 {
1221    int  xx;
1222    int  i;
1223
1224    xx = x;
1225    V_DrawNamePatch(xx, y, 0, "M_THERML", CR_DEFAULT, VPT_STRETCH);
1226    xx += 8;
1227    for (i=0;i<thermWidth;i++)
1228    {
1229       V_DrawNamePatch(xx, y, 0, "M_THERMM", CR_DEFAULT, VPT_STRETCH);
1230       xx += 8;
1231    }
1232    V_DrawNamePatch(xx, y, 0, "M_THERMR", CR_DEFAULT, VPT_STRETCH);
1233    V_DrawNamePatch((x+8)+thermDot*8,y,0,"M_THERMO",CR_DEFAULT,VPT_STRETCH);
1234 }
1235
1236
1237
1238 void
1239 M_DrawEmptyCell
1240 ( menu_t* menu,
1241   int  item )
1242 {
1243    // CPhipps - patch drawing updated
1244    V_DrawNamePatch(menu->x - 10, menu->y+item*LINEHEIGHT - 1, 0,
1245                    "M_CELL1", CR_DEFAULT, VPT_STRETCH);
1246 }
1247
1248 void
1249 M_DrawSelCell
1250 ( menu_t* menu,
1251   int  item )
1252 {
1253    // CPhipps - patch drawing updated
1254    V_DrawNamePatch(menu->x - 10, menu->y+item*LINEHEIGHT - 1, 0,
1255                    "M_CELL2", CR_DEFAULT, VPT_STRETCH);
1256 }
1257
1258
1259 void
1260 M_StartMessage
1261 ( const char*  string,
1262   void*  routine,
1263   boolean input )
1264 {
1265    messageLastMenuActive = menuactive;
1266    messageToPrint = 1;
1267    messageString = string;
1268    messageRoutine = routine;
1269    messageNeedsInput = input;
1270    menuactive = true;
1271    return;
1272 }
1273
1274
1275
1276 void M_StopMessage(void)
1277 {
1278    menuactive = messageLastMenuActive;
1279    messageToPrint = 0;
1280 }
1281
1282
1283
1284 //
1285 // Find string width from hu_font chars
1286 //
1287 int M_StringWidth(const char* string)
1288 {
1289    int i, c, w = 0;
1290    for (i = 0;(size_t)i < strlen(string);i++)
1291       w += (c = toupper(string[i]) - HU_FONTSTART) < 0 || c >= HU_FONTSIZE ?
1292            4 : SHORT(hu_font[c].width);
1293    return w;
1294 }
1295
1296 //
1297 //    Find string height from hu_font chars
1298 //
1299
1300 int M_StringHeight(const char* string)
1301 {
1302    int i, h, height = h = SHORT(hu_font[0].height);
1303    for (i = 0;string[i];i++)            // killough 1/31/98
1304       if (string[i] == '\n')
1305          h += height;
1306    return h;
1307 }
1308
1309
1310 //
1311 //      Write a string using the hu_font
1312 //
1313 void
1314 M_WriteText
1315 ( int  x,
1316   int  y,
1317   char*  string)
1318 {
1319    int  w;
1320    char* ch;
1321    int  c;
1322    int  cx;
1323    int  cy;
1324
1325
1326    ch = string;
1327    cx = x;
1328    cy = y;
1329
1330    while(1)
1331    {
1332       c = *ch++;
1333       if (!c)
1334          break;
1335       if (c == '\n')
1336       {
1337          cx = x;
1338          cy += 12;
1339          continue;
1340       }
1341
1342       c = toupper(c) - HU_FONTSTART;
1343       if (c < 0 || c>= HU_FONTSIZE)
1344       {
1345          cx += 4;
1346          continue;
1347       }
1348
1349       w = SHORT (hu_font[c].width);
1350       if (cx+w > 320)
1351          break;
1352       // proff/nicolas 09/20/98 -- changed for hi-res
1353       // CPhipps - patch drawing updated
1354       V_DrawNumPatch(cx, cy, 0, hu_font[c].lumpnum, CR_DEFAULT, VPT_STRETCH);
1355       cx+=w;
1356    }
1357 }
1358
1359
1360
1361 //
1362 // CONTROL PANEL
1363 //
1364
1365 //
1366 // M_Responder
1367 //
1368 boolean M_Responder (event_t* ev)
1369 {
1370    int             ch;
1371    int             i;
1372 //   static  int     joywait = 0;
1373 //   static  int     mousewait = 0;
1374 //   static  int     mousey = 0;
1375 //   static  int     lasty = 0;
1376 //   static  int     mousex = 0;
1377 //   static  int     lastx = 0;
1378
1379    ch = -1;
1380
1381   // Process joystick input
1382
1383 /*   if (ev->type == ev_joystick && joywait < I_GetTime())
1384    {
1385       if (ev->data3 == -1)
1386       {
1387          ch = KEY_UPARROW;
1388          joywait = I_GetTime() + 5;
1389       }
1390       else if (ev->data3 == 1)
1391       {
1392          ch = KEY_DOWNARROW;
1393          joywait = I_GetTime() + 5;
1394       }
1395
1396       if (ev->data2 == -1)
1397       {
1398          ch = KEY_LEFTARROW;
1399          joywait = I_GetTime() + 2;
1400       }
1401       else if (ev->data2 == 1)
1402       {
1403          ch = KEY_RIGHTARROW;
1404          joywait = I_GetTime() + 2;
1405       }
1406
1407       if (ev->data1&1)
1408       {
1409          ch = key_menu_enter;
1410          joywait = I_GetTime() + 5;
1411       }
1412       if (ev->data1&2)
1413       {
1414          ch = KEY_BACKSPACE;
1415          joywait = I_GetTime() + 5;
1416       }
1417    }
1418    else
1419    {
1420       // Process mouse input
1421       if (ev->type == ev_mouse && mousewait < I_GetTime())
1422       {
1423          mousey += ev->data3;
1424          if (mousey < lasty-30)
1425          {
1426             ch = KEY_DOWNARROW;
1427             mousewait = I_GetTime() + 5;
1428             mousey = lasty -= 30;
1429          }
1430          else if (mousey > lasty+30)
1431          {
1432             ch = KEY_UPARROW;
1433             mousewait = I_GetTime() + 5;
1434             mousey = lasty += 30;
1435          }
1436
1437          mousex += ev->data2;
1438          if (mousex < lastx-30)
1439          {
1440             ch = KEY_LEFTARROW;
1441             mousewait = I_GetTime() + 5;
1442             mousex = lastx -= 30;
1443          }
1444          else if (mousex > lastx+30)
1445          {
1446             ch = KEY_RIGHTARROW;
1447             mousewait = I_GetTime() + 5;
1448             mousex = lastx += 30;
1449          }
1450
1451          if (ev->data1&1)
1452          {
1453             ch = key_menu_enter;
1454             mousewait = I_GetTime() + 15;
1455          }
1456
1457          if (ev->data1&2)
1458          {
1459             ch = KEY_BACKSPACE;
1460             mousewait = I_GetTime() + 15;
1461          }
1462       }
1463       else */if (ev->type == ev_keydown)
1464       {
1465          ch = ev->data1;
1466       }
1467 //   }
1468
1469    if (ch == -1)
1470       return false;
1471
1472
1473    // Save Game string input
1474    if (saveStringEnter)
1475    {
1476       switch(ch)
1477       {
1478       case KEY_BACKSPACE:
1479          if (saveCharIndex > 0)
1480          {
1481             saveCharIndex--;
1482             savegamestrings[saveSlot][saveCharIndex] = 0;
1483          }
1484          break;
1485
1486       case KEY_ESCAPE:
1487          saveStringEnter = 0;
1488          strcpy(&savegamestrings[saveSlot][0],saveOldString);
1489          break;
1490
1491       case KEY_ENTER:
1492          saveStringEnter = 0;
1493          if (savegamestrings[saveSlot][0])
1494             M_DoSave(saveSlot);
1495          break;
1496
1497       default:
1498          ch = toupper(ch);
1499          if (ch != 32)
1500             if (ch-HU_FONTSTART < 0 || ch-HU_FONTSTART >= HU_FONTSIZE)
1501                break;
1502          if (ch >= 32 && ch <= 127 &&
1503                saveCharIndex < SAVESTRINGSIZE-1 &&
1504                M_StringWidth(savegamestrings[saveSlot]) <
1505                (SAVESTRINGSIZE-2)*8)
1506          {
1507             savegamestrings[saveSlot][saveCharIndex++] = ch;
1508             savegamestrings[saveSlot][saveCharIndex] = 0;
1509          }
1510          break;
1511       }
1512       return true;
1513    }
1514
1515    // Take care of any messages that need input
1516    if (messageToPrint)
1517    {
1518       if (messageNeedsInput == true &&
1519             !(ch == ' ' || ch == 'n' || ch == key_menu_enter || ch == key_menu_escape))
1520          return false;
1521
1522       menuactive = messageLastMenuActive;
1523       messageToPrint = 0;
1524       if (messageRoutine)
1525          messageRoutine(ch);
1526
1527       menuactive = false;
1528       S_StartSound(NULL,sfx_swtchx);
1529       return true;
1530    }
1531 /*
1532    if (ch == KEY_F1) // devparm &&
1533    {
1534       G_ScreenShot ();
1535       return true;
1536    }
1537 */
1538    // F-Keys
1539    if (!menuactive)
1540    {
1541       if (ch == key_autorun)      // Autorun                          //  V
1542       {
1543          autorun = !autorun;
1544          return true;
1545       }
1546
1547       switch(ch)
1548       {
1549 /*
1550       case KEY_F1:            // Help key
1551          M_StartControlPanel ();
1552
1553          if ( gamemode == retail )
1554             currentMenu = &ReadDef2;
1555          else
1556             currentMenu = &ReadDef1;
1557
1558          itemOn = 0;
1559          S_StartSound(NULL,sfx_swtchn);
1560          return true;
1561
1562       case KEY_F6:            // Quicksave
1563          S_StartSound(NULL,sfx_swtchn);
1564          M_QuickSave();
1565          return true;
1566
1567       case KEY_F9:            // Quickload
1568          S_StartSound(NULL,sfx_swtchn);
1569          M_QuickLoad();
1570          return true;
1571 */
1572       }
1573    }
1574
1575
1576    // Pop-up menu?
1577    if (!menuactive)
1578    {
1579       if (ch == key_menu_escape)
1580       {
1581          M_StartControlPanel ();
1582          S_StartSound(NULL,sfx_swtchn);
1583          return true;
1584       }
1585       return false;
1586    }
1587
1588
1589    // Keys usable within menu
1590    switch (ch)
1591    {
1592    case KEY_DOWNARROW:
1593       do
1594       {
1595          if (itemOn+1 > currentMenu->numitems-1)
1596             itemOn = 0;
1597          else
1598             itemOn++;
1599          S_StartSound(NULL,sfx_pstop);
1600       }
1601       while(currentMenu->menuitems[itemOn].status==-1);
1602       return true;
1603
1604    case KEY_UPARROW:
1605       do
1606       {
1607          if (!itemOn)
1608             itemOn = currentMenu->numitems-1;
1609          else
1610             itemOn--;
1611          S_StartSound(NULL,sfx_pstop);
1612       }
1613       while(currentMenu->menuitems[itemOn].status==-1);
1614       return true;
1615
1616    case KEY_LEFTARROW:
1617       if (currentMenu->menuitems[itemOn].routine &&
1618             currentMenu->menuitems[itemOn].status == 2)
1619       {
1620          S_StartSound(NULL,sfx_stnmov);
1621          currentMenu->menuitems[itemOn].routine(0);
1622       }
1623       return true;
1624
1625    case KEY_RIGHTARROW:
1626       if (currentMenu->menuitems[itemOn].routine &&
1627             currentMenu->menuitems[itemOn].status == 2)
1628       {
1629          S_StartSound(NULL,sfx_stnmov);
1630          currentMenu->menuitems[itemOn].routine(1);
1631       }
1632       return true;
1633
1634    case KEY_ENTER:
1635       if (currentMenu->menuitems[itemOn].routine &&
1636             currentMenu->menuitems[itemOn].status)
1637       {
1638          currentMenu->lastOn = itemOn;
1639          if (currentMenu->menuitems[itemOn].status == 2)
1640          {
1641             currentMenu->menuitems[itemOn].routine(1);      // right arrow
1642             S_StartSound(NULL,sfx_stnmov);
1643          }
1644          else
1645          {
1646             currentMenu->menuitems[itemOn].routine(itemOn);
1647             S_StartSound(NULL,sfx_pistol);
1648          }
1649       }
1650       return true;
1651
1652    case KEY_ESCAPE:
1653       currentMenu->lastOn = itemOn;
1654       M_ClearMenus ();
1655       S_StartSound(NULL,sfx_swtchx);
1656       return true;
1657
1658    case KEY_BACKSPACE:
1659       currentMenu->lastOn = itemOn;
1660       if (currentMenu->prevMenu)
1661       {
1662          currentMenu = currentMenu->prevMenu;
1663          itemOn = currentMenu->lastOn;
1664          S_StartSound(NULL,sfx_swtchn);
1665       }
1666       return true;
1667
1668    default:
1669       for (i = itemOn+1;i < currentMenu->numitems;i++)
1670          if (currentMenu->menuitems[i].alphaKey == ch)
1671          {
1672             itemOn = i;
1673             S_StartSound(NULL,sfx_pstop);
1674             return true;
1675          }
1676       for (i = 0;i <= itemOn;i++)
1677          if (currentMenu->menuitems[i].alphaKey == ch)
1678          {
1679             itemOn = i;
1680             S_StartSound(NULL,sfx_pstop);
1681             return true;
1682          }
1683       break;
1684
1685    }
1686
1687    return false;
1688 }
1689
1690
1691
1692 //
1693 // M_StartControlPanel
1694 //
1695 void M_StartControlPanel (void)
1696 {
1697    // intro might call this repeatedly
1698    if (menuactive)
1699       return;
1700
1701    menuactive = 1;
1702    currentMenu = &MainDef;         // JDC
1703    itemOn = currentMenu->lastOn;   // JDC
1704 }
1705
1706
1707 //
1708 // M_Drawer
1709 // Called after the view has been rendered,
1710 // but before it has been blitted.
1711 //
1712 void M_Drawer (void)
1713 {
1714    static short x;
1715    static short y;
1716    unsigned short  i;
1717    short  max;
1718    char  string[40];
1719    int   start;
1720
1721    inhelpscreens = false;
1722
1723
1724    // Horiz. & Vertically center string and print it.
1725    if (messageToPrint)
1726    {
1727       start = 0;
1728       y = 100 - M_StringHeight(messageString)/2;
1729       while(*(messageString+start))
1730       {
1731          for (i = 0;i < strlen(messageString+start);i++)
1732             if (*(messageString+start+i) == '\n')
1733             {
1734                memset(string,0,40);
1735                strncpy(string,messageString+start,i);
1736                start += i+1;
1737                break;
1738             }
1739          if (i == strlen(messageString+start))
1740          {
1741             strcpy(string,messageString+start);
1742             start += i;
1743          }
1744
1745          x = 160 - M_StringWidth(string)/2;
1746          M_WriteText(x,y,string);
1747          y += SHORT(hu_font[0].height);
1748       }
1749       return;
1750    }
1751
1752    if (!menuactive)
1753       return;
1754
1755    if (currentMenu->routine)
1756       currentMenu->routine();         // call Draw routine
1757
1758    // DRAW MENU
1759    x = currentMenu->x;
1760    y = currentMenu->y;
1761    max = currentMenu->numitems;
1762
1763    for (i=0;i<max;i++)
1764    {
1765       if (currentMenu->menuitems[i].name[0])
1766          V_DrawNamePatch(x,y,0,currentMenu->menuitems[i].name,
1767                          CR_DEFAULT, VPT_STRETCH);
1768       y += LINEHEIGHT;
1769    }
1770
1771    // DRAW SKULL
1772    // CPhipps - patch drawing updated
1773    V_DrawNamePatch(x + SKULLXOFF, currentMenu->y - 5 + itemOn*LINEHEIGHT,0,
1774                    skullName[whichSkull], CR_DEFAULT, VPT_STRETCH);
1775
1776 }
1777
1778
1779 //
1780 // M_ClearMenus
1781 //
1782 void M_ClearMenus (void)
1783 {
1784    menuactive = 0;
1785    // if (!netgame && usergame && paused)
1786    //       sendpause = true;
1787 }
1788
1789
1790
1791
1792 //
1793 // M_SetupNextMenu
1794 //
1795 void M_SetupNextMenu(menu_t *menudef)
1796 {
1797    currentMenu = menudef;
1798    itemOn = currentMenu->lastOn;
1799 }
1800
1801
1802 //
1803 // M_Ticker
1804 //
1805 void M_Ticker (void)
1806 {
1807    if (--skullAnimCounter <= 0)
1808    {
1809       whichSkull ^= 1;
1810       skullAnimCounter = 8;
1811    }
1812 }
1813
1814
1815 //
1816 // M_Init
1817 //
1818 void M_Init (void)
1819 {
1820    currentMenu = &MainDef;
1821    menuactive = 0;
1822    itemOn = currentMenu->lastOn;
1823    whichSkull = 0;
1824    skullAnimCounter = 10;
1825    screenSize = screenblocks - 3;
1826    messageToPrint = 0;
1827    messageString = NULL;
1828    messageLastMenuActive = menuactive;
1829    quickSaveSlot = -1;
1830
1831    // Here we could catch other version dependencies,
1832    //  like HELP1/2, and four episodes.
1833
1834
1835    switch ( gamemode )
1836    {
1837    case commercial:
1838       // This is used because DOOM 2 had only one HELP
1839       //  page. I use CREDIT as second page now, but
1840       //  kept this hack for educational purposes.
1841       MainMenu[readthis] = MainMenu[quitdoom];
1842       MainDef.numitems--;
1843       MainDef.y += 8;
1844       NewDef.prevMenu = &MainDef;
1845       ReadDef1.routine = M_DrawReadThis1;
1846       ReadDef1.x = 330;
1847       ReadDef1.y = 165;
1848       ReadMenu1[0].routine = M_FinishReadThis;
1849       break;
1850    case shareware:
1851       // Episode 2 and 3 are handled,
1852       //  branching to an ad screen.
1853    case registered:
1854       // We need to remove the fourth episode.
1855       EpiDef.numitems--;
1856       break;
1857    case retail:
1858       // We are fine.
1859    default:
1860       break;
1861    }
1862
1863 }
1864