WebSVN – Kolibri OS – Diff – /programs/games/doom/trunk/m_menu.c


// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
//      DOOM selection menu, options, episode etc.
//      Sliders and icons. Kinda widget stuff.
//
//-----------------------------------------------------------------------------
 
static const char
rcsid[] = "$Id: m_menu.c,v 1.7 1997/02/03 22:45:10 b1 Exp $";
 
#include 
#include 
 
#include "m_swap.h"
#include "doomdef.h"
#include "dstrings.h"
 
#include "d_main.h"
 
#include "i_system.h"
#include "i_video.h"
#include "z_zone.h"
#include "v_video.h"
#include "w_wad.h"
 
#include "r_local.h"
 
 
#include "hu_stuff.h"
 
#include "g_game.h"
 
#include "m_argv.h"
 
#include "s_sound.h"
 
#include "doomstat.h"
 
// Data.
#include "sounds.h"
 
#include "m_menu.h"
 
 
 
extern patch_t*         hu_font[HU_FONTSIZE];
extern boolean          message_dontfuckwithme;
 
extern boolean          chat_on;                // in heads-up code
 
//
// defaulted values
//
int                     mouseSensitivity;       // has default
 
// Show messages has default, 0 = off, 1 = on
int                     showMessages;
        
 
// Blocky mode, has default, 0 = high, 1 = normal
int                     detailLevel;            
int                     screenblocks;           // has default
 
// temp for screenblocks (0-9)
int                     screenSize;             
 
// -1 = no quicksave slot picked!
int                     quickSaveSlot;          
 
 // 1 = message to be printed
int                     messageToPrint;
// ...and here is the message string!
char*                   messageString;          
 
// message x & y
int                     messx;                  
int                     messy;
int                     messageLastMenuActive;
 
// timed message = no input from user
boolean                 messageNeedsInput;     
 
void    (*messageRoutine)(int response);
 
#define SAVESTRINGSIZE  24
 
char gammamsg[5][26] =
{
    GAMMALVL0,
    GAMMALVL1,
    GAMMALVL2,
    GAMMALVL3,
    GAMMALVL4
};
 
// we are going to be entering a savegame string
int                     saveStringEnter;              
int                     saveSlot;       // which slot to save in
int                     saveCharIndex;  // which char we're editing
// old save description before edit
char                    saveOldString[SAVESTRINGSIZE];  
 
boolean                 inhelpscreens;
boolean                 menuactive;
 
#define SKULLXOFF               -32
#define LINEHEIGHT              16
 
extern boolean          sendpause;
char                    savegamestrings[10][SAVESTRINGSIZE];
 
char    endstring[160];
 
 
//
// MENU TYPEDEFS
//
typedef struct
{
    // 0 = no cursor here, 1 = ok, 2 = arrows ok
    short       status;
    
    char        name[10];
    
    // choice = menu item #.
    // if status = 2,
    //   choice=0:leftarrow,1:rightarrow
    void        (*routine)(int choice);
    
    // hotkey in menu
    char        alphaKey;                       
} menuitem_t;
 
 
 
typedef struct menu_s
{
    short               numitems;       // # of menu items
    struct menu_s*      prevMenu;       // previous menu
    menuitem_t*         menuitems;      // menu items
    void                (*routine)();   // draw routine
    short               x;
    short               y;              // x,y of menu
    short               lastOn;         // last item user was on in menu
} menu_t;
 
short           itemOn;                 // menu item skull is on
short           skullAnimCounter;       // skull animation counter
short           whichSkull;             // which skull to draw
 
// graphic name of skulls
// warning: initializer-string for array of chars is too long
char    skullName[2][/*8*/9] = {"M_SKULL1","M_SKULL2"};
 
// current menudef
menu_t* currentMenu;                          
 
//
// PROTOTYPES
//
void M_NewGame(int choice);
void M_Episode(int choice);
void M_ChooseSkill(int choice);
void M_LoadGame(int choice);
void M_SaveGame(int choice);
void M_Options(int choice);
void M_EndGame(int choice);
void M_ReadThis(int choice);
void M_ReadThis2(int choice);
void M_QuitDOOM(int choice);
 
void M_ChangeMessages(int choice);
void M_ChangeSensitivity(int choice);
void M_SfxVol(int choice);
void M_MusicVol(int choice);
void M_ChangeDetail(int choice);
void M_SizeDisplay(int choice);
void M_StartGame(int choice);
void M_Sound(int choice);
 
void M_FinishReadThis(int choice);
void M_LoadSelect(int choice);
void M_SaveSelect(int choice);
void M_ReadSaveStrings(void);
void M_QuickSave(void);
void M_QuickLoad(void);
 
void M_DrawMainMenu(void);
void M_DrawReadThis1(void);
void M_DrawReadThis2(void);
void M_DrawNewGame(void);
void M_DrawEpisode(void);
void M_DrawOptions(void);
void M_DrawSound(void);
void M_DrawLoad(void);
void M_DrawSave(void);
 
void M_DrawSaveLoadBorder(int x,int y);
void M_SetupNextMenu(menu_t *menudef);
void M_DrawThermo(int x,int y,int thermWidth,int thermDot);
void M_DrawEmptyCell(menu_t *menu,int item);
void M_DrawSelCell(menu_t *menu,int item);
void M_WriteText(int x, int y, char *string);
int  M_StringWidth(char *string);
int  M_StringHeight(char *string);
void M_StartControlPanel(void);
void M_StartMessage(char *string,void *routine,boolean input);
void M_StopMessage(void);
void M_ClearMenus (void);
 
 
 
 
//
// DOOM MENU
//
enum
{
    newgame = 0,
    options,
    loadgame,
    savegame,
    readthis,
    quitdoom,
    main_end
} main_e;
 
menuitem_t MainMenu[]=
{
    {1,"M_NGAME",M_NewGame,'n'},
    {1,"M_OPTION",M_Options,'o'},
    {1,"M_LOADG",M_LoadGame,'l'},
    {1,"M_SAVEG",M_SaveGame,'s'},
    // Another hickup with Special edition.
    {1,"M_RDTHIS",M_ReadThis,'r'},
    {1,"M_QUITG",M_QuitDOOM,'q'}
};
 
menu_t  MainDef =
{
    main_end,
    NULL,
    MainMenu,
    M_DrawMainMenu,
    97,64,
    0
};
 
 
//
// EPISODE SELECT
//
enum
{
    ep1,
    ep2,
    ep3,
    ep4,
    ep_end
} episodes_e;
 
menuitem_t EpisodeMenu[]=
{
    {1,"M_EPI1", M_Episode,'k'},
    {1,"M_EPI2", M_Episode,'t'},
    {1,"M_EPI3", M_Episode,'i'},
    {1,"M_EPI4", M_Episode,'t'}
};
 
menu_t  EpiDef =
{
    ep_end,             // # of menu items
    &MainDef,           // previous menu
    EpisodeMenu,        // menuitem_t ->
    M_DrawEpisode,      // drawing routine ->
    48,63,              // x,y
    ep1                 // lastOn
};
 
//
// NEW GAME
//
enum
{
    killthings,
    toorough,
    hurtme,
    violence,
    nightmare,
    newg_end
} newgame_e;
 
menuitem_t NewGameMenu[]=
{
    {1,"M_JKILL",       M_ChooseSkill, 'i'},
    {1,"M_ROUGH",       M_ChooseSkill, 'h'},
    {1,"M_HURT",        M_ChooseSkill, 'h'},
    {1,"M_ULTRA",       M_ChooseSkill, 'u'},
    {1,"M_NMARE",       M_ChooseSkill, 'n'}
};
 
menu_t  NewDef =
{
    newg_end,           // # of menu items
    &EpiDef,            // previous menu
    NewGameMenu,        // menuitem_t ->
    M_DrawNewGame,      // drawing routine ->
    48,63,              // x,y
    hurtme              // lastOn
};
 
 
 
//
// OPTIONS MENU
//
enum
{
    endgame,
    messages,
    detail,
    scrnsize,
    option_empty1,
    mousesens,
    option_empty2,
    soundvol,
    opt_end
} options_e;
 
menuitem_t OptionsMenu[]=
{
    {1,"M_ENDGAM",      M_EndGame,'e'},
    {1,"M_MESSG",       M_ChangeMessages,'m'},
    {1,"M_DETAIL",      M_ChangeDetail,'g'},
    {2,"M_SCRNSZ",      M_SizeDisplay,'s'},
    {-1,"",0},
    {2,"M_MSENS",       M_ChangeSensitivity,'m'},
    {-1,"",0},
    {1,"M_SVOL",        M_Sound,'s'}
};
 
menu_t  OptionsDef =
{
    opt_end,
    &MainDef,
    OptionsMenu,
    M_DrawOptions,
    60,37,
    0
};
 
//
// Read This! MENU 1 & 2
//
enum
{
    rdthsempty1,
    read1_end
} read_e;
 
menuitem_t ReadMenu1[] =
{
    {1,"",M_ReadThis2,0}
};
 
menu_t  ReadDef1 =
{
    read1_end,
    &MainDef,
    ReadMenu1,
    M_DrawReadThis1,
    280,185,
    0
};
 
enum
{
    rdthsempty2,
    read2_end
} read_e2;
 
menuitem_t ReadMenu2[]=
{
    {1,"",M_FinishReadThis,0}
};
 
menu_t  ReadDef2 =
{
    read2_end,
    &ReadDef1,
    ReadMenu2,
    M_DrawReadThis2,
    330,175,
    0
};
 
//
// SOUND VOLUME MENU
//
enum
{
    sfx_vol,
    sfx_empty1,
    music_vol,
    sfx_empty2,
    sound_end
} sound_e;
 
menuitem_t SoundMenu[]=
{
    {2,"M_SFXVOL",M_SfxVol,'s'},
    {-1,"",0},
    {2,"M_MUSVOL",M_MusicVol,'m'},
    {-1,"",0}
};
 
menu_t  SoundDef =
{
    sound_end,
    &OptionsDef,
    SoundMenu,
    M_DrawSound,
    80,64,
    0
};
 
//
// LOAD GAME MENU
//
enum
{
    load1,
    load2,
    load3,
    load4,
    load5,
    load6,
    load_end
} load_e;
 
menuitem_t LoadMenu[]=
{
    {1,"", M_LoadSelect,'1'},
    {1,"", M_LoadSelect,'2'},
    {1,"", M_LoadSelect,'3'},
    {1,"", M_LoadSelect,'4'},
    {1,"", M_LoadSelect,'5'},
    {1,"", M_LoadSelect,'6'}
};
 
menu_t  LoadDef =
{
    load_end,
    &MainDef,
    LoadMenu,
    M_DrawLoad,
    80,54,
    0
};
 
//
// SAVE GAME MENU
//
menuitem_t SaveMenu[]=
{
    {1,"", M_SaveSelect,'1'},
    {1,"", M_SaveSelect,'2'},
    {1,"", M_SaveSelect,'3'},
    {1,"", M_SaveSelect,'4'},
    {1,"", M_SaveSelect,'5'},
    {1,"", M_SaveSelect,'6'}
};
 
menu_t  SaveDef =
{
    load_end,
    &MainDef,
    SaveMenu,
    M_DrawSave,
    80,54,
    0
};
 
 
//
// M_ReadSaveStrings
//  read the strings from the savegame files
//
void M_ReadSaveStrings(void)
{
    FILE           *handle;
    int             count;
    int             i;
    char    name[256];
 
    for (i = 0;i < load_end;i++)
    {
        sprintf(name,"doomsav%d.dsg",i);
 
        handle = fopen (name, "r");
        if (handle == NULL)
        {
            strcpy(&savegamestrings[i][0],EMPTYSTRING);
            LoadMenu[i].status = 0;
            continue;
        }
        count = fread (&savegamestrings[i], 1, SAVESTRINGSIZE, handle);
        fclose (handle);
        LoadMenu[i].status = 1;
    }
}
 
 
//
// M_LoadGame & Cie.
//
void M_DrawLoad(void)
{
    int             i;
        
    V_DrawPatchDirect (72,28,0,W_CacheLumpName("M_LOADG",PU_CACHE));
    for (i = 0;i < load_end; i++)
    {
        M_DrawSaveLoadBorder(LoadDef.x,LoadDef.y+LINEHEIGHT*i);
        M_WriteText(LoadDef.x,LoadDef.y+LINEHEIGHT*i,savegamestrings[i]);
    }
}
 
 
 
//
// Draw border for the savegame description
//
void M_DrawSaveLoadBorder(int x,int y)
{
    int             i;
        
    V_DrawPatchDirect (x-8,y+7,0,W_CacheLumpName("M_LSLEFT",PU_CACHE));
        
    for (i = 0;i < 24;i++)
    {
        V_DrawPatchDirect (x,y+7,0,W_CacheLumpName("M_LSCNTR",PU_CACHE));
        x += 8;
    }
 
    V_DrawPatchDirect (x,y+7,0,W_CacheLumpName("M_LSRGHT",PU_CACHE));
}
 
 
 
//
// User wants to load this game
//
void M_LoadSelect(int choice)
{
    char    name[256];
        
//    if (M_CheckParm("-cdrom"))
//        sprintf(name,"c:\\doomdata\\doomsav%d.dsg",choice);
//    else
        sprintf(name,"doomsav%d.dsg",choice);
 
    G_LoadGame (name);
    M_ClearMenus ();
}
 
//
// Selected from DOOM menu
//
void M_LoadGame (int choice)
{
    if (netgame)
    {
        M_StartMessage(LOADNET,NULL,false);
        return;
    }
        
    M_SetupNextMenu(&LoadDef);
    M_ReadSaveStrings();
}
 
 
//
//  M_SaveGame & Cie.
//
void M_DrawSave(void)
{
    int             i;
        
    V_DrawPatchDirect (72,28,0,W_CacheLumpName("M_SAVEG",PU_CACHE));
    for (i = 0;i < load_end; i++)
    {
        M_DrawSaveLoadBorder(LoadDef.x,LoadDef.y+LINEHEIGHT*i);
        M_WriteText(LoadDef.x,LoadDef.y+LINEHEIGHT*i,savegamestrings[i]);
    }
        
    if (saveStringEnter)
    {
        i = M_StringWidth(savegamestrings[saveSlot]);
        M_WriteText(LoadDef.x + i,LoadDef.y+LINEHEIGHT*saveSlot,"_");
    }
}
 
//
// M_Responder calls this when user is finished
//
void M_DoSave(int slot)
{
 
    G_SaveGame (slot,savegamestrings[slot]);
    M_ClearMenus ();
 
    // PICK QUICKSAVE SLOT YET?
    if (quickSaveSlot == -2)
        quickSaveSlot = slot;
}
 
//
// User wants to save. Start string input for M_Responder
//
void M_SaveSelect(int choice)
{
    // we are going to be intercepting all chars
    saveStringEnter = 1;
    
    saveSlot = choice;
    strcpy(saveOldString,savegamestrings[choice]);
    if (!strcmp(savegamestrings[choice],EMPTYSTRING))
        savegamestrings[choice][0] = 0;
    saveCharIndex = strlen(savegamestrings[choice]);
}
 
//
// Selected from DOOM menu
//
void M_SaveGame (int choice)
{
    if (!usergame)
    {
        M_StartMessage(SAVEDEAD,NULL,false);
        return;
    }
        
    if (gamestate != GS_LEVEL)
        return;
        
    M_SetupNextMenu(&SaveDef);
    M_ReadSaveStrings();
}
 
 
 
//
//      M_QuickSave
//
char    tempstring[80];
 
void M_QuickSaveResponse(int ch)
{
    if (ch == 'y')
    {
        M_DoSave(quickSaveSlot);
        S_StartSound(NULL,sfx_swtchx);
    }
}
 
void M_QuickSave(void)
{
    if (!usergame)
    {
        S_StartSound(NULL,sfx_oof);
        return;
    }
 
    if (gamestate != GS_LEVEL)
        return;
        
    if (quickSaveSlot < 0)
    {
        M_StartControlPanel();
        M_ReadSaveStrings();
        M_SetupNextMenu(&SaveDef);
        quickSaveSlot = -2;     // means to pick a slot now
        return;
    }
    sprintf(tempstring,QSPROMPT,savegamestrings[quickSaveSlot]);
    M_StartMessage(tempstring,M_QuickSaveResponse,true);
}
 
 
 
//
// M_QuickLoad
//
void M_QuickLoadResponse(int ch)
{
    if (ch == 'y')
    {
        M_LoadSelect(quickSaveSlot);
        S_StartSound(NULL,sfx_swtchx);
    }
}
 
 
void M_QuickLoad(void)
{
    if (netgame)
    {
        M_StartMessage(QLOADNET,NULL,false);
        return;
    }
        
    if (quickSaveSlot < 0)
    {
        M_StartMessage(QSAVESPOT,NULL,false);
        return;
    }
    sprintf(tempstring,QLPROMPT,savegamestrings[quickSaveSlot]);
    M_StartMessage(tempstring,M_QuickLoadResponse,true);
}
 
 
 
 
//
// Read This Menus
// Had a "quick hack to fix romero bug"
//
void M_DrawReadThis1(void)
{
    inhelpscreens = true;
    switch ( gamemode )
    {
      case commercial:
        V_DrawPatchDirect (0,0,0,W_CacheLumpName("HELP",PU_CACHE));
        break;
      case shareware:
      case registered:
      case retail:
        V_DrawPatchDirect (0,0,0,W_CacheLumpName("HELP1",PU_CACHE));
        break;
      default:
        break;
    }
    return;
}
 
 
 
//
// Read This Menus - optional second page.
//
void M_DrawReadThis2(void)
{
    inhelpscreens = true;
    switch ( gamemode )
    {
      case retail:
      case commercial:
        // This hack keeps us from having to change menus.
        V_DrawPatchDirect (0,0,0,W_CacheLumpName("CREDIT",PU_CACHE));
        break;
      case shareware:
      case registered:
        V_DrawPatchDirect (0,0,0,W_CacheLumpName("HELP2",PU_CACHE));
        break;
      default:
        break;
    }
    return;
}
 
 
//
// Change Sfx & Music volumes
//
void M_DrawSound(void)
{
    V_DrawPatchDirect (60,38,0,W_CacheLumpName("M_SVOL",PU_CACHE));
 
    M_DrawThermo(SoundDef.x,SoundDef.y+LINEHEIGHT*(sfx_vol+1),
                 16,snd_SfxVolume);
 
    M_DrawThermo(SoundDef.x,SoundDef.y+LINEHEIGHT*(music_vol+1),
                 16,snd_MusicVolume);
}
 
void M_Sound(int choice)
{
    M_SetupNextMenu(&SoundDef);
}
 
void M_SfxVol(int choice)
{
    switch(choice)
    {
      case 0:
        if (snd_SfxVolume)
            snd_SfxVolume--;
        break;
      case 1:
        if (snd_SfxVolume < 15)
            snd_SfxVolume++;
        break;
    }
        
    S_SetSfxVolume(snd_SfxVolume /* *8 */);
}
 
void M_MusicVol(int choice)
{
    switch(choice)
    {
      case 0:
        if (snd_MusicVolume)
            snd_MusicVolume--;
        break;
      case 1:
        if (snd_MusicVolume < 15)
            snd_MusicVolume++;
        break;
    }
        
    S_SetMusicVolume(snd_MusicVolume /* *8 */);
}
 
 
 
 
//
// M_DrawMainMenu
//
void M_DrawMainMenu(void)
{
    V_DrawPatchDirect (94,2,0,W_CacheLumpName("M_DOOM",PU_CACHE));
}
 
 
 
 
//
// M_NewGame
//
void M_DrawNewGame(void)
{
    V_DrawPatchDirect (96,14,0,W_CacheLumpName("M_NEWG",PU_CACHE));
    V_DrawPatchDirect (54,38,0,W_CacheLumpName("M_SKILL",PU_CACHE));
}
 
void M_NewGame(int choice)
{
    if (netgame && !demoplayback)
    {
        M_StartMessage(NEWGAME,NULL,false);
        return;
    }
        
    if ( gamemode == commercial )
        M_SetupNextMenu(&NewDef);
    else
        M_SetupNextMenu(&EpiDef);
}
 
 
//
//      M_Episode
//
int     epi;
 
void M_DrawEpisode(void)
{
    V_DrawPatchDirect (54,38,0,W_CacheLumpName("M_EPISOD",PU_CACHE));
}
 
void M_VerifyNightmare(int ch)
{
    if (ch != 'y')
        return;
                
    G_DeferedInitNew(nightmare,epi+1,1);
    M_ClearMenus ();
}
 
void M_ChooseSkill(int choice)
{
    if (choice == nightmare)
    {
        M_StartMessage(NIGHTMARE,M_VerifyNightmare,true);
        return;
    }
        
    G_DeferedInitNew(choice,epi+1,1);
    M_ClearMenus ();
}
 
void M_Episode(int choice)
{
    if ( (gamemode == shareware)
         && choice)
    {
        M_StartMessage(SWSTRING,NULL,false);
        M_SetupNextMenu(&ReadDef1);
        return;
    }
 
    // Yet another hack...
    if ( (gamemode == registered)
         && (choice > 2))
    {
 //     __libclog_printf("M_Episode: 4th episode requires UltimateDOOM\n");
      choice = 0;
    }
         
    epi = choice;
    M_SetupNextMenu(&NewDef);
}
 
 
 
//
// M_Options
//
char    detailNames[2][9]       = {"M_GDHIGH","M_GDLOW"};
char    msgNames[2][9]          = {"M_MSGOFF","M_MSGON"};
 
 
void M_DrawOptions(void)
{
    V_DrawPatchDirect (108,15,0,W_CacheLumpName("M_OPTTTL",PU_CACHE));
        
    V_DrawPatchDirect (OptionsDef.x + 175,OptionsDef.y+LINEHEIGHT*detail,0,
                       W_CacheLumpName(detailNames[detailLevel],PU_CACHE));
 
    V_DrawPatchDirect (OptionsDef.x + 120,OptionsDef.y+LINEHEIGHT*messages,0,
                       W_CacheLumpName(msgNames[showMessages],PU_CACHE));
 
    M_DrawThermo(OptionsDef.x,OptionsDef.y+LINEHEIGHT*(mousesens+1),
                 10,mouseSensitivity);
        
    M_DrawThermo(OptionsDef.x,OptionsDef.y+LINEHEIGHT*(scrnsize+1),
                 9,screenSize);
}
 
void M_Options(int choice)
{
    M_SetupNextMenu(&OptionsDef);
}
 
 
 
//
//      Toggle messages on/off
//
void M_ChangeMessages(int choice)
{
    // warning: unused parameter `int choice'
    choice = 0;
    showMessages = 1 - showMessages;
        
    if (!showMessages)
        players[consoleplayer].message = MSGOFF;
    else
        players[consoleplayer].message = MSGON ;
 
    message_dontfuckwithme = true;
}
 
 
//
// M_EndGame
//
void M_EndGameResponse(int ch)
{
    if (ch != 'y')
        return;
                
    currentMenu->lastOn = itemOn;
    M_ClearMenus ();
    D_StartTitle ();
}
 
void M_EndGame(int choice)
{
    choice = 0;
    if (!usergame)
    {
        S_StartSound(NULL,sfx_oof);
        return;
    }
        
    if (netgame)
    {
        M_StartMessage(NETEND,NULL,false);
        return;
    }
        
    M_StartMessage(ENDGAME,M_EndGameResponse,true);
}
 
 
 
 
//
// M_ReadThis
//
void M_ReadThis(int choice)
{
    choice = 0;
    M_SetupNextMenu(&ReadDef1);
}
 
void M_ReadThis2(int choice)
{
    choice = 0;
    M_SetupNextMenu(&ReadDef2);
}
 
void M_FinishReadThis(int choice)
{
    choice = 0;
    M_SetupNextMenu(&MainDef);
}
 
 
 
 
//
// M_QuitDOOM
//
int     quitsounds[8] =
{
    sfx_pldeth,
    sfx_dmpain,
    sfx_popain,
    sfx_slop,
    sfx_telept,
    sfx_posit1,
    sfx_posit3,
    sfx_sgtatk
};
 
int     quitsounds2[8] =
{
    sfx_vilact,
    sfx_getpow,
    sfx_boscub,
    sfx_slop,
    sfx_skeswg,
    sfx_kntdth,
    sfx_bspact,
    sfx_sgtatk
};
 
 
 
void M_QuitResponse(int ch)
{
    if (ch != 'y')
        return;
    if (!netgame)
    {
        if (gamemode == commercial)
            S_StartSound(NULL,quitsounds2[(gametic>>2)&7]);
        else
            S_StartSound(NULL,quitsounds[(gametic>>2)&7]);
        I_WaitVBL(105);
    }
    I_Quit ();
}
 
 
 
 
void M_QuitDOOM(int choice)
{
  // We pick index 0 which is language sensitive,
  //  or one at random, between 1 and maximum number.
  if (language != english )
    sprintf(endstring,"%s\n\n"DOSY, endmsg[0] );
  else
    sprintf(endstring,"%s\n\n"DOSY, endmsg[ (gametic%(NUM_QUITMESSAGES-2))+1 ]);
  
  M_StartMessage(endstring,M_QuitResponse,true);
}
 
 
 
void M_ChangeSensitivity(int choice)
{
    switch(choice)
    {
      case 0:
        if (mouseSensitivity)
            mouseSensitivity--;
        break;
      case 1:
        if (mouseSensitivity < 9)
            mouseSensitivity++;
        break;
    }
}
 
 
 
 
void M_ChangeDetail(int choice)
{
    choice = 0;
    detailLevel = 1 - detailLevel;
 
    // FIXME - does not work. Remove anyway?
//    __libclog_printf("M_ChangeDetail: low detail mode n.a.\n");
 
    return;
    
    /*R_SetViewSize (screenblocks, detailLevel);
 
    if (!detailLevel)
        players[consoleplayer].message = DETAILHI;
    else
        players[consoleplayer].message = DETAILLO;*/
}
 
 
 
 
void M_SizeDisplay(int choice)
{
    switch(choice)
    {
      case 0:
        if (screenSize > 0)
        {
            screenblocks--;
            screenSize--;
        }
        break;
      case 1:
        if (screenSize < 8)
        {
            screenblocks++;
            screenSize++;
        }
        break;
    }
        
 
    R_SetViewSize (screenblocks, detailLevel);
}
 
 
 
 
//
//      Menu Functions
//
void
M_DrawThermo
( int   x,
  int   y,
  int   thermWidth,
  int   thermDot )
{
    int         xx;
    int         i;
 
    xx = x;
    V_DrawPatchDirect (xx,y,0,W_CacheLumpName("M_THERML",PU_CACHE));
    xx += 8;
    for (i=0;i
    {
        V_DrawPatchDirect (xx,y,0,W_CacheLumpName("M_THERMM",PU_CACHE));
        xx += 8;
    }
    V_DrawPatchDirect (xx,y,0,W_CacheLumpName("M_THERMR",PU_CACHE));
 
    V_DrawPatchDirect ((x+8) + thermDot*8,y,
                       0,W_CacheLumpName("M_THERMO",PU_CACHE));
}
 
 
 
void
M_DrawEmptyCell
( menu_t*       menu,
  int           item )
{
    V_DrawPatchDirect (menu->x - 10,        menu->y+item*LINEHEIGHT - 1, 0,
                       W_CacheLumpName("M_CELL1",PU_CACHE));
}
 
void
M_DrawSelCell
( menu_t*       menu,
  int           item )
{
    V_DrawPatchDirect (menu->x - 10,        menu->y+item*LINEHEIGHT - 1, 0,
                       W_CacheLumpName("M_CELL2",PU_CACHE));
}
 
 
void
M_StartMessage
( char*         string,
  void*         routine,
  boolean       input )
{
    messageLastMenuActive = menuactive;
    messageToPrint = 1;
    messageString = string;
    messageRoutine = routine;
    messageNeedsInput = input;
    menuactive = true;
    return;
}
 
 
 
void M_StopMessage(void)
{
    menuactive = messageLastMenuActive;
    messageToPrint = 0;
}
 
 
 
//
// Find string width from hu_font chars
//
int M_StringWidth(char* string)
{
    int             i;
    int             w = 0;
    int             c;
        
    for (i = 0;i < strlen(string);i++)
    {
        c = toupper(string[i]) - HU_FONTSTART;
        if (c < 0 || c >= HU_FONTSIZE)
            w += 4;
        else
            w += SHORT (hu_font[c]->width);
    }
                
    return w;
}
 
 
 
//
//      Find string height from hu_font chars
//
int M_StringHeight(char* string)
{
    int             i;
    int             h;
    int             height = SHORT(hu_font[0]->height);
        
    h = height;
    for (i = 0;i < strlen(string);i++)
        if (string[i] == '\n')
            h += height;
                
    return h;
}
 
 
//
//      Write a string using the hu_font
//
void
M_WriteText
( int           x,
  int           y,
  char*         string)
{
    int         w;
    char*       ch;
    int         c;
    int         cx;
    int         cy;
                
 
    ch = string;
    cx = x;
    cy = y;
        
    while(1)
    {
        c = *ch++;
        if (!c)
            break;
        if (c == '\n')
        {
            cx = x;
            cy += 12;
            continue;
        }
                
        c = toupper(c) - HU_FONTSTART;
        if (c < 0 || c>= HU_FONTSIZE)
        {
            cx += 4;
            continue;
        }
                
        w = SHORT (hu_font[c]->width);
        if (cx+w > SCREENWIDTH)
            break;
        V_DrawPatchDirect(cx, cy, 0, hu_font[c]);
        cx+=w;
    }
}
 
 
 
//
// CONTROL PANEL
//
 
//
// M_Responder
//
boolean M_Responder (event_t* ev)
{
    int             ch;
    int             i;
    static  int     joywait = 0;
    static  int     mousewait = 0;
    static  int     mousey = 0;
    static  int     lasty = 0;
    static  int     mousex = 0;
    static  int     lastx = 0;
        
    ch = -1;
        
    if (ev->type == ev_joystick && joywait < I_GetTime())
    {
        if (ev->data3 == -1)
        {
            ch = KEY_UPARROW;
            joywait = I_GetTime() + 5;
        }
        else if (ev->data3 == 1)
        {
            ch = KEY_DOWNARROW;
            joywait = I_GetTime() + 5;
        }
                
        if (ev->data2 == -1)
        {
            ch = KEY_LEFTARROW;
            joywait = I_GetTime() + 2;
        }
        else if (ev->data2 == 1)
        {
            ch = KEY_RIGHTARROW;
            joywait = I_GetTime() + 2;
        }
                
        if (ev->data1&1)
        {
            ch = KEY_ENTER;
            joywait = I_GetTime() + 5;
        }
        if (ev->data1&2)
        {
            ch = KEY_BACKSPACE;
            joywait = I_GetTime() + 5;
        }
    }
    else
    {
        if (ev->type == ev_mouse && mousewait < I_GetTime())
        {
            mousey += ev->data3;
            if (mousey < lasty-30)
            {
                ch = KEY_DOWNARROW;
                mousewait = I_GetTime() + 5;
                mousey = lasty -= 30;
            }
            else if (mousey > lasty+30)
            {
                ch = KEY_UPARROW;
                mousewait = I_GetTime() + 5;
                mousey = lasty += 30;
            }
                
            mousex += ev->data2;
            if (mousex < lastx-30)
            {
                ch = KEY_LEFTARROW;
                mousewait = I_GetTime() + 5;
                mousex = lastx -= 30;
            }
            else if (mousex > lastx+30)
            {
                ch = KEY_RIGHTARROW;
                mousewait = I_GetTime() + 5;
                mousex = lastx += 30;
            }
                
            if (ev->data1&1)
            {
                ch = KEY_ENTER;
                mousewait = I_GetTime() + 15;
            }
                        
            if (ev->data1&2)
            {
                ch = KEY_BACKSPACE;
                mousewait = I_GetTime() + 15;
            }
        }
        else
            if (ev->type == ev_keydown)
            {
                ch = ev->data1;
            }
    }
    
    if (ch == -1)
        return false;
 
    
    // Save Game string input
    if (saveStringEnter)
    {
        switch(ch)
        {
          case KEY_BACKSPACE:
            if (saveCharIndex > 0)
            {
                saveCharIndex--;
                savegamestrings[saveSlot][saveCharIndex] = 0;
            }
            break;
                                
          case KEY_ESCAPE:
            saveStringEnter = 0;
            strcpy(&savegamestrings[saveSlot][0],saveOldString);
            break;
                                
          case KEY_ENTER:
            saveStringEnter = 0;
            if (savegamestrings[saveSlot][0])
                M_DoSave(saveSlot);
            break;
                                
          default:
            ch = toupper(ch);
            if (ch != 32)
                if (ch-HU_FONTSTART < 0 || ch-HU_FONTSTART >= HU_FONTSIZE)
                    break;
            if (ch >= 32 && ch <= 127 &&
                saveCharIndex < SAVESTRINGSIZE-1 &&
                M_StringWidth(savegamestrings[saveSlot]) <
                (SAVESTRINGSIZE-2)*8)
            {
                savegamestrings[saveSlot][saveCharIndex++] = ch;
                savegamestrings[saveSlot][saveCharIndex] = 0;
            }
            break;
        }
        return true;
    }
    
    // Take care of any messages that need input
    if (messageToPrint)
    {
        if (messageNeedsInput == true &&
            !(ch == ' ' || ch == 'n' || ch == 'y' || ch == KEY_ESCAPE))
            return false;
                
        menuactive = messageLastMenuActive;
        messageToPrint = 0;
        if (messageRoutine)
            messageRoutine(ch);
                        
        menuactive = false;
        S_StartSound(NULL,sfx_swtchx);
        return true;
    }
        
    if (devparm && ch == KEY_F1)
    {
        G_ScreenShot ();
        return true;
    }
                
    
    // F-Keys
    if (!menuactive)
        switch(ch)
        {
          case KEY_MINUS:         // Screen size down
            if (automapactive || chat_on)
                return false;
            M_SizeDisplay(0);
            S_StartSound(NULL,sfx_stnmov);
            return true;
                                
          case KEY_EQUALS:        // Screen size up
            if (automapactive || chat_on)
                return false;
            M_SizeDisplay(1);
            S_StartSound(NULL,sfx_stnmov);
            return true;
                                
          case KEY_F1:            // Help key
            M_StartControlPanel ();
 
            if ( gamemode == retail )
              currentMenu = &ReadDef2;
            else
              currentMenu = &ReadDef1;
            
            itemOn = 0;
            S_StartSound(NULL,sfx_swtchn);
            return true;
                                
          case KEY_F2:            // Save
            M_StartControlPanel();
            S_StartSound(NULL,sfx_swtchn);
            M_SaveGame(0);
            return true;
                                
          case KEY_F3:            // Load
            M_StartControlPanel();
            S_StartSound(NULL,sfx_swtchn);
            M_LoadGame(0);
            return true;
                                
          case KEY_F4:            // Sound Volume
            M_StartControlPanel ();
            currentMenu = &SoundDef;
            itemOn = sfx_vol;
            S_StartSound(NULL,sfx_swtchn);
            return true;
                                
          case KEY_F5:            // Detail toggle
            M_ChangeDetail(0);
            S_StartSound(NULL,sfx_swtchn);
            return true;
                                
          case KEY_F6:            // Quicksave
            S_StartSound(NULL,sfx_swtchn);
            M_QuickSave();
            return true;
                                
          case KEY_F7:            // End game
            S_StartSound(NULL,sfx_swtchn);
            M_EndGame(0);
            return true;
                                
          case KEY_F8:            // Toggle messages
            M_ChangeMessages(0);
            S_StartSound(NULL,sfx_swtchn);
            return true;
                                
          case KEY_F9:            // Quickload
            S_StartSound(NULL,sfx_swtchn);
            M_QuickLoad();
            return true;
                                
          case KEY_F10:           // Quit DOOM
            S_StartSound(NULL,sfx_swtchn);
            M_QuitDOOM(0);
            return true;
                                
          case KEY_F11:           // gamma toggle
            usegamma++;
            if (usegamma > 4)
                usegamma = 0;
            players[consoleplayer].message = gammamsg[usegamma];
            I_SetPalette (W_CacheLumpName ("PLAYPAL",PU_CACHE));
            return true;
                                
        }
 
    
    // Pop-up menu?
    if (!menuactive)
    {
        if (ch == KEY_ESCAPE)
        {
            M_StartControlPanel ();
            S_StartSound(NULL,sfx_swtchn);
            return true;
        }
        return false;
    }
 
    
    // Keys usable within menu
    switch (ch)
    {
      case KEY_DOWNARROW:
        do
        {
            if (itemOn+1 > currentMenu->numitems-1)
                itemOn = 0;
            else itemOn++;
            S_StartSound(NULL,sfx_pstop);
        } while(currentMenu->menuitems[itemOn].status==-1);
        return true;
                
      case KEY_UPARROW:
        do
        {
            if (!itemOn)
                itemOn = currentMenu->numitems-1;
            else itemOn--;
            S_StartSound(NULL,sfx_pstop);
        } while(currentMenu->menuitems[itemOn].status==-1);
        return true;
 
      case KEY_LEFTARROW:
        if (currentMenu->menuitems[itemOn].routine &&
            currentMenu->menuitems[itemOn].status == 2)
        {
            S_StartSound(NULL,sfx_stnmov);
            currentMenu->menuitems[itemOn].routine(0);
        }
        return true;
                
      case KEY_RIGHTARROW:
        if (currentMenu->menuitems[itemOn].routine &&
            currentMenu->menuitems[itemOn].status == 2)
        {
            S_StartSound(NULL,sfx_stnmov);
            currentMenu->menuitems[itemOn].routine(1);
        }
        return true;
 
      case KEY_ENTER:
        if (currentMenu->menuitems[itemOn].routine &&
            currentMenu->menuitems[itemOn].status)
        {
            currentMenu->lastOn = itemOn;
            if (currentMenu->menuitems[itemOn].status == 2)
            {
                currentMenu->menuitems[itemOn].routine(1);      // right arrow
                S_StartSound(NULL,sfx_stnmov);
            }
            else
            {
                currentMenu->menuitems[itemOn].routine(itemOn);
                S_StartSound(NULL,sfx_pistol);
            }
        }
        return true;
                
      case KEY_ESCAPE:
        currentMenu->lastOn = itemOn;
        M_ClearMenus ();
        S_StartSound(NULL,sfx_swtchx);
        return true;
                
      case KEY_BACKSPACE:
        currentMenu->lastOn = itemOn;
        if (currentMenu->prevMenu)
        {
            currentMenu = currentMenu->prevMenu;
            itemOn = currentMenu->lastOn;
            S_StartSound(NULL,sfx_swtchn);
        }
        return true;
        
      default:
        for (i = itemOn+1;i < currentMenu->numitems;i++)
            if (currentMenu->menuitems[i].alphaKey == ch)
            {
                itemOn = i;
                S_StartSound(NULL,sfx_pstop);
                return true;
            }
        for (i = 0;i <= itemOn;i++)
            if (currentMenu->menuitems[i].alphaKey == ch)
            {
                itemOn = i;
                S_StartSound(NULL,sfx_pstop);
                return true;
            }
        break;
        
    }
 
    return false;
}
 
 
 
//
// M_StartControlPanel
//
void M_StartControlPanel (void)
{
    // intro might call this repeatedly
    if (menuactive)
        return;
    
    menuactive = 1;
    currentMenu = &MainDef;         // JDC
    itemOn = currentMenu->lastOn;   // JDC
}
 
 
//
// M_Drawer
// Called after the view has been rendered,
// but before it has been blitted.
//
void M_Drawer (void)
{
    static short        x;
    static short        y;
    short               i;
    short               max;
    char *p;
    int len;
    char                string[40];
    int                 start;
 
    inhelpscreens = false;
 
    // Horiz. & Vertically center string and print it.
    if (messageToPrint)
    {
          y = 100 - M_StringHeight(messageString)/2;
          p = messageString;
          len = strlen(p);
          while(*p)
          {
        for (i = 0;len;i++,len--)
        {
              if (*(p+i) == '\n')
                  { memset(string,0,40);
                    strncpy(string,p,i);
                    p+= i+1;
                    len-= 1;
                    break;
                  };
            };    
        
        if (len == 0)
        { strncpy(string,p,i);
          p+=i;
        };  
        x = 160 - M_StringWidth(string)/2;
        M_WriteText(x,y,string);
        y += SHORT(hu_font[0]->height);
          };
          return;
    };
 
    if (!menuactive)
        return;
 
    if (currentMenu->routine)
        currentMenu->routine();         // call Draw routine
    
    // DRAW MENU
    x = currentMenu->x;
    y = currentMenu->y;
    max = currentMenu->numitems;
 
    for (i=0;i
    {
        if (currentMenu->menuitems[i].name[0])
            V_DrawPatchDirect (x,y,0,
                               W_CacheLumpName(currentMenu->menuitems[i].name ,PU_CACHE));
        y += LINEHEIGHT;
    }
 
    
    // DRAW SKULL
    V_DrawPatchDirect(x + SKULLXOFF,currentMenu->y - 5 + itemOn*LINEHEIGHT, 0,
                      W_CacheLumpName(skullName[whichSkull],PU_CACHE));
 
}
 
 
//
// M_ClearMenus
//
void M_ClearMenus (void)
{
    menuactive = 0;
    // if (!netgame && usergame && paused)
    //       sendpause = true;
}
 
 
 
 
//
// M_SetupNextMenu
//
void M_SetupNextMenu(menu_t *menudef)
{
    currentMenu = menudef;
    itemOn = currentMenu->lastOn;
}
 
 
//
// M_Ticker
//
void M_Ticker (void)
{
    if (--skullAnimCounter <= 0)
    {
        whichSkull ^= 1;
        skullAnimCounter = 8;
    }
}
 
 
//
// M_Init
//
void M_Init (void)
{
    currentMenu = &MainDef;
    menuactive = 0;
    itemOn = currentMenu->lastOn;
    whichSkull = 0;
    skullAnimCounter = 10;
    screenSize = screenblocks - 3;
    messageToPrint = 0;
    messageString = NULL;
    messageLastMenuActive = menuactive;
    quickSaveSlot = -1;
 
    // Here we could catch other version dependencies,
    //  like HELP1/2, and four episodes.
 
  
    switch ( gamemode )
    {
      case commercial:
        // This is used because DOOM 2 had only one HELP
        //  page. I use CREDIT as second page now, but
        //  kept this hack for educational purposes.
        MainMenu[readthis] = MainMenu[quitdoom];
        MainDef.numitems--;
        MainDef.y += 8;
        NewDef.prevMenu = &MainDef;
        ReadDef1.routine = M_DrawReadThis1;
        ReadDef1.x = 330;
        ReadDef1.y = 165;
        ReadMenu1[0].routine = M_FinishReadThis;
        break;
      case shareware:
        // Episode 2 and 3 are handled,
        //  branching to an ad screen.
      case registered:
        // We need to remove the fourth episode.
        EpiDef.numitems--;
        break;
      case retail:
        // We are fine.
      default:
        break;
    }
    
}
>
>
>

Rev 300	Rev 550
1	// Emacs style mode select -- C++ --	1	// Emacs style mode select -- C++ --
2	//-----------------------------------------------------------------------------	2	//-----------------------------------------------------------------------------
3	//	3	//
4	// $Id:$	4	// $Id:$
5	//	5	//
6	// Copyright (C) 1993-1996 by id Software, Inc.	6	// Copyright (C) 1993-1996 by id Software, Inc.
7	//	7	//
8	// This source is available for distribution and/or modification	8	// This source is available for distribution and/or modification
9	// only under the terms of the DOOM Source Code License as	9	// only under the terms of the DOOM Source Code License as
10	// published by id Software. All rights reserved.	10	// published by id Software. All rights reserved.
11	//	11	//
12	// The source is distributed in the hope that it will be useful,	12	// The source is distributed in the hope that it will be useful,
13	// but WITHOUT ANY WARRANTY; without even the implied warranty of	13	// but WITHOUT ANY WARRANTY; without even the implied warranty of
14	// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License	14	// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
15	// for more details.	15	// for more details.
16	//	16	//
17	// $Log:$	17	// $Log:$
18	//	18	//
19	// DESCRIPTION:	19	// DESCRIPTION:
20	// DOOM selection menu, options, episode etc.	20	// DOOM selection menu, options, episode etc.
21	// Sliders and icons. Kinda widget stuff.	21	// Sliders and icons. Kinda widget stuff.
22	//	22	//
23	//-----------------------------------------------------------------------------	23	//-----------------------------------------------------------------------------
24		24
25	static const char	25	static const char
26	rcsid[] = "$Id: m_menu.c,v 1.7 1997/02/03 22:45:10 b1 Exp $";	26	rcsid[] = "$Id: m_menu.c,v 1.7 1997/02/03 22:45:10 b1 Exp $";
27		27
28	#include	28	#include
29	#include	29	#include
30		30
31	#include "m_swap.h"	31	#include "m_swap.h"
32	#include "doomdef.h"	32	#include "doomdef.h"
33	#include "dstrings.h"	33	#include "dstrings.h"
34		34
35	#include "d_main.h"	35	#include "d_main.h"
36		36
37	#include "i_system.h"	37	#include "i_system.h"
38	#include "i_video.h"	38	#include "i_video.h"
39	#include "z_zone.h"	39	#include "z_zone.h"
40	#include "v_video.h"	40	#include "v_video.h"
41	#include "w_wad.h"	41	#include "w_wad.h"
42		42
43	#include "r_local.h"	43	#include "r_local.h"
44		44
45		45
46	#include "hu_stuff.h"	46	#include "hu_stuff.h"
47		47
48	#include "g_game.h"	48	#include "g_game.h"
49		49
50	#include "m_argv.h"	50	#include "m_argv.h"
51		51
52	#include "s_sound.h"	52	#include "s_sound.h"
53		53
54	#include "doomstat.h"	54	#include "doomstat.h"
55		55
56	// Data.	56	// Data.
57	#include "sounds.h"	57	#include "sounds.h"
58		58
59	#include "m_menu.h"	59	#include "m_menu.h"
60		60
61		61
62		62
63	extern patch_t* hu_font[HU_FONTSIZE];	63	extern patch_t* hu_font[HU_FONTSIZE];
64	extern boolean message_dontfuckwithme;	64	extern boolean message_dontfuckwithme;
65		65
66	extern boolean chat_on; // in heads-up code	66	extern boolean chat_on; // in heads-up code
67		67
68	//	68	//
69	// defaulted values	69	// defaulted values
70	//	70	//
71	int mouseSensitivity; // has default	71	int mouseSensitivity; // has default
72		72
73	// Show messages has default, 0 = off, 1 = on	73	// Show messages has default, 0 = off, 1 = on
74	int showMessages;	74	int showMessages;
75		75
76		76
77	// Blocky mode, has default, 0 = high, 1 = normal	77	// Blocky mode, has default, 0 = high, 1 = normal
78	int detailLevel;	78	int detailLevel;
79	int screenblocks; // has default	79	int screenblocks; // has default
80		80
81	// temp for screenblocks (0-9)	81	// temp for screenblocks (0-9)
82	int screenSize;	82	int screenSize;
83		83
84	// -1 = no quicksave slot picked!	84	// -1 = no quicksave slot picked!
85	int quickSaveSlot;	85	int quickSaveSlot;
86		86
87	// 1 = message to be printed	87	// 1 = message to be printed
88	int messageToPrint;	88	int messageToPrint;
89	// ...and here is the message string!	89	// ...and here is the message string!
90	char* messageString;	90	char* messageString;
91		91
92	// message x & y	92	// message x & y
93	int messx;	93	int messx;
94	int messy;	94	int messy;
95	int messageLastMenuActive;	95	int messageLastMenuActive;
96		96
97	// timed message = no input from user	97	// timed message = no input from user
98	boolean messageNeedsInput;	98	boolean messageNeedsInput;
99		99
100	void (*messageRoutine)(int response);	100	void (*messageRoutine)(int response);
101		101
102	#define SAVESTRINGSIZE 24	102	#define SAVESTRINGSIZE 24
103		103
104	char gammamsg[5][26] =	104	char gammamsg[5][26] =
105	{	105	{
106	GAMMALVL0,	106	GAMMALVL0,
107	GAMMALVL1,	107	GAMMALVL1,
108	GAMMALVL2,	108	GAMMALVL2,
109	GAMMALVL3,	109	GAMMALVL3,
110	GAMMALVL4	110	GAMMALVL4
111	};	111	};
112		112
113	// we are going to be entering a savegame string	113	// we are going to be entering a savegame string
114	int saveStringEnter;	114	int saveStringEnter;
115	int saveSlot; // which slot to save in	115	int saveSlot; // which slot to save in
116	int saveCharIndex; // which char we're editing	116	int saveCharIndex; // which char we're editing
117	// old save description before edit	117	// old save description before edit
118	char saveOldString[SAVESTRINGSIZE];	118	char saveOldString[SAVESTRINGSIZE];
119		119
120	boolean inhelpscreens;	120	boolean inhelpscreens;
121	boolean menuactive;	121	boolean menuactive;
122		122
123	#define SKULLXOFF -32	123	#define SKULLXOFF -32
124	#define LINEHEIGHT 16	124	#define LINEHEIGHT 16
125		125
126	extern boolean sendpause;	126	extern boolean sendpause;
127	char savegamestrings[10][SAVESTRINGSIZE];	127	char savegamestrings[10][SAVESTRINGSIZE];
128		128
129	char endstring[160];	129	char endstring[160];
130		130
131		131
132	//	132	//
133	// MENU TYPEDEFS	133	// MENU TYPEDEFS
134	//	134	//
135	typedef struct	135	typedef struct
136	{	136	{
137	// 0 = no cursor here, 1 = ok, 2 = arrows ok	137	// 0 = no cursor here, 1 = ok, 2 = arrows ok
138	short status;	138	short status;
139		139
140	char name[10];	140	char name[10];
141		141
142	// choice = menu item #.	142	// choice = menu item #.
143	// if status = 2,	143	// if status = 2,
144	// choice=0:leftarrow,1:rightarrow	144	// choice=0:leftarrow,1:rightarrow
145	void (*routine)(int choice);	145	void (*routine)(int choice);
146		146
147	// hotkey in menu	147	// hotkey in menu
148	char alphaKey;	148	char alphaKey;
149	} menuitem_t;	149	} menuitem_t;
150		150
151		151
152		152
153	typedef struct menu_s	153	typedef struct menu_s
154	{	154	{
155	short numitems; // # of menu items	155	short numitems; // # of menu items
156	struct menu_s* prevMenu; // previous menu	156	struct menu_s* prevMenu; // previous menu
157	menuitem_t* menuitems; // menu items	157	menuitem_t* menuitems; // menu items
158	void (*routine)(); // draw routine	158	void (*routine)(); // draw routine
159	short x;	159	short x;
160	short y; // x,y of menu	160	short y; // x,y of menu
161	short lastOn; // last item user was on in menu	161	short lastOn; // last item user was on in menu
162	} menu_t;	162	} menu_t;
163		163
164	short itemOn; // menu item skull is on	164	short itemOn; // menu item skull is on
165	short skullAnimCounter; // skull animation counter	165	short skullAnimCounter; // skull animation counter
166	short whichSkull; // which skull to draw	166	short whichSkull; // which skull to draw
167		167
168	// graphic name of skulls	168	// graphic name of skulls
169	// warning: initializer-string for array of chars is too long	169	// warning: initializer-string for array of chars is too long
170	char skullName[2][/8/9] = {"M_SKULL1","M_SKULL2"};	170	char skullName[2][/8/9] = {"M_SKULL1","M_SKULL2"};
171		171
172	// current menudef	172	// current menudef
173	menu_t* currentMenu;	173	menu_t* currentMenu;
174		174
175	//	175	//
176	// PROTOTYPES	176	// PROTOTYPES
177	//	177	//
178	void M_NewGame(int choice);	178	void M_NewGame(int choice);
179	void M_Episode(int choice);	179	void M_Episode(int choice);
180	void M_ChooseSkill(int choice);	180	void M_ChooseSkill(int choice);
181	void M_LoadGame(int choice);	181	void M_LoadGame(int choice);
182	void M_SaveGame(int choice);	182	void M_SaveGame(int choice);
183	void M_Options(int choice);	183	void M_Options(int choice);
184	void M_EndGame(int choice);	184	void M_EndGame(int choice);
185	void M_ReadThis(int choice);	185	void M_ReadThis(int choice);
186	void M_ReadThis2(int choice);	186	void M_ReadThis2(int choice);
187	void M_QuitDOOM(int choice);	187	void M_QuitDOOM(int choice);
188		188
189	void M_ChangeMessages(int choice);	189	void M_ChangeMessages(int choice);
190	void M_ChangeSensitivity(int choice);	190	void M_ChangeSensitivity(int choice);
191	void M_SfxVol(int choice);	191	void M_SfxVol(int choice);
192	void M_MusicVol(int choice);	192	void M_MusicVol(int choice);
193	void M_ChangeDetail(int choice);	193	void M_ChangeDetail(int choice);
194	void M_SizeDisplay(int choice);	194	void M_SizeDisplay(int choice);
195	void M_StartGame(int choice);	195	void M_StartGame(int choice);
196	void M_Sound(int choice);	196	void M_Sound(int choice);
197		197
198	void M_FinishReadThis(int choice);	198	void M_FinishReadThis(int choice);
199	void M_LoadSelect(int choice);	199	void M_LoadSelect(int choice);
200	void M_SaveSelect(int choice);	200	void M_SaveSelect(int choice);
201	void M_ReadSaveStrings(void);	201	void M_ReadSaveStrings(void);
202	void M_QuickSave(void);	202	void M_QuickSave(void);
203	void M_QuickLoad(void);	203	void M_QuickLoad(void);
204		204
205	void M_DrawMainMenu(void);	205	void M_DrawMainMenu(void);
206	void M_DrawReadThis1(void);	206	void M_DrawReadThis1(void);
207	void M_DrawReadThis2(void);	207	void M_DrawReadThis2(void);
208	void M_DrawNewGame(void);	208	void M_DrawNewGame(void);
209	void M_DrawEpisode(void);	209	void M_DrawEpisode(void);
210	void M_DrawOptions(void);	210	void M_DrawOptions(void);
211	void M_DrawSound(void);	211	void M_DrawSound(void);
212	void M_DrawLoad(void);	212	void M_DrawLoad(void);
213	void M_DrawSave(void);	213	void M_DrawSave(void);
214		214
215	void M_DrawSaveLoadBorder(int x,int y);	215	void M_DrawSaveLoadBorder(int x,int y);
216	void M_SetupNextMenu(menu_t *menudef);	216	void M_SetupNextMenu(menu_t *menudef);
217	void M_DrawThermo(int x,int y,int thermWidth,int thermDot);	217	void M_DrawThermo(int x,int y,int thermWidth,int thermDot);
218	void M_DrawEmptyCell(menu_t *menu,int item);	218	void M_DrawEmptyCell(menu_t *menu,int item);
219	void M_DrawSelCell(menu_t *menu,int item);	219	void M_DrawSelCell(menu_t *menu,int item);
220	void M_WriteText(int x, int y, char *string);	220	void M_WriteText(int x, int y, char *string);
221	int M_StringWidth(char *string);	221	int M_StringWidth(char *string);
222	int M_StringHeight(char *string);	222	int M_StringHeight(char *string);
223	void M_StartControlPanel(void);	223	void M_StartControlPanel(void);
224	void M_StartMessage(char string,void routine,boolean input);	224	void M_StartMessage(char string,void routine,boolean input);
225	void M_StopMessage(void);	225	void M_StopMessage(void);
226	void M_ClearMenus (void);	226	void M_ClearMenus (void);
227		227
228		228
229		229
230		230
231	//	231	//
232	// DOOM MENU	232	// DOOM MENU
233	//	233	//
234	enum	234	enum
235	{	235	{
236	newgame = 0,	236	newgame = 0,
237	options,	237	options,
238	loadgame,	238	loadgame,
239	savegame,	239	savegame,
240	readthis,	240	readthis,
241	quitdoom,	241	quitdoom,
242	main_end	242	main_end
243	} main_e;	243	} main_e;
244		244
245	menuitem_t MainMenu[]=	245	menuitem_t MainMenu[]=
246	{	246	{
247	{1,"M_NGAME",M_NewGame,'n'},	247	{1,"M_NGAME",M_NewGame,'n'},
248	{1,"M_OPTION",M_Options,'o'},	248	{1,"M_OPTION",M_Options,'o'},
249	{1,"M_LOADG",M_LoadGame,'l'},	249	{1,"M_LOADG",M_LoadGame,'l'},
250	{1,"M_SAVEG",M_SaveGame,'s'},	250	{1,"M_SAVEG",M_SaveGame,'s'},
251	// Another hickup with Special edition.	251	// Another hickup with Special edition.
252	{1,"M_RDTHIS",M_ReadThis,'r'},	252	{1,"M_RDTHIS",M_ReadThis,'r'},
253	{1,"M_QUITG",M_QuitDOOM,'q'}	253	{1,"M_QUITG",M_QuitDOOM,'q'}
254	};	254	};
255		255
256	menu_t MainDef =	256	menu_t MainDef =
257	{	257	{
258	main_end,	258	main_end,
259	NULL,	259	NULL,
260	MainMenu,	260	MainMenu,
261	M_DrawMainMenu,	261	M_DrawMainMenu,
262	97,64,	262	97,64,
263	0	263	0
264	};	264	};
265		265
266		266
267	//	267	//
268	// EPISODE SELECT	268	// EPISODE SELECT
269	//	269	//
270	enum	270	enum
271	{	271	{
272	ep1,	272	ep1,
273	ep2,	273	ep2,
274	ep3,	274	ep3,
275	ep4,	275	ep4,
276	ep_end	276	ep_end
277	} episodes_e;	277	} episodes_e;
278		278
279	menuitem_t EpisodeMenu[]=	279	menuitem_t EpisodeMenu[]=
280	{	280	{
281	{1,"M_EPI1", M_Episode,'k'},	281	{1,"M_EPI1", M_Episode,'k'},
282	{1,"M_EPI2", M_Episode,'t'},	282	{1,"M_EPI2", M_Episode,'t'},
283	{1,"M_EPI3", M_Episode,'i'},	283	{1,"M_EPI3", M_Episode,'i'},
284	{1,"M_EPI4", M_Episode,'t'}	284	{1,"M_EPI4", M_Episode,'t'}
285	};	285	};
286		286
287	menu_t EpiDef =	287	menu_t EpiDef =
288	{	288	{
289	ep_end, // # of menu items	289	ep_end, // # of menu items
290	&MainDef, // previous menu	290	&MainDef, // previous menu
291	EpisodeMenu, // menuitem_t ->	291	EpisodeMenu, // menuitem_t ->
292	M_DrawEpisode, // drawing routine ->	292	M_DrawEpisode, // drawing routine ->
293	48,63, // x,y	293	48,63, // x,y
294	ep1 // lastOn	294	ep1 // lastOn
295	};	295	};
296		296
297	//	297	//
298	// NEW GAME	298	// NEW GAME
299	//	299	//
300	enum	300	enum
301	{	301	{
302	killthings,	302	killthings,
303	toorough,	303	toorough,
304	hurtme,	304	hurtme,
305	violence,	305	violence,
306	nightmare,	306	nightmare,
307	newg_end	307	newg_end
308	} newgame_e;	308	} newgame_e;
309		309
310	menuitem_t NewGameMenu[]=	310	menuitem_t NewGameMenu[]=
311	{	311	{
312	{1,"M_JKILL", M_ChooseSkill, 'i'},	312	{1,"M_JKILL", M_ChooseSkill, 'i'},
313	{1,"M_ROUGH", M_ChooseSkill, 'h'},	313	{1,"M_ROUGH", M_ChooseSkill, 'h'},
314	{1,"M_HURT", M_ChooseSkill, 'h'},	314	{1,"M_HURT", M_ChooseSkill, 'h'},
315	{1,"M_ULTRA", M_ChooseSkill, 'u'},	315	{1,"M_ULTRA", M_ChooseSkill, 'u'},
316	{1,"M_NMARE", M_ChooseSkill, 'n'}	316	{1,"M_NMARE", M_ChooseSkill, 'n'}
317	};	317	};
318		318
319	menu_t NewDef =	319	menu_t NewDef =
320	{	320	{
321	newg_end, // # of menu items	321	newg_end, // # of menu items
322	&EpiDef, // previous menu	322	&EpiDef, // previous menu
323	NewGameMenu, // menuitem_t ->	323	NewGameMenu, // menuitem_t ->
324	M_DrawNewGame, // drawing routine ->	324	M_DrawNewGame, // drawing routine ->
325	48,63, // x,y	325	48,63, // x,y
326	hurtme // lastOn	326	hurtme // lastOn
327	};	327	};
328		328
329		329
330		330
331	//	331	//
332	// OPTIONS MENU	332	// OPTIONS MENU
333	//	333	//
334	enum	334	enum
335	{	335	{
336	endgame,	336	endgame,
337	messages,	337	messages,
338	detail,	338	detail,
339	scrnsize,	339	scrnsize,
340	option_empty1,	340	option_empty1,
341	mousesens,	341	mousesens,
342	option_empty2,	342	option_empty2,
343	soundvol,	343	soundvol,
344	opt_end	344	opt_end
345	} options_e;	345	} options_e;
346		346
347	menuitem_t OptionsMenu[]=	347	menuitem_t OptionsMenu[]=
348	{	348	{
349	{1,"M_ENDGAM", M_EndGame,'e'},	349	{1,"M_ENDGAM", M_EndGame,'e'},
350	{1,"M_MESSG", M_ChangeMessages,'m'},	350	{1,"M_MESSG", M_ChangeMessages,'m'},
351	{1,"M_DETAIL", M_ChangeDetail,'g'},	351	{1,"M_DETAIL", M_ChangeDetail,'g'},
352	{2,"M_SCRNSZ", M_SizeDisplay,'s'},	352	{2,"M_SCRNSZ", M_SizeDisplay,'s'},
353	{-1,"",0},	353	{-1,"",0},
354	{2,"M_MSENS", M_ChangeSensitivity,'m'},	354	{2,"M_MSENS", M_ChangeSensitivity,'m'},
355	{-1,"",0},	355	{-1,"",0},
356	{1,"M_SVOL", M_Sound,'s'}	356	{1,"M_SVOL", M_Sound,'s'}
357	};	357	};
358		358
359	menu_t OptionsDef =	359	menu_t OptionsDef =
360	{	360	{
361	opt_end,	361	opt_end,
362	&MainDef,	362	&MainDef,
363	OptionsMenu,	363	OptionsMenu,
364	M_DrawOptions,	364	M_DrawOptions,
365	60,37,	365	60,37,
366	0	366	0
367	};	367	};
368		368
369	//	369	//
370	// Read This! MENU 1 & 2	370	// Read This! MENU 1 & 2
371	//	371	//
372	enum	372	enum
373	{	373	{
374	rdthsempty1,	374	rdthsempty1,
375	read1_end	375	read1_end
376	} read_e;	376	} read_e;
377		377
378	menuitem_t ReadMenu1[] =	378	menuitem_t ReadMenu1[] =
379	{	379	{
380	{1,"",M_ReadThis2,0}	380	{1,"",M_ReadThis2,0}
381	};	381	};
382		382
383	menu_t ReadDef1 =	383	menu_t ReadDef1 =
384	{	384	{
385	read1_end,	385	read1_end,
386	&MainDef,	386	&MainDef,
387	ReadMenu1,	387	ReadMenu1,
388	M_DrawReadThis1,	388	M_DrawReadThis1,
389	280,185,	389	280,185,
390	0	390	0
391	};	391	};
392		392
393	enum	393	enum
394	{	394	{
395	rdthsempty2,	395	rdthsempty2,
396	read2_end	396	read2_end
397	} read_e2;	397	} read_e2;
398		398
399	menuitem_t ReadMenu2[]=	399	menuitem_t ReadMenu2[]=
400	{	400	{
401	{1,"",M_FinishReadThis,0}	401	{1,"",M_FinishReadThis,0}
402	};	402	};
403		403
404	menu_t ReadDef2 =	404	menu_t ReadDef2 =
405	{	405	{
406	read2_end,	406	read2_end,
407	&ReadDef1,	407	&ReadDef1,
408	ReadMenu2,	408	ReadMenu2,
409	M_DrawReadThis2,	409	M_DrawReadThis2,
410	330,175,	410	330,175,
411	0	411	0
412	};	412	};
413		413
414	//	414	//
415	// SOUND VOLUME MENU	415	// SOUND VOLUME MENU
416	//	416	//
417	enum	417	enum
418	{	418	{
419	sfx_vol,	419	sfx_vol,
420	sfx_empty1,	420	sfx_empty1,
421	music_vol,	421	music_vol,
422	sfx_empty2,	422	sfx_empty2,
423	sound_end	423	sound_end
424	} sound_e;	424	} sound_e;
425		425
426	menuitem_t SoundMenu[]=	426	menuitem_t SoundMenu[]=
427	{	427	{
428	{2,"M_SFXVOL",M_SfxVol,'s'},	428	{2,"M_SFXVOL",M_SfxVol,'s'},
429	{-1,"",0},	429	{-1,"",0},
430	{2,"M_MUSVOL",M_MusicVol,'m'},	430	{2,"M_MUSVOL",M_MusicVol,'m'},
431	{-1,"",0}	431	{-1,"",0}
432	};	432	};
433		433
434	menu_t SoundDef =	434	menu_t SoundDef =
435	{	435	{
436	sound_end,	436	sound_end,
437	&OptionsDef,	437	&OptionsDef,
438	SoundMenu,	438	SoundMenu,
439	M_DrawSound,	439	M_DrawSound,
440	80,64,	440	80,64,
441	0	441	0
442	};	442	};
443		443
444	//	444	//
445	// LOAD GAME MENU	445	// LOAD GAME MENU
446	//	446	//
447	enum	447	enum
448	{	448	{
449	load1,	449	load1,
450	load2,	450	load2,
451	load3,	451	load3,
452	load4,	452	load4,
453	load5,	453	load5,
454	load6,	454	load6,
455	load_end	455	load_end
456	} load_e;	456	} load_e;
457		457
458	menuitem_t LoadMenu[]=	458	menuitem_t LoadMenu[]=
459	{	459	{
460	{1,"", M_LoadSelect,'1'},	460	{1,"", M_LoadSelect,'1'},
461	{1,"", M_LoadSelect,'2'},	461	{1,"", M_LoadSelect,'2'},
462	{1,"", M_LoadSelect,'3'},	462	{1,"", M_LoadSelect,'3'},
463	{1,"", M_LoadSelect,'4'},	463	{1,"", M_LoadSelect,'4'},
464	{1,"", M_LoadSelect,'5'},	464	{1,"", M_LoadSelect,'5'},
465	{1,"", M_LoadSelect,'6'}	465	{1,"", M_LoadSelect,'6'}
466	};	466	};
467		467
468	menu_t LoadDef =	468	menu_t LoadDef =
469	{	469	{
470	load_end,	470	load_end,
471	&MainDef,	471	&MainDef,
472	LoadMenu,	472	LoadMenu,
473	M_DrawLoad,	473	M_DrawLoad,
474	80,54,	474	80,54,
475	0	475	0
476	};	476	};
477		477
478	//	478	//
479	// SAVE GAME MENU	479	// SAVE GAME MENU
480	//	480	//
481	menuitem_t SaveMenu[]=	481	menuitem_t SaveMenu[]=
482	{	482	{
483	{1,"", M_SaveSelect,'1'},	483	{1,"", M_SaveSelect,'1'},
484	{1,"", M_SaveSelect,'2'},	484	{1,"", M_SaveSelect,'2'},
485	{1,"", M_SaveSelect,'3'},	485	{1,"", M_SaveSelect,'3'},
486	{1,"", M_SaveSelect,'4'},	486	{1,"", M_SaveSelect,'4'},
487	{1,"", M_SaveSelect,'5'},	487	{1,"", M_SaveSelect,'5'},
488	{1,"", M_SaveSelect,'6'}	488	{1,"", M_SaveSelect,'6'}
489	};	489	};
490		490
491	menu_t SaveDef =	491	menu_t SaveDef =
492	{	492	{
493	load_end,	493	load_end,
494	&MainDef,	494	&MainDef,
495	SaveMenu,	495	SaveMenu,
496	M_DrawSave,	496	M_DrawSave,
497	80,54,	497	80,54,
498	0	498	0
499	};	499	};
500		500

Subversion Repositories Kolibri OS

(root)/programs/games/doom/trunk/m_menu.c – Rev 300 → 550