id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-12-02 08:51:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
doom3-bfg/doomclassic/doom/m_menu.cpp

1708 lines
32 KiB
C++
Raw Normal View History

Initial commit
2012-11-26 18:58:24 +00:00
/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "Precompiled.h"
#include "globaldata.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <ctype.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 "m_misc.h"
#include "r_local.h"
#include "hu_stuff.h"
#include "g_game.h"
#include "m_argv.h"
#include "m_swap.h"
#include "s_sound.h"
#include "doomstat.h"
// Data.
#include "sounds.h"
#include "m_menu.h"
#include "Main.h"
//#include "../game/player/PlayerProfileDoom.h"
#include "sys/sys_session.h"
#include "sys/sys_signin.h"
#include "d3xp/Game_local.h"
extern idCVar in_useJoystick;
//
// defaulted values
//
// Show messages has default, 0 = off, 1 = on
// Blocky mode, has default, 0 = high, 1 = normal
// temp for ::g->screenblocks (0-9)
// -1 = no quicksave slot picked!
// 1 = message to be printed
// ...and here is the message string!
// message x & y
// timed message = no input from user
const char gammamsg[5][26] =
{
GAMMALVL0,
GAMMALVL1,
GAMMALVL2,
GAMMALVL3,
GAMMALVL4
};
// we are going to be entering a savegame string
// old save description before edit
//
// MENU TYPEDEFS
//
// 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
//
// PROTOTYPES
//
void M_NewGame(int choice);
void M_Episode(int choice);
void M_Expansion(int choice);
void M_ChooseSkill(int choice);
void M_LoadGame(int choice);
void M_LoadExpansion(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_ExitGame(int choice);
void M_GameSelection(int choice);
void M_CancelExit(int choice);
void M_ChangeMessages(int choice);
void M_ChangeGPad(int choice);
void M_FullScreen(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_DrawQuit(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);
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
void M_WriteText(int x, int y, const char *string);
int M_StringWidth(const char *string);
int M_StringHeight(const char *string);
Initial commit
2012-11-26 18:58:24 +00:00
void M_StartControlPanel(void);
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
void M_StartMessage(const char *string,messageRoutine_t routine,qboolean input);
Initial commit
2012-11-26 18:58:24 +00:00
void M_StopMessage(void);
void M_ClearMenus (void);
//
// DOOM MENU
//
//
// EPISODE SELECT
//
//
// NEW GAME
//
//
// OPTIONS MENU
//
//
// Read This! MENU 1 & 2
//
//
// SOUND VOLUME MENU
//
//
// LOAD GAME MENU
//
//
// SAVE GAME MENU
//
//
// M_ReadSaveStrings
// read the strings from the savegame files
//
void M_ReadSaveStrings(void)
{
idFile* handle;
int count;
int i;
char name[256];
for (i = 0;i < load_end;i++)
{
if( common->GetCurrentGame() == DOOM_CLASSIC ) {
sprintf(name,"DOOM\\%s%d.dsg", SAVEGAMENAME,i );
} else {
if( DoomLib::idealExpansion == doom2 ) {
sprintf(name,"DOOM2\\%s%d.dsg", SAVEGAMENAME,i );
} else {
sprintf(name,"DOOM2_NRFTL\\%s%d.dsg", SAVEGAMENAME,i );
}
}
handle = fileSystem->OpenFileRead ( name, false );
if (handle == NULL)
{
strcpy(&::g->savegamestrings[i][0],EMPTYSTRING);
::g->LoadMenu[i].status = 0;
continue;
}
count = handle->Read( &::g->savegamestrings[i], SAVESTRINGSIZE );
fileSystem->CloseFile( handle );
strcpy( ::g->savegamepaths[i], name );
::g->LoadMenu[i].status = 1;
}
}
//
// M_LoadGame & Cie.
//
void M_DrawLoad(void)
{
int i;
V_DrawPatchDirect (72,28,0,(patch_t*)W_CacheLumpName("M_LOADG",PU_CACHE_SHARED));
for (i = 0;i < load_end; i++)
{
M_DrawSaveLoadBorder(::g->LoadDef.x,::g->LoadDef.y+LINEHEIGHT*i);
M_WriteText(::g->LoadDef.x,::g->LoadDef.y+LINEHEIGHT*i,::g->savegamestrings[i]);
}
}
//
// Draw border for the savegame description
//
void M_DrawSaveLoadBorder(int x,int y)
{
int i;
V_DrawPatchDirect (x-8,y+7,0,(patch_t*)W_CacheLumpName("M_LSLEFT",PU_CACHE_SHARED));
for (i = 0;i < 28;i++)
{
V_DrawPatchDirect (x,y+7,0,(patch_t*)W_CacheLumpName("M_LSCNTR",PU_CACHE_SHARED));
x += 8;
}
V_DrawPatchDirect (x,y+7,0,(patch_t*)W_CacheLumpName("M_LSRGHT",PU_CACHE_SHARED));
}
//
// User wants to load this game
//
void M_LoadSelect(int choice)
{
if( ::g->gamemode != commercial ) {
G_LoadGame ( ::g->savegamepaths[ choice ] );
} else {
strcpy( DoomLib::loadGamePath, ::g->savegamepaths[ choice ] );
DoomLib::SetCurrentExpansion( DoomLib::idealExpansion );
DoomLib::skipToLoad = true;
}
M_ClearMenus ();
}
void M_LoadExpansion(int choice)
{
::g->exp = choice;
if( choice == 0 ) {
DoomLib::SetIdealExpansion( doom2 );
}else {
DoomLib::SetIdealExpansion( pack_nerve );
}
M_SetupNextMenu(&::g->LoadDef);
M_ReadSaveStrings();
}
//
// Selected from DOOM menu
//
void M_LoadGame (int choice)
{
if (::g->netgame)
{
M_StartMessage(LOADNET,NULL,false);
return;
}
if (::g->gamemode == commercial) {
M_SetupNextMenu(&::g->LoadExpDef);
} else{
M_SetupNextMenu(&::g->LoadDef);
M_ReadSaveStrings();
}
}
//
// M_SaveGame & Cie.
//
void M_DrawSave(void)
{
int i;
V_DrawPatchDirect (72,28,0,(patch_t*)W_CacheLumpName("M_SAVEG",PU_CACHE_SHARED));
for (i = 0;i < load_end; i++)
{
M_DrawSaveLoadBorder(::g->LoadDef.x,::g->LoadDef.y+LINEHEIGHT*i);
M_WriteText(::g->LoadDef.x,::g->LoadDef.y+LINEHEIGHT*i,::g->savegamestrings[i]);
}
if (::g->saveStringEnter)
{
i = M_StringWidth(::g->savegamestrings[::g->saveSlot]);
M_WriteText(::g->LoadDef.x + i,::g->LoadDef.y+LINEHEIGHT*::g->saveSlot,"_");
}
}
//
// M_Responder calls this when user is finished
//
void M_DoSave(int slot)
{
G_SaveGame (slot,::g->savegamestrings[slot]);
M_ClearMenus ();
// PICK QUICKSAVE SLOT YET?
if (::g->quickSaveSlot == -2)
::g->quickSaveSlot = slot;
}
//
// User wants to save. Start string input for M_Responder
//
//
// Locally used constants, shortcuts.
//
extern const char* mapnames[];
extern const char* mapnames2[];
void M_SaveSelect(int choice)
{
const char* s;
const ExpansionData* exp = DoomLib::GetCurrentExpansion();
switch ( ::g->gamemode )
{
case shareware:
case registered:
case retail:
s = (exp->mapNames[(::g->gameepisode-1)*9+::g->gamemap-1]);
break;
case commercial:
default:
s = (exp->mapNames[::g->gamemap-1]);
break;
}
::g->saveSlot = choice;
strcpy(::g->savegamestrings[::g->saveSlot], s);
M_DoSave(::g->saveSlot);
}
//
// Selected from DOOM menu
//
void M_SaveGame (int choice)
{
if (!::g->usergame)
{
M_StartMessage(SAVEDEAD,NULL,false);
return;
}
else if( ::g->plyr && ::g->plyr->mo && ::g->plyr->mo->health <= 0 ) {
M_StartMessage("you can't save if you're dead!\n\npress any button",NULL,false);
return;
}
if (::g->gamestate != GS_LEVEL)
return;
// Reset back to what expansion we are currently playing.
DoomLib::SetIdealExpansion( DoomLib::expansionSelected );
M_SetupNextMenu(&::g->SaveDef);
M_ReadSaveStrings();
}
//
// M_QuickSave
//
void M_QuickSaveResponse(int ch)
{
if (ch == KEY_ENTER)
{
M_DoSave(::g->quickSaveSlot);
S_StartSound(NULL,sfx_swtchx);
}
}
void M_QuickSave(void)
{
if (!::g->usergame)
{
S_StartSound(NULL,sfx_oof);
return;
}
if (::g->gamestate != GS_LEVEL)
return;
if (::g->quickSaveSlot < 0)
{
M_StartControlPanel();
M_ReadSaveStrings();
M_SetupNextMenu(&::g->SaveDef);
::g->quickSaveSlot = -2; // means to pick a slot now
return;
}
sprintf(::g->tempstring,QSPROMPT,::g->savegamestrings[::g->quickSaveSlot]);
M_StartMessage(::g->tempstring,M_QuickSaveResponse,true);
}
//
// M_QuickLoad
//
void M_QuickLoadResponse(int ch)
{
if (ch == KEY_ENTER)
{
M_LoadSelect(::g->quickSaveSlot);
S_StartSound(NULL,sfx_swtchx);
}
}
void M_QuickLoad(void)
{
if (::g->netgame)
{
M_StartMessage(QLOADNET,NULL,false);
return;
}
if (::g->quickSaveSlot < 0)
{
M_StartMessage(QSAVESPOT,NULL,false);
return;
}
sprintf(::g->tempstring,QLPROMPT,::g->savegamestrings[::g->quickSaveSlot]);
M_StartMessage(::g->tempstring,M_QuickLoadResponse,true);
}
//
// Read This Menus
// Had a "quick hack to fix romero bug"
//
void M_DrawReadThis1(void)
{
::g->inhelpscreens = true;
switch ( ::g->gamemode )
{
case commercial:
V_DrawPatchDirect (0,0,0,(patch_t*)W_CacheLumpName("HELP",PU_CACHE_SHARED));
break;
case shareware:
case registered:
case retail:
V_DrawPatchDirect (0,0,0,(patch_t*)W_CacheLumpName("HELP1",PU_CACHE_SHARED));
break;
default:
break;
}
return;
}
//
// Read This Menus - optional second page.
//
void M_DrawReadThis2(void)
{
::g->inhelpscreens = true;
switch ( ::g->gamemode )
{
case retail:
case commercial:
// This hack keeps us from having to change menus.
V_DrawPatchDirect (0,0,0,(patch_t*)W_CacheLumpName("CREDIT",PU_CACHE_SHARED));
break;
case shareware:
case registered:
V_DrawPatchDirect (0,0,0,(patch_t*)W_CacheLumpName("HELP2",PU_CACHE_SHARED));
break;
default:
break;
}
return;
}
//
// Change Sfx & Music volumes
//
void M_DrawSound(void)
{
V_DrawPatchDirect (60,38,0,(patch_t*)W_CacheLumpName("M_SVOL",PU_CACHE_SHARED));
M_DrawThermo( ::g->SoundDef.x,::g->SoundDef.y+LINEHEIGHT*(sfx_vol+1),
16, s_volume_sound.GetInteger() );
M_DrawThermo(::g->SoundDef.x,::g->SoundDef.y+LINEHEIGHT*(music_vol+1),
16, s_volume_midi.GetInteger() );
}
void M_Sound(int choice)
{
M_SetupNextMenu(&::g->SoundDef);
}
void M_SfxVol(int choice)
{
switch(choice)
{
case 0:
s_volume_sound.SetInteger( s_volume_sound.GetInteger() - 1 );
break;
case 1:
s_volume_sound.SetInteger( s_volume_sound.GetInteger() + 1 );
break;
}
S_SetSfxVolume( s_volume_sound.GetInteger() );
}
void M_MusicVol(int choice)
{
switch(choice)
{
case 0:
s_volume_midi.SetInteger( s_volume_midi.GetInteger() - 1 );
break;
case 1:
s_volume_midi.SetInteger( s_volume_midi.GetInteger() + 1 );
break;
}
S_SetMusicVolume( s_volume_midi.GetInteger() );
}
//
// M_DrawMainMenu
//
void M_DrawMainMenu(void)
{
V_DrawPatchDirect (94,2,0,(patch_t*)W_CacheLumpName("M_DOOM",PU_CACHE_SHARED));
}
//
// M_DrawQuit
//
void M_DrawQuit(void) {
V_DrawPatchDirect (54,38,0,(patch_t*)W_CacheLumpName("M_EXITO",PU_CACHE_SHARED));
}
//
// M_NewGame
//
void M_DrawNewGame(void)
{
V_DrawPatchDirect (96,14,0,(patch_t*)W_CacheLumpName("M_NEWG",PU_CACHE_SHARED));
V_DrawPatchDirect (54,38,0,(patch_t*)W_CacheLumpName("M_SKILL",PU_CACHE_SHARED));
}
void M_NewGame(int choice)
{
if (::g->netgame && !::g->demoplayback)
{
M_StartMessage(NEWGAME,NULL,false);
return;
}
if ( ::g->gamemode == commercial )
M_SetupNextMenu(&::g->ExpDef);
else
M_SetupNextMenu(&::g->EpiDef);
}
//
// M_Episode
//
void M_DrawEpisode(void)
{
V_DrawPatchDirect (54,38,0,(patch_t*)W_CacheLumpName("M_EPISOD",PU_CACHE_SHARED));
}
void M_VerifyNightmare(int ch)
{
if (ch != KEY_ENTER)
return;
G_DeferedInitNew((skill_t)nightmare,::g->epi+1, 1);
M_ClearMenus ();
}
void M_ChooseSkill(int choice)
{
/*
if (choice == nightmare)
{
M_StartMessage(NIGHTMARE,M_VerifyNightmare,true);
return;
}
*/
if ( ::g->gamemode != commercial ) {
static int startLevel = 1;
G_DeferedInitNew((skill_t)choice,::g->epi+1, startLevel);
M_ClearMenus ();
} else {
DoomLib::SetCurrentExpansion( DoomLib::idealExpansion );
DoomLib::skipToNew = true;
DoomLib::chosenSkill = choice;
DoomLib::chosenEpisode = ::g->epi+1;
}
}
void M_Episode(int choice)
{
// Yet another hack...
if ( (::g->gamemode == registered)
&& (choice > 2))
{
I_PrintfE("M_Episode: 4th episode requires UltimateDOOM\n");
choice = 0;
}
::g->epi = choice;
M_SetupNextMenu(&::g->NewDef);
}
void M_Expansion(int choice)
{
::g->exp = choice;
if( choice == 0 ) {
DoomLib::SetIdealExpansion( doom2 );
}else {
DoomLib::SetIdealExpansion( pack_nerve );
}
M_SetupNextMenu(&::g->NewDef);
}
//
// M_Options
//
char detailNames[2][9] =
{
"M_GDHIGH","M_GDLOW"
};
char msgNames[2][9] =
{
"M_MSGOFF","M_MSGON"
};
int M_GetMouseSpeedForMenu( float cvarValue ) {
const float shiftedMouseSpeed = cvarValue - 0.25f;
const float normalizedMouseSpeed = shiftedMouseSpeed / ( 4.0f - 0.25 );
const float scaledMouseSpeed = normalizedMouseSpeed * 15.0f;
const int roundedMouseSpeed = static_cast< int >( scaledMouseSpeed + 0.5f );
return roundedMouseSpeed;
}
void M_DrawOptions(void)
{
V_DrawPatchDirect (108,15,0,(patch_t*)W_CacheLumpName("M_OPTTTL",PU_CACHE_SHARED));
//V_DrawPatchDirect (::g->OptionsDef.x + 175,::g->OptionsDef.y+LINEHEIGHT*detail,0,
// (patch_t*)W_CacheLumpName(detailNames[::g->detailLevel],PU_CACHE_SHARED));
int fullscreenOnOff = r_fullscreen.GetInteger() >= 1 ? 1 : 0;
V_DrawPatchDirect (::g->OptionsDef.x + 150,::g->OptionsDef.y+LINEHEIGHT*endgame,0,
(patch_t*)W_CacheLumpName(msgNames[fullscreenOnOff],PU_CACHE_SHARED));
V_DrawPatchDirect (::g->OptionsDef.x + 120,::g->OptionsDef.y+LINEHEIGHT*scrnsize,0,
(patch_t*)W_CacheLumpName(msgNames[in_useJoystick.GetInteger()],PU_CACHE_SHARED));
V_DrawPatchDirect (::g->OptionsDef.x + 120,::g->OptionsDef.y+LINEHEIGHT*messages,0,
(patch_t*)W_CacheLumpName(msgNames[m_show_messages.GetInteger()],PU_CACHE_SHARED));
extern idCVar in_mouseSpeed;
const int roundedMouseSpeed = M_GetMouseSpeedForMenu( in_mouseSpeed.GetFloat() );
M_DrawThermo( ::g->OptionsDef.x, ::g->OptionsDef.y + LINEHEIGHT * ( mousesens + 1 ), 16, roundedMouseSpeed );
//M_DrawThermo(::g->OptionsDef.x,::g->OptionsDef.y+LINEHEIGHT*(scrnsize+1),
// 9,::g->screenSize);
}
void M_Options(int choice)
{
M_SetupNextMenu(&::g->OptionsDef);
}
//
// Toggle messages on/off
//
void M_ChangeMessages(int choice)
{
// warning: unused parameter `int choice'
choice = 0;
m_show_messages.SetBool( !m_show_messages.GetBool() );
if (!m_show_messages.GetBool())
::g->players[::g->consoleplayer].message = MSGOFF;
else
::g->players[::g->consoleplayer].message = MSGON ;
::g->message_dontfuckwithme = true;
}
//
// Toggle messages on/off
//
void M_ChangeGPad(int choice)
{
// warning: unused parameter `int choice'
choice = 0;
in_useJoystick.SetBool( !in_useJoystick.GetBool() );
::g->message_dontfuckwithme = true;
}
//
// Toggle Fullscreen
//
void M_FullScreen( int choice ) {
r_fullscreen.SetInteger( r_fullscreen.GetInteger() ? 0: 1 );
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "vid_restart\n" );
}
//
// M_EndGame
//
void M_EndGameResponse(int ch)
{
if (ch != KEY_ENTER)
return;
::g->currentMenu->lastOn = ::g->itemOn;
M_ClearMenus ();
D_StartTitle ();
}
void M_EndGame(int choice)
{
choice = 0;
if (!::g->usergame)
{
S_StartSound(NULL,sfx_oof);
return;
}
if (::g->netgame)
{
M_StartMessage(NETEND,NULL,false);
return;
}
M_StartMessage(ENDGAME,M_EndGameResponse,true);
}
//
// M_ReadThis
//
void M_ReadThis(int choice)
{
}
void M_ReadThis2(int choice)
{
}
void M_FinishReadThis(int choice)
{
choice = 0;
M_SetupNextMenu(&::g->MainDef);
}
//
// M_QuitDOOM
//
void M_QuitResponse(int ch)
{
// Exceptions disabled by default on PS3
//throw "";
}
void M_QuitDOOM(int choice)
{
M_SetupNextMenu(&::g->QuitDef);
//M_StartMessage("are you sure?\npress A to quit, or B to cancel",M_QuitResponse,true);
//common->SwitchToGame( DOOM3_BFG );
}
void M_ExitGame(int choice)
{
common->Quit();
}
void M_CancelExit(int choice) {
M_SetupNextMenu(&::g->MainDef);
}
void M_GameSelection(int choice)
{
common->SwitchToGame( DOOM3_BFG );
}
void M_ChangeSensitivity(int choice)
{
extern idCVar in_mouseSpeed;
int roundedMouseSpeed = M_GetMouseSpeedForMenu( in_mouseSpeed.GetFloat() );
switch(choice)
{
case 0:
if ( roundedMouseSpeed > 0 ) {
roundedMouseSpeed--;
}
break;
case 1:
if ( roundedMouseSpeed < 15 ) {
roundedMouseSpeed++;
}
break;
}
const float normalizedNewMouseSpeed = roundedMouseSpeed / 15.0f;
const float rescaledNewMouseSpeed = 0.25f + ( ( 4.0f - 0.25 ) * normalizedNewMouseSpeed );
in_mouseSpeed.SetFloat( rescaledNewMouseSpeed );
}
void M_ChangeDetail(int choice)
{
choice = 0;
::g->detailLevel = 1 - ::g->detailLevel;
// FIXME - does not work. Remove anyway?
I_PrintfE("M_ChangeDetail: low detail mode n.a.\n");
return;
/*R_SetViewSize (::g->screenblocks, ::g->detailLevel);
if (!::g->detailLevel)
::g->players[::g->consoleplayer].message = DETAILHI;
else
::g->players[::g->consoleplayer].message = DETAILLO;*/
}
void M_SizeDisplay(int choice)
{
switch(choice)
{
case 0:
if (::g->screenSize > 7)
{
::g->screenblocks--;
::g->screenSize--;
}
break;
case 1:
if (::g->screenSize < 8)
{
::g->screenblocks++;
::g->screenSize++;
}
break;
}
R_SetViewSize (::g->screenblocks, ::g->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,(patch_t*)W_CacheLumpName("M_THERML",PU_CACHE_SHARED));
xx += 8;
for (i=0;i<thermWidth;i++)
{
V_DrawPatchDirect (xx,y,0,(patch_t*)W_CacheLumpName("M_THERMM",PU_CACHE_SHARED));
xx += 8;
}
V_DrawPatchDirect (xx,y,0,(patch_t*)W_CacheLumpName("M_THERMR",PU_CACHE_SHARED));
V_DrawPatchDirect ((x+8) + thermDot*8,y,
0,(patch_t*)W_CacheLumpName("M_THERMO",PU_CACHE_SHARED));
}
void
M_DrawEmptyCell
( menu_t* menu,
int item )
{
V_DrawPatchDirect (menu->x - 10, menu->y+item*LINEHEIGHT - 1, 0,
(patch_t*)W_CacheLumpName("M_CELL1",PU_CACHE_SHARED));
}
void
M_DrawSelCell
( menu_t* menu,
int item )
{
V_DrawPatchDirect (menu->x - 10, menu->y+item*LINEHEIGHT - 1, 0,
(patch_t*)W_CacheLumpName("M_CELL2",PU_CACHE_SHARED));
}
void
M_StartMessage
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
( const char* string,
Initial commit
2012-11-26 18:58:24 +00:00
messageRoutine_t routine,
qboolean input )
{
::g->messageLastMenuActive = ::g->menuactive;
::g->messageToPrint = 1;
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
::g->messageString = (char *)string;
Initial commit
2012-11-26 18:58:24 +00:00
::g->messageRoutine = (messageRoutine_t)routine;
::g->messageNeedsInput = input;
::g->menuactive = true;
return;
}
void M_StopMessage(void)
{
::g->menuactive = ::g->messageLastMenuActive;
::g->messageToPrint = 0;
}
//
// Find string width from ::g->hu_font chars
//
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
int M_StringWidth(const char* string)
Initial commit
2012-11-26 18:58:24 +00:00
{
unsigned 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 (::g->hu_font[c]->width);
}
return w;
}
//
// Find string height from ::g->hu_font chars
//
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
int M_StringHeight(const char* string)
Initial commit
2012-11-26 18:58:24 +00:00
{
unsigned int i;
int h;
int height = SHORT(::g->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 ::g->hu_font
//
void
M_WriteText
( int x,
int y,
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
const char* string)
Initial commit
2012-11-26 18:58:24 +00:00
{
int w;
Fixed doomclassic compiler warnings
2013-11-16 15:22:42 +00:00
const char* ch;
Initial commit
2012-11-26 18:58:24 +00:00
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 (::g->hu_font[c]->width);
if (cx+w > SCREENWIDTH)
break;
V_DrawPatchDirect(cx, cy, 0, ::g->hu_font[c]);
cx+=w;
}
}
//
// CONTROL PANEL
//
//
// M_Responder
//
qboolean M_Responder (event_t* ev)
{
int ch;
int i;
ch = -1;
if (ev->type == ev_joystick && ::g->joywait < I_GetTime())
{
if (ev->data3 == -1)
{
ch = KEY_UPARROW;
::g->joywait = I_GetTime() + 5;
}
else if (ev->data3 == 1)
{
ch = KEY_DOWNARROW;
::g->joywait = I_GetTime() + 5;
}
if (ev->data2 == -1)
{
ch = KEY_LEFTARROW;
::g->joywait = I_GetTime() + 2;
}
else if (ev->data2 == 1)
{
ch = KEY_RIGHTARROW;
::g->joywait = I_GetTime() + 2;
}
if (ev->data1&1)
{
ch = KEY_ENTER;
::g->joywait = I_GetTime() + 5;
}
if (ev->data1&2)
{
ch = KEY_BACKSPACE;
::g->joywait = I_GetTime() + 5;
}
}
else
{
if (ev->type == ev_mouse && ::g->mousewait < I_GetTime())
{
::g->mmenu_mousey += ev->data3;
if (::g->mmenu_mousey < ::g->lasty-30)
{
ch = KEY_DOWNARROW;
::g->mousewait = I_GetTime() + 5;
::g->mmenu_mousey = ::g->lasty -= 30;
}
else if (::g->mmenu_mousey > ::g->lasty+30)
{
ch = KEY_UPARROW;
::g->mousewait = I_GetTime() + 5;
::g->mmenu_mousey = ::g->lasty += 30;
}
::g->mmenu_mousex += ev->data2;
if (::g->mmenu_mousex < ::g->lastx-30)
{
ch = KEY_LEFTARROW;
::g->mousewait = I_GetTime() + 5;
::g->mmenu_mousex = ::g->lastx -= 30;
}
else if (::g->mmenu_mousex > ::g->lastx+30)
{
ch = KEY_RIGHTARROW;
::g->mousewait = I_GetTime() + 5;
::g->mmenu_mousex = ::g->lastx += 30;
}
if (ev->data1&1)
{
ch = KEY_ENTER;
::g->mousewait = I_GetTime() + 15;
}
if (ev->data1&2)
{
ch = KEY_BACKSPACE;
::g->mousewait = I_GetTime() + 15;
}
} else
if (ev->type == ev_keydown)
{
ch = ev->data1;
}
}
if (ch == -1)
return false;
// Save Game string input
if (::g->saveStringEnter)
{
switch(ch)
{
case KEY_BACKSPACE:
if (::g->saveCharIndex > 0)
{
::g->saveCharIndex--;
::g->savegamestrings[::g->saveSlot][::g->saveCharIndex] = 0;
}
break;
case KEY_ESCAPE:
::g->saveStringEnter = 0;
strcpy(&::g->savegamestrings[::g->saveSlot][0],::g->saveOldString);
break;
case KEY_ENTER:
::g->saveStringEnter = 0;
if (::g->savegamestrings[::g->saveSlot][0])
M_DoSave(::g->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 &&
::g->saveCharIndex < SAVESTRINGSIZE-1 &&
M_StringWidth(::g->savegamestrings[::g->saveSlot]) <
(SAVESTRINGSIZE-2)*8)
{
::g->savegamestrings[::g->saveSlot][::g->saveCharIndex++] = ch;
::g->savegamestrings[::g->saveSlot][::g->saveCharIndex] = 0;
}
break;
}
return true;
}
// Take care of any messages that need input
if (::g->messageToPrint)
{
if (::g->messageNeedsInput == true &&
!(ch == KEY_ENTER || ch == KEY_BACKSPACE || ch == KEY_ESCAPE))
return false;
::g->menuactive = ::g->messageLastMenuActive;
::g->messageToPrint = 0;
if (::g->messageRoutine)
::g->messageRoutine(ch);
S_StartSound(NULL,sfx_swtchx);
return true;
}
/*
if (::g->devparm && ch == KEY_F1)
{
G_ScreenShot ();
return true;
}
// F-Keys
if (!::g->menuactive)
switch(ch)
{
case KEY_MINUS: // Screen size down
if (::g->automapactive || ::g->chat_on)
return false;
//M_SizeDisplay(0);
S_StartSound(NULL,sfx_stnmov);
return true;
case KEY_EQUALS: // Screen size up
if (::g->automapactive || ::g->chat_on)
return false;
//M_SizeDisplay(1);
S_StartSound(NULL,sfx_stnmov);
return true;
case KEY_F1: // Help key
M_StartControlPanel ();
if ( ::g->gamemode == retail )
::g->currentMenu = &::g->ReadDef2;
else
::g->currentMenu = &::g->ReadDef1;
::g->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 ();
::g->currentMenu = &::g->SoundDef;
::g->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
::g->usegamma++;
if (::g->usegamma > 4)
::g->usegamma = 0;
::g->players[::g->consoleplayer].message = gammamsg[::g->usegamma];
I_SetPalette ((byte*)W_CacheLumpName ("PLAYPAL",PU_CACHE_SHARED));
return true;
}
*/
// Pop-up menu?
if (!::g->menuactive)
{
if (ch == KEY_ESCAPE && ( ::g->gamestate == GS_LEVEL || ::g->gamestate == GS_INTERMISSION || ::g->gamestate == GS_FINALE ) )
{
M_StartControlPanel ();
S_StartSound(NULL,sfx_swtchn);
return true;
}
return false;
}
// Keys usable within menu
switch (ch)
{
case KEY_DOWNARROW:
do
{
if (::g->itemOn+1 > ::g->currentMenu->numitems-1)
::g->itemOn = 0;
else ::g->itemOn++;
S_StartSound(NULL,sfx_pstop);
} while(::g->currentMenu->menuitems[::g->itemOn].status==-1);
return true;
case KEY_UPARROW:
do
{
if (!::g->itemOn)
::g->itemOn = ::g->currentMenu->numitems-1;
else ::g->itemOn--;
S_StartSound(NULL,sfx_pstop);
} while(::g->currentMenu->menuitems[::g->itemOn].status==-1);
return true;
case KEY_LEFTARROW:
if (::g->currentMenu->menuitems[::g->itemOn].routine &&
::g->currentMenu->menuitems[::g->itemOn].status == 2)
{
S_StartSound(NULL,sfx_stnmov);
::g->currentMenu->menuitems[::g->itemOn].routine(0);
}
return true;
case KEY_RIGHTARROW:
if (::g->currentMenu->menuitems[::g->itemOn].routine &&
::g->currentMenu->menuitems[::g->itemOn].status == 2)
{
S_StartSound(NULL,sfx_stnmov);
::g->currentMenu->menuitems[::g->itemOn].routine(1);
}
return true;
case KEY_ENTER:
if (::g->currentMenu->menuitems[::g->itemOn].routine &&
::g->currentMenu->menuitems[::g->itemOn].status)
{
::g->currentMenu->lastOn = ::g->itemOn;
if (::g->currentMenu->menuitems[::g->itemOn].status == 2)
{
::g->currentMenu->menuitems[::g->itemOn].routine(1); // right arrow
S_StartSound(NULL,sfx_stnmov);
}
else
{
::g->currentMenu->menuitems[::g->itemOn].routine(::g->itemOn);
S_StartSound(NULL,sfx_pistol);
}
}
return true;
case KEY_ESCAPE:
case KEY_BACKSPACE:
::g->currentMenu->lastOn = ::g->itemOn;
if (::g->currentMenu->prevMenu)
{
::g->currentMenu = ::g->currentMenu->prevMenu;
::g->itemOn = ::g->currentMenu->lastOn;
S_StartSound(NULL,sfx_swtchn);
} else if ( ::g->currentMenu == &::g->MainDef && ( !::g->demoplayback && ::g->gamestate != GS_DEMOSCREEN ) ) {
M_ClearMenus();
::g->paused = false;
}
return true;
default:
for (i = ::g->itemOn+1;i < ::g->currentMenu->numitems;i++)
if (::g->currentMenu->menuitems[i].alphaKey == ch)
{
::g->itemOn = i;
S_StartSound(NULL,sfx_pstop);
return true;
}
for (i = 0;i <= ::g->itemOn;i++)
if (::g->currentMenu->menuitems[i].alphaKey == ch)
{
::g->itemOn = i;
S_StartSound(NULL,sfx_pstop);
return true;
}
break;
}
return false;
}
//
// M_StartControlPanel
//
void M_StartControlPanel (void)
{
// intro might call this repeatedly
if (::g->menuactive)
return;
::g->menuactive = 1;
::g->currentMenu = &::g->MainDef;
::g->itemOn = ::g->currentMenu->lastOn;
}
//
// M_Drawer
// Called after the view has been rendered,
// but before it has been blitted.
//
void M_Drawer (void)
{
unsigned short i;
short max;
char string[40];
int start;
::g->inhelpscreens = false;
// Horiz. & Vertically center string and print it.
if (::g->messageToPrint)
{
start = 0;
::g->md_y = 100 - M_StringHeight(::g->messageString)/2;
while(*(::g->messageString+start))
{
for (i = 0;i < strlen(::g->messageString+start);i++)
if (*(::g->messageString+start+i) == '\n')
{
memset(string,0,40);
strncpy(string,::g->messageString+start,i);
start += i+1;
break;
}
if (i == strlen(::g->messageString+start))
{
strcpy(string,::g->messageString+start);
start += i;
}
::g->md_x = 160 - M_StringWidth(string)/2;
M_WriteText(::g->md_x,::g->md_y,string);
::g->md_y += SHORT(::g->hu_font[0]->height);
}
return;
}
if (!::g->menuactive)
return;
if (::g->currentMenu->routine)
::g->currentMenu->routine(); // call Draw routine
// DRAW MENU
::g->md_x = ::g->currentMenu->x;
::g->md_y = ::g->currentMenu->y;
max = ::g->currentMenu->numitems;
for (i=0;i<max;i++)
{
if (::g->currentMenu->menuitems[i].name[0])
V_DrawPatchDirect (::g->md_x,::g->md_y,0,
(patch_t*)W_CacheLumpName(::g->currentMenu->menuitems[i].name ,PU_CACHE_SHARED));
::g->md_y += LINEHEIGHT;
}
// DRAW SKULL
V_DrawPatchDirect(::g->md_x + SKULLXOFF,::g->currentMenu->y - 5 + ::g->itemOn*LINEHEIGHT, 0,
(patch_t*)W_CacheLumpName(skullName[::g->whichSkull],PU_CACHE_SHARED));
}
//
// M_ClearMenus
//
void M_ClearMenus (void)
{
::g->menuactive = 0;
// if (!::g->netgame && ::g->usergame && ::g->paused)
// ::g->sendpause = true;
}
//
// M_SetupNextMenu
//
void M_SetupNextMenu(menu_t *menudef)
{
::g->currentMenu = menudef;
::g->itemOn = ::g->currentMenu->lastOn;
}
//
// M_Ticker
//
void M_Ticker (void)
{
if (--::g->skullAnimCounter <= 0)
{
::g->whichSkull ^= 1;
::g->skullAnimCounter = 8;
}
}
//
// M_Init
//
void M_Init (void)
{
::g->currentMenu = &::g->MainDef;
::g->menuactive = 1;
::g->itemOn = ::g->currentMenu->lastOn;
::g->whichSkull = 0;
::g->skullAnimCounter = 10;
::g->screenSize = ::g->screenblocks - 3;
::g->messageToPrint = 0;
::g->messageString = NULL;
::g->messageLastMenuActive = ::g->menuactive;
::g->quickSaveSlot = -1;
// Here we could catch other version dependencies,
// like HELP1/2, and four episodes.
switch ( ::g->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.
//::g->MainMenu[readthis] = ::g->MainMenu[quitdoom];
//::g->MainDef.numitems--;
::g->MainDef.y += 8;
::g->NewDef.prevMenu = &::g->MainDef;
//::g->ReadDef1.routine = M_DrawReadThis1;
//::g->ReadDef1.x = 330;
//::g->ReadDef1.y = 165;
//::g->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.
::g->EpiDef.numitems--;
break;
case retail:
// We are fine.
default:
break;
}
}
Reference in a new issue Copy permalink