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