开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
m_menu.c
资源名称：21.rar　[点击查看]
上传用户：xuyinpeng
上传日期：2021-05-12
资源大小：455k
文件大小：37k
源码类别：

射击游戏

开发平台：

Visual C++

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 source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. // DOOM selection menu, options, episode etc.
  21. // Sliders and icons. Kinda widget stuff.
  22. //
  23. //-----------------------------------------------------------------------------
  25. static const char
  26. rcsid[] = "$Id: m_menu.c,v 1.7 1997/02/03 22:45:10 b1 Exp $";
  28. //#include <unistd.h>
  29. #include <sys/types.h>
  30. #include <sys/stat.h>
  31. #include <fcntl.h>
  32. #include <stdlib.h>
  33. #include <ctype.h>
  34. #include <io.h>
  37. #include "doomdef.h"
  38. #include "dstrings.h"
  40. #include "d_main.h"
  42. #include "i_system.h"
  43. #include "i_video.h"
  44. #include "z_zone.h"
  45. #include "v_video.h"
  46. #include "w_wad.h"
  48. #include "r_local.h"
  51. #include "hu_stuff.h"
  53. #include "g_game.h"
  55. #include "m_argv.h"
  56. #include "m_swap.h"
  58. #include "s_sound.h"
  60. #include "doomstat.h"
  62. // Data.
  63. #include "sounds.h"
  65. #include "m_menu.h"
  67. #include "d_console.h"
  69. void WriteDebug(char *);
  71. extern patch_t* hu_font[HU_FONTSIZE];
  72. extern boolean message_dontfuckwithme;
  74. extern boolean chat_on; // in heads-up code
  76. extern int          always_run;
  78. //
  79. // defaulted values
  80. //
  81. int mouseSensitivity;       // has default
  83. // Show messages has default, 0 = off, 1 = on
  84. int showMessages;
  87. // Blocky mode, has default, 0 = high, 1 = normal
  88. int detailLevel = 0;
  89. int screenblocks = 9; // has default
  91. // temp for screenblocks (0-9)
  92. int screenSize;
  94. // -1 = no quicksave slot picked!
  95. int quickSaveSlot;          
  97.  // 1 = message to be printed
  98. int messageToPrint;
  99. // ...and here is the message string!
  100. char* messageString;
  102. // message x & y
  103. int messx;
  104. int messy;
  105. int messageLastMenuActive;
  107. // timed message = no input from user
  108. boolean messageNeedsInput;     
  110. void    (*messageRoutine)(int response);
  112. #define SAVESTRINGSIZE  24
  114. char gammamsg[5][26] =
  115. {
  116.     GAMMALVL0,
  117.     GAMMALVL1,
  118.     GAMMALVL2,
  119.     GAMMALVL3,
  120.     GAMMALVL4
  121. };
  123. // we are going to be entering a savegame string
  124. int saveStringEnter;              
  125. int              saveSlot; // which slot to save in
  126. int saveCharIndex; // which char we're editing
  127. // old save description before edit
  128. char saveOldString[SAVESTRINGSIZE];  
  130. boolean inhelpscreens;
  131. boolean menuactive;
  133. #define SKULLXOFF -32
  134. #define LINEHEIGHT 16
  136. extern boolean sendpause;
  137. char savegamestrings[10][SAVESTRINGSIZE];
  139. char endstring[160];
  142. //
  143. // MENU TYPEDEFS
  144. //
  145. typedef struct
  146. {
  147.     // 0 = no cursor here, 1 = ok, 2 = arrows ok
  148.     short status;
  149.     
  150.     char name[10];
  151.     
  152.     // choice = menu item #.
  153.     // if status = 2,
  154.     //   choice=0:leftarrow,1:rightarrow
  155.     void (*routine)(int choice);
  156.     
  157.     // hotkey in menu
  158.     char alphaKey;
  159. } menuitem_t;
  163. typedef struct menu_s
  164. {
  165.     short numitems; // # of menu items
  166.     struct menu_s* prevMenu; // previous menu
  167.     menuitem_t* menuitems; // menu items
  168.     void (*routine)(); // draw routine
  169.     short x;
  170.     short y; // x,y of menu
  171.     short lastOn; // last item user was on in menu
  172. } menu_t;
  174. short itemOn; // menu item skull is on
  175. short skullAnimCounter; // skull animation counter
  176. short whichSkull; // which skull to draw
  178. // graphic name of skulls
  179. // warning: initializer-string for array of chars is too long
  180. char    skullName[2][/*8*/9] = {"M_SKULL1","M_SKULL2"};
  182. // current menudef
  183. menu_t* currentMenu;                          
  185. //
  186. // PROTOTYPES
  187. //
  188. void M_NewGame(int choice);
  189. void M_Episode(int choice);
  190. void M_ChooseSkill(int choice);
  191. void M_LoadGame(int choice);
  192. void M_SaveGame(int choice);
  193. void M_Options(int choice);
  194. void M_EndGame(int choice);
  195. void M_ReadThis(int choice);
  196. void M_ReadThis2(int choice);
  197. void M_QuitDOOM(int choice);
  199. void M_ChangeMessages(int choice);
  200. void M_ChangeSensitivity(int choice);
  201. void M_SfxVol(int choice);
  202. void M_MusicVol(int choice);
  203. void M_ChangeDetail(int choice);
  204. void M_SizeDisplay(int choice);
  205. void M_StartGame(int choice);
  206. void M_Sound(int choice);
  208. void M_FinishReadThis(int choice);
  209. void M_LoadSelect(int choice);
  210. void M_SaveSelect(int choice);
  211. void M_ReadSaveStrings(void);
  212. void M_QuickSave(void);
  213. void M_QuickLoad(void);
  215. void M_DrawMainMenu(void);
  216. void M_DrawReadThis1(void);
  217. void M_DrawReadThis2(void);
  218. void M_DrawNewGame(void);
  219. void M_DrawEpisode(void);
  220. void M_DrawOptions(void);
  221. void M_DrawSound(void);
  222. void M_DrawLoad(void);
  223. void M_DrawSave(void);
  225. void M_DrawSaveLoadBorder(int x,int y);
  226. void M_SetupNextMenu(menu_t *menudef);
  227. void M_DrawThermo(int x,int y,int thermWidth,int thermDot);
  228. void M_DrawEmptyCell(menu_t *menu,int item);
  229. void M_DrawSelCell(menu_t *menu,int item);
  230. void M_WriteText(int x, int y, char *string);
  231. int  M_StringWidth(char *string);
  232. int  M_StringHeight(char *string);
  233. void M_StartControlPanel(void);
  234. void M_StartMessage(char *string,void *routine,boolean input);
  235. void M_StopMessage(void);
  236. void M_ClearMenus (void);
  239. extern unsigned char scan2char[256];
  241. //
  242. // DOOM MENU
  243. //
  244. enum
  245. {
  246.     newgame = 0,
  247.     options,
  248.     loadgame,
  249.     savegame,
  250.     readthis,
  251.     quitdoom,
  252.     main_end
  253. } main_e;
  255. menuitem_t MainMenu[]=
  256. {
  257.     {1,"M_NGAME",M_NewGame,'n'},
  258.     {1,"M_OPTION",M_Options,'o'},
  259.     {1,"M_LOADG",M_LoadGame,'l'},
  260.     {1,"M_SAVEG",M_SaveGame,'s'},
  261.     // Another hickup with Special edition.
  262.     {1,"M_RDTHIS",M_ReadThis,'r'},
  263.     {1,"M_QUITG",M_QuitDOOM,'q'}
  264. };
  266. menu_t  MainDef =
  267. {
  268.     main_end,
  269.     NULL,
  270.     MainMenu,
  271.     M_DrawMainMenu,
  272.     97,64,
  273.     0
  274. };
  277. //
  278. // EPISODE SELECT
  279. //
  280. enum
  281. {
  282.     ep1,
  283.     ep2,
  284.     ep3,
  285.     ep4,
  286.     ep_end
  287. } episodes_e;
  289. menuitem_t EpisodeMenu[]=
  290. {
  291.     {1,"M_EPI1", M_Episode,'k'},
  292.     {1,"M_EPI2", M_Episode,'t'},
  293.     {1,"M_EPI3", M_Episode,'i'},
  294.     {1,"M_EPI4", M_Episode,'t'}
  295. };
  297. menu_t  EpiDef =
  298. {
  299.     ep_end, // # of menu items
  300.     &MainDef, // previous menu
  301.     EpisodeMenu, // menuitem_t ->
  302.     M_DrawEpisode, // drawing routine ->
  303.     48,63,              // x,y
  304.     ep1 // lastOn
  305. };
  307. //
  308. // NEW GAME
  309. //
  310. enum
  311. {
  312.     killthings,
  313.     toorough,
  314.     hurtme,
  315.     violence,
  316.     nightmare,
  317.     newg_end
  318. } newgame_e;
  320. menuitem_t NewGameMenu[]=
  321. {
  322.     {1,"M_JKILL", M_ChooseSkill, 'i'},
  323.     {1,"M_ROUGH", M_ChooseSkill, 'h'},
  324.     {1,"M_HURT", M_ChooseSkill, 'h'},
  325.     {1,"M_ULTRA", M_ChooseSkill, 'u'},
  326.     {1,"M_NMARE", M_ChooseSkill, 'n'}
  327. };
  329. menu_t  NewDef =
  330. {
  331.     newg_end, // # of menu items
  332.     &EpiDef, // previous menu
  333.     NewGameMenu, // menuitem_t ->
  334.     M_DrawNewGame, // drawing routine ->
  335.     48,63,              // x,y
  336.     hurtme // lastOn
  337. };
  341. //
  342. // OPTIONS MENU
  343. //
  344. enum
  345. {
  346.     endgame,
  347.     messages,
  348.     detail,
  349.     scrnsize,
  350.     option_empty1,
  351.     mousesens,
  352.     option_empty2,
  353.     soundvol,
  354.     opt_end
  355. } options_e;
  357. menuitem_t OptionsMenu[]=
  358. {
  359.     {1,"M_ENDGAM", M_EndGame,'e'},
  360.     {1,"M_MESSG", M_ChangeMessages,'m'},
  361.     {1,"M_DETAIL", M_ChangeDetail,'g'},
  362.     {2,"M_SCRNSZ", M_SizeDisplay,'s'},
  363.     {-1,"",0},
  364.     {2,"M_MSENS", M_ChangeSensitivity,'m'},
  365.     {-1,"",0},
  366.     {1,"M_SVOL", M_Sound,'s'}
  367. };
  369. menu_t  OptionsDef =
  370. {
  371.     opt_end,
  372.     &MainDef,
  373.     OptionsMenu,
  374.     M_DrawOptions,
  375.     60,37,
  376.     0
  377. };
  379. //
  380. // Read This! MENU 1 & 2
  381. //
  382. enum
  383. {
  384.     rdthsempty1,
  385.     read1_end
  386. } read_e;
  388. menuitem_t ReadMenu1[] =
  389. {
  390.     {1,"",M_ReadThis2,0}
  391. };
  393. menu_t  ReadDef1 =
  394. {
  395.     read1_end,
  396.     &MainDef,
  397.     ReadMenu1,
  398.     M_DrawReadThis1,
  399.     280,185,
  400.     0
  401. };
  403. enum
  404. {
  405.     rdthsempty2,
  406.     read2_end
  407. } read_e2;
  409. menuitem_t ReadMenu2[]=
  410. {
  411.     {1,"",M_FinishReadThis,0}
  412. };
  414. menu_t  ReadDef2 =
  415. {
  416.     read2_end,
  417.     &ReadDef1,
  418.     ReadMenu2,
  419.     M_DrawReadThis2,
  420.     330,175,
  421.     0
  422. };
  424. //
  425. // SOUND VOLUME MENU
  426. //
  427. enum
  428. {
  429.     sfx_vol,
  430.     sfx_empty1,
  431.     music_vol,
  432.     sfx_empty2,
  433.     sound_end
  434. } sound_e;
  436. menuitem_t SoundMenu[]=
  437. {
  438.     {2,"M_SFXVOL",M_SfxVol,'s'},
  439.     {-1,"",0},
  440.     {2,"M_MUSVOL",M_MusicVol,'m'},
  441.     {-1,"",0}
  442. };
  444. menu_t  SoundDef =
  445. {
  446.     sound_end,
  447.     &OptionsDef,
  448.     SoundMenu,
  449.     M_DrawSound,
  450.     80,64,
  451.     0
  452. };
  454. //
  455. // LOAD GAME MENU
  456. //
  457. enum
  458. {
  459.     load1,
  460.     load2,
  461.     load3,
  462.     load4,
  463.     load5,
  464.     load6,
  465.     load_end
  466. } load_e;
  468. menuitem_t LoadGameMenu[]=
  469. {
  470.     {1,"", M_LoadSelect,'1'},
  471.     {1,"", M_LoadSelect,'2'},
  472.     {1,"", M_LoadSelect,'3'},
  473.     {1,"", M_LoadSelect,'4'},
  474.     {1,"", M_LoadSelect,'5'},
  475.     {1,"", M_LoadSelect,'6'}
  476. };
  478. menu_t  LoadDef =
  479. {
  480.     load_end,
  481.     &MainDef,
  482.     LoadGameMenu,
  483.     M_DrawLoad,
  484.     80,54,
  485.     0
  486. };
  488. //
  489. // SAVE GAME MENU
  490. //
  491. menuitem_t SaveMenu[]=
  492. {
  493.     {1,"", M_SaveSelect,'1'},
  494.     {1,"", M_SaveSelect,'2'},
  495.     {1,"", M_SaveSelect,'3'},
  496.     {1,"", M_SaveSelect,'4'},
  497.     {1,"", M_SaveSelect,'5'},
  498.     {1,"", M_SaveSelect,'6'}
  499. };
  501. menu_t  SaveDef =
  502. {
  503.     load_end,
  504.     &MainDef,
  505.     SaveMenu,
  506.     M_DrawSave,
  507.     80,54,
  508.     0
  509. };
  512. //
  513. // M_ReadSaveStrings
  514. //  read the strings from the savegame files
  515. //
  516. void M_ReadSaveStrings(void)
  517. {
  518.     int             handle;
  519.     int             count;
  520.     int             i;
  521.     char    name[256];
  523.     for (i = 0;i < load_end;i++)
  524.     {
  525. if (M_CheckParm("-cdrom"))
  526.     sprintf(name,"c:\doomdata\"SAVEGAMENAME"%d.dsg",i);
  527. else
  528.     sprintf(name,SAVEGAMENAME"%d.dsg",i);
  530. handle = open (name, O_RDONLY | 0, 0666);
  531. if (handle == -1)
  532. {
  533.     strcpy(&savegamestrings[i][0],EMPTYSTRING);
  534.     LoadGameMenu[i].status = 0;
  535.     continue;
  536. }
  537. count = read (handle, &savegamestrings[i], SAVESTRINGSIZE);
  538. close (handle);
  539. LoadGameMenu[i].status = 1;
  540.     }
  541. }
  544. //
  545. // M_LoadGame & Cie.
  546. //
  547. void M_DrawLoad(void)
  548. {
  549.     int             i;
  551.     V_DrawPatchDirect(((SCREENWIDTH-320)/2)+72,((SCREENHEIGHT-200)/2)+28,0,W_CacheLumpName("M_LOADG",PU_CACHE));
  552.     for (i = 0;i < load_end; i++)
  553.     {
  554. M_DrawSaveLoadBorder(((SCREENWIDTH-320)/2)+LoadDef.x,((SCREENHEIGHT-200)/2)+LoadDef.y+LINEHEIGHT*i);
  555. M_WriteText(((SCREENWIDTH-320)/2)+LoadDef.x,((SCREENHEIGHT-200)/2)+LoadDef.y+LINEHEIGHT*i,savegamestrings[i]);
  556.     }
  557. }
  561. //
  562. // Draw border for the savegame description
  563. //
  564. void M_DrawSaveLoadBorder(int x,int y)
  565. {
  566.     int             i;
  568.     V_DrawPatchDirect (x-8,y+7,0,W_CacheLumpName("M_LSLEFT",PU_CACHE));
  570.     for (i = 0;i < 24;i++)
  571.     {
  572. V_DrawPatchDirect (x,y+7,0,W_CacheLumpName("M_LSCNTR",PU_CACHE));
  573. x += 8;
  574.     }
  576.     V_DrawPatchDirect (x,y+7,0,W_CacheLumpName("M_LSRGHT",PU_CACHE));
  577. }
  581. //
  582. // User wants to load this game
  583. //
  584. void M_LoadSelect(int choice)
  585. {
  586.     char    name[256];
  588.     if (M_CheckParm("-cdrom"))
  589. sprintf(name,"c:\doomdata\"SAVEGAMENAME"%d.dsg",choice);
  590.     else
  591. sprintf(name,SAVEGAMENAME"%d.dsg",choice);
  592.     G_LoadGame (name);
  593.     M_ClearMenus ();
  594. }
  596. //
  597. // Selected from DOOM menu
  598. //
  599. void M_LoadGame (int choice)
  600. {
  601.     if (netgame)
  602.     {
  603. M_StartMessage(LOADNET,NULL,false);
  604. return;
  605.     }
  607.     M_SetupNextMenu(&LoadDef);
  608.     M_ReadSaveStrings();
  609. }
  612. //
  613. //  M_SaveGame & Cie.
  614. //
  615. void M_DrawSave(void)
  616. {
  617.     int             i;
  619.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+72,((SCREENHEIGHT-200)/2)+28,0,W_CacheLumpName("M_SAVEG",PU_CACHE));
  620.     for (i = 0;i < load_end; i++)
  621.     {
  622. M_DrawSaveLoadBorder(((SCREENWIDTH-320)/2)+LoadDef.x,((SCREENHEIGHT-200)/2)+LoadDef.y+LINEHEIGHT*i);
  623. M_WriteText(((SCREENWIDTH-320)/2)+LoadDef.x,((SCREENHEIGHT-200)/2)+LoadDef.y+LINEHEIGHT*i,savegamestrings[i]);
  624.     }
  626.     if (saveStringEnter)
  627.     {
  628. i = M_StringWidth(savegamestrings[saveSlot]);
  629. M_WriteText(((SCREENWIDTH-320)/2)+LoadDef.x + i,((SCREENHEIGHT-200)/2)+LoadDef.y+LINEHEIGHT*saveSlot,"_");
  630.     }
  631. }
  633. //
  634. // M_Responder calls this when user is finished
  635. //
  636. void M_DoSave(int slot)
  637. {
  638.     G_SaveGame (slot,savegamestrings[slot]);
  639.     M_ClearMenus ();
  641.     // PICK QUICKSAVE SLOT YET?
  642.     if (quickSaveSlot == -2)
  643. quickSaveSlot = slot;
  644. }
  646. //
  647. // User wants to save. Start string input for M_Responder
  648. //
  649. void M_SaveSelect(int choice)
  650. {
  651.     // we are going to be intercepting all chars
  652.     saveStringEnter = 1;
  653.     
  654.     saveSlot = choice;
  655.     strcpy(saveOldString,savegamestrings[choice]);
  656.     if (!strcmp(savegamestrings[choice],EMPTYSTRING))
  657. savegamestrings[choice][0] = 0;
  658.     saveCharIndex = strlen(savegamestrings[choice]);
  659. }
  661. //
  662. // Selected from DOOM menu
  663. //
  664. void M_SaveGame (int choice)
  665. {
  666.     if (!usergame)
  667.     {
  668. M_StartMessage(SAVEDEAD,NULL,false);
  669. return;
  670.     }
  672.     if (gamestate != GS_LEVEL)
  673. return;
  675.     M_SetupNextMenu(&SaveDef);
  676.     M_ReadSaveStrings();
  677. }
  681. //
  682. //      M_QuickSave
  683. //
  684. char    tempstring[80];
  686. void M_QuickSaveResponse(int ch)
  687. {
  688.     if (ch == KEY_Y)
  689.     {
  690. M_DoSave(quickSaveSlot);
  691. S_StartSound(NULL,sfx_swtchx);
  692.     }
  693. }
  695. void M_QuickSave(void)
  696. {
  697.     if (!usergame)
  698.     {
  699. S_StartSound(NULL,sfx_oof);
  700. return;
  701.     }
  703.     if (gamestate != GS_LEVEL)
  704. return;
  706.     if (quickSaveSlot < 0)
  707.     {
  708. M_StartControlPanel();
  709. M_ReadSaveStrings();
  710. M_SetupNextMenu(&SaveDef);
  711. quickSaveSlot = -2; // means to pick a slot now
  712. return;
  713.     }
  714.     sprintf(tempstring,QSPROMPT,savegamestrings[quickSaveSlot]);
  715.     M_StartMessage(tempstring,M_QuickSaveResponse,true);
  716. }
  720. //
  721. // M_QuickLoad
  722. //
  723. void M_QuickLoadResponse(int ch)
  724. {
  725.     if (ch == KEY_Y)
  726.     {
  727. M_LoadSelect(quickSaveSlot);
  728. S_StartSound(NULL,sfx_swtchx);
  729.     }
  730. }
  733. void M_QuickLoad(void)
  734. {
  735.     if (netgame)
  736.     {
  737. M_StartMessage(QLOADNET,NULL,false);
  738. return;
  739.     }
  741.     if (quickSaveSlot < 0)
  742.     {
  743. M_StartMessage(QSAVESPOT,NULL,false);
  744. return;
  745.     }
  746.     sprintf(tempstring,QLPROMPT,savegamestrings[quickSaveSlot]);
  747.     M_StartMessage(tempstring,M_QuickLoadResponse,true);
  748. }
  753. //
  754. // Read This Menus
  755. // Had a "quick hack to fix romero bug"
  756. //
  757. void M_DrawReadThis1(void)
  758. {
  759.     inhelpscreens = true;
  760.     switch ( gamemode )
  761.     {
  762.       case commercial:
  763. V_DrawPatchDirect (((SCREENWIDTH-320)/2)+0,((SCREENHEIGHT-200)/2)+0,0,W_CacheLumpName("HELP",PU_CACHE));
  764. break;
  765.       case shareware:
  766.       case registered:
  767.       case retail:
  768. V_DrawPatchDirect (((SCREENWIDTH-320)/2)+0,((SCREENHEIGHT-200)/2)+0,0,W_CacheLumpName("HELP1",PU_CACHE));
  769. break;
  770.       default:
  771. break;
  772.     }
  773.     return;
  774. }
  778. //
  779. // Read This Menus - optional second page.
  780. //
  781. void M_DrawReadThis2(void)
  782. {
  783.     inhelpscreens = true;
  784.     switch ( gamemode )
  785.     {
  786.       case retail:
  787.       case commercial:
  788. // This hack keeps us from having to change menus.
  789. V_DrawPatchDirect (((SCREENWIDTH-320)/2)+0,((SCREENHEIGHT-200)/2)+0,0,W_CacheLumpName("CREDIT",PU_CACHE));
  790. break;
  791.       case shareware:
  792.       case registered:
  793. V_DrawPatchDirect (((SCREENWIDTH-320)/2)+0,((SCREENHEIGHT-200)/2)+0,0,W_CacheLumpName("HELP2",PU_CACHE));
  794. break;
  795.       default:
  796. break;
  797.     }
  798.     return;
  799. }
  802. //
  803. // Change Sfx & Music volumes
  804. //
  805. void M_DrawSound(void)
  806. {
  807.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+60,((SCREENHEIGHT-200)/2)+38,0,W_CacheLumpName("M_SVOL",PU_CACHE));
  809.     M_DrawThermo(SoundDef.x,SoundDef.y+LINEHEIGHT*(sfx_vol+1),
  810.  16,snd_SfxVolume);
  812.     M_DrawThermo(SoundDef.x,SoundDef.y+LINEHEIGHT*(music_vol+1),
  813.  16,snd_MusicVolume);
  814. }
  816. void M_Sound(int choice)
  817. {
  818.     M_SetupNextMenu(&SoundDef);
  819. }
  821. void M_SfxVol(int choice)
  822. {
  823.     switch(choice)
  824.     {
  825.       case 0:
  826. if (snd_SfxVolume)
  827.     snd_SfxVolume--;
  828. break;
  829.       case 1:
  830. if (snd_SfxVolume < 15)
  831.     snd_SfxVolume++;
  832. break;
  833.     }
  835.     S_SetSfxVolume(snd_SfxVolume /* *8 */);
  836. }
  838. void M_MusicVol(int choice)
  839. {
  840.     switch(choice)
  841.     {
  842.       case 0:
  843. if (snd_MusicVolume)
  844.     snd_MusicVolume--;
  845. break;
  846.       case 1:
  847. if (snd_MusicVolume < 15)
  848.     snd_MusicVolume++;
  849. break;
  850.     }
  852.     S_SetMusicVolume(snd_MusicVolume /* *8 */);
  853. }
  858. //
  859. // M_DrawMainMenu
  860. //
  861. void M_DrawMainMenu(void)
  862. {
  863.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+94,((SCREENHEIGHT-200)/2)+2,0,W_CacheLumpName("M_DOOM",PU_CACHE));
  864. }
  869. //
  870. // M_NewGame
  871. //
  872. void M_DrawNewGame(void)
  873. {
  874.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+96,((SCREENHEIGHT-200)/2)+14,0,W_CacheLumpName("M_NEWG",PU_CACHE));
  875.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+54,((SCREENHEIGHT-200)/2)+38,0,W_CacheLumpName("M_SKILL",PU_CACHE));
  876. }
  878. void M_NewGame(int choice)
  879. {
  880.     if (netgame && !demoplayback)
  881.     {
  882. M_StartMessage(NEWGAME,NULL,false);
  883. return;
  884.     }
  886.     if ( gamemode == commercial )
  887. M_SetupNextMenu(&NewDef);
  888.     else
  889. M_SetupNextMenu(&EpiDef);
  890. }
  893. //
  894. //      M_Episode
  895. //
  896. int     epi;
  898. void M_DrawEpisode(void)
  899. {
  900.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+54,((SCREENHEIGHT-200)/2)+38,0,W_CacheLumpName("M_EPISOD",PU_CACHE));
  901. }
  903. void M_VerifyNightmare(int ch)
  904. {
  905.     if (ch != KEY_Y)
  906. return;
  908.     G_DeferedInitNew(nightmare,epi+1,1);
  909.     M_ClearMenus ();
  910. }
  912. void M_ChooseSkill(int choice)
  913. {
  914.     if (choice == nightmare)
  915.     {
  916. M_StartMessage(NIGHTMARE,M_VerifyNightmare,true);
  917. return;
  918.     }
  920.     G_DeferedInitNew(choice,epi+1,1);
  921.     M_ClearMenus ();
  922. }
  924. void M_Episode(int choice)
  925. {
  926.     if ( (gamemode == shareware)
  927.  && choice)
  928.     {
  929. M_StartMessage(SWSTRING,NULL,false);
  930. M_SetupNextMenu(&ReadDef1);
  931. return;
  932.     }
  934.     // Yet another hack...
  935.     if ( (gamemode == registered)
  936.  && (choice > 2))
  937.     {
  938.       fprintf( stderr,
  939.        "M_Episode: 4th episode requires UltimateDOOMn");
  940.       choice = 0;
  941.     }
  942.  
  943.     epi = choice;
  944.     M_SetupNextMenu(&NewDef);
  945. }
  949. //
  950. // M_Options
  951. //
  952. char    detailNames[2][9] = {"M_GDHIGH","M_GDLOW"};
  953. char msgNames[2][9] = {"M_MSGOFF","M_MSGON"};
  956. void M_DrawOptions(void)
  957. {
  958.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+108,((SCREENHEIGHT-200)/2)+15,0,W_CacheLumpName("M_OPTTTL",PU_CACHE));
  960.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+OptionsDef.x + 175,((SCREENHEIGHT-200)/2)+OptionsDef.y+LINEHEIGHT*detail,0,
  961.        W_CacheLumpName(detailNames[detailLevel],PU_CACHE));
  963.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+OptionsDef.x + 120,((SCREENHEIGHT-200)/2)+OptionsDef.y+LINEHEIGHT*messages,0,
  964.        W_CacheLumpName(msgNames[showMessages],PU_CACHE));
  966.     M_DrawThermo(OptionsDef.x,OptionsDef.y+LINEHEIGHT*(mousesens+1),
  967.  10,mouseSensitivity);
  969.     M_DrawThermo(OptionsDef.x,OptionsDef.y+LINEHEIGHT*(scrnsize+1),
  970.  9,screenSize);
  971. }
  973. void M_Options(int choice)
  974. {
  975.     M_SetupNextMenu(&OptionsDef);
  976. }
  980. //
  981. //      Toggle messages on/off
  982. //
  983. void M_ChangeMessages(int choice)
  984. {
  985.     // warning: unused parameter `int choice'
  986.     choice = 0;
  987.     showMessages = 1 - showMessages;
  989.     if (!showMessages)
  990. players[consoleplayer].message = MSGOFF;
  991.     else
  992. players[consoleplayer].message = MSGON ;
  994.     message_dontfuckwithme = true;
  995. }
  998. //
  999. // M_EndGame
  1000. //
  1001. void M_EndGameResponse(int ch)
  1002. {
  1003.     if (ch != KEY_Y)
  1004. return;
  1006.     currentMenu->lastOn = itemOn;
  1007.     M_ClearMenus ();
  1008.     D_StartTitle ();
  1009. }
  1011. void M_EndGame(int choice)
  1012. {
  1013.     choice = 0;
  1014.     if (!usergame)
  1015.     {
  1016. S_StartSound(NULL,sfx_oof);
  1017. return;
  1018.     }
  1020.     if (netgame)
  1021.     {
  1022. M_StartMessage(NETEND,NULL,false);
  1023. return;
  1024.     }
  1026.     M_StartMessage(ENDGAME,M_EndGameResponse,true);
  1027. }
  1032. //
  1033. // M_ReadThis
  1034. //
  1035. void M_ReadThis(int choice)
  1036. {
  1037.     choice = 0;
  1038.     M_SetupNextMenu(&ReadDef1);
  1039. }
  1041. void M_ReadThis2(int choice)
  1042. {
  1043.     choice = 0;
  1044.     M_SetupNextMenu(&ReadDef2);
  1045. }
  1047. void M_FinishReadThis(int choice)
  1048. {
  1049.     choice = 0;
  1050.     M_SetupNextMenu(&MainDef);
  1051. }
  1056. //
  1057. // M_QuitDOOM
  1058. //
  1059. int     quitsounds[8] =
  1060. {
  1061.     sfx_pldeth,
  1062.     sfx_dmpain,
  1063.     sfx_popain,
  1064.     sfx_slop,
  1065.     sfx_telept,
  1066.     sfx_posit1,
  1067.     sfx_posit3,
  1068.     sfx_sgtatk
  1069. };
  1071. int     quitsounds2[8] =
  1072. {
  1073.     sfx_vilact,
  1074.     sfx_getpow,
  1075.     sfx_boscub,
  1076.     sfx_slop,
  1077.     sfx_skeswg,
  1078.     sfx_kntdth,
  1079.     sfx_bspact,
  1080.     sfx_sgtatk
  1081. };
  1084. char MsgText[256];
  1086. void M_QuitResponse(int ch)
  1087. {
  1088. //WriteDebug("M_QuitResponse...n");
  1089.     if (ch != KEY_Y)
  1090.        {
  1091. //        sprintf(MsgText, "ch = %c - 0x%02Xn", ch, ch );
  1092. //        WriteDebug(MsgText);
  1093.         return;
  1094.        }
  1095.     if (!netgame)
  1096.     {
  1097. if (gamemode == commercial)
  1098.     S_StartSound(NULL,quitsounds2[(gametic>>2)&7]);
  1099. else
  1100.     S_StartSound(NULL,quitsounds[(gametic>>2)&7]);
  1101. I_WaitVBL(105);
  1102.     }
  1103.     I_Quit ();
  1104. }
  1109. void M_QuitDOOM(int choice)
  1110. {
  1111. //WriteDebug("M_QuitDoom...n");
  1112.   // We pick index 0 which is language sensitive,
  1113.   //  or one at random, between 1 and maximum number.
  1114.   if (language != english )
  1115.     sprintf(endstring,"%snn"DOSY, endmsg[0] );
  1116.   else
  1117.     sprintf(endstring,"%snn"DOSY, endmsg[ (gametic%(NUM_QUITMESSAGES-10))+1 ]);
  1118.   
  1119.   M_StartMessage(endstring,M_QuitResponse,true);
  1120. }
  1125. void M_ChangeSensitivity(int choice)
  1126. {
  1127.     switch(choice)
  1128.     {
  1129.       case 0:
  1130. if (mouseSensitivity)
  1131.     mouseSensitivity--;
  1132. break;
  1133.       case 1:
  1134. if (mouseSensitivity < 9)
  1135.     mouseSensitivity++;
  1136. break;
  1137.     }
  1138. }
  1143. void M_ChangeDetail(int choice)
  1144. {
  1145.     choice = 0;
  1146.     //detailLevel = 1 - detailLevel;
  1148.     // FIXME - does not work. Remove anyway?
  1149.     sprintf( MsgText, "M_ChangeDetail: low detail mode n.a.n");
  1150.     WriteDebug(MsgText);
  1151.     
  1152. /*
  1153.     R_SetViewSize (screenblocks, detailLevel);
  1155.     if (!detailLevel)
  1156. players[consoleplayer].message = DETAILHI;
  1157.     else
  1158. players[consoleplayer].message = DETAILLO;
  1159. */
  1160. }
  1165. void M_SizeDisplay(int choice)
  1166. {
  1167.     switch(choice)
  1168.     {
  1169.       case 0:
  1170. if (screenSize > 0)
  1171. {
  1172.     screenblocks--;
  1173.     screenSize--;
  1174. }
  1175. break;
  1176.       case 1:
  1177. if (screenSize < 8)
  1178. {
  1179.     screenblocks++;
  1180.     screenSize++;
  1181. }
  1182. break;
  1183.     }
  1186.     R_SetViewSize (screenblocks, detailLevel);
  1187. }
  1192. //
  1193. //      Menu Functions
  1194. //
  1195. void
  1196. M_DrawThermo
  1197. ( int x,
  1198.   int y,
  1199.   int thermWidth,
  1200.   int thermDot )
  1201. {
  1202.     int xx;
  1203.     int i;
  1205.     xx = x;
  1206.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+xx,((SCREENHEIGHT-200)/2)+y,0,W_CacheLumpName("M_THERML",PU_CACHE));
  1207.     xx += 8;
  1208.     for (i=0;i<thermWidth;i++)
  1209.     {
  1210. V_DrawPatchDirect (((SCREENWIDTH-320)/2)+xx,((SCREENHEIGHT-200)/2)+y,0,W_CacheLumpName("M_THERMM",PU_CACHE));
  1211. xx += 8;
  1212.     }
  1213.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+xx,((SCREENHEIGHT-200)/2)+y,0,W_CacheLumpName("M_THERMR",PU_CACHE));
  1215.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+(x+8) + thermDot*8,((SCREENHEIGHT-200)/2)+y,
  1216.        0,W_CacheLumpName("M_THERMO",PU_CACHE));
  1217. }
  1221. void
  1222. M_DrawEmptyCell
  1223. ( menu_t* menu,
  1224.   int item )
  1225. {
  1226.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+menu->x - 10,((SCREENHEIGHT-200)/2)+menu->y+item*LINEHEIGHT - 1, 0,
  1227.        W_CacheLumpName("M_CELL1",PU_CACHE));
  1228. }
  1230. void
  1231. M_DrawSelCell
  1232. ( menu_t* menu,
  1233.   int item )
  1234. {
  1235.     V_DrawPatchDirect (((SCREENWIDTH-320)/2)+menu->x - 10,((SCREENHEIGHT-200)/2)+menu->y+item*LINEHEIGHT - 1, 0,
  1236.        W_CacheLumpName("M_CELL2",PU_CACHE));
  1237. }
  1240. void
  1241. M_StartMessage
  1242. ( char* string,
  1243.   void* routine,
  1244.   boolean input )
  1245. {
  1246. //WriteDebug("M_StartMessage...n");
  1247. //WriteDebug(string);
  1248. //WriteDebug("n");
  1249.     messageLastMenuActive = menuactive;
  1250.     messageToPrint = 1;
  1251.     messageString = string;
  1252.     messageRoutine = routine;
  1253.     messageNeedsInput = input;
  1254.     menuactive = true;
  1255.     return;
  1256. }
  1260. void M_StopMessage(void)
  1261. {
  1262.     menuactive = messageLastMenuActive;
  1263.     messageToPrint = 0;
  1264. }
  1268. //
  1269. // Find string width from hu_font chars
  1270. //
  1271. int M_StringWidth(char* string)
  1272. {
  1273.     int             i;
  1274.     int             w = 0;
  1275.     int             c;
  1277.     for (i = 0;(unsigned)i < strlen(string);i++)
  1278.     {
  1279. c = toupper(string[i]) - HU_FONTSTART;
  1280. if (c < 0 || c >= HU_FONTSIZE)
  1281.     w += 4;
  1282. else
  1283.     w += SHORT (hu_font[c]->width);
  1284.     }
  1286.     return w;
  1287. }
  1291. //
  1292. //      Find string height from hu_font chars
  1293. //
  1294. int M_StringHeight(char* string)
  1295. {
  1296.     int             i;
  1297.     int             h;
  1298.     int             height = SHORT(hu_font[0]->height);
  1300.     h = height;
  1301.     for (i = 0;(unsigned)i < strlen(string);i++)
  1302. if (string[i] == 'n')
  1303.     h += height;
  1305.     return h;
  1306. }
  1309. //
  1310. //      Write a string using the hu_font
  1311. //
  1312. void M_WriteText( int x, int y, char *string)
  1313.    {
  1314.     int w;
  1315.     char* ch;
  1316.     int c;
  1317.     int cx;
  1318.     int cy;
  1321.     ch = string;
  1322.     cx = x;
  1323.     cy = y;
  1325.     while(1)
  1326.        {
  1327.         c = *ch++;
  1328.         if (!c)
  1329.             break;
  1330.         if (c == 'n')
  1331.            {
  1332.             cx = x;
  1333.             cy += 12;
  1334.             continue;
  1335.            }
  1337.         c = toupper(c) - HU_FONTSTART;
  1338.         if (c < 0 || c>= HU_FONTSIZE)
  1339.            {
  1340.             cx += 4;
  1341.             continue;
  1342.            }
  1344.         w = SHORT (hu_font[c]->width);
  1345.         if (cx+w > SCREENWIDTH)
  1346.             break;
  1347.         V_DrawPatchDirect(cx, cy, 0, hu_font[c]);
  1348.         cx+=w;
  1349.        }
  1350.    }
  1354. //
  1355. // CONTROL PANEL
  1356. //
  1358. //
  1359. // M_Responder
  1360. //
  1361. boolean M_Responder (event_t* ev)
  1362. {
  1363.     int             ch;
  1364.     int             i;
  1365.     static  int     joywait = 0;
  1366.     static  int     mousewait = 0;
  1367.     static  int     mousey = 0;
  1368.     static  int     lasty = 0;
  1369.     static  int     mousex = 0;
  1370.     static  int     lastx = 0;
  1372.     ch = -1;
  1374.     if (ev->type == ev_joystick && joywait < I_GetTime())
  1375.     {
  1376. if (ev->data3 == -1)
  1377. {
  1378.     ch = KEY_UPARROW;
  1379.     joywait = I_GetTime() + 5;
  1380. }
  1381. else if (ev->data3 == 1)
  1382. {
  1383.     ch = KEY_DOWNARROW;
  1384.     joywait = I_GetTime() + 5;
  1385. }
  1387. if (ev->data2 == -1)
  1388. {
  1389.     ch = KEY_LEFTARROW;
  1390.     joywait = I_GetTime() + 2;
  1391. }
  1392. else if (ev->data2 == 1)
  1393. {
  1394.     ch = KEY_RIGHTARROW;
  1395.     joywait = I_GetTime() + 2;
  1396. }
  1398. if (ev->data1&1)
  1399. {
  1400.     ch = KEY_ENTER;
  1401.     joywait = I_GetTime() + 5;
  1402. }
  1403. if (ev->data1&2)
  1404. {
  1405.     ch = KEY_BACKSPACE;
  1406.     joywait = I_GetTime() + 5;
  1407. }
  1408.     }
  1409.     else
  1410.     {
  1411. if (ev->type == ev_mouse && mousewait < I_GetTime())
  1412. {
  1413.     mousey += ev->data3;
  1414.     if (mousey < lasty-30)
  1415.     {
  1416. ch = KEY_DOWNARROW;
  1417. mousewait = I_GetTime() + 5;
  1418. mousey = lasty -= 30;
  1419.     }
  1420.     else if (mousey > lasty+30)
  1421.     {
  1422. ch = KEY_UPARROW;
  1423. mousewait = I_GetTime() + 5;
  1424. mousey = lasty += 30;
  1425.     }
  1427.     mousex += ev->data2;
  1428.     if (mousex < lastx-30)
  1429.     {
  1430. ch = KEY_LEFTARROW;
  1431. mousewait = I_GetTime() + 5;
  1432. mousex = lastx -= 30;
  1433.     }
  1434.     else if (mousex > lastx+30)
  1435.     {
  1436. ch = KEY_RIGHTARROW;
  1437. mousewait = I_GetTime() + 5;
  1438. mousex = lastx += 30;
  1439.     }
  1441.     if (ev->data1&1)
  1442.     {
  1443. ch = KEY_ENTER;
  1444. mousewait = I_GetTime() + 15;
  1445.     }
  1447.     if (ev->data1&2)
  1448.     {
  1449. ch = KEY_BACKSPACE;
  1450. mousewait = I_GetTime() + 15;
  1451.     }
  1452. }
  1453. else
  1454.     if (ev->type == ev_keydown)
  1455.     {
  1456. ch = ev->data1;
  1457.         //WriteDebug("Assigning data1 to ch...n");
  1458.     }
  1459.     }
  1460.     
  1461.     if (ch == -1)
  1462. return false;
  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;
  1478.   case KEY_ESCAPE:
  1479.     saveStringEnter = 0;
  1480.     strcpy(&savegamestrings[saveSlot][0],saveOldString);
  1481.     break;
  1483.   case KEY_ENTER:
  1484.     saveStringEnter = 0;
  1485.     if (savegamestrings[saveSlot][0])
  1486. M_DoSave(saveSlot);
  1487.     break;
  1489.   default:
  1490.     ch = toupper(scan2char[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 == KEY_SPACE || ch == KEY_N || ch == KEY_Y || ch == KEY_ESCAPE))
  1512.     return false;
  1514. menuactive = messageLastMenuActive;
  1515. messageToPrint = 0;
  1516. if (messageRoutine)
  1517.        {
  1518.         //WriteDebug("Calling message routine that needs answering...n");
  1519.     messageRoutine(ch);
  1520.        }
  1522. menuactive = false;
  1523. S_StartSound(NULL,sfx_swtchx);
  1524. return true;
  1525.     }
  1527.     //Don't really need this anymore -- keeping it for legacy...
  1528.     if (devparm && ch == KEY_F1)
  1529.     {
  1530. G_ScreenShot ();
  1531. return true;
  1532.     }
  1534.     if (ch == KEY_SCRNSHOT)
  1535.        {
  1536.         G_ScreenShot();
  1537.         return true;
  1538.        }
  1540.     if (ch == KEY_CAPITAL)
  1541.        {
  1542.         if (always_run == FALSE)
  1543.            always_run = TRUE;
  1544.         else
  1545.            always_run = FALSE;
  1546.         return true;
  1547.        }
  1548.     
  1549.     // F-Keys
  1550.     if (!menuactive)
  1551. switch(ch)
  1552. {
  1553.   case KEY_MINUS:         // Screen size down
  1554.     if (automapactive || chat_on)
  1555. return false;
  1556.     M_SizeDisplay(0);
  1557.     S_StartSound(NULL,sfx_stnmov);
  1558.     return true;
  1560.   case KEY_EQUALS:        // Screen size up
  1561.     if (automapactive || chat_on)
  1562. return false;
  1563.     M_SizeDisplay(1);
  1564.     S_StartSound(NULL,sfx_stnmov);
  1565.     return true;
  1567.   case KEY_F1:            // Help key
  1568.     M_StartControlPanel ();
  1570.     if ( gamemode == retail )
  1571.       currentMenu = &ReadDef2;
  1572.     else
  1573.       currentMenu = &ReadDef1;
  1574.     
  1575.     itemOn = 0;
  1576.     S_StartSound(NULL,sfx_swtchn);
  1577.     return true;
  1579.   case KEY_F2:            // Save
  1580.     M_StartControlPanel();
  1581.     S_StartSound(NULL,sfx_swtchn);
  1582.     M_SaveGame(0);
  1583.     return true;
  1585.   case KEY_F3:            // Load
  1586.     M_StartControlPanel();
  1587.     S_StartSound(NULL,sfx_swtchn);
  1588.     M_LoadGame(0);
  1589.     return true;
  1591.   case KEY_F4:            // Sound Volume
  1592.     M_StartControlPanel ();
  1593.     currentMenu = &SoundDef;
  1594.     itemOn = sfx_vol;
  1595.     S_StartSound(NULL,sfx_swtchn);
  1596.     return true;
  1598.   case KEY_F5:            // Detail toggle
  1599.     M_ChangeDetail(0);
  1600.     S_StartSound(NULL,sfx_swtchn);
  1601.     return true;
  1603.   case KEY_F6:            // Quicksave
  1604.     S_StartSound(NULL,sfx_swtchn);
  1605.     M_QuickSave();
  1606.     return true;
  1608.   case KEY_F7:            // End game
  1609.     S_StartSound(NULL,sfx_swtchn);
  1610.     M_EndGame(0);
  1611.     return true;
  1613.   case KEY_F8:            // Toggle messages
  1614.     M_ChangeMessages(0);
  1615.     S_StartSound(NULL,sfx_swtchn);
  1616.     return true;
  1618.   case KEY_F9:            // Quickload
  1619.     S_StartSound(NULL,sfx_swtchn);
  1620.     M_QuickLoad();
  1621.     return true;
  1623.   case KEY_F10:           // Quit DOOM
  1624.     S_StartSound(NULL,sfx_swtchn);
  1625.     M_QuitDOOM(0);
  1626.     return true;
  1628.   case KEY_F11:           // gamma toggle
  1629.     usegamma++;
  1630.     if (usegamma > 4)
  1631. usegamma = 0;
  1632.     players[consoleplayer].message = gammamsg[usegamma];
  1633.     I_SetPalette (W_CacheLumpName ("PLAYPAL",PU_CACHE));
  1634.     return true;
  1636. }
  1638.     
  1639.     // Pop-up menu?
  1640.     if (!menuactive)
  1641.     {
  1642. if (ch == KEY_ESCAPE)
  1643. {
  1644.     M_StartControlPanel ();
  1645.     S_StartSound(NULL,sfx_swtchn);
  1646.     return true;
  1647. }
  1648. return false;
  1649.     }
  1651.     
  1652.     // Keys usable within menu
  1653.     switch (ch)
  1654.     {
  1655.       case KEY_DOWNARROW:
  1656. do
  1657. {
  1658.     if (itemOn+1 > currentMenu->numitems-1)
  1659. itemOn = 0;
  1660.     else itemOn++;
  1661.     S_StartSound(NULL,sfx_pstop);
  1662. } while(currentMenu->menuitems[itemOn].status==-1);
  1663. return true;
  1665.       case KEY_UPARROW:
  1666. do
  1667. {
  1668.     if (!itemOn)
  1669. itemOn = currentMenu->numitems-1;
  1670.     else itemOn--;
  1671.     S_StartSound(NULL,sfx_pstop);
  1672. } while(currentMenu->menuitems[itemOn].status==-1);
  1673. return true;
  1675.       case KEY_LEFTARROW:
  1676. if (currentMenu->menuitems[itemOn].routine &&
  1677.     currentMenu->menuitems[itemOn].status == 2)
  1678. {
  1679.     S_StartSound(NULL,sfx_stnmov);
  1680.     currentMenu->menuitems[itemOn].routine(0);
  1681. }
  1682. return true;
  1684.       case KEY_RIGHTARROW:
  1685. if (currentMenu->menuitems[itemOn].routine &&
  1686.     currentMenu->menuitems[itemOn].status == 2)
  1687. {
  1688.     S_StartSound(NULL,sfx_stnmov);
  1689.     currentMenu->menuitems[itemOn].routine(1);
  1690. }
  1691. return true;
  1693.       case KEY_ENTER:
  1694. if (currentMenu->menuitems[itemOn].routine &&
  1695.     currentMenu->menuitems[itemOn].status)
  1696. {
  1697.     currentMenu->lastOn = itemOn;
  1698.     if (currentMenu->menuitems[itemOn].status == 2)
  1699.     {
  1700. currentMenu->menuitems[itemOn].routine(1);      // right arrow
  1701. S_StartSound(NULL,sfx_stnmov);
  1702.     }
  1703.     else
  1704.     {
  1705. currentMenu->menuitems[itemOn].routine(itemOn);
  1706. S_StartSound(NULL,sfx_pistol);
  1707.     }
  1708. }
  1709. return true;
  1711.       case KEY_CONSOLE:
  1712.            currentMenu->lastOn = itemOn;
  1713.            M_ClearMenus ();
  1714.            return true;
  1716.       case KEY_ESCAPE:
  1717. currentMenu->lastOn = itemOn;
  1718. M_ClearMenus ();
  1719. S_StartSound(NULL,sfx_swtchx);
  1720. return true;
  1722.       case KEY_BACKSPACE:
  1723. currentMenu->lastOn = itemOn;
  1724. if (currentMenu->prevMenu)
  1725. {
  1726.     currentMenu = currentMenu->prevMenu;
  1727.     itemOn = currentMenu->lastOn;
  1728.     S_StartSound(NULL,sfx_swtchn);
  1729. }
  1730. return true;
  1732.       default:
  1733. for (i = itemOn+1;i < currentMenu->numitems;i++)
  1734.     if (currentMenu->menuitems[i].alphaKey == ch)
  1735.     {
  1736. itemOn = i;
  1737. S_StartSound(NULL,sfx_pstop);
  1738. return true;
  1739.     }
  1740. for (i = 0;i <= itemOn;i++)
  1741.     if (currentMenu->menuitems[i].alphaKey == ch)
  1742.     {
  1743. itemOn = i;
  1744. S_StartSound(NULL,sfx_pstop);
  1745. return true;
  1746.     }
  1747. break;
  1749.     }
  1751.     return false;
  1752. }
  1756. //
  1757. // M_StartControlPanel
  1758. //
  1759. void M_StartControlPanel (void)
  1760. {
  1761.     // intro might call this repeatedly
  1762.     if (menuactive)
  1763. return;
  1764.     
  1765.     menuactive = 1;
  1766.     currentMenu = &MainDef;         // JDC
  1767.     itemOn = currentMenu->lastOn;   // JDC
  1768. }
  1771. //
  1772. // M_Drawer
  1773. // Called after the view has been rendered,
  1774. // but before it has been blitted.
  1775. //
  1776. void M_Drawer (void)
  1777. {
  1778.     static short x;
  1779.     static short y;
  1780.     short i;
  1781.     short max;
  1782.     char string[40];
  1783.     int start;
  1785.     inhelpscreens = false;
  1787.     
  1788.     // Horiz. & Vertically center string and print it.
  1789.     if (messageToPrint)
  1790.     {
  1791. start = 0;
  1792. y = (SCREENHEIGHT/2) - M_StringHeight(messageString)/2;
  1793. while(*(messageString+start))
  1794. {
  1795.     for (i = 0;(unsigned)i < strlen(messageString+start);i++)
  1796. if (*(messageString+start+i) == 'n')
  1797. {
  1798.     memset(string,0,40);
  1799.     strncpy(string,messageString+start,i);
  1800.     start += i+1;
  1801.     break;
  1802. }
  1804.     if ((unsigned)i == strlen(messageString+start))
  1805.     {
  1806. strcpy(string,messageString+start);
  1807. start += i;
  1808.     }
  1810.     x = (SCREENWIDTH/2) - M_StringWidth(string)/2;
  1811.     M_WriteText(x,y,string);
  1812.     y += SHORT(hu_font[0]->height);
  1813. }
  1814. return;
  1815.     }
  1817.     if (!menuactive)
  1818. return;
  1820.     if (currentMenu->routine)
  1821. currentMenu->routine();         // call Draw routine
  1822.     
  1823.     // DRAW MENU
  1824.     x = ((SCREENWIDTH-320)/2)+currentMenu->x;
  1825.     y = ((SCREENHEIGHT-200)/2)+currentMenu->y;
  1826.     max = currentMenu->numitems;
  1828.     for (i=0;i<max;i++)
  1829.     {
  1830. if (currentMenu->menuitems[i].name[0])
  1831.     V_DrawPatchDirect (x,y,0,
  1832.        W_CacheLumpName(currentMenu->menuitems[i].name ,PU_CACHE));
  1833. y += LINEHEIGHT;
  1834.     }
  1836.     
  1837.     // DRAW SKULL
  1838.     V_DrawPatchDirect(x+SKULLXOFF,((SCREENHEIGHT-200)/2)+currentMenu->y - 5 + itemOn*LINEHEIGHT, 0,
  1839.       W_CacheLumpName(skullName[whichSkull],PU_CACHE));
  1841. }
  1844. //
  1845. // M_ClearMenus
  1846. //
  1847. void M_ClearMenus (void)
  1848. {
  1849.     menuactive = 0;
  1850.     // if (!netgame && usergame && paused)
  1851.     //       sendpause = true;
  1852. }
  1857. //
  1858. // M_SetupNextMenu
  1859. //
  1860. void M_SetupNextMenu(menu_t *menudef)
  1861. {
  1862.     currentMenu = menudef;
  1863.     itemOn = currentMenu->lastOn;
  1864. }
  1867. //
  1868. // M_Ticker
  1869. //
  1870. void M_Ticker (void)
  1871. {
  1872.     if (--skullAnimCounter <= 0)
  1873.     {
  1874. whichSkull ^= 1;
  1875. skullAnimCounter = 8;
  1876.     }
  1877. }
  1880. //
  1881. // M_Init
  1882. //
  1883. void M_Init (void)
  1884. {
  1885.     currentMenu = &MainDef;
  1886.     menuactive = 0;
  1887.     itemOn = currentMenu->lastOn;
  1888.     whichSkull = 0;
  1889.     skullAnimCounter = 10;
  1890.     screenSize = screenblocks - 3;
  1891.     messageToPrint = 0;
  1892.     messageString = NULL;
  1893.     messageLastMenuActive = menuactive;
  1894.     quickSaveSlot = -1;
  1896.     // Here we could catch other version dependencies,
  1897.     //  like HELP1/2, and four episodes.
  1899.   
  1900.     switch ( gamemode )
  1901.     {
  1902.       case commercial:
  1903. // This is used because DOOM 2 had only one HELP
  1904.         //  page. I use CREDIT as second page now, but
  1905. //  kept this hack for educational purposes.
  1906. MainMenu[readthis] = MainMenu[quitdoom];
  1907. MainDef.numitems--;
  1908. MainDef.y += 8;
  1909. NewDef.prevMenu = &MainDef;
  1910. ReadDef1.routine = M_DrawReadThis1;
  1911. ReadDef1.x = 330;
  1912. ReadDef1.y = 165;
  1913. ReadMenu1[0].routine = M_FinishReadThis;
  1914. break;
  1915.       case shareware:
  1916. // Episode 2 and 3 are handled,
  1917. //  branching to an ad screen.
  1918.       case registered:
  1919. // We need to remove the fourth episode.
  1920. EpiDef.numitems--;
  1921. break;
  1922.       case retail:
  1923. // We are fine.
  1924.       default:
  1925. break;
  1926.     }
  1927.     
  1928. }