q3aql/Serious-Engine
q3aql/Serious-Engine
1
0
Fork 0
mirror of https://github.com/ptitSeb/Serious-Engine synced 2024-11-22 18:30:27 +01:00
Code Issues Packages Projects Releases Wiki Activity

Backed out the splitting up of SeriousSam/Menu.cpp

Browse Source
This commit is contained in:
Ryan C. Gordon 2016-04-04 16:09:41 -04:00
parent f35e86661e
commit 5ba4bccabd
104 changed files with 8661 additions and 11567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
Sources/CMakeLists.txt
View File

@ -598,54 +598,9 @@ add_executable(SeriousSam
SeriousSam/LCDDrawing.cpp SeriousSam/LCDDrawing.cpp
SeriousSam/SplashScreen.cpp SeriousSam/SplashScreen.cpp
SeriousSam/MainWindow.cpp SeriousSam/MainWindow.cpp
SeriousSam/GUI/Menus/GameMenu.cpp SeriousSam/Menu.cpp
SeriousSam/GUI/Menus/MAudioOptions.cpp SeriousSam/MenuGadgets.cpp
SeriousSam/GUI/Menus/MConfirm.cpp SeriousSam/MenuPrinting.cpp
SeriousSam/GUI/Menus/MControls.cpp
SeriousSam/GUI/Menus/MCustomizeAxis.cpp
SeriousSam/GUI/Menus/MCustomizeKeyboard.cpp
SeriousSam/GUI/Menus/MDisabled.cpp
SeriousSam/GUI/Menus/MenuActions.cpp
SeriousSam/GUI/Menus/Menu.cpp
SeriousSam/GUI/Menus/MenuManager.cpp
SeriousSam/GUI/Menus/MenuPrinting.cpp
SeriousSam/GUI/Menus/MenuStartersAF.cpp
SeriousSam/GUI/Menus/MenuStarters.cpp
SeriousSam/GUI/Menus/MenuStuff.cpp
SeriousSam/GUI/Menus/MHighScore.cpp
SeriousSam/GUI/Menus/MInGame.cpp
SeriousSam/GUI/Menus/MLevels.cpp
SeriousSam/GUI/Menus/MLoadSave.cpp
SeriousSam/GUI/Menus/MMain.cpp
SeriousSam/GUI/Menus/MNetwork.cpp
SeriousSam/GUI/Menus/MNetworkJoin.cpp
SeriousSam/GUI/Menus/MNetworkOpen.cpp
SeriousSam/GUI/Menus/MNetworkStart.cpp
SeriousSam/GUI/Menus/MOptions.cpp
SeriousSam/GUI/Menus/MPlayerProfile.cpp
SeriousSam/GUI/Menus/MSelectPlayers.cpp
SeriousSam/GUI/Menus/MServers.cpp
SeriousSam/GUI/Menus/MSinglePlayer.cpp
SeriousSam/GUI/Menus/MSinglePlayerNew.cpp
SeriousSam/GUI/Menus/MSplitScreen.cpp
SeriousSam/GUI/Menus/MSplitStart.cpp
SeriousSam/GUI/Menus/MVar.cpp
SeriousSam/GUI/Menus/MVideoOptions.cpp
SeriousSam/GUI/Components/MenuGadget.cpp
SeriousSam/GUI/Components/MGArrow.cpp
SeriousSam/GUI/Components/MGButton.cpp
SeriousSam/GUI/Components/MGChangePlayer.cpp
SeriousSam/GUI/Components/MGEdit.cpp
SeriousSam/GUI/Components/MGFileButton.cpp
SeriousSam/GUI/Components/MGHighScore.cpp
SeriousSam/GUI/Components/MGKeyDefinition.cpp
SeriousSam/GUI/Components/MGLevelButton.cpp
SeriousSam/GUI/Components/MGModel.cpp
SeriousSam/GUI/Components/MGServerList.cpp
SeriousSam/GUI/Components/MGSlider.cpp
SeriousSam/GUI/Components/MGTitle.cpp
SeriousSam/GUI/Components/MGTrigger.cpp
SeriousSam/GUI/Components/MGVarButton.cpp
) )
add_dependencies(SeriousSam ParseAllEntities) add_dependencies(SeriousSam ParseAllEntities)

54
Sources/SeriousSam/GUI/Components/MGArrow.cpp
View File

@ -1,54 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGArrow.h"
void CMGArrow::Render(CDrawPort *pdp)
{
SetFontMedium(pdp);
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
COLOR col = GetCurrentColor();
CTString str;
if (mg_adDirection == AD_NONE) {
str = "???";
} else if (mg_adDirection == AD_UP) {
str = TRANS("Page Up");
} else if (mg_adDirection == AD_DOWN) {
str = TRANS("Page Down");
} else {
ASSERT(FALSE);
}
PIX pixI = box.Min()(1);
PIX pixJ = box.Min()(2);
pdp->PutText(str, pixI, pixJ, col);
}
void CMGArrow::OnActivate(void)
{
if (mg_adDirection == AD_UP) {
pgmCurrentMenu->ScrollList(-3);
}
else if (mg_adDirection == AD_DOWN) {
pgmCurrentMenu->ScrollList(+3);
}
}

33
Sources/SeriousSam/GUI/Components/MGArrow.h
View File

@ -1,33 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_ARROW_H
#define SE_INCL_MENU_GADGET_ARROW_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/ArrowDir.h"
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGArrow : public CMGButton {
public:
enum ArrowDir mg_adDirection;
void Render(CDrawPort *pdp);
void OnActivate(void);
};
#endif /* include-once check. */

182
Sources/SeriousSam/GUI/Components/MGButton.cpp
View File

@ -1,182 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/LevelInfo.h"
#include "SeriousSam/VarList.h"
#include "SeriousSam/GUI/Components/MGButton.h"
extern CSoundData *_psdPress;
extern CMenuGadget *_pmgLastActivatedGadget;
CMGButton::CMGButton(void)
{
mg_pActivatedFunction = NULL;
mg_iIndex = 0;
mg_iCenterI = 0;
mg_iTextMode = 1;
mg_bfsFontSize = BFS_MEDIUM;
mg_iCursorPos = -1;
mg_bRectangle = FALSE;
mg_bMental = FALSE;
mg_bEditing = FALSE;
mg_bHighlighted = FALSE;
}
void CMGButton::SetText(CTString strNew)
{
mg_strText = strNew;
}
void CMGButton::OnActivate(void)
{
if (mg_pActivatedFunction != NULL && mg_bEnabled)
{
PlayMenuSound(_psdPress);
IFeel_PlayEffect("Menu_press");
_pmgLastActivatedGadget = this;
(*mg_pActivatedFunction)();
}
}
void CMGButton::Render(CDrawPort *pdp)
{
if (mg_bfsFontSize == BFS_LARGE) {
SetFontBig(pdp);
} else if (mg_bfsFontSize == BFS_MEDIUM) {
SetFontMedium(pdp);
} else {
ASSERT(mg_bfsFontSize == BFS_SMALL);
SetFontSmall(pdp);
}
pdp->SetTextMode(mg_iTextMode);
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
COLOR col = GetCurrentColor();
if (mg_bEditing) {
col = _pGame->LCDGetColor(C_GREEN | 0xFF, "editing");
}
COLOR colRectangle = col;
if (mg_bHighlighted) {
col = _pGame->LCDGetColor(C_WHITE | 0xFF, "hilited");
if (!mg_bFocused) {
colRectangle = _pGame->LCDGetColor(C_WHITE | 0xFF, "hilited rectangle");
}
}
if (mg_bMental) {
FLOAT tmIn = 0.2f;
FLOAT tmOut = 1.0f;
FLOAT tmFade = 0.1f;
FLOAT tmExist = tmFade + tmIn + tmFade;
FLOAT tmTotal = tmFade + tmIn + tmFade + tmOut;
FLOAT tmTime = _pTimer->GetHighPrecisionTimer().GetSeconds();
FLOAT fFactor = 1;
if (tmTime>0.1f) {
tmTime = fmod(tmTime, tmTotal);
fFactor = CalculateRatio(tmTime, 0, tmExist, tmFade / tmExist, tmFade / tmExist);
}
col = (col&~0xFF) | INDEX(0xFF * fFactor);
}
if (mg_bRectangle) {
// put border
const PIX pixLeft = box.Min()(1);
const PIX pixUp = box.Min()(2) - 3;
const PIX pixWidth = box.Size()(1) + 1;
const PIX pixHeight = box.Size()(2);
pdp->DrawBorder(pixLeft, pixUp, pixWidth, pixHeight, colRectangle);
}
if (mg_bEditing) {
// put border
PIX pixLeft = box.Min()(1);
PIX pixUp = box.Min()(2) - 3;
PIX pixWidth = box.Size()(1) + 1;
PIX pixHeight = box.Size()(2);
if (mg_strLabel != "") {
pixLeft = box.Min()(1) + box.Size()(1)*0.55f;
pixWidth = box.Size()(1)*0.45f + 1;
}
pdp->Fill(pixLeft, pixUp, pixWidth, pixHeight, _pGame->LCDGetColor(C_dGREEN | 0x40, "edit fill"));
}
INDEX iCursor = mg_iCursorPos;
// print text
if (mg_strLabel != "") {
PIX pixIL = box.Min()(1) + box.Size()(1)*0.45f;
PIX pixIR = box.Min()(1) + box.Size()(1)*0.55f;
PIX pixJ = box.Min()(2);
pdp->PutTextR(mg_strLabel, pixIL, pixJ, col);
pdp->PutText(mg_strText, pixIR, pixJ, col);
} else {
CTString str = mg_strText;
if (pdp->dp_FontData->fd_bFixedWidth) {
str = str.Undecorated();
INDEX iLen = str.Length();
INDEX iMaxLen = ClampDn(box.Size()(1) / (pdp->dp_pixTextCharSpacing + pdp->dp_FontData->fd_pixCharWidth), 1L);
if (iCursor >= iMaxLen) {
str.TrimRight(iCursor);
str.TrimLeft(iMaxLen);
iCursor = iMaxLen;
} else {
str.TrimRight(iMaxLen);
}
}
if (mg_iCenterI == -1) pdp->PutText(str, box.Min()(1), box.Min()(2), col);
else if (mg_iCenterI == +1) pdp->PutTextR(str, box.Max()(1), box.Min()(2), col);
else pdp->PutTextC(str, box.Center()(1), box.Min()(2), col);
}
// put cursor if editing
if (mg_bEditing && (((ULONG)(_pTimer->GetRealTimeTick() * 2)) & 1)) {
PIX pixX = box.Min()(1) + GetCharOffset(pdp, iCursor);
if (mg_strLabel != "") {
pixX += box.Size()(1)*0.55f;
}
PIX pixY = box.Min()(2);
if (!pdp->dp_FontData->fd_bFixedWidth) {
pixY -= pdp->dp_fTextScaling * 2;
}
pdp->PutText("|", pixX, pixY, _pGame->LCDGetColor(C_WHITE | 0xFF, "editing cursor"));
}
}
PIX CMGButton::GetCharOffset(CDrawPort *pdp, INDEX iCharNo)
{
if (pdp->dp_FontData->fd_bFixedWidth) {
return (pdp->dp_FontData->fd_pixCharWidth + pdp->dp_pixTextCharSpacing)*(iCharNo - 0.5f);
}
CTString strCut(mg_strText);
strCut.TrimLeft(strlen(mg_strText) - iCharNo);
PIX pixFullWidth = pdp->GetTextWidth(mg_strText);
PIX pixCutWidth = pdp->GetTextWidth(strCut);
// !!!! not implemented for different centering
return pixFullWidth - pixCutWidth;
}

48
Sources/SeriousSam/GUI/Components/MGButton.h
View File

@ -1,48 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_BUTTON_H
#define SE_INCL_MENU_GADGET_BUTTON_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MenuGadget.h"
class CMGButton : public CMenuGadget {
public:
CTString mg_strLabel; // for those that have labels separately from main text
CTString mg_strText;
INDEX mg_iCenterI;
enum ButtonFontSize mg_bfsFontSize;
BOOL mg_bEditing;
BOOL mg_bHighlighted;
BOOL mg_bRectangle;
BOOL mg_bMental;
INDEX mg_iTextMode;
INDEX mg_iCursorPos;
INDEX mg_iIndex;
void(*mg_pActivatedFunction)(void);
CMGButton(void);
void SetText(CTString strNew);
void OnActivate(void);
void Render(CDrawPort *pdp);
PIX GetCharOffset(CDrawPort *pdp, INDEX iCharNo);
};
#endif /* include-once check. */

53
Sources/SeriousSam/GUI/Components/MGChangePlayer.cpp
View File

@ -1,53 +0,0 @@
/* C/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGChangePlayer.h"
#include "SeriousSam/GUI/Menus/MenuManager.h"
extern CSoundData *_psdPress;
void CMGChangePlayer::OnActivate(void)
{
PlayMenuSound(_psdPress);
IFeel_PlayEffect("Menu_press");
_iLocalPlayer = mg_iLocalPlayer;
if (_pGame->gm_aiMenuLocalPlayers[mg_iLocalPlayer] < 0)
_pGame->gm_aiMenuLocalPlayers[mg_iLocalPlayer] = 0;
_pGUIM->gmPlayerProfile.gm_piCurrentPlayer = &_pGame->gm_aiMenuLocalPlayers[mg_iLocalPlayer];
_pGUIM->gmPlayerProfile.gm_pgmParentMenu = &_pGUIM->gmSelectPlayersMenu;
extern BOOL _bPlayerMenuFromSinglePlayer;
_bPlayerMenuFromSinglePlayer = FALSE;
ChangeToMenu(&_pGUIM->gmPlayerProfile);
}
void CMGChangePlayer::SetPlayerText(void)
{
INDEX iPlayer = _pGame->gm_aiMenuLocalPlayers[mg_iLocalPlayer];
CPlayerCharacter &pc = _pGame->gm_apcPlayers[iPlayer];
if (iPlayer<0 || iPlayer>7) {
mg_strText = "????";
} else {
mg_strText.PrintF(TRANS("Player %d: %s\n"), mg_iLocalPlayer + 1, (const char *) pc.GetNameForPrinting());
}
}

33
Sources/SeriousSam/GUI/Components/MGChangePlayer.h
View File

@ -1,33 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_CHANGEPLAYER_H
#define SE_INCL_MENU_GADGET_CHANGEPLAYER_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGChangePlayer : public CMGButton {
public:
INDEX mg_iLocalPlayer;
void SetPlayerText(void);
void OnActivate(void);
};
#endif /* include-once check. */

174
Sources/SeriousSam/GUI/Components/MGEdit.cpp
View File

@ -1,174 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGEdit.h"
extern CSoundData *_psdPress;
extern BOOL _bEditingString;
CMGEdit::CMGEdit(void)
{
mg_pstrToChange = NULL;
mg_ctMaxStringLen = 70;
Clear();
}
void CMGEdit::Clear(void)
{
mg_iCursorPos = 0;
mg_bEditing = FALSE;
_bEditingString = FALSE;
}
void CMGEdit::OnActivate(void)
{
if (!mg_bEnabled) {
return;
}
ASSERT(mg_pstrToChange != NULL);
PlayMenuSound(_psdPress);
IFeel_PlayEffect("Menu_press");
SetText(mg_strText);
mg_iCursorPos = strlen(mg_strText);
mg_bEditing = TRUE;
_bEditingString = TRUE;
}
// focus lost
void CMGEdit::OnKillFocus(void)
{
// go out of editing mode
if (mg_bEditing) {
OnKeyDown(VK_RETURN);
Clear();
}
// proceed
CMenuGadget::OnKillFocus();
}
// helper function for deleting char(s) from string
static void Key_BackDel(CTString &str, INDEX &iPos, BOOL bShift, BOOL bRight)
{
// do nothing if string is empty
INDEX ctChars = strlen(str);
if (ctChars == 0) return;
if (bRight && iPos<ctChars) { // DELETE key
if (bShift) {
// delete to end of line
str.TrimRight(iPos);
} else {
// delete only one char
str.DeleteChar(iPos);
}
}
if (!bRight && iPos>0) { // BACKSPACE key
if (bShift) {
// delete to start of line
str.TrimLeft(ctChars - iPos);
iPos = 0;
} else {
// delete only one char
str.DeleteChar(iPos - 1);
iPos--;
}
}
}
// key/mouse button pressed
BOOL CMGEdit::OnKeyDown(int iVKey)
{
// if not in edit mode
if (!mg_bEditing) {
// behave like normal gadget
return CMenuGadget::OnKeyDown(iVKey);
}
// finish editing?
BOOL bShift = GetKeyState(VK_SHIFT) & 0x8000;
switch (iVKey) {
case VK_UP: case VK_DOWN:
case VK_RETURN: case VK_LBUTTON: *mg_pstrToChange = mg_strText; Clear(); OnStringChanged(); break;
case VK_ESCAPE: case VK_RBUTTON: mg_strText = *mg_pstrToChange; Clear(); OnStringCanceled(); break;
case VK_LEFT: if (mg_iCursorPos > 0) mg_iCursorPos--; break;
case VK_RIGHT: if (mg_iCursorPos < strlen(mg_strText)) mg_iCursorPos++; break;
case VK_HOME: mg_iCursorPos = 0; break;
case VK_END: mg_iCursorPos = strlen(mg_strText); break;
case VK_BACK: Key_BackDel(mg_strText, mg_iCursorPos, bShift, FALSE); break;
case VK_DELETE: Key_BackDel(mg_strText, mg_iCursorPos, bShift, TRUE); break;
default: break; // ignore all other special keys
}
// key is handled
return TRUE;
}
// char typed
BOOL CMGEdit::OnChar(MSG msg)
{
// if not in edit mode
if (!mg_bEditing) {
// behave like normal gadget
return CMenuGadget::OnChar(msg);
}
// only chars are allowed
const INDEX ctFullLen = mg_strText.Length();
const INDEX ctNakedLen = mg_strText.LengthNaked();
mg_iCursorPos = Clamp(mg_iCursorPos, 0L, ctFullLen);
int iVKey = msg.wParam;
if (isprint(iVKey) && ctNakedLen <= mg_ctMaxStringLen) {
mg_strText.InsertChar(mg_iCursorPos, (char)iVKey);
mg_iCursorPos++;
}
// key is handled
return TRUE;
}
void CMGEdit::Render(CDrawPort *pdp)
{
if (mg_bEditing) {
mg_iTextMode = -1;
} else if (mg_bFocused) {
mg_iTextMode = 0;
} else {
mg_iTextMode = 1;
}
if (mg_strText == "" && !mg_bEditing) {
if (mg_bfsFontSize == BFS_SMALL) {
mg_strText = "*";
} else {
mg_strText = TRANS("<none>");
}
CMGButton::Render(pdp);
mg_strText = "";
} else {
CMGButton::Render(pdp);
}
}
void CMGEdit::OnStringChanged(void)
{
}
void CMGEdit::OnStringCanceled(void)
{
}

43
Sources/SeriousSam/GUI/Components/MGEdit.h
View File

@ -1,43 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_EDIT_H
#define SE_INCL_MENU_GADGET_EDIT_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGEdit : public CMGButton {
public:
INDEX mg_ctMaxStringLen;
CTString *mg_pstrToChange;
CMGEdit(void);
// return TRUE if handled
BOOL OnKeyDown(int iVKey);
BOOL OnChar(MSG msg);
void Clear(void);
void OnActivate(void);
void OnKillFocus(void);
void Render(CDrawPort *pdp);
virtual void OnStringChanged(void);
virtual void OnStringCanceled(void);
};
#endif /* include-once check. */

243
Sources/SeriousSam/GUI/Components/MGFileButton.cpp
View File

@ -1,243 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGFileButton.h"
#include "SeriousSam/GUI/Menus/MenuManager.h"
extern CSoundData *_psdPress;
CMGFileButton::CMGFileButton(void)
{
mg_iState = FBS_NORMAL;
}
// refresh current text from description
void CMGFileButton::RefreshText(void)
{
mg_strText = mg_strDes;
mg_strText.OnlyFirstLine();
mg_strInfo = mg_strDes;
mg_strInfo.RemovePrefix(mg_strText);
mg_strInfo.DeleteChar(0);
}
void CMGFileButton::SaveDescription(void)
{
CTFileName fnFileNameDescription = mg_fnm.NoExt() + ".des";
try {
mg_strDes.Save_t(fnFileNameDescription);
} catch (char *strError) {
CPrintF("%s\n", strError);
}
}
CMGFileButton *_pmgFileToSave = NULL;
void OnFileSaveOK(void)
{
if (_pmgFileToSave != NULL) {
_pmgFileToSave->SaveYes();
}
}
void CMGFileButton::DoSave(void)
{
if (FileExistsForWriting(mg_fnm)) {
_pmgFileToSave = this;
extern void SaveConfirm(void);
SaveConfirm();
} else {
SaveYes();
}
}
void CMGFileButton::SaveYes(void)
{
ASSERT(_pGUIM->gmLoadSaveMenu.gm_bSave);
// call saving function
BOOL bSucceeded = _pGUIM->gmLoadSaveMenu.gm_pAfterFileChosen(mg_fnm);
// if saved
if (bSucceeded) {
// save the description too
SaveDescription();
}
}
void CMGFileButton::DoLoad(void)
{
ASSERT(!_pGUIM->gmLoadSaveMenu.gm_bSave);
// if no file
if (!FileExists(mg_fnm)) {
// do nothing
return;
}
if (_pGUIM->gmLoadSaveMenu.gm_pgmNextMenu != NULL) {
_pGUIM->gmLoadSaveMenu.gm_pgmParentMenu = _pGUIM->gmLoadSaveMenu.gm_pgmNextMenu;
}
// call loading function
BOOL bSucceeded = _pGUIM->gmLoadSaveMenu.gm_pAfterFileChosen(mg_fnm);
ASSERT(bSucceeded);
}
static CTString _strTmpDescription;
static CTString _strOrgDescription;
void CMGFileButton::StartEdit(void)
{
CMGEdit::OnActivate();
}
void CMGFileButton::OnActivate(void)
{
if (mg_fnm == "") {
return;
}
PlayMenuSound(_psdPress);
IFeel_PlayEffect("Menu_press");
// if loading
if (!_pGUIM->gmLoadSaveMenu.gm_bSave) {
// load now
DoLoad();
// if saving
} else {
// switch to editing mode
BOOL bWasEmpty = mg_strText == EMPTYSLOTSTRING;
mg_strDes = _pGUIM->gmLoadSaveMenu.gm_strSaveDes;
RefreshText();
_strOrgDescription = _strTmpDescription = mg_strText;
if (bWasEmpty) {
_strOrgDescription = EMPTYSLOTSTRING;
}
mg_pstrToChange = &_strTmpDescription;
StartEdit();
mg_iState = FBS_SAVENAME;
}
}
BOOL CMGFileButton::OnKeyDown(int iVKey)
{
if (mg_iState == FBS_NORMAL) {
if (_pGUIM->gmLoadSaveMenu.gm_bSave || _pGUIM->gmLoadSaveMenu.gm_bManage) {
if (iVKey == VK_F2) {
if (FileExistsForWriting(mg_fnm)) {
// switch to renaming mode
_strOrgDescription = mg_strText;
_strTmpDescription = mg_strText;
mg_pstrToChange = &_strTmpDescription;
StartEdit();
mg_iState = FBS_RENAME;
}
return TRUE;
} else if (iVKey == VK_DELETE) {
if (FileExistsForWriting(mg_fnm)) {
// delete the file, its description and thumbnail
RemoveFile(mg_fnm);
RemoveFile(mg_fnm.NoExt() + ".des");
RemoveFile(mg_fnm.NoExt() + "Tbn.tex");
// refresh menu
_pGUIM->gmLoadSaveMenu.EndMenu();
_pGUIM->gmLoadSaveMenu.StartMenu();
OnSetFocus();
}
return TRUE;
}
}
return CMenuGadget::OnKeyDown(iVKey);
} else {
// go out of editing mode
if (mg_bEditing) {
if (iVKey == VK_UP || iVKey == VK_DOWN) {
CMGEdit::OnKeyDown(VK_ESCAPE);
}
}
return CMGEdit::OnKeyDown(iVKey);
}
}
void CMGFileButton::OnSetFocus(void)
{
mg_iState = FBS_NORMAL;
if (_pGUIM->gmLoadSaveMenu.gm_bAllowThumbnails && mg_bEnabled) {
SetThumbnail(mg_fnm);
} else {
ClearThumbnail();
}
pgmCurrentMenu->KillAllFocuses();
CMGButton::OnSetFocus();
}
void CMGFileButton::OnKillFocus(void)
{
// go out of editing mode
if (mg_bEditing) {
OnKeyDown(VK_ESCAPE);
}
CMGEdit::OnKillFocus();
}
// override from edit gadget
void CMGFileButton::OnStringChanged(void)
{
// if saving
if (mg_iState == FBS_SAVENAME) {
// do the save
mg_strDes = _strTmpDescription + "\n" + mg_strInfo;
DoSave();
// if renaming
} else if (mg_iState == FBS_RENAME) {
// do the rename
mg_strDes = _strTmpDescription + "\n" + mg_strInfo;
SaveDescription();
// refresh menu
_pGUIM->gmLoadSaveMenu.EndMenu();
_pGUIM->gmLoadSaveMenu.StartMenu();
OnSetFocus();
}
}
void CMGFileButton::OnStringCanceled(void)
{
mg_strText = _strOrgDescription;
}
void CMGFileButton::Render(CDrawPort *pdp)
{
// render original gadget first
CMGEdit::Render(pdp);
// if currently selected
if (mg_bFocused && mg_bEnabled) {
// add info at the bottom if screen
SetFontMedium(pdp);
PIXaabbox2D box = FloatBoxToPixBox(pdp, BoxSaveLoad(15.0));
PIX pixI = box.Min()(1);
PIX pixJ = box.Min()(2);
COLOR col = _pGame->LCDGetColor(C_mlGREEN | 255, "file info");
pdp->PutText(mg_strInfo, pixI, pixJ, col);
}
}

57
Sources/SeriousSam/GUI/Components/MGFileButton.h
View File

@ -1,57 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_FILEBUTTON_H
#define SE_INCL_MENU_GADGET_FILEBUTTON_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGEdit.h"
// file button states
#define FBS_NORMAL 0 // normal active state
#define FBS_SAVENAME 1 // typing in the save name
#define FBS_RENAME 2 // renaming existing file
class CMGFileButton : public CMGEdit {
public:
CMGFileButton(void);
CTFileName mg_fnm;
CTString mg_strDes; // entire description goes here
CTString mg_strInfo; // info part of text to print above the gadget tip
INDEX mg_iState;
// refresh current text from description
void RefreshText(void);
// save description to disk
void SaveDescription(void);
void SaveYes(void);
void DoSave(void);
void DoLoad(void);
void StartEdit(void);
// return TRUE if handled
BOOL OnKeyDown(int iVKey);
void OnActivate(void);
void OnSetFocus(void);
void OnKillFocus(void);
// overrides from edit gadget
void OnStringChanged(void);
void OnStringCanceled(void);
void Render(CDrawPort *pdp);
};
#endif /* include-once check. */

102
Sources/SeriousSam/GUI/Components/MGHighScore.cpp
View File

@ -1,102 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGHighScore.h"
#define HSCOLUMNS 6
CTString strHighScores[HIGHSCORE_COUNT + 1][HSCOLUMNS];
FLOAT afI[HSCOLUMNS] = {
0.12f, 0.15f, 0.6f, 0.7f, 0.78f, 0.9f
};
void CMGHighScore::Render(CDrawPort *pdp)
{
SetFontMedium(pdp);
COLOR colHeader = _pGame->LCDGetColor(C_GREEN | 255, "hiscore header");
COLOR colData = _pGame->LCDGetColor(C_mdGREEN | 255, "hiscore data");
COLOR colLastSet = _pGame->LCDGetColor(C_mlGREEN | 255, "hiscore last set");
INDEX iLastSet = _pGame->gm_iLastSetHighScore;
CTString strText;
strHighScores[0][0] = TRANS("No.");
strHighScores[0][1] = TRANS("Player Name");
strHighScores[0][2] = TRANS("Difficulty");
strHighScores[0][3] = TRANS("Time");
strHighScores[0][4] = TRANS("Kills");
strHighScores[0][5] = TRANS("Score");
{for (INDEX i = 0; i<HIGHSCORE_COUNT; i++) {
switch (_pGame->gm_ahseHighScores[i].hse_gdDifficulty) {
default:
ASSERT(FALSE);
case (CSessionProperties::GameDifficulty) - 100:
strHighScores[i + 1][1] = "---";
continue;
break;
case CSessionProperties::GD_TOURIST:
strHighScores[i + 1][2] = TRANS("Tourist");
break;
case CSessionProperties::GD_EASY:
strHighScores[i + 1][2] = TRANS("Easy");
break;
case CSessionProperties::GD_NORMAL:
strHighScores[i + 1][2] = TRANS("Normal");
break;
case CSessionProperties::GD_HARD:
strHighScores[i + 1][2] = TRANS("Hard");
break;
case CSessionProperties::GD_EXTREME:
strHighScores[i + 1][2] = TRANS("Serious");
break;
case CSessionProperties::GD_EXTREME + 1:
strHighScores[i + 1][2] = TRANS("Mental");
break;
}
strHighScores[i + 1][0].PrintF("%d", i + 1);
strHighScores[i + 1][1] = _pGame->gm_ahseHighScores[i].hse_strPlayer;
strHighScores[i + 1][3] = TimeToString(_pGame->gm_ahseHighScores[i].hse_tmTime);
strHighScores[i + 1][4].PrintF("%03d", _pGame->gm_ahseHighScores[i].hse_ctKills);
strHighScores[i + 1][5].PrintF("%9d", _pGame->gm_ahseHighScores[i].hse_ctScore);
}}
PIX pixJ = pdp->GetHeight()*0.25f;
{for (INDEX iRow = 0; iRow<HIGHSCORE_COUNT + 1; iRow++) {
COLOR col = (iRow == 0) ? colHeader : colData;
if (iLastSet != -1 && iRow - 1 == iLastSet) {
col = colLastSet;
}
{for (INDEX iColumn = 0; iColumn<HSCOLUMNS; iColumn++) {
PIX pixI = pdp->GetWidth()*afI[iColumn];
if (iColumn == 1) {
pdp->PutText(strHighScores[iRow][iColumn], pixI, pixJ, col);
}
else {
pdp->PutTextR(strHighScores[iRow][iColumn], pixI, pixJ, col);
}
}}
if (iRow == 0) {
pixJ += pdp->GetHeight()*0.06f;
} else {
pixJ += pdp->GetHeight()*0.04f;
}
}}
}

30
Sources/SeriousSam/GUI/Components/MGHighScore.h
View File

@ -1,30 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_HIGHSCORE_H
#define SE_INCL_MENU_GADGET_HIGHSCORE_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MenuGadget.h"
class CMGHighScore : public CMenuGadget {
public:
void Render(CDrawPort *pdp);
};
#endif /* include-once check. */

223
Sources/SeriousSam/GUI/Components/MGKeyDefinition.cpp
View File

@ -1,223 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGKeyDefinition.h"
extern CSoundData *_psdSelect;
extern CSoundData *_psdPress;
extern BOOL _bDefiningKey;
CMGKeyDefinition::CMGKeyDefinition(void)
{
mg_iState = DOING_NOTHING;
}
void CMGKeyDefinition::OnActivate(void)
{
PlayMenuSound(_psdPress);
IFeel_PlayEffect("Menu_press");
SetBindingNames(/*bDefining=*/TRUE);
mg_iState = RELEASE_RETURN_WAITING;
}
BOOL CMGKeyDefinition::OnKeyDown(int iVKey)
{
// if waiting for a key definition
if (mg_iState == PRESS_KEY_WAITING) {
// do nothing
return TRUE;
}
// if backspace pressed
if (iVKey == VK_BACK) {
// clear both keys
DefineKey(KID_NONE);
// message is processed
return TRUE;
}
return CMenuGadget::OnKeyDown(iVKey);
}
// set names for both key bindings
void CMGKeyDefinition::SetBindingNames(BOOL bDefining)
{
// find the button
INDEX ict = 0;
INDEX iDik = 0;
FOREACHINLIST(CButtonAction, ba_lnNode, _pGame->gm_ctrlControlsExtra->ctrl_lhButtonActions, itba) {
if (ict == mg_iControlNumber) {
CButtonAction &ba = *itba;
// get the current bindings and names
INDEX iKey1 = ba.ba_iFirstKey;
INDEX iKey2 = ba.ba_iSecondKey;
BOOL bKey1Bound = iKey1 != KID_NONE;
BOOL bKey2Bound = iKey2 != KID_NONE;
CTString strKey1 = _pInput->GetButtonTransName(iKey1);
CTString strKey2 = _pInput->GetButtonTransName(iKey2);
// if defining
if (bDefining) {
// if only first key is defined
if (bKey1Bound && !bKey2Bound) {
// put question mark for second key
mg_strBinding = strKey1 + TRANS(" or ") + "?";
// otherwise
} else {
// put question mark only
mg_strBinding = "?";
}
// if not defining
}
else {
// if second key is defined
if (bKey2Bound) {
// add both
mg_strBinding = strKey1 + TRANS(" or ") + strKey2;
// if second key is undefined
} else {
// display only first one
mg_strBinding = strKey1;
}
}
return;
}
ict++;
}
// if not found, put errorneous string
mg_strBinding = "???";
}
void CMGKeyDefinition::Appear(void)
{
SetBindingNames(/*bDefining=*/FALSE);
CMenuGadget::Appear();
}
void CMGKeyDefinition::Disappear(void)
{
CMenuGadget::Disappear();
}
void CMGKeyDefinition::DefineKey(INDEX iDik)
{
// for each button in controls
INDEX ict = 0;
FOREACHINLIST(CButtonAction, ba_lnNode, _pGame->gm_ctrlControlsExtra->ctrl_lhButtonActions, itba) {
CButtonAction &ba = *itba;
// if it is this one
if (ict == mg_iControlNumber) {
// if should clear
if (iDik == KID_NONE) {
// unbind both
ba.ba_iFirstKey = KID_NONE;
ba.ba_iSecondKey = KID_NONE;
}
// if first key is unbound, or both keys are bound
if (ba.ba_iFirstKey == KID_NONE || ba.ba_iSecondKey != KID_NONE) {
// bind first key
ba.ba_iFirstKey = iDik;
// clear second key
ba.ba_iSecondKey = KID_NONE;
// if only first key bound
} else {
// bind second key
ba.ba_iSecondKey = iDik;
}
// if it is not this one
} else {
// clear bindings that contain this key
if (ba.ba_iFirstKey == iDik) {
ba.ba_iFirstKey = KID_NONE;
}
if (ba.ba_iSecondKey == iDik) {
ba.ba_iSecondKey = KID_NONE;
}
}
ict++;
}
SetBindingNames(/*bDefining=*/FALSE);
}
void CMGKeyDefinition::Think(void)
{
if (mg_iState == RELEASE_RETURN_WAITING)
{
_bDefiningKey = TRUE;
extern BOOL _bMouseUsedLast;
_bMouseUsedLast = FALSE;
_pInput->SetJoyPolling(TRUE);
_pInput->GetInput(FALSE);
if (_pInput->IsInputEnabled() &&
!_pInput->GetButtonState(KID_ENTER) &&
!_pInput->GetButtonState(KID_MOUSE1))
{
mg_iState = PRESS_KEY_WAITING;
}
}
else if (mg_iState == PRESS_KEY_WAITING)
{
_pInput->SetJoyPolling(TRUE);
_pInput->GetInput(FALSE);
for (INDEX iDik = 0; iDik<MAX_OVERALL_BUTTONS; iDik++)
{
if (_pInput->GetButtonState(iDik))
{
// skip keys that cannot be defined
if (iDik == KID_TILDE) {
continue;
}
// if escape not pressed
if (iDik != KID_ESCAPE) {
// define the new key
DefineKey(iDik);
// if escape pressed
} else {
// undefine the key
DefineKey(KID_NONE);
}
// end defining loop
mg_iState = DOING_NOTHING;
_bDefiningKey = FALSE;
// refresh all buttons
pgmCurrentMenu->FillListItems();
break;
}
}
}
}
void CMGKeyDefinition::Render(CDrawPort *pdp)
{
SetFontMedium(pdp);
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
PIX pixIL = box.Min()(1) + box.Size()(1)*0.45f;
PIX pixIR = box.Min()(1) + box.Size()(1)*0.55f;
PIX pixJ = box.Min()(2);
COLOR col = GetCurrentColor();
pdp->PutTextR(mg_strLabel, pixIL, pixJ, col);
pdp->PutText(mg_strBinding, pixIR, pixJ, col);
}

46
Sources/SeriousSam/GUI/Components/MGKeyDefinition.h
View File

@ -1,46 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_KEYDEFINITION_H
#define SE_INCL_MENU_GADGET_KEYDEFINITION_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MenuGadget.h"
class CMGKeyDefinition : public CMenuGadget {
public:
INDEX mg_iState;
INDEX mg_iControlNumber;
CTString mg_strLabel;
CTString mg_strBinding;
CMGKeyDefinition(void);
void Appear(void);
void Disappear(void);
void OnActivate(void);
// return TRUE if handled
BOOL OnKeyDown(int iVKey);
void Think(void);
// set names for both key bindings
void SetBindingNames(BOOL bDefining);
void DefineKey(INDEX iDik);
void Render(CDrawPort *pdp);
};
#endif /* include-once check. */

38
Sources/SeriousSam/GUI/Components/MGLevelButton.cpp
View File

@ -1,38 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGLevelButton.h"
extern CSoundData *_psdPress;
void CMGLevelButton::OnActivate(void)
{
PlayMenuSound(_psdPress);
IFeel_PlayEffect("Menu_press");
_pGame->gam_strCustomLevel = mg_fnmLevel;
extern void(*_pAfterLevelChosen)(void);
_pAfterLevelChosen();
}
void CMGLevelButton::OnSetFocus(void)
{
SetThumbnail(mg_fnmLevel);
CMGButton::OnSetFocus();
}

33
Sources/SeriousSam/GUI/Components/MGLevelButton.h
View File

@ -1,33 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_LEVELBUTTON_H
#define SE_INCL_MENU_GADGET_LEVELBUTTON_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGLevelButton : public CMGButton {
public:
CTFileName mg_fnmLevel;
void OnActivate(void);
void OnSetFocus(void);
};
#endif /* include-once check. */

126
Sources/SeriousSam/GUI/Components/MGModel.cpp
View File

@ -1,126 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGModel.h"
extern INDEX sam_bWideScreen;
CMGModel::CMGModel(void)
{
mg_fFloorY = 0;
}
void CMGModel::Render(CDrawPort *pdp)
{
// if no model
if (mg_moModel.GetData() == NULL) {
// just render text
mg_strText = TRANS("No model");
CMGButton::Render(pdp);
return;
}
// get position on screen
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
CDrawPort dpModel(pdp, box);
dpModel.Lock();
dpModel.FillZBuffer(1.0f);
_pGame->LCDSetDrawport(&dpModel);
// clear menu here
dpModel.Fill(C_BLACK | 255);
_pGame->LCDRenderClouds1();
_pGame->LCDRenderClouds2();
// prepare projection
CRenderModel rmRenderModel;
CPerspectiveProjection3D pr;
pr.FOVL() = sam_bWideScreen ? AngleDeg(45.0f) : AngleDeg(30.0f);
pr.ScreenBBoxL() = FLOATaabbox2D(
FLOAT2D(0.0f, 0.0f),
FLOAT2D((float)dpModel.GetWidth(), (float)dpModel.GetHeight())
);
pr.AspectRatioL() = 1.0f;
pr.FrontClipDistanceL() = 0.3f;
pr.ViewerPlacementL() = CPlacement3D(FLOAT3D(0, 0, 0), ANGLE3D(0, 0, 0));
// initialize remdering
CAnyProjection3D apr;
apr = pr;
BeginModelRenderingView(apr, &dpModel);
rmRenderModel.rm_vLightDirection = FLOAT3D(0.2f, -0.2f, -0.2f);
// if model needs floor
if (mg_moFloor.GetData() != NULL) {
// set floor's position
CPlacement3D pl = mg_plModel;
pl.pl_OrientationAngle = ANGLE3D(0, 0, 0);
pl.pl_PositionVector = mg_plModel.pl_PositionVector;
pl.pl_PositionVector(2) += mg_fFloorY;
rmRenderModel.SetObjectPlacement(pl);
// render the floor
rmRenderModel.rm_colLight = C_WHITE;
rmRenderModel.rm_colAmbient = C_WHITE;
mg_moFloor.SetupModelRendering(rmRenderModel);
mg_moFloor.RenderModel(rmRenderModel);
}
// set model's position
CPlacement3D pl;
pl.pl_OrientationAngle = mg_plModel.pl_OrientationAngle;
pl.pl_PositionVector = mg_plModel.pl_PositionVector;
extern FLOAT sam_fPlayerOffset;
pl.pl_PositionVector(3) += sam_fPlayerOffset;
rmRenderModel.SetObjectPlacement(pl);
// render the model
rmRenderModel.rm_colLight = LerpColor(C_BLACK, C_WHITE, 0.4f) | CT_OPAQUE;
rmRenderModel.rm_colAmbient = LerpColor(C_BLACK, C_WHITE, 0.2f) | CT_OPAQUE;
mg_moModel.SetupModelRendering(rmRenderModel);
FLOATplane3D plFloorPlane = FLOATplane3D(FLOAT3D(0.0f, 1.0f, 0.0f),
mg_plModel.pl_PositionVector(2) + mg_fFloorY);
FLOAT3D vShadowLightDir = FLOAT3D(-0.2f, -0.4f, -0.6f);
CPlacement3D plLightPlacement = CPlacement3D(
mg_plModel.pl_PositionVector +
vShadowLightDir*mg_plModel.pl_PositionVector(3) * 5,
ANGLE3D(0, 0, 0));
mg_moModel.RenderShadow(rmRenderModel, plLightPlacement, 200.0f, 200.0f, 1.0f, plFloorPlane);
mg_moModel.RenderModel(rmRenderModel);
EndModelRenderingView();
_pGame->LCDScreenBox(_pGame->LCDGetColor(C_GREEN, "model box") | GetCurrentColor());
dpModel.Unlock();
pdp->Unlock();
pdp->Lock();
_pGame->LCDSetDrawport(pdp);
// print the model name
{
PIXaabbox2D box = FloatBoxToPixBox(pdp, BoxPlayerModelName());
COLOR col = GetCurrentColor();
PIX pixI = box.Min()(1);
PIX pixJ = box.Max()(2);
pdp->PutText(mg_strText, pixI, pixJ, col);
}
}

36
Sources/SeriousSam/GUI/Components/MGModel.h
View File

@ -1,36 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_MODEL_H
#define SE_INCL_MENU_GADGET_MODEL_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGModel : public CMGButton {
public:
CModelObject mg_moModel;
CModelObject mg_moFloor;
CPlacement3D mg_plModel;
BOOL mg_fFloorY;
CMGModel(void);
void Render(CDrawPort *pdp);
};
#endif /* include-once check. */

454
Sources/SeriousSam/GUI/Components/MGServerList.cpp
View File

@ -1,454 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "MGServerList.h"
#include "SeriousSam/GUI/Components/MGEdit.h"
extern CSoundData *_psdSelect;
extern CSoundData *_psdPress;
FLOATaabbox2D GetBoxPartHoriz(const FLOATaabbox2D &box, FLOAT fMin, FLOAT fMax)
{
FLOAT fBoxMin = box.Min()(1);
FLOAT fBoxSize = box.Size()(1);
return FLOATaabbox2D(
FLOAT2D(fBoxMin + fBoxSize*fMin, box.Min()(2)),
FLOAT2D(fBoxMin + fBoxSize*fMax, box.Max()(2)));
}
void PrintInBox(CDrawPort *pdp, PIX pixI, PIX pixJ, PIX pixSizeI, CTString str, COLOR col)
{
str = str.Undecorated();
PIX pixCharSize = pdp->dp_pixTextCharSpacing + pdp->dp_FontData->fd_pixCharWidth;
str.TrimRight(pixSizeI / pixCharSize);
// print text
pdp->PutText(str, pixI, pixJ, col);
}
CMGServerList::CMGServerList()
{
mg_iSelected = 0;
mg_iFirstOnScreen = 0;
mg_ctOnScreen = 10;
mg_pixMinI = 0;
mg_pixMaxI = 0;
mg_pixListMinJ = 0;
mg_pixListStepJ = 0;
mg_pixDragJ = -1;
mg_iDragLine = -1;
mg_pixMouseDrag = -1;
// by default, sort by ping, best on top
mg_iSort = 2;
mg_bSortDown = FALSE;
}
void CMGServerList::AdjustFirstOnScreen(void)
{
INDEX ctSessions = _lhServers.Count();
mg_iSelected = Clamp(mg_iSelected, 0L, ClampDn(ctSessions - 1L, 0L));
mg_iFirstOnScreen = Clamp(mg_iFirstOnScreen, 0L, ClampDn(ctSessions - mg_ctOnScreen, 0L));
if (mg_iSelected<mg_iFirstOnScreen) {
mg_iFirstOnScreen = ClampUp(mg_iSelected, ClampDn(ctSessions - mg_ctOnScreen - 1L, 0L));
} else if (mg_iSelected >= mg_iFirstOnScreen + mg_ctOnScreen) {
mg_iFirstOnScreen = ClampDn(mg_iSelected - mg_ctOnScreen + 1L, 0L);
}
}
BOOL _iSort = 0;
BOOL _bSortDown = FALSE;
int CompareSessions(const void *pv0, const void *pv1)
{
const CNetworkSession &ns0 = **(const CNetworkSession **)pv0;
const CNetworkSession &ns1 = **(const CNetworkSession **)pv1;
int iResult = 0;
switch (_iSort) {
case 0: iResult = stricmp(ns0.ns_strSession, ns1.ns_strSession); break;
case 1: iResult = stricmp(ns0.ns_strWorld, ns1.ns_strWorld); break;
case 2: iResult = Sgn(ns0.ns_tmPing - ns1.ns_tmPing); break;
case 3: iResult = Sgn(ns0.ns_ctPlayers - ns1.ns_ctPlayers); break;
case 4: iResult = stricmp(ns0.ns_strGameType, ns1.ns_strGameType); break;
case 5: iResult = stricmp(ns0.ns_strMod, ns1.ns_strMod); break;
case 6: iResult = stricmp(ns0.ns_strVer, ns1.ns_strVer); break;
}
if (iResult == 0) { // make sure we always have unique order when resorting
return stricmp(ns0.ns_strAddress, ns1.ns_strAddress);;
}
return _bSortDown ? -iResult : iResult;
}
extern CMGButton mgServerColumn[7];
extern CMGEdit mgServerFilter[7];
void SortAndFilterServers(void)
{
{FORDELETELIST(CNetworkSession, ns_lnNode, _lhServers, itns) {
delete &*itns;
}}
{FOREACHINLIST(CNetworkSession, ns_lnNode, _pNetwork->ga_lhEnumeratedSessions, itns) {
CNetworkSession &ns = *itns;
extern CTString _strServerFilter[7];
if (_strServerFilter[0] != "" && !ns.ns_strSession.Matches("*" + _strServerFilter[0] + "*")) continue;
if (_strServerFilter[1] != "" && !ns.ns_strWorld.Matches("*" + _strServerFilter[1] + "*")) continue;
if (_strServerFilter[2] != "") {
char strCompare[3] = { 0, 0, 0 };
int iPing = 0;
_strServerFilter[2].ScanF("%2[<>=]%d", strCompare, &iPing);
if (strcmp(strCompare, "<") == 0 && !(int(ns.ns_tmPing * 1000)< iPing)) continue;
if (strcmp(strCompare, "<=") == 0 && !(int(ns.ns_tmPing * 1000) <= iPing)) continue;
if (strcmp(strCompare, ">") == 0 && !(int(ns.ns_tmPing * 1000)> iPing)) continue;
if (strcmp(strCompare, ">=") == 0 && !(int(ns.ns_tmPing * 1000) >= iPing)) continue;
if (strcmp(strCompare, "=") == 0 && !(int(ns.ns_tmPing * 1000) == iPing)) continue;
}
if (_strServerFilter[3] != "") {
char strCompare[3] = { 0, 0, 0 };
int iPlayers = 0;
_strServerFilter[3].ScanF("%2[<>=]%d", strCompare, &iPlayers);
if (strcmp(strCompare, "<") == 0 && !(ns.ns_ctPlayers< iPlayers)) continue;
if (strcmp(strCompare, "<=") == 0 && !(ns.ns_ctPlayers <= iPlayers)) continue;
if (strcmp(strCompare, ">") == 0 && !(ns.ns_ctPlayers> iPlayers)) continue;
if (strcmp(strCompare, ">=") == 0 && !(ns.ns_ctPlayers >= iPlayers)) continue;
if (strcmp(strCompare, "=") == 0 && !(ns.ns_ctPlayers == iPlayers)) continue;
}
if (_strServerFilter[4] != "" && !ns.ns_strGameType.Matches("*" + _strServerFilter[4] + "*")) continue;
if (_strServerFilter[5] != "" && !ns.ns_strMod.Matches("*" + _strServerFilter[5] + "*")) continue;
if (_strServerFilter[6] != "" && !ns.ns_strVer.Matches("*" + _strServerFilter[6] + "*")) continue;
CNetworkSession *pnsNew = new CNetworkSession;
pnsNew->Copy(*itns);
_lhServers.AddTail(pnsNew->ns_lnNode);
}
}
_lhServers.Sort(CompareSessions, offsetof(CNetworkSession, ns_lnNode));
}
void CMGServerList::Render(CDrawPort *pdp)
{
_iSort = mg_iSort;
_bSortDown = mg_bSortDown;
SortAndFilterServers();
SetFontSmall(pdp);
BOOL bFocusedBefore = mg_bFocused;
mg_bFocused = FALSE;
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
COLOR col = GetCurrentColor();
PIX pixDPSizeI = pdp->GetWidth();
PIX pixDPSizeJ = pdp->GetHeight();
PIX pixCharSizeI = pdp->dp_pixTextCharSpacing + pdp->dp_FontData->fd_pixCharWidth;
PIX pixCharSizeJ = pdp->dp_pixTextLineSpacing + pdp->dp_FontData->fd_pixCharHeight + 1;
PIX pixLineSize = 1;
PIX pixSliderSizeI = 10;
PIX pixOuterMargin = 20;
INDEX ctSessions = _lhServers.Count();
INDEX iSession = 0;
INDEX ctColumns[7];
{for (INDEX i = 0; i<ARRAYCOUNT(ctColumns); i++) {
ctColumns[i] = mgServerColumn[i].mg_strText.Length() + 1;
}}
PIX pixSizePing = Max(PIX(pixCharSizeI * 5), pixCharSizeI*ctColumns[2]) + pixLineSize * 2;
PIX pixSizePlayerCt = Max(PIX(pixCharSizeI * 5), pixCharSizeI*ctColumns[3]) + pixLineSize * 2;
PIX pixSizeGameType = Max(Min(PIX(pixCharSizeI * 20), PIX(pixDPSizeI*0.2f)), pixCharSizeI*ctColumns[4]) + pixLineSize * 2;
PIX pixSizeMapName = Max(PIX(pixDPSizeI*0.25f), pixCharSizeI*ctColumns[1]) + pixLineSize * 2;
PIX pixSizeMod = Max(Min(PIX(pixCharSizeI * 11), PIX(pixDPSizeI*0.2f)), pixCharSizeI*ctColumns[5]) + pixLineSize * 2;
PIX pixSizeVer = Max(PIX(pixCharSizeI * 7), pixCharSizeI*ctColumns[6]) + pixLineSize * 2;
PIX apixSeparatorI[9];
apixSeparatorI[0] = pixOuterMargin;
apixSeparatorI[8] = pixDPSizeI - pixOuterMargin - pixLineSize;
apixSeparatorI[7] = apixSeparatorI[8] - pixSliderSizeI - pixLineSize;
apixSeparatorI[6] = apixSeparatorI[7] - pixSizeVer - pixLineSize;
apixSeparatorI[5] = apixSeparatorI[6] - pixSizeMod - pixLineSize;
apixSeparatorI[4] = apixSeparatorI[5] - pixSizeGameType - pixLineSize;
apixSeparatorI[3] = apixSeparatorI[4] - pixSizePlayerCt - pixLineSize;
apixSeparatorI[2] = apixSeparatorI[3] - pixSizePing - pixLineSize;
apixSeparatorI[1] = apixSeparatorI[2] - pixSizeMapName - pixLineSize;
apixSeparatorI[1] = apixSeparatorI[2] - pixSizeMapName - pixLineSize;
PIX pixSizeServerName = apixSeparatorI[1] - apixSeparatorI[0] - pixLineSize;
PIX pixTopJ = pixDPSizeJ*0.15f;
PIX pixBottomJ = pixDPSizeJ*0.82f;
PIX pixFilterTopJ = pixTopJ + pixLineSize * 3 + pixCharSizeJ + pixLineSize * 3;
PIX pixListTopJ = pixFilterTopJ + pixLineSize + pixCharSizeJ + pixLineSize;
INDEX ctSessionsOnScreen = (pixBottomJ - pixListTopJ) / pixCharSizeJ;
pixBottomJ = pixListTopJ + pixCharSizeJ*ctSessionsOnScreen + pixLineSize * 2;
mg_pixMinI = apixSeparatorI[0];
mg_pixMaxI = apixSeparatorI[5];
mg_pixListMinJ = pixListTopJ;
mg_pixListStepJ = pixCharSizeJ;
mg_pixSBMinI = apixSeparatorI[7];
mg_pixSBMaxI = apixSeparatorI[8];
mg_pixSBMinJ = pixListTopJ;
mg_pixSBMaxJ = pixBottomJ;
mg_pixHeaderMinJ = pixTopJ;
mg_pixHeaderMidJ = pixTopJ + pixLineSize + pixCharSizeJ;
mg_pixHeaderMaxJ = pixTopJ + (pixLineSize + pixCharSizeJ) * 2;
memcpy(mg_pixHeaderI, apixSeparatorI, sizeof(mg_pixHeaderI));
{for (INDEX i = 0; i<ARRAYCOUNT(mgServerFilter); i++) {
mgServerColumn[i].mg_boxOnScreen = PixBoxToFloatBox(pdp,
PIXaabbox2D(PIX2D(apixSeparatorI[i] + pixCharSizeI / 2, pixTopJ + pixLineSize * 4), PIX2D(apixSeparatorI[i + 1] - pixCharSizeI / 2, pixTopJ + pixLineSize * 4 + pixCharSizeJ)));
mgServerFilter[i].mg_boxOnScreen = PixBoxToFloatBox(pdp,
PIXaabbox2D(PIX2D(apixSeparatorI[i] + pixCharSizeI / 2, pixFilterTopJ), PIX2D(apixSeparatorI[i + 1] - pixCharSizeI / 2, pixFilterTopJ + pixCharSizeJ)));
}}
for (INDEX i = 0; i<ARRAYCOUNT(apixSeparatorI); i++) {
pdp->DrawLine(apixSeparatorI[i], pixTopJ, apixSeparatorI[i], pixBottomJ, col | CT_OPAQUE);
}
pdp->DrawLine(apixSeparatorI[0], pixTopJ, apixSeparatorI[8], pixTopJ, col | CT_OPAQUE);
pdp->DrawLine(apixSeparatorI[0], pixListTopJ - pixLineSize, apixSeparatorI[8], pixListTopJ - pixLineSize, col | CT_OPAQUE);
pdp->DrawLine(apixSeparatorI[0], pixBottomJ, apixSeparatorI[8], pixBottomJ, col | CT_OPAQUE);
PIXaabbox2D boxHandle = GetScrollBarHandleBox();
pdp->Fill(boxHandle.Min()(1) + 2, boxHandle.Min()(2) + 2, boxHandle.Size()(1) - 3, boxHandle.Size()(2) - 3, col | CT_OPAQUE);
PIX pixJ = pixTopJ + pixLineSize * 2 + 1;
mg_ctOnScreen = ctSessionsOnScreen;
AdjustFirstOnScreen();
if (_lhServers.Count() == 0) {
if (_pNetwork->ga_strEnumerationStatus != "") {
mg_bFocused = TRUE;
COLOR colItem = GetCurrentColor();
PrintInBox(pdp, apixSeparatorI[0] + pixCharSizeI, pixListTopJ + pixCharSizeJ + pixLineSize + 1, apixSeparatorI[1] - apixSeparatorI[0],
TRANS("searching..."), colItem);
}
} else {
FOREACHINLIST(CNetworkSession, ns_lnNode, _lhServers, itns) {
CNetworkSession &ns = *itns;
if (iSession<mg_iFirstOnScreen || iSession >= mg_iFirstOnScreen + ctSessionsOnScreen) {
iSession++;
continue;
}
PIX pixJ = pixListTopJ + (iSession - mg_iFirstOnScreen)*pixCharSizeJ + pixLineSize + 1;
mg_bFocused = bFocusedBefore&&iSession == mg_iSelected;
COLOR colItem = GetCurrentColor();
if (ns.ns_strVer != _SE_VER_STRING) {
colItem = MulColors(colItem, 0xA0A0A0FF);
}
CTString strPing(0, "%4d", INDEX(ns.ns_tmPing * 1000));
CTString strPlayersCt(0, "%2d/%2d", ns.ns_ctPlayers, ns.ns_ctMaxPlayers);
CTString strMod = ns.ns_strMod;
if (strMod == "") {
strMod = "SeriousSam";
}
PrintInBox(pdp, apixSeparatorI[0] + pixCharSizeI / 2, pixJ, apixSeparatorI[1] - apixSeparatorI[0] - pixCharSizeI, ns.ns_strSession, colItem);
PrintInBox(pdp, apixSeparatorI[1] + pixCharSizeI / 2, pixJ, apixSeparatorI[2] - apixSeparatorI[1] - pixCharSizeI, TranslateConst(ns.ns_strWorld), colItem);
PrintInBox(pdp, apixSeparatorI[2] + pixCharSizeI / 2, pixJ, apixSeparatorI[3] - apixSeparatorI[2] - pixCharSizeI, strPing, colItem);
PrintInBox(pdp, apixSeparatorI[3] + pixCharSizeI / 2, pixJ, apixSeparatorI[4] - apixSeparatorI[3] - pixCharSizeI, strPlayersCt, colItem);
PrintInBox(pdp, apixSeparatorI[4] + pixCharSizeI / 2, pixJ, apixSeparatorI[5] - apixSeparatorI[4] - pixCharSizeI, TranslateConst(ns.ns_strGameType), colItem);
PrintInBox(pdp, apixSeparatorI[5] + pixCharSizeI / 2, pixJ, apixSeparatorI[6] - apixSeparatorI[5] - pixCharSizeI, TranslateConst(strMod), colItem);
PrintInBox(pdp, apixSeparatorI[6] + pixCharSizeI / 2, pixJ, apixSeparatorI[7] - apixSeparatorI[6] - pixCharSizeI, ns.ns_strVer, colItem);
iSession++;
}
}
mg_bFocused = bFocusedBefore;
}
static INDEX SliderPixToIndex(PIX pixOffset, INDEX iVisible, INDEX iTotal, PIXaabbox2D boxFull)
{
FLOAT fSize = ClampUp(FLOAT(iVisible) / iTotal, 1.0f);
PIX pixFull = boxFull.Size()(2);
PIX pixSize = PIX(pixFull*fSize);
if (pixSize >= boxFull.Size()(2)) {
return 0;
}
return (iTotal*pixOffset) / pixFull;
}
static PIXaabbox2D GetSliderBox(INDEX iFirst, INDEX iVisible, INDEX iTotal,
PIXaabbox2D boxFull)
{
if (iTotal <= 0) {
return boxFull;
}
FLOAT fSize = ClampUp(FLOAT(iVisible) / iTotal, 1.0f);
PIX pixFull = boxFull.Size()(2);
PIX pixSize = PIX(pixFull*fSize);
pixSize = ClampDn(pixSize, boxFull.Size()(1));
PIX pixTop = pixFull*(FLOAT(iFirst) / iTotal) + boxFull.Min()(2);
PIX pixI0 = boxFull.Min()(1);
PIX pixI1 = boxFull.Max()(1);
return PIXaabbox2D(PIX2D(pixI0, pixTop), PIX2D(pixI1, pixTop + pixSize));
}
PIXaabbox2D CMGServerList::GetScrollBarFullBox(void)
{
return PIXaabbox2D(PIX2D(mg_pixSBMinI, mg_pixSBMinJ), PIX2D(mg_pixSBMaxI, mg_pixSBMaxJ));
}
PIXaabbox2D CMGServerList::GetScrollBarHandleBox(void)
{
return GetSliderBox(mg_iFirstOnScreen, mg_ctOnScreen, _lhServers.Count(), GetScrollBarFullBox());
}
void CMGServerList::OnMouseOver(PIX pixI, PIX pixJ)
{
mg_pixMouseI = pixI;
mg_pixMouseJ = pixJ;
if (!(GetKeyState(VK_LBUTTON) & 0x8000)) {
mg_pixDragJ = -1;
}
BOOL bInSlider = (pixI >= mg_pixSBMinI && pixI <= mg_pixSBMaxI && pixJ >= mg_pixSBMinJ && pixJ <= mg_pixSBMaxJ);
if (mg_pixDragJ >= 0 && bInSlider) {
PIX pixDelta = pixJ - mg_pixDragJ;
INDEX ctSessions = _lhServers.Count();
INDEX iWantedLine = mg_iDragLine +
SliderPixToIndex(pixDelta, mg_ctOnScreen, ctSessions, GetScrollBarFullBox());
mg_iFirstOnScreen = Clamp(iWantedLine, 0L, ClampDn(ctSessions - mg_ctOnScreen, 0L));
mg_iSelected = Clamp(mg_iSelected, mg_iFirstOnScreen, mg_iFirstOnScreen + mg_ctOnScreen - 1L);
// AdjustFirstOnScreen();
return;
}
// if some server is selected
if (pixI >= mg_pixMinI && pixI <= mg_pixMaxI) {
INDEX iOnScreen = (pixJ - mg_pixListMinJ) / mg_pixListStepJ;
if (iOnScreen >= 0 && iOnScreen<mg_ctOnScreen) {
// put focus on it
mg_iSelected = mg_iFirstOnScreen + iOnScreen;
AdjustFirstOnScreen();
mg_pixMouseDrag = -1;
}
} else if (bInSlider) {
mg_pixMouseDrag = pixJ;
}
}
BOOL CMGServerList::OnKeyDown(int iVKey)
{
switch (iVKey) {
case VK_UP:
mg_iSelected -= 1;
AdjustFirstOnScreen();
break;
case VK_DOWN:
mg_iSelected += 1;
AdjustFirstOnScreen();
break;
case VK_PRIOR:
mg_iSelected -= mg_ctOnScreen - 1;
mg_iFirstOnScreen -= mg_ctOnScreen - 1;
AdjustFirstOnScreen();
break;
case VK_NEXT:
mg_iSelected += mg_ctOnScreen - 1;
mg_iFirstOnScreen += mg_ctOnScreen - 1;
AdjustFirstOnScreen();
break;
case 11:
mg_iSelected -= 3;
mg_iFirstOnScreen -= 3;
AdjustFirstOnScreen();
break;
case 10:
mg_iSelected += 3;
mg_iFirstOnScreen += 3;
AdjustFirstOnScreen();
break;
case VK_LBUTTON:
/* if (mg_pixMouseJ>=mg_pixHeaderMinJ && mg_pixMouseJ<=mg_pixHeaderMidJ
&& mg_pixMouseI>=mg_pixHeaderI[0] && mg_pixMouseI<=mg_pixHeaderI[7]) {
INDEX iNewSort = mg_iSort;
if (mg_pixMouseI<=mg_pixHeaderI[1]) {
iNewSort = 0;
} else if (mg_pixMouseI<=mg_pixHeaderI[2]) {
iNewSort = 1;
} else if (mg_pixMouseI<=mg_pixHeaderI[3]) {
iNewSort = 2;
} else if (mg_pixMouseI<=mg_pixHeaderI[4]) {
iNewSort = 3;
} else if (mg_pixMouseI<=mg_pixHeaderI[5]) {
iNewSort = 4;
} else if (mg_pixMouseI<=mg_pixHeaderI[6]) {
iNewSort = 5;
} else if (mg_pixMouseI<=mg_pixHeaderI[7]) {
iNewSort = 6;
}
if (iNewSort==mg_iSort) {
mg_bSortDown = !mg_bSortDown;
} else {
mg_bSortDown = FALSE;
}
mg_iSort = iNewSort;
break;
} else */if (mg_pixMouseDrag >= 0) {
mg_pixDragJ = mg_pixMouseDrag;
mg_iDragLine = mg_iFirstOnScreen;
break;
}
case VK_RETURN:
PlayMenuSound(_psdPress);
IFeel_PlayEffect("Menu_press");
{INDEX i = 0;
FOREACHINLIST(CNetworkSession, ns_lnNode, _lhServers, itns) {
if (i == mg_iSelected) {
char strAddress[256];
int iPort;
itns->ns_strAddress.ScanF("%200[^:]:%d", &strAddress, &iPort);
_pGame->gam_strJoinAddress = strAddress;
_pShell->SetINDEX("net_iPort", iPort);
extern void StartSelectPlayersMenuFromServers(void);
StartSelectPlayersMenuFromServers();
return TRUE;
}
i++;
}}
break;
default:
return FALSE;
}
return TRUE;
}
void CMGServerList::OnSetFocus(void)
{
mg_bFocused = TRUE;
}
void CMGServerList::OnKillFocus(void)
{
mg_bFocused = FALSE;
}

67
Sources/SeriousSam/GUI/Components/MGServerList.h
View File

@ -1,67 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_SERVERLIST_H
#define SE_INCL_MENU_GADGET_SERVERLIST_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGServerList : public CMGButton {
public:
INDEX mg_iSelected;
INDEX mg_iFirstOnScreen;
INDEX mg_ctOnScreen;
// server list dimensions
PIX mg_pixMinI;
PIX mg_pixMaxI;
PIX mg_pixListMinJ;
PIX mg_pixListStepJ;
// header dimensions
PIX mg_pixHeaderMinJ;
PIX mg_pixHeaderMidJ;
PIX mg_pixHeaderMaxJ;
PIX mg_pixHeaderI[8];
// scrollbar dimensions
PIX mg_pixSBMinI;
PIX mg_pixSBMaxI;
PIX mg_pixSBMinJ;
PIX mg_pixSBMaxJ;
// scrollbar dragging params
PIX mg_pixDragJ;
PIX mg_iDragLine;
PIX mg_pixMouseDrag;
// current mouse pos
PIX mg_pixMouseI;
PIX mg_pixMouseJ;
INDEX mg_iSort; // column to sort by
BOOL mg_bSortDown; // sort in reverse order
CMGServerList();
BOOL OnKeyDown(int iVKey);
PIXaabbox2D GetScrollBarFullBox(void);
PIXaabbox2D GetScrollBarHandleBox(void);
void OnSetFocus(void);
void OnKillFocus(void);
void Render(CDrawPort *pdp);
void AdjustFirstOnScreen(void);
void OnMouseOver(PIX pixI, PIX pixJ);
};
#endif /* include-once check. */

126
Sources/SeriousSam/GUI/Components/MGSlider.cpp
View File

@ -1,126 +0,0 @@
/* /* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGSlider.h"
extern PIX _pixCursorPosI;
extern PIX _pixCursorPosJ;
extern INDEX sam_bWideScreen;
CMGSlider::CMGSlider()
{
mg_iMinPos = 0;
mg_iMaxPos = 16;
mg_iCurPos = 8;
mg_pOnSliderChange = NULL;
mg_fFactor = 1.0f;
}
void CMGSlider::ApplyCurrentPosition(void)
{
mg_iCurPos = Clamp(mg_iCurPos, mg_iMinPos, mg_iMaxPos);
FLOAT fStretch = FLOAT(mg_iCurPos) / (mg_iMaxPos - mg_iMinPos);
mg_fFactor = fStretch;
if (mg_pOnSliderChange != NULL) {
mg_pOnSliderChange(mg_iCurPos);
}
}
void CMGSlider::ApplyGivenPosition(INDEX iMin, INDEX iMax, INDEX iCur)
{
mg_iMinPos = iMin;
mg_iMaxPos = iMax;
mg_iCurPos = iCur;
ApplyCurrentPosition();
}
BOOL CMGSlider::OnKeyDown(int iVKey)
{
// if scrolling left
if ((iVKey == VK_BACK || iVKey == VK_LEFT) && mg_iCurPos>mg_iMinPos) {
mg_iCurPos--;
ApplyCurrentPosition();
return TRUE;
// if scrolling right
} else if ((iVKey == VK_RETURN || iVKey == VK_RIGHT) && mg_iCurPos<mg_iMaxPos) {
mg_iCurPos++;
ApplyCurrentPosition();
return TRUE;
// if lmb pressed
} else if (iVKey == VK_LBUTTON) {
// get position of slider box on screen
PIXaabbox2D boxSlider = GetSliderBox();
// if mouse is within
if (boxSlider >= PIX2D(_pixCursorPosI, _pixCursorPosJ)) {
// set new position exactly where mouse pointer is
FLOAT fRatio = FLOAT(_pixCursorPosI - boxSlider.Min()(1)) / boxSlider.Size()(1);
fRatio = (fRatio - 0.01f) / (0.99f - 0.01f);
fRatio = Clamp(fRatio, 0.0f, 1.0f);
mg_iCurPos = fRatio*(mg_iMaxPos - mg_iMinPos) + mg_iMinPos;
ApplyCurrentPosition();
return TRUE;
}
}
return CMenuGadget::OnKeyDown(iVKey);
}
PIXaabbox2D CMGSlider::GetSliderBox(void)
{
extern CDrawPort *pdp;
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
PIX pixIR = box.Min()(1) + box.Size()(1)*0.55f;
PIX pixJ = box.Min()(2);
PIX pixJSize = box.Size()(2)*0.95f;
PIX pixISizeR = box.Size()(1)*0.45f;
if (sam_bWideScreen) pixJSize++;
return PIXaabbox2D(PIX2D(pixIR + 1, pixJ + 1), PIX2D(pixIR + pixISizeR - 2, pixJ + pixJSize - 2));
}
void CMGSlider::Render(CDrawPort *pdp)
{
SetFontMedium(pdp);
// get geometry
COLOR col = GetCurrentColor();
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
PIX pixIL = box.Min()(1) + box.Size()(1)*0.45f;
PIX pixIR = box.Min()(1) + box.Size()(1)*0.55f;
PIX pixJ = box.Min()(2);
PIX pixJSize = box.Size()(2)*0.95f;
PIX pixISizeR = box.Size()(1)*0.45f;
if (sam_bWideScreen) pixJSize++;
// print text left of slider
pdp->PutTextR(mg_strText, pixIL, pixJ, col);
// draw box around slider
_pGame->LCDDrawBox(0, -1, PIXaabbox2D(PIX2D(pixIR + 1, pixJ), PIX2D(pixIR + pixISizeR - 2, pixJ + pixJSize - 2)),
_pGame->LCDGetColor(C_GREEN | 255, "slider box"));
// draw filled part of slider
pdp->Fill(pixIR + 2, pixJ + 1, (pixISizeR - 5)*mg_fFactor, (pixJSize - 4), col);
// print percentage text
CTString strPercentage;
strPercentage.PrintF("%d%%", (int)floor(mg_fFactor * 100 + 0.5f));
pdp->PutTextC(strPercentage, pixIR + pixISizeR / 2, pixJ + 1, col);
}

42
Sources/SeriousSam/GUI/Components/MGSlider.h
View File

@ -1,42 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_SLIDER_H
#define SE_INCL_MENU_GADGET_SLIDER_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGSlider : public CMGButton {
public:
FLOAT mg_fFactor;
INDEX mg_iMinPos;
INDEX mg_iMaxPos;
INDEX mg_iCurPos;
CMGSlider();
void ApplyCurrentPosition(void);
void ApplyGivenPosition(INDEX iMin, INDEX iMax, INDEX iCur);
// return TRUE if handled
virtual BOOL OnKeyDown(int iVKey);
void(*mg_pOnSliderChange)(INDEX iCurPos);
PIXaabbox2D GetSliderBox(void);
void Render(CDrawPort *pdp);
};
#endif /* include-once check. */

32
Sources/SeriousSam/GUI/Components/MGTitle.cpp
View File

@ -1,32 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGTitle.h"
void CMGTitle::Render(CDrawPort *pdp)
{
SetFontTitle(pdp);
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
PIX pixI = box.Center()(1);
PIX pixJ = box.Min()(2);
pdp->PutTextC(mg_strText, pixI, pixJ, _pGame->LCDGetColor(C_WHITE | CT_OPAQUE, "title"));
}

31
Sources/SeriousSam/GUI/Components/MGTitle.h
View File

@ -1,31 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_TITLE_H
#define SE_INCL_MENU_GADGET_TITLE_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MenuGadget.h"
class CMGTitle : public CMenuGadget {
public:
CTString mg_strText;
void Render(CDrawPort *pdp);
};
#endif /* include-once check. */

122
Sources/SeriousSam/GUI/Components/MGTrigger.cpp
View File

@ -1,122 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Components/MGTrigger.h"
INDEX GetNewLoopValue(int iVKey, INDEX iCurrent, INDEX ctMembers)
{
INDEX iPrev = (iCurrent + ctMembers - 1) % ctMembers;
INDEX iNext = (iCurrent + 1) % ctMembers;
// return and right arrow set new text
if (iVKey == VK_RETURN || iVKey == VK_LBUTTON || iVKey == VK_RIGHT)
{
return iNext;
// left arrow and backspace sets prev text
} else if ((iVKey == VK_BACK || iVKey == VK_RBUTTON) || (iVKey == VK_LEFT)) {
return iPrev;
}
return iCurrent;
}
CMGTrigger::CMGTrigger(void)
{
mg_pPreTriggerChange = NULL;
mg_pOnTriggerChange = NULL;
mg_iCenterI = 0;
mg_bVisual = FALSE;
}
void CMGTrigger::ApplyCurrentSelection(void)
{
mg_iSelected = Clamp(mg_iSelected, 0L, mg_ctTexts - 1L);
mg_strValue = mg_astrTexts[mg_iSelected];
}
void CMGTrigger::OnSetNextInList(int iVKey)
{
if (mg_pPreTriggerChange != NULL) {
mg_pPreTriggerChange(mg_iSelected);
}
mg_iSelected = GetNewLoopValue(iVKey, mg_iSelected, mg_ctTexts);
mg_strValue = mg_astrTexts[mg_iSelected];
if (mg_pOnTriggerChange != NULL) {
(*mg_pOnTriggerChange)(mg_iSelected);
}
}
BOOL CMGTrigger::OnKeyDown(int iVKey)
{
if ((iVKey == VK_RETURN || iVKey == VK_LBUTTON) ||
(iVKey == VK_LEFT) ||
(iVKey == VK_BACK || iVKey == VK_RBUTTON) ||
(iVKey == VK_RIGHT))
{
// key is handled
if (mg_bEnabled) OnSetNextInList(iVKey);
return TRUE;
}
// key is not handled
return FALSE;
}
void CMGTrigger::Render(CDrawPort *pdp)
{
SetFontMedium(pdp);
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
PIX pixIL = box.Min()(1) + box.Size()(1)*0.45f;
PIX pixIR = box.Min()(1) + box.Size()(1)*0.55f;
PIX pixJ = box.Min()(2);
COLOR col = GetCurrentColor();
if (!mg_bVisual || mg_strValue == "") {
CTString strValue = mg_strValue;
if (mg_bVisual) {
strValue = TRANS("none");
}
if (mg_iCenterI == -1) {
pdp->PutText(mg_strLabel, box.Min()(1), pixJ, col);
pdp->PutTextR(strValue, box.Max()(1), pixJ, col);
} else {
pdp->PutTextR(mg_strLabel, pixIL, pixJ, col);
pdp->PutText(strValue, pixIR, pixJ, col);
}
} else {
CTString strLabel = mg_strLabel + ": ";
pdp->PutText(strLabel, box.Min()(1), pixJ, col);
CTextureObject to;
try {
to.SetData_t(mg_strValue);
CTextureData *ptd = (CTextureData *)to.GetData();
PIX pixSize = box.Size()(2);
PIX pixCX = box.Max()(1) - pixSize / 2;
PIX pixCY = box.Center()(2);
pdp->PutTexture(&to, PIXaabbox2D(
PIX2D(pixCX - pixSize / 2, pixCY - pixSize / 2),
PIX2D(pixCX - pixSize / 2 + pixSize, pixCY - pixSize / 2 + pixSize)), C_WHITE | 255);
} catch (char *strError) {
CPrintF("%s\n", strError);
}
to.SetData(NULL);
}
}

47
Sources/SeriousSam/GUI/Components/MGTrigger.h
View File

@ -1,47 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_TRIGGER_H
#define SE_INCL_MENU_GADGET_TRIGGER_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MenuGadget.h"
class CMGTrigger : public CMenuGadget {
public:
CTString mg_strLabel;
CTString mg_strValue;
CTString *mg_astrTexts;
INDEX mg_ctTexts;
INDEX mg_iSelected;
INDEX mg_iCenterI;
BOOL mg_bVisual;
CMGTrigger(void);
void ApplyCurrentSelection(void);
void OnSetNextInList(int iVKey);
void(*mg_pPreTriggerChange)(INDEX iCurrentlySelected);
void(*mg_pOnTriggerChange)(INDEX iCurrentlySelected);
// return TRUE if handled
BOOL OnKeyDown(int iVKey);
void Render(CDrawPort *pdp);
};
#endif /* include-once check. */

181
Sources/SeriousSam/GUI/Components/MGVarButton.cpp
View File

@ -1,181 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/VarList.h"
#include "SeriousSam/GUI/Components/MGVarButton.h"
extern PIX _pixCursorPosI;
extern PIX _pixCursorPosJ;
BOOL CMGVarButton::IsSeparator(void)
{
if (mg_pvsVar == NULL) return FALSE;
return mg_pvsVar->vs_bSeparator;
}
BOOL CMGVarButton::IsEnabled(void)
{
return(_gmRunningGameMode == GM_NONE
|| mg_pvsVar == NULL
|| mg_pvsVar->vs_bCanChangeInGame);
}
// return slider position on scren
PIXaabbox2D CMGVarButton::GetSliderBox(void)
{
extern CDrawPort *pdp;
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
PIX pixIR = box.Min()(1) + box.Size()(1)*0.55f;
PIX pixJ = box.Min()(2);
PIX pixISize = box.Size()(1)*0.13f;
PIX pixJSize = box.Size()(2);
return PIXaabbox2D(PIX2D(pixIR, pixJ + 1), PIX2D(pixIR + pixISize - 4, pixJ + pixJSize - 6));
}
extern BOOL _bVarChanged;
BOOL CMGVarButton::OnKeyDown(int iVKey)
{
if (mg_pvsVar == NULL || mg_pvsVar->vs_bSeparator || !mg_pvsVar->Validate() || !mg_bEnabled) {
return CMenuGadget::OnKeyDown(iVKey);
}
// handle slider
if (mg_pvsVar->vs_iSlider && !mg_pvsVar->vs_bCustom) {
// ignore RMB
if (iVKey == VK_RBUTTON) return TRUE;
// handle LMB
if (iVKey == VK_LBUTTON) {
// get position of slider box on screen
PIXaabbox2D boxSlider = GetSliderBox();
// if mouse is within
if (boxSlider >= PIX2D(_pixCursorPosI, _pixCursorPosJ)) {
// set new position exactly where mouse pointer is
mg_pvsVar->vs_iValue = (FLOAT)(_pixCursorPosI - boxSlider.Min()(1)) / boxSlider.Size()(1) * (mg_pvsVar->vs_ctValues);
_bVarChanged = TRUE;
}
// handled
return TRUE;
}
}
if (iVKey == VK_RETURN) {
FlushVarSettings(TRUE);
void MenuGoToParent(void);
MenuGoToParent();
return TRUE;
}
if (iVKey == VK_LBUTTON || iVKey == VK_RIGHT) {
if (mg_pvsVar != NULL) {
INDEX iOldValue = mg_pvsVar->vs_iValue;
mg_pvsVar->vs_iValue++;
if (mg_pvsVar->vs_iValue >= mg_pvsVar->vs_ctValues) {
// wrap non-sliders, clamp sliders
if (mg_pvsVar->vs_iSlider) mg_pvsVar->vs_iValue = mg_pvsVar->vs_ctValues - 1L;
else mg_pvsVar->vs_iValue = 0;
}
if (iOldValue != mg_pvsVar->vs_iValue) {
_bVarChanged = TRUE;
mg_pvsVar->vs_bCustom = FALSE;
mg_pvsVar->Validate();
}
}
return TRUE;
}
if (iVKey == VK_LEFT || iVKey == VK_RBUTTON) {
if (mg_pvsVar != NULL) {
INDEX iOldValue = mg_pvsVar->vs_iValue;
mg_pvsVar->vs_iValue--;
if (mg_pvsVar->vs_iValue<0) {
// wrap non-sliders, clamp sliders
if (mg_pvsVar->vs_iSlider) mg_pvsVar->vs_iValue = 0;
else mg_pvsVar->vs_iValue = mg_pvsVar->vs_ctValues - 1L;
}
if (iOldValue != mg_pvsVar->vs_iValue) {
_bVarChanged = TRUE;
mg_pvsVar->vs_bCustom = FALSE;
mg_pvsVar->Validate();
}
}
return TRUE;
}
// not handled
return CMenuGadget::OnKeyDown(iVKey);
}
void CMGVarButton::Render(CDrawPort *pdp)
{
if (mg_pvsVar == NULL) {
return;
}
SetFontMedium(pdp);
PIXaabbox2D box = FloatBoxToPixBox(pdp, mg_boxOnScreen);
PIX pixIL = box.Min()(1) + box.Size()(1)*0.45f;
PIX pixIR = box.Min()(1) + box.Size()(1)*0.55f;
PIX pixIC = box.Center()(1);
PIX pixJ = box.Min()(2);
if (mg_pvsVar->vs_bSeparator)
{
mg_bEnabled = FALSE;
COLOR col = _pGame->LCDGetColor(C_WHITE | 255, "separator");
CTString strText = mg_pvsVar->vs_strName;
pdp->PutTextC(strText, pixIC, pixJ, col);
} else if (mg_pvsVar->Validate()) {
// check whether the variable is disabled
if (mg_pvsVar->vs_strFilter != "") mg_bEnabled = _pShell->GetINDEX(mg_pvsVar->vs_strFilter);
COLOR col = GetCurrentColor();
pdp->PutTextR(mg_pvsVar->vs_strName, pixIL, pixJ, col);
// custom is by default
CTString strText = TRANS("Custom");
if (!mg_pvsVar->vs_bCustom)
{ // not custom!
strText = mg_pvsVar->vs_astrTexts[mg_pvsVar->vs_iValue];
// need slider?
if (mg_pvsVar->vs_iSlider>0) {
// draw box around slider
PIX pixISize = box.Size()(1)*0.13f;
PIX pixJSize = box.Size()(2);
_pGame->LCDDrawBox(0, -1, PIXaabbox2D(PIX2D(pixIR, pixJ + 1), PIX2D(pixIR + pixISize - 4, pixJ + pixJSize - 6)),
_pGame->LCDGetColor(C_GREEN | 255, "slider box"));
// draw filled part of slider
if (mg_pvsVar->vs_iSlider == 1) {
// fill slider
FLOAT fFactor = (FLOAT)(mg_pvsVar->vs_iValue + 1) / mg_pvsVar->vs_ctValues;
pdp->Fill(pixIR + 1, pixJ + 2, (pixISize - 6)*fFactor, pixJSize - 9, col);
} else {
// ratio slider
ASSERT(mg_pvsVar->vs_iSlider == 2);
FLOAT fUnitWidth = (FLOAT)(pixISize - 5) / mg_pvsVar->vs_ctValues;
pdp->Fill(pixIR + 1 + (mg_pvsVar->vs_iValue*fUnitWidth), pixJ + 2, fUnitWidth, pixJSize - 9, col);
}
// move text printout to the right of slider
pixIR += box.Size()(1)*0.15f;
}
}
// write right text
pdp->PutText(strText, pixIR, pixJ, col);
}
}

35
Sources/SeriousSam/GUI/Components/MGVarButton.h
View File

@ -1,35 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_VARBUTTON_H
#define SE_INCL_MENU_GADGET_VARBUTTON_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Components/MGButton.h"
class CMGVarButton : public CMGButton {
public:
class CVarSetting *mg_pvsVar;
PIXaabbox2D GetSliderBox(void);
BOOL OnKeyDown(int iVKey);
void Render(CDrawPort *pdp);
BOOL IsSeparator(void);
BOOL IsEnabled(void);
};
#endif /* include-once check. */

137
Sources/SeriousSam/GUI/Components/MenuGadget.cpp
View File

@ -1,137 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Base/KeyNames.h>
#include <Engine/CurrentVersion.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/LevelInfo.h"
#include "SeriousSam/VarList.h"
#include "SeriousSam/GUI/Components/MenuGadget.h"
extern CSoundData *_psdSelect;
BOOL _bDefiningKey = FALSE;
BOOL _bEditingString = FALSE;
CMenuGadget *_pmgLastActivatedGadget = NULL;
CMenuGadget::CMenuGadget(void)
{
mg_pmgLeft = NULL;
mg_pmgRight = NULL;
mg_pmgUp = NULL;
mg_pmgDown = NULL;
mg_bVisible = TRUE;
mg_bEnabled = TRUE;
mg_bLabel = FALSE;
mg_bFocused = FALSE;
mg_iInList = -1; // not in list
}
void CMenuGadget::OnActivate(void)
{
NOTHING;
}
// return TRUE if handled
BOOL CMenuGadget::OnKeyDown(int iVKey)
{
// if return pressed
if (iVKey == VK_RETURN || iVKey == VK_LBUTTON) {
// activate
OnActivate();
// key is handled
return TRUE;
}
// key is not handled
return FALSE;
}
BOOL CMenuGadget::OnChar(MSG msg)
{
// key is not handled
return FALSE;
}
void CMenuGadget::OnSetFocus(void)
{
mg_bFocused = TRUE;
if (!IsSeparator())
{
PlayMenuSound(_psdSelect);
IFeel_PlayEffect("Menu_select");
}
}
void CMenuGadget::OnKillFocus(void)
{
mg_bFocused = FALSE;
}
void CMenuGadget::Appear(void)
{
mg_bVisible = TRUE;
}
void CMenuGadget::Disappear(void)
{
mg_bVisible = FALSE;
mg_bFocused = FALSE;
}
void CMenuGadget::Think(void)
{
}
void CMenuGadget::OnMouseOver(PIX pixI, PIX pixJ)
{
}
// get current color for the gadget
COLOR CMenuGadget::GetCurrentColor(void)
{
// use normal colors
COLOR colUnselected = _pGame->LCDGetColor(C_GREEN, "unselected");
COLOR colSelected = _pGame->LCDGetColor(C_WHITE, "selected");
// if disabled
if (!mg_bEnabled) {
// use a bit darker colors
colUnselected = _pGame->LCDGetColor(C_dGREEN, "disabled unselected");
colSelected = _pGame->LCDGetColor(C_GRAY, "disabled selected");
// if label
if (mg_bLabel) {
// use white
colUnselected = colSelected = _pGame->LCDGetColor(C_WHITE, "label");
}
}
// use unselected color
COLOR colRet = colUnselected;
// if selected
if (mg_bFocused) {
// oscilate towards selected color
FLOAT tmNow = _pTimer->GetHighPrecisionTimer().GetSeconds();
colRet = LerpColor((colUnselected >> 1) & 0x7F7F7F7F, colSelected, sin(tmNow*10.0f)*0.5f + 0.5f);
}
return colRet | CT_OPAQUE;
}
void CMenuGadget::Render(CDrawPort *pdp)
{
}

70
Sources/SeriousSam/GUI/Components/MenuGadget.h
View File

@ -1,70 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_GADGET_H
#define SE_INCL_MENU_GADGET_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#define DOING_NOTHING 0
#define PRESS_KEY_WAITING 1
#define RELEASE_RETURN_WAITING 2
#define EMPTYSLOTSTRING TRANS("<save a new one>")
class CMenuGadget {
public:
CListNode mg_lnNode;
FLOATaabbox2D mg_boxOnScreen;
BOOL mg_bVisible;
BOOL mg_bEnabled;
BOOL mg_bLabel;
BOOL mg_bFocused;
INDEX mg_iInList; // for scrollable gadget lists
CTString mg_strTip;
CMenuGadget *mg_pmgLeft;
CMenuGadget *mg_pmgRight;
CMenuGadget *mg_pmgUp;
CMenuGadget *mg_pmgDown;
CMenuGadget(void);
// return TRUE if handled
virtual BOOL OnKeyDown(int iVKey);
virtual BOOL OnChar(MSG msg);
virtual void OnActivate(void);
virtual void OnSetFocus(void);
virtual void OnKillFocus(void);
virtual void Appear(void);
virtual void Disappear(void);
virtual void Think(void);
virtual void OnMouseOver(PIX pixI, PIX pixJ);
virtual COLOR GetCurrentColor(void);
virtual void Render(CDrawPort *pdp);
virtual BOOL IsSeparator(void) { return FALSE; };
};
enum ButtonFontSize {
BFS_SMALL = 0,
BFS_MEDIUM = 1,
BFS_LARGE = 2,
};
#endif /* include-once check. */

351
Sources/SeriousSam/GUI/Menus/GameMenu.cpp
View File

@ -1,351 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "SeriousSam/GUI/Menus/GameMenu.h"
CGameMenu::CGameMenu(void)
{
gm_pgmParentMenu = NULL;
gm_pmgSelectedByDefault = NULL;
gm_pmgArrowUp = NULL;
gm_pmgArrowDn = NULL;
gm_pmgListTop = NULL;
gm_pmgListBottom = NULL;
gm_iListOffset = 0;
gm_ctListVisible = 0;
gm_ctListTotal = 0;
gm_bPopup = FALSE;
}
void CGameMenu::Initialize_t(void)
{
}
void CGameMenu::Destroy(void)
{
}
void CGameMenu::FillListItems(void)
{
ASSERT(FALSE); // must be implemented to scroll up/down
}
void CGameMenu::KillAllFocuses(void)
{
// for each menu gadget in menu
FOREACHINLIST(CMenuGadget, mg_lnNode, gm_lhGadgets, itmg) {
itmg->mg_bFocused = FALSE;
}
}
void CGameMenu::Think(void)
{
}
// +-1 -> hit top/bottom when pressing up/down on keyboard
// +-2 -> pressed pageup/pagedown on keyboard
// +-3 -> pressed arrow up/down button in menu
// +-4 -> scrolling with mouse wheel
void CGameMenu::ScrollList(INDEX iDir)
{
// if not valid for scrolling
if (gm_ctListTotal <= 0
|| gm_pmgArrowUp == NULL || gm_pmgArrowDn == NULL
|| gm_pmgListTop == NULL || gm_pmgListBottom == NULL) {
// do nothing
return;
}
INDEX iOldTopKey = gm_iListOffset;
// change offset
switch (iDir) {
case -1:
gm_iListOffset -= 1;
break;
case -4:
gm_iListOffset -= 3;
break;
case -2:
case -3:
gm_iListOffset -= gm_ctListVisible;
break;
case +1:
gm_iListOffset += 1;
break;
case +4:
gm_iListOffset += 3;
break;
case +2:
case +3:
gm_iListOffset += gm_ctListVisible;
break;
default:
ASSERT(FALSE);
return;
}
if (gm_ctListTotal <= gm_ctListVisible) {
gm_iListOffset = 0;
}
else {
gm_iListOffset = Clamp(gm_iListOffset, INDEX(0), INDEX(gm_ctListTotal - gm_ctListVisible));
}
// set new names
FillListItems();
// if scroling with wheel
if (iDir == +4 || iDir == -4) {
// no focus changing
return;
}
// delete all focuses
FOREACHINLIST(CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
itmg->OnKillFocus();
}
// set new focus
const INDEX iFirst = 0;
const INDEX iLast = gm_ctListVisible - 1;
switch (iDir) {
case +1:
gm_pmgListBottom->OnSetFocus();
break;
case +2:
if (gm_iListOffset != iOldTopKey) {
gm_pmgListTop->OnSetFocus();
}
else {
gm_pmgListBottom->OnSetFocus();
}
break;
case +3:
gm_pmgArrowDn->OnSetFocus();
break;
case -1:
gm_pmgListTop->OnSetFocus();
break;
case -2:
gm_pmgListTop->OnSetFocus();
break;
case -3:
gm_pmgArrowUp->OnSetFocus();
break;
}
}
BOOL CGameMenu::OnChar(MSG msg)
{
// find curently active gadget
CMenuGadget *pmgActive = NULL;
// for each menu gadget in menu
FOREACHINLIST(CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
// if focused
if (itmg->mg_bFocused) {
// remember as active
pmgActive = &itmg.Current();
}
}
// if none focused
if (pmgActive == NULL) {
// do nothing
return FALSE;
}
// if active gadget handles it
if (pmgActive->OnChar(msg)) {
// key is handled
return TRUE;
}
// key is not handled
return FALSE;
}
// return TRUE if handled
BOOL CGameMenu::OnKeyDown(int iVKey)
{
// find curently active gadget
CMenuGadget *pmgActive = NULL;
// for each menu gadget in menu
FOREACHINLIST(CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
// if focused
if (itmg->mg_bFocused) {
// remember as active
pmgActive = &itmg.Current();
}
}
// if none focused
if (pmgActive == NULL) {
// do nothing
return FALSE;
}
// if active gadget handles it
if (pmgActive->OnKeyDown(iVKey)) {
// key is handled
return TRUE;
}
// process normal in menu movement
switch (iVKey) {
case VK_PRIOR:
ScrollList(-2);
return TRUE;
case VK_NEXT:
ScrollList(+2);
return TRUE;
case 11:
ScrollList(-4);
return TRUE;
case 10:
ScrollList(+4);
return TRUE;
case VK_UP:
// if this is top button in list
if (pmgActive == gm_pmgListTop) {
// scroll list up
ScrollList(-1);
// key is handled
return TRUE;
}
// if we can go up
if (pmgActive->mg_pmgUp != NULL && pmgActive->mg_pmgUp->mg_bVisible) {
// call lose focus to still active gadget and
pmgActive->OnKillFocus();
// set focus to new one
pmgActive = pmgActive->mg_pmgUp;
pmgActive->OnSetFocus();
// key is handled
return TRUE;
}
break;
case VK_DOWN:
// if this is bottom button in list
if (pmgActive == gm_pmgListBottom) {
// scroll list down
ScrollList(+1);
// key is handled
return TRUE;
}
// if we can go down
if (pmgActive->mg_pmgDown != NULL && pmgActive->mg_pmgDown->mg_bVisible) {
// call lose focus to still active gadget and
pmgActive->OnKillFocus();
// set focus to new one
pmgActive = pmgActive->mg_pmgDown;
pmgActive->OnSetFocus();
// key is handled
return TRUE;
}
break;
case VK_LEFT:
// if we can go left
if (pmgActive->mg_pmgLeft != NULL) {
// call lose focus to still active gadget and
pmgActive->OnKillFocus();
// set focus to new one
if (!pmgActive->mg_pmgLeft->mg_bVisible && gm_pmgSelectedByDefault != NULL) {
pmgActive = gm_pmgSelectedByDefault;
}
else {
pmgActive = pmgActive->mg_pmgLeft;
}
pmgActive->OnSetFocus();
// key is handled
return TRUE;
}
break;
case VK_RIGHT:
// if we can go right
if (pmgActive->mg_pmgRight != NULL) {
// call lose focus to still active gadget and
pmgActive->OnKillFocus();
// set focus to new one
if (!pmgActive->mg_pmgRight->mg_bVisible && gm_pmgSelectedByDefault != NULL) {
pmgActive = gm_pmgSelectedByDefault;
}
else {
pmgActive = pmgActive->mg_pmgRight;
}
pmgActive->OnSetFocus();
// key is handled
return TRUE;
}
break;
}
// key is not handled
return FALSE;
}
void CGameMenu::StartMenu(void)
{
// for each menu gadget in menu
FOREACHINLIST(CMenuGadget, mg_lnNode, gm_lhGadgets, itmg)
{
itmg->mg_bFocused = FALSE;
// call appear
itmg->Appear();
}
// if there is a list
if (gm_pmgListTop != NULL) {
// scroll it so that the wanted tem is centered
gm_iListOffset = gm_iListWantedItem - gm_ctListVisible / 2;
// clamp the scrolling
gm_iListOffset = Clamp(gm_iListOffset, 0L, Max(0L, gm_ctListTotal - gm_ctListVisible));
// fill the list
FillListItems();
// for each menu gadget in menu
FOREACHINLIST(CMenuGadget, mg_lnNode, gm_lhGadgets, itmg) {
// if in list, but disabled
if (itmg->mg_iInList == -2) {
// hide it
itmg->mg_bVisible = FALSE;
// if in list
} else if (itmg->mg_iInList >= 0) {
// show it
itmg->mg_bVisible = TRUE;
}
// if wanted
if (itmg->mg_iInList == gm_iListWantedItem) {
// focus it
itmg->OnSetFocus();
gm_pmgSelectedByDefault = itmg;
}
}
}
}
void CGameMenu::EndMenu(void)
{
// for each menu gadget in menu
FOREACHINLIST(CMenuGadget, mg_lnNode, gm_lhGadgets, itmg)
{
// call disappear
itmg->Disappear();
}
}

52
Sources/SeriousSam/GUI/Menus/GameMenu.h
View File

@ -1,52 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_H
#define SE_INCL_GAME_MENU_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
class CGameMenu {
public:
CListHead gm_lhGadgets;
CGameMenu *gm_pgmParentMenu;
BOOL gm_bPopup;
const char *gm_strName; // menu name (for mod interface only)
class CMenuGadget *gm_pmgSelectedByDefault;
class CMenuGadget *gm_pmgArrowUp;
class CMenuGadget *gm_pmgArrowDn;
class CMenuGadget *gm_pmgListTop;
class CMenuGadget *gm_pmgListBottom;
INDEX gm_iListOffset;
INDEX gm_iListWantedItem; // item you want to focus initially
INDEX gm_ctListVisible;
INDEX gm_ctListTotal;
CGameMenu(void);
void ScrollList(INDEX iDir);
void KillAllFocuses(void);
virtual void Initialize_t(void);
virtual void Destroy(void);
virtual void StartMenu(void);
virtual void FillListItems(void);
virtual void EndMenu(void);
// return TRUE if handled
virtual BOOL OnKeyDown(int iVKey);
virtual BOOL OnChar(MSG msg);
virtual void Think(void);
};
#endif /* include-once check. */

78
Sources/SeriousSam/GUI/Menus/MAudioOptions.cpp
View File

@ -1,78 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MAudioOptions.h"
extern void RefreshSoundFormat(void);
void CAudioOptionsMenu::Initialize_t(void)
{
// intialize Audio options menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("AUDIO");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
TRIGGER_MG(gm_mgAudioAutoTrigger, 0,
gm_mgApply, gm_mgFrequencyTrigger, TRANS("AUTO-ADJUST"), astrNoYes);
gm_mgAudioAutoTrigger.mg_strTip = TRANS("adjust quality to fit your system");
TRIGGER_MG(gm_mgFrequencyTrigger, 1,
gm_mgAudioAutoTrigger, gm_mgAudioAPITrigger, TRANS("FREQUENCY"), astrFrequencyRadioTexts);
gm_mgFrequencyTrigger.mg_strTip = TRANS("select sound quality or turn sound off");
gm_mgFrequencyTrigger.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgAudioAPITrigger, 2,
gm_mgFrequencyTrigger, gm_mgWaveVolume, TRANS("SOUND SYSTEM"), astrSoundAPIRadioTexts);
gm_mgAudioAPITrigger.mg_strTip = TRANS("choose sound system (API) to use");
gm_mgAudioAPITrigger.mg_pOnTriggerChange = NULL;
gm_mgWaveVolume.mg_boxOnScreen = BoxMediumRow(3);
gm_mgWaveVolume.mg_strText = TRANS("SOUND EFFECTS VOLUME");
gm_mgWaveVolume.mg_strTip = TRANS("adjust volume of in-game sound effects");
gm_mgWaveVolume.mg_pmgUp = &gm_mgAudioAPITrigger;
gm_mgWaveVolume.mg_pmgDown = &gm_mgMPEGVolume;
gm_mgWaveVolume.mg_pOnSliderChange = NULL;
gm_mgWaveVolume.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgWaveVolume.mg_lnNode);
gm_mgMPEGVolume.mg_boxOnScreen = BoxMediumRow(4);
gm_mgMPEGVolume.mg_strText = TRANS("MUSIC VOLUME");
gm_mgMPEGVolume.mg_strTip = TRANS("adjust volume of in-game music");
gm_mgMPEGVolume.mg_pmgUp = &gm_mgWaveVolume;
gm_mgMPEGVolume.mg_pmgDown = &gm_mgApply;
gm_mgMPEGVolume.mg_pOnSliderChange = NULL;
gm_mgMPEGVolume.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgMPEGVolume.mg_lnNode);
gm_mgApply.mg_bfsFontSize = BFS_LARGE;
gm_mgApply.mg_boxOnScreen = BoxBigRow(4);
gm_mgApply.mg_strText = TRANS("APPLY");
gm_mgApply.mg_strTip = TRANS("activate selected options");
gm_lhGadgets.AddTail(gm_mgApply.mg_lnNode);
gm_mgApply.mg_pmgUp = &gm_mgMPEGVolume;
gm_mgApply.mg_pmgDown = &gm_mgAudioAutoTrigger;
gm_mgApply.mg_pActivatedFunction = NULL;
}
void CAudioOptionsMenu::StartMenu(void)
{
RefreshSoundFormat();
CGameMenu::StartMenu();
}

43
Sources/SeriousSam/GUI/Menus/MAudioOptions.h
View File

@ -1,43 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_AUDIOOPTIONS_H
#define SE_INCL_GAME_MENU_AUDIOOPTIONS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGSlider.h"
#include "SeriousSam/GUI/Components/MGTrigger.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CAudioOptionsMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGTrigger gm_mgAudioAutoTrigger;
CMGTrigger gm_mgAudioAPITrigger;
CMGTrigger gm_mgFrequencyTrigger;
CMGSlider gm_mgWaveVolume;
CMGSlider gm_mgMPEGVolume;
CMGButton gm_mgApply;
void StartMenu(void);
void Initialize_t(void);
};
#endif /* include-once check. */

83
Sources/SeriousSam/GUI/Menus/MConfirm.cpp
View File

@ -1,83 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MConfirm.h"
void CConfirmMenu::Initialize_t(void)
{
gm_bPopup = TRUE;
gm_mgConfirmLabel.mg_strText = "";
gm_lhGadgets.AddTail(gm_mgConfirmLabel.mg_lnNode);
gm_mgConfirmLabel.mg_boxOnScreen = BoxPopupLabel();
gm_mgConfirmLabel.mg_iCenterI = 0;
gm_mgConfirmLabel.mg_bfsFontSize = BFS_LARGE;
gm_mgConfirmYes.mg_strText = TRANS("YES");
gm_lhGadgets.AddTail(gm_mgConfirmYes.mg_lnNode);
gm_mgConfirmYes.mg_boxOnScreen = BoxPopupYesLarge();
gm_mgConfirmYes.mg_pActivatedFunction = NULL;
gm_mgConfirmYes.mg_pmgLeft =
gm_mgConfirmYes.mg_pmgRight = &gm_mgConfirmNo;
gm_mgConfirmYes.mg_iCenterI = 1;
gm_mgConfirmYes.mg_bfsFontSize = BFS_LARGE;
gm_mgConfirmNo.mg_strText = TRANS("NO");
gm_lhGadgets.AddTail(gm_mgConfirmNo.mg_lnNode);
gm_mgConfirmNo.mg_boxOnScreen = BoxPopupNoLarge();
gm_mgConfirmNo.mg_pActivatedFunction = NULL;
gm_mgConfirmNo.mg_pmgLeft =
gm_mgConfirmNo.mg_pmgRight = &gm_mgConfirmYes;
gm_mgConfirmNo.mg_iCenterI = -1;
gm_mgConfirmNo.mg_bfsFontSize = BFS_LARGE;
_pConfimedYes = NULL;
_pConfimedNo = NULL;
}
void CConfirmMenu::BeLarge(void)
{
gm_mgConfirmLabel.mg_bfsFontSize = BFS_LARGE;
gm_mgConfirmYes.mg_bfsFontSize = BFS_LARGE;
gm_mgConfirmNo.mg_bfsFontSize = BFS_LARGE;
gm_mgConfirmLabel.mg_iCenterI = 0;
gm_mgConfirmYes.mg_boxOnScreen = BoxPopupYesLarge();
gm_mgConfirmNo.mg_boxOnScreen = BoxPopupNoLarge();
}
void CConfirmMenu::BeSmall(void)
{
gm_mgConfirmLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgConfirmYes.mg_bfsFontSize = BFS_MEDIUM;
gm_mgConfirmNo.mg_bfsFontSize = BFS_MEDIUM;
gm_mgConfirmLabel.mg_iCenterI = -1;
gm_mgConfirmYes.mg_boxOnScreen = BoxPopupYesSmall();
gm_mgConfirmNo.mg_boxOnScreen = BoxPopupNoSmall();
}
// return TRUE if handled
BOOL CConfirmMenu::OnKeyDown(int iVKey)
{
if ((iVKey == VK_ESCAPE || iVKey == VK_RBUTTON) && gm_mgConfirmNo.mg_pActivatedFunction != NULL) {
gm_mgConfirmNo.OnActivate();
return TRUE;
}
return CGameMenu::OnKeyDown(iVKey);
}

43
Sources/SeriousSam/GUI/Menus/MConfirm.h
View File

@ -1,43 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_CONFIRM_H
#define SE_INCL_GAME_MENU_CONFIRM_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
class CConfirmMenu : public CGameMenu {
public:
CMGButton gm_mgConfirmLabel;
CMGButton gm_mgConfirmYes;
CMGButton gm_mgConfirmNo;
void(*_pConfimedYes)(void) = NULL;
void(*_pConfimedNo)(void) = NULL;
void Initialize_t(void);
// return TRUE if handled
BOOL OnKeyDown(int iVKey);
void BeLarge(void);
void BeSmall(void);
};
#endif /* include-once check. */

159
Sources/SeriousSam/GUI/Menus/MControls.cpp
View File

@ -1,159 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MControls.h"
extern CTFileName _fnmControlsToCustomize;
void CControlsMenu::Initialize_t(void)
{
// intialize player and controls menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("CONTROLS");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgNameLabel.mg_strText = "";
gm_mgNameLabel.mg_boxOnScreen = BoxMediumRow(0.0);
gm_mgNameLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgNameLabel.mg_iCenterI = -1;
gm_mgNameLabel.mg_bEnabled = FALSE;
gm_mgNameLabel.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgNameLabel.mg_lnNode);
gm_mgButtons.mg_strText = TRANS("CUSTOMIZE BUTTONS");
gm_mgButtons.mg_boxOnScreen = BoxMediumRow(2.0);
gm_mgButtons.mg_bfsFontSize = BFS_MEDIUM;
gm_mgButtons.mg_iCenterI = 0;
gm_lhGadgets.AddTail(gm_mgButtons.mg_lnNode);
gm_mgButtons.mg_pmgUp = &gm_mgPredefined;
gm_mgButtons.mg_pmgDown = &gm_mgAdvanced;
gm_mgButtons.mg_pActivatedFunction = NULL;
gm_mgButtons.mg_strTip = TRANS("customize buttons in current controls");
gm_mgAdvanced.mg_strText = TRANS("ADVANCED JOYSTICK SETUP");
gm_mgAdvanced.mg_iCenterI = 0;
gm_mgAdvanced.mg_boxOnScreen = BoxMediumRow(3);
gm_mgAdvanced.mg_bfsFontSize = BFS_MEDIUM;
gm_lhGadgets.AddTail(gm_mgAdvanced.mg_lnNode);
gm_mgAdvanced.mg_pmgUp = &gm_mgButtons;
gm_mgAdvanced.mg_pmgDown = &gm_mgSensitivity;
gm_mgAdvanced.mg_pActivatedFunction = NULL;
gm_mgAdvanced.mg_strTip = TRANS("adjust advanced settings for joystick axis");
gm_mgSensitivity.mg_boxOnScreen = BoxMediumRow(4.5);
gm_mgSensitivity.mg_strText = TRANS("SENSITIVITY");
gm_mgSensitivity.mg_pmgUp = &gm_mgAdvanced;
gm_mgSensitivity.mg_pmgDown = &gm_mgInvertTrigger;
gm_mgSensitivity.mg_strTip = TRANS("sensitivity for all axis in this control set");
gm_lhGadgets.AddTail(gm_mgSensitivity.mg_lnNode);
TRIGGER_MG(gm_mgInvertTrigger, 5.5, gm_mgSensitivity, gm_mgSmoothTrigger,
TRANS("INVERT LOOK"), astrNoYes);
gm_mgInvertTrigger.mg_strTip = TRANS("invert up/down looking");
TRIGGER_MG(gm_mgSmoothTrigger, 6.5, gm_mgInvertTrigger, gm_mgAccelTrigger,
TRANS("SMOOTH AXIS"), astrNoYes);
gm_mgSmoothTrigger.mg_strTip = TRANS("smooth mouse/joystick movements");
TRIGGER_MG(gm_mgAccelTrigger, 7.5, gm_mgSmoothTrigger, gm_mgIFeelTrigger,
TRANS("MOUSE ACCELERATION"), astrNoYes);
gm_mgAccelTrigger.mg_strTip = TRANS("allow mouse acceleration");
TRIGGER_MG(gm_mgIFeelTrigger, 8.5, gm_mgAccelTrigger, gm_mgPredefined,
TRANS("ENABLE IFEEL"), astrNoYes);
gm_mgIFeelTrigger.mg_strTip = TRANS("enable support for iFeel tactile feedback mouse");
gm_mgPredefined.mg_strText = TRANS("LOAD PREDEFINED SETTINGS");
gm_mgPredefined.mg_iCenterI = 0;
gm_mgPredefined.mg_boxOnScreen = BoxMediumRow(10);
gm_mgPredefined.mg_bfsFontSize = BFS_MEDIUM;
gm_lhGadgets.AddTail(gm_mgPredefined.mg_lnNode);
gm_mgPredefined.mg_pmgUp = &gm_mgIFeelTrigger;
gm_mgPredefined.mg_pmgDown = &gm_mgButtons;
gm_mgPredefined.mg_pActivatedFunction = NULL;
gm_mgPredefined.mg_strTip = TRANS("load one of several predefined control settings");
}
void CControlsMenu::StartMenu(void)
{
gm_pmgSelectedByDefault = &gm_mgButtons;
INDEX iPlayer = _pGame->gm_iSinglePlayer;
if (_iLocalPlayer >= 0 && _iLocalPlayer<4) {
iPlayer = _pGame->gm_aiMenuLocalPlayers[_iLocalPlayer];
}
_fnmControlsToCustomize.PrintF("Controls\\Controls%d.ctl", iPlayer);
ControlsMenuOn();
gm_mgNameLabel.mg_strText.PrintF(TRANS("CONTROLS FOR: %s"), (const char *) _pGame->gm_apcPlayers[iPlayer].GetNameForPrinting());
ObtainActionSettings();
CGameMenu::StartMenu();
}
void CControlsMenu::EndMenu(void)
{
ApplyActionSettings();
ControlsMenuOff();
CGameMenu::EndMenu();
}
void CControlsMenu::ObtainActionSettings(void)
{
CControls &ctrls = *_pGame->gm_ctrlControlsExtra;
gm_mgSensitivity.mg_iMinPos = 0;
gm_mgSensitivity.mg_iMaxPos = 50;
gm_mgSensitivity.mg_iCurPos = ctrls.ctrl_fSensitivity / 2;
gm_mgSensitivity.ApplyCurrentPosition();
gm_mgInvertTrigger.mg_iSelected = ctrls.ctrl_bInvertLook ? 1 : 0;
gm_mgSmoothTrigger.mg_iSelected = ctrls.ctrl_bSmoothAxes ? 1 : 0;
gm_mgAccelTrigger.mg_iSelected = _pShell->GetINDEX("inp_bAllowMouseAcceleration") ? 1 : 0;
gm_mgIFeelTrigger.mg_bEnabled = _pShell->GetINDEX("sys_bIFeelEnabled") ? 1 : 0;
gm_mgIFeelTrigger.mg_iSelected = _pShell->GetFLOAT("inp_fIFeelGain")>0 ? 1 : 0;
gm_mgInvertTrigger.ApplyCurrentSelection();
gm_mgSmoothTrigger.ApplyCurrentSelection();
gm_mgAccelTrigger.ApplyCurrentSelection();
gm_mgIFeelTrigger.ApplyCurrentSelection();
}
void CControlsMenu::ApplyActionSettings(void)
{
CControls &ctrls = *_pGame->gm_ctrlControlsExtra;
FLOAT fSensitivity =
FLOAT(gm_mgSensitivity.mg_iCurPos - gm_mgSensitivity.mg_iMinPos) /
FLOAT(gm_mgSensitivity.mg_iMaxPos - gm_mgSensitivity.mg_iMinPos)*100.0f;
BOOL bInvert = gm_mgInvertTrigger.mg_iSelected != 0;
BOOL bSmooth = gm_mgSmoothTrigger.mg_iSelected != 0;
BOOL bAccel = gm_mgAccelTrigger.mg_iSelected != 0;
BOOL bIFeel = gm_mgIFeelTrigger.mg_iSelected != 0;
if (INDEX(ctrls.ctrl_fSensitivity) != INDEX(fSensitivity)) {
ctrls.ctrl_fSensitivity = fSensitivity;
}
ctrls.ctrl_bInvertLook = bInvert;
ctrls.ctrl_bSmoothAxes = bSmooth;
_pShell->SetINDEX("inp_bAllowMouseAcceleration", bAccel);
_pShell->SetFLOAT("inp_fIFeelGain", bIFeel ? 1.0f : 0.0f);
ctrls.CalculateInfluencesForAllAxis();
}

49
Sources/SeriousSam/GUI/Menus/MControls.h
View File

@ -1,49 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_CONTROLS_H
#define SE_INCL_GAME_MENU_CONTROLS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGSlider.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#include "SeriousSam/GUI/Components/MGTrigger.h"
class CControlsMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgNameLabel;
CMGButton gm_mgButtons;
CMGSlider gm_mgSensitivity;
CMGTrigger gm_mgInvertTrigger;
CMGTrigger gm_mgSmoothTrigger;
CMGTrigger gm_mgAccelTrigger;
CMGTrigger gm_mgIFeelTrigger;
CMGButton gm_mgPredefined;
CMGButton gm_mgAdvanced;
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void ObtainActionSettings(void);
void ApplyActionSettings(void);
};
#endif /* include-once check. */

30
Sources/SeriousSam/GUI/Menus/MCredits.h
View File

@ -1,30 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_CREDITS_H
#define SE_INCL_GAME_MENU_CREDITS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
class CCreditsMenu : public CGameMenu {
public:
void Initialize_t(void);
};
#endif /* include-once check. */

156
Sources/SeriousSam/GUI/Menus/MCustomizeAxis.cpp
View File

@ -1,156 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MCustomizeAxis.h"
void CCustomizeAxisMenu::Initialize_t(void)
{
// intialize axis menu
gm_mgTitle.mg_strText = TRANS("CUSTOMIZE AXIS");
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
TRIGGER_MG(gm_mgActionTrigger, 0, gm_mgSmoothTrigger, gm_mgMountedTrigger, TRANS("ACTION"), astrNoYes);
gm_mgActionTrigger.mg_strTip = TRANS("choose action to customize");
TRIGGER_MG(gm_mgMountedTrigger, 2, gm_mgActionTrigger, gm_mgSensitivity, TRANS("MOUNTED TO"), astrNoYes);
gm_mgMountedTrigger.mg_strTip = TRANS("choose controller axis that will perform the action");
gm_mgActionTrigger.mg_astrTexts = new CTString[AXIS_ACTIONS_CT];
gm_mgActionTrigger.mg_ctTexts = AXIS_ACTIONS_CT;
gm_mgActionTrigger.mg_pPreTriggerChange = NULL;
gm_mgActionTrigger.mg_pOnTriggerChange = NULL;
// for all available axis type controlers
for (INDEX iControler = 0; iControler<AXIS_ACTIONS_CT; iControler++) {
gm_mgActionTrigger.mg_astrTexts[iControler] = TranslateConst(CTString(_pGame->gm_astrAxisNames[iControler]), 0);
}
gm_mgActionTrigger.mg_iSelected = 3;
INDEX ctAxis = _pInput->GetAvailableAxisCount();
gm_mgMountedTrigger.mg_astrTexts = new CTString[ctAxis];
gm_mgMountedTrigger.mg_ctTexts = ctAxis;
// for all axis actions that can be mounted
for (INDEX iAxis = 0; iAxis<ctAxis; iAxis++) {
gm_mgMountedTrigger.mg_astrTexts[iAxis] = _pInput->GetAxisTransName(iAxis);
}
gm_mgSensitivity.mg_boxOnScreen = BoxMediumRow(3);
gm_mgSensitivity.mg_strText = TRANS("SENSITIVITY");
gm_mgSensitivity.mg_pmgUp = &gm_mgMountedTrigger;
gm_mgSensitivity.mg_pmgDown = &gm_mgDeadzone;
gm_lhGadgets.AddTail(gm_mgSensitivity.mg_lnNode);
gm_mgSensitivity.mg_strTip = TRANS("set sensitivity for this axis");
gm_mgDeadzone.mg_boxOnScreen = BoxMediumRow(4);
gm_mgDeadzone.mg_strText = TRANS("DEAD ZONE");
gm_mgDeadzone.mg_pmgUp = &gm_mgSensitivity;
gm_mgDeadzone.mg_pmgDown = &gm_mgInvertTrigger;
gm_lhGadgets.AddTail(gm_mgDeadzone.mg_lnNode);
gm_mgDeadzone.mg_strTip = TRANS("set dead zone for this axis");
TRIGGER_MG(gm_mgInvertTrigger, 5, gm_mgDeadzone, gm_mgRelativeTrigger, TRANS("INVERTED"), astrNoYes);
gm_mgInvertTrigger.mg_strTip = TRANS("choose whether to invert this axis or not");
TRIGGER_MG(gm_mgRelativeTrigger, 6, gm_mgInvertTrigger, gm_mgSmoothTrigger, TRANS("RELATIVE"), astrNoYes);
gm_mgRelativeTrigger.mg_strTip = TRANS("select relative or absolute axis reading");
TRIGGER_MG(gm_mgSmoothTrigger, 7, gm_mgRelativeTrigger, gm_mgActionTrigger, TRANS("SMOOTH"), astrNoYes);
gm_mgSmoothTrigger.mg_strTip = TRANS("turn this on to filter readings on this axis");
}
CCustomizeAxisMenu::~CCustomizeAxisMenu(void)
{
delete[] gm_mgActionTrigger.mg_astrTexts;
delete[] gm_mgMountedTrigger.mg_astrTexts;
}
void CCustomizeAxisMenu::ObtainActionSettings(void)
{
ControlsMenuOn();
CControls &ctrls = *_pGame->gm_ctrlControlsExtra;
INDEX iSelectedAction = gm_mgActionTrigger.mg_iSelected;
INDEX iMountedAxis = ctrls.ctrl_aaAxisActions[iSelectedAction].aa_iAxisAction;
gm_mgMountedTrigger.mg_iSelected = iMountedAxis;
gm_mgSensitivity.mg_iMinPos = 0;
gm_mgSensitivity.mg_iMaxPos = 50;
gm_mgSensitivity.mg_iCurPos = ctrls.ctrl_aaAxisActions[iSelectedAction].aa_fSensitivity / 2;
gm_mgSensitivity.ApplyCurrentPosition();
gm_mgDeadzone.mg_iMinPos = 0;
gm_mgDeadzone.mg_iMaxPos = 50;
gm_mgDeadzone.mg_iCurPos = ctrls.ctrl_aaAxisActions[iSelectedAction].aa_fDeadZone / 2;
gm_mgDeadzone.ApplyCurrentPosition();
gm_mgInvertTrigger.mg_iSelected = ctrls.ctrl_aaAxisActions[iSelectedAction].aa_bInvert ? 1 : 0;
gm_mgRelativeTrigger.mg_iSelected = ctrls.ctrl_aaAxisActions[iSelectedAction].aa_bRelativeControler ? 1 : 0;
gm_mgSmoothTrigger.mg_iSelected = ctrls.ctrl_aaAxisActions[iSelectedAction].aa_bSmooth ? 1 : 0;
gm_mgActionTrigger.ApplyCurrentSelection();
gm_mgMountedTrigger.ApplyCurrentSelection();
gm_mgInvertTrigger.ApplyCurrentSelection();
gm_mgRelativeTrigger.ApplyCurrentSelection();
gm_mgSmoothTrigger.ApplyCurrentSelection();
}
void CCustomizeAxisMenu::ApplyActionSettings(void)
{
CControls &ctrls = *_pGame->gm_ctrlControlsExtra;
INDEX iSelectedAction = gm_mgActionTrigger.mg_iSelected;
INDEX iMountedAxis = gm_mgMountedTrigger.mg_iSelected;
FLOAT fSensitivity =
FLOAT(gm_mgSensitivity.mg_iCurPos - gm_mgSensitivity.mg_iMinPos) /
FLOAT(gm_mgSensitivity.mg_iMaxPos - gm_mgSensitivity.mg_iMinPos)*100.0f;
FLOAT fDeadZone =
FLOAT(gm_mgDeadzone.mg_iCurPos - gm_mgDeadzone.mg_iMinPos) /
FLOAT(gm_mgDeadzone.mg_iMaxPos - gm_mgDeadzone.mg_iMinPos)*100.0f;
BOOL bInvert = gm_mgInvertTrigger.mg_iSelected != 0;
BOOL bRelative = gm_mgRelativeTrigger.mg_iSelected != 0;
BOOL bSmooth = gm_mgSmoothTrigger.mg_iSelected != 0;
ctrls.ctrl_aaAxisActions[iSelectedAction].aa_iAxisAction = iMountedAxis;
if (INDEX(ctrls.ctrl_aaAxisActions[iSelectedAction].aa_fSensitivity) != INDEX(fSensitivity)) {
ctrls.ctrl_aaAxisActions[iSelectedAction].aa_fSensitivity = fSensitivity;
}
if (INDEX(ctrls.ctrl_aaAxisActions[iSelectedAction].aa_fDeadZone) != INDEX(fDeadZone)) {
ctrls.ctrl_aaAxisActions[iSelectedAction].aa_fDeadZone = fDeadZone;
}
ctrls.ctrl_aaAxisActions[iSelectedAction].aa_bInvert = bInvert;
ctrls.ctrl_aaAxisActions[iSelectedAction].aa_bRelativeControler = bRelative;
ctrls.ctrl_aaAxisActions[iSelectedAction].aa_bSmooth = bSmooth;
ctrls.CalculateInfluencesForAllAxis();
ControlsMenuOff();
}
void CCustomizeAxisMenu::StartMenu(void)
{
ObtainActionSettings();
CGameMenu::StartMenu();
}
void CCustomizeAxisMenu::EndMenu(void)
{
ApplyActionSettings();
CGameMenu::EndMenu();
}

47
Sources/SeriousSam/GUI/Menus/MCustomizeAxis.h
View File

@ -1,47 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_CUSTOMIZEAXIS_H
#define SE_INCL_GAME_MENU_CUSTOMIZEAXIS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGSlider.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#include "SeriousSam/GUI/Components/MGTrigger.h"
class CCustomizeAxisMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGTrigger gm_mgActionTrigger;
CMGTrigger gm_mgMountedTrigger;
CMGSlider gm_mgSensitivity;
CMGSlider gm_mgDeadzone;
CMGTrigger gm_mgInvertTrigger;
CMGTrigger gm_mgRelativeTrigger;
CMGTrigger gm_mgSmoothTrigger;
~CCustomizeAxisMenu(void);
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void ObtainActionSettings(void);
void ApplyActionSettings(void);
};
#endif /* include-once check. */

112
Sources/SeriousSam/GUI/Menus/MCustomizeKeyboard.cpp
View File

@ -1,112 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MCustomizeKeyboard.h"
void CCustomizeKeyboardMenu::FillListItems(void)
{
// disable all items first
for (INDEX i = 0; i<KEYS_ON_SCREEN; i++) {
gm_mgKey[i].mg_bEnabled = FALSE;
gm_mgKey[i].mg_iInList = -2;
}
BOOL bHasFirst = FALSE;
BOOL bHasLast = FALSE;
// set diks to key buttons
INDEX iLabel = 0;
INDEX ctLabels = _pGame->gm_ctrlControlsExtra->ctrl_lhButtonActions.Count();
FOREACHINLIST(CButtonAction, ba_lnNode, _pGame->gm_ctrlControlsExtra->ctrl_lhButtonActions, itAct)
{
INDEX iInMenu = iLabel - gm_iListOffset;
if ((iLabel >= gm_iListOffset) &&
(iLabel<(gm_iListOffset + gm_ctListVisible)))
{
bHasFirst |= (iLabel == 0);
bHasLast |= (iLabel == ctLabels - 1);
gm_mgKey[iInMenu].mg_strLabel = TranslateConst(itAct->ba_strName, 0);
gm_mgKey[iInMenu].mg_iControlNumber = iLabel;
gm_mgKey[iInMenu].SetBindingNames(FALSE);
gm_mgKey[iInMenu].mg_strTip = TRANS("Enter - change binding, Backspace - unbind");
gm_mgKey[iInMenu].mg_bEnabled = TRUE;
gm_mgKey[iInMenu].mg_iInList = iLabel;
}
iLabel++;
}
// enable/disable up/down arrows
gm_mgArrowUp.mg_bEnabled = !bHasFirst && ctLabels>0;
gm_mgArrowDn.mg_bEnabled = !bHasLast && ctLabels>0;
}
void CCustomizeKeyboardMenu::Initialize_t(void)
{
// intialize Audio options menu
gm_mgTitle.mg_strText = TRANS("CUSTOMIZE BUTTONS");
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
#define KL_START 3.0f
#define KL_STEEP -1.45f
for (INDEX iLabel = 0; iLabel<KEYS_ON_SCREEN; iLabel++)
{
INDEX iPrev = (gm_ctListVisible + iLabel - 1) % KEYS_ON_SCREEN;
INDEX iNext = (iLabel + 1) % KEYS_ON_SCREEN;
// initialize label entities
gm_mgKey[iLabel].mg_boxOnScreen = BoxKeyRow(iLabel);
// initialize label gadgets
gm_mgKey[iLabel].mg_pmgUp = &gm_mgKey[iPrev];
gm_mgKey[iLabel].mg_pmgDown = &gm_mgKey[iNext];
gm_mgKey[iLabel].mg_bVisible = TRUE;
gm_lhGadgets.AddTail(gm_mgKey[iLabel].mg_lnNode);
}
// arrows just exist
gm_lhGadgets.AddTail(gm_mgArrowDn.mg_lnNode);
gm_lhGadgets.AddTail(gm_mgArrowUp.mg_lnNode);
gm_mgArrowDn.mg_adDirection = AD_DOWN;
gm_mgArrowUp.mg_adDirection = AD_UP;
gm_mgArrowDn.mg_boxOnScreen = BoxArrow(AD_DOWN);
gm_mgArrowUp.mg_boxOnScreen = BoxArrow(AD_UP);
gm_mgArrowDn.mg_pmgRight = gm_mgArrowDn.mg_pmgUp =
&gm_mgKey[KEYS_ON_SCREEN - 1];
gm_mgArrowUp.mg_pmgRight = gm_mgArrowUp.mg_pmgDown =
&gm_mgKey[0];
gm_ctListVisible = KEYS_ON_SCREEN;
gm_pmgArrowUp = &gm_mgArrowUp;
gm_pmgArrowDn = &gm_mgArrowDn;
gm_pmgListTop = &gm_mgKey[0];
gm_pmgListBottom = &gm_mgKey[KEYS_ON_SCREEN - 1];
}
void CCustomizeKeyboardMenu::StartMenu(void)
{
ControlsMenuOn();
gm_iListOffset = 0;
gm_ctListTotal = _pGame->gm_ctrlControlsExtra->ctrl_lhButtonActions.Count();
gm_iListWantedItem = 0;
CGameMenu::StartMenu();
}
void CCustomizeKeyboardMenu::EndMenu(void)
{
ControlsMenuOff();
CGameMenu::EndMenu();
}

41
Sources/SeriousSam/GUI/Menus/MCustomizeKeyboard.h
View File

@ -1,41 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_CUSTOMIZEKEYBOARD_H
#define SE_INCL_GAME_MENU_CUSTOMIZEKEYBOARD_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGArrow.h"
#include "SeriousSam/GUI/Components/MGKeyDefinition.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CCustomizeKeyboardMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGKeyDefinition gm_mgKey[KEYS_ON_SCREEN];
CMGArrow gm_mgArrowUp;
CMGArrow gm_mgArrowDn;
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void FillListItems(void);
};
#endif /* include-once check. */

31
Sources/SeriousSam/GUI/Menus/MDisabled.cpp
View File

@ -1,31 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MDisabled.h"
void CDisabledMenu::Initialize_t(void)
{
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgButton.mg_bfsFontSize = BFS_MEDIUM;
gm_mgButton.mg_boxOnScreen = BoxBigRow(0.0f);
gm_lhGadgets.AddTail(gm_mgButton.mg_lnNode);
gm_mgButton.mg_pActivatedFunction = NULL;
}

35
Sources/SeriousSam/GUI/Menus/MDisabled.h
View File

@ -1,35 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_DISABLED_H
#define SE_INCL_GAME_MENU_DISABLED_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CDisabledMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgButton;
void Initialize_t(void);
};
#endif /* include-once check. */

36
Sources/SeriousSam/GUI/Menus/MHighScore.cpp
View File

@ -1,36 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MHighScore.h"
void CHighScoreMenu::Initialize_t(void)
{
gm_mgHScore.mg_boxOnScreen = FLOATaabbox2D(FLOAT2D(0, 0), FLOAT2D(1, 0.5));
gm_lhGadgets.AddTail(gm_mgHScore.mg_lnNode);
gm_mgTitle.mg_strText = TRANS("HIGH SCORE TABLE");
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
}
void CHighScoreMenu::StartMenu(void)
{
gm_pgmParentMenu = pgmCurrentMenu;
CGameMenu::StartMenu();
}

36
Sources/SeriousSam/GUI/Menus/MHighScore.h
View File

@ -1,36 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_HIGHSCORE_H
#define SE_INCL_GAME_MENU_HIGHSCORE_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGHighScore.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CHighScoreMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGHighScore gm_mgHScore;
void Initialize_t(void);
void StartMenu(void);
};
#endif /* include-once check. */

174
Sources/SeriousSam/GUI/Menus/MInGame.cpp
View File

@ -1,174 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MInGame.h"
void CInGameMenu::Initialize_t(void)
{
// intialize main menu
gm_mgTitle.mg_strText = TRANS("GAME");
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgLabel1.mg_strText = "";
gm_mgLabel1.mg_boxOnScreen = BoxMediumRow(-2.0);
gm_mgLabel1.mg_bfsFontSize = BFS_MEDIUM;
gm_mgLabel1.mg_iCenterI = -1;
gm_mgLabel1.mg_bEnabled = FALSE;
gm_mgLabel1.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgLabel1.mg_lnNode);
gm_mgLabel2.mg_strText = "";
gm_mgLabel2.mg_boxOnScreen = BoxMediumRow(-1.0);
gm_mgLabel2.mg_bfsFontSize = BFS_MEDIUM;
gm_mgLabel2.mg_iCenterI = -1;
gm_mgLabel2.mg_bEnabled = FALSE;
gm_mgLabel2.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgLabel2.mg_lnNode);
gm_mgQuickLoad.mg_strText = TRANS("QUICK LOAD");
gm_mgQuickLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgQuickLoad.mg_boxOnScreen = BoxBigRow(0.0f);
gm_mgQuickLoad.mg_strTip = TRANS("load a quick-saved game (F9)");
gm_lhGadgets.AddTail(gm_mgQuickLoad.mg_lnNode);
gm_mgQuickLoad.mg_pmgUp = &gm_mgQuit;
gm_mgQuickLoad.mg_pmgDown = &gm_mgQuickSave;
gm_mgQuickLoad.mg_pActivatedFunction = NULL;
gm_mgQuickSave.mg_strText = TRANS("QUICK SAVE");
gm_mgQuickSave.mg_bfsFontSize = BFS_LARGE;
gm_mgQuickSave.mg_boxOnScreen = BoxBigRow(1.0f);
gm_mgQuickSave.mg_strTip = TRANS("quick-save current game (F6)");
gm_lhGadgets.AddTail(gm_mgQuickSave.mg_lnNode);
gm_mgQuickSave.mg_pmgUp = &gm_mgQuickLoad;
gm_mgQuickSave.mg_pmgDown = &gm_mgLoad;
gm_mgQuickSave.mg_pActivatedFunction = NULL;
gm_mgLoad.mg_strText = TRANS("LOAD");
gm_mgLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgLoad.mg_boxOnScreen = BoxBigRow(2.0f);
gm_mgLoad.mg_strTip = TRANS("load a saved game");
gm_lhGadgets.AddTail(gm_mgLoad.mg_lnNode);
gm_mgLoad.mg_pmgUp = &gm_mgQuickSave;
gm_mgLoad.mg_pmgDown = &gm_mgSave;
gm_mgLoad.mg_pActivatedFunction = NULL;
gm_mgSave.mg_strText = TRANS("SAVE");
gm_mgSave.mg_bfsFontSize = BFS_LARGE;
gm_mgSave.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgSave.mg_strTip = TRANS("save current game (each player has own slots!)");
gm_lhGadgets.AddTail(gm_mgSave.mg_lnNode);
gm_mgSave.mg_pmgUp = &gm_mgLoad;
gm_mgSave.mg_pmgDown = &gm_mgDemoRec;
gm_mgSave.mg_pActivatedFunction = NULL;
gm_mgDemoRec.mg_boxOnScreen = BoxBigRow(4.0f);
gm_mgDemoRec.mg_bfsFontSize = BFS_LARGE;
gm_mgDemoRec.mg_pmgUp = &gm_mgSave;
gm_mgDemoRec.mg_pmgDown = &gm_mgHighScore;
gm_mgDemoRec.mg_strText = "Text not set";
gm_lhGadgets.AddTail(gm_mgDemoRec.mg_lnNode);
gm_mgDemoRec.mg_pActivatedFunction = NULL;
gm_mgHighScore.mg_strText = TRANS("HIGH SCORES");
gm_mgHighScore.mg_bfsFontSize = BFS_LARGE;
gm_mgHighScore.mg_boxOnScreen = BoxBigRow(5.0f);
gm_mgHighScore.mg_strTip = TRANS("view list of top ten best scores");
gm_lhGadgets.AddTail(gm_mgHighScore.mg_lnNode);
gm_mgHighScore.mg_pmgUp = &gm_mgDemoRec;
gm_mgHighScore.mg_pmgDown = &gm_mgOptions;
gm_mgHighScore.mg_pActivatedFunction = NULL;
gm_mgOptions.mg_strText = TRANS("OPTIONS");
gm_mgOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgOptions.mg_boxOnScreen = BoxBigRow(6.0f);
gm_mgOptions.mg_strTip = TRANS("adjust video, audio and input options");
gm_lhGadgets.AddTail(gm_mgOptions.mg_lnNode);
gm_mgOptions.mg_pmgUp = &gm_mgHighScore;
gm_mgOptions.mg_pmgDown = &gm_mgStop;
gm_mgOptions.mg_pActivatedFunction = NULL;
gm_mgStop.mg_strText = TRANS("STOP GAME");
gm_mgStop.mg_bfsFontSize = BFS_LARGE;
gm_mgStop.mg_boxOnScreen = BoxBigRow(7.0f);
gm_mgStop.mg_strTip = TRANS("stop currently running game");
gm_lhGadgets.AddTail(gm_mgStop.mg_lnNode);
gm_mgStop.mg_pmgUp = &gm_mgOptions;
gm_mgStop.mg_pmgDown = &gm_mgQuit;
gm_mgStop.mg_pActivatedFunction = NULL;
gm_mgQuit.mg_strText = TRANS("QUIT");
gm_mgQuit.mg_bfsFontSize = BFS_LARGE;
gm_mgQuit.mg_boxOnScreen = BoxBigRow(8.0f);
gm_mgQuit.mg_strTip = TRANS("exit game immediately");
gm_lhGadgets.AddTail(gm_mgQuit.mg_lnNode);
gm_mgQuit.mg_pmgUp = &gm_mgStop;
gm_mgQuit.mg_pmgDown = &gm_mgQuickLoad;
gm_mgQuit.mg_pActivatedFunction = NULL;
}
void CInGameMenu::StartMenu(void)
{
gm_mgQuickLoad.mg_bEnabled = _pNetwork->IsServer();
gm_mgQuickSave.mg_bEnabled = _pNetwork->IsServer();
gm_mgLoad.mg_bEnabled = _pNetwork->IsServer();
gm_mgSave.mg_bEnabled = _pNetwork->IsServer();
gm_mgDemoRec.mg_bEnabled = TRUE;//_pNetwork->IsServer();
extern void SetDemoStartStopRecText();
SetDemoStartStopRecText();
if (_gmRunningGameMode == GM_SINGLE_PLAYER) {
CPlayerCharacter &pc = _pGame->gm_apcPlayers[_pGame->gm_iSinglePlayer];
gm_mgLabel1.mg_strText.PrintF(TRANS("Player: %s"), (const char *) pc.GetNameForPrinting());
gm_mgLabel2.mg_strText = "";
} else {
if (_pNetwork->IsServer()) {
CTString strHost, strAddress;
CTString strHostName;
_pNetwork->GetHostName(strHost, strAddress);
if (strHost == "") {
strHostName = TRANS("<not started yet>");
}
else {
strHostName = strHost + " (" + strAddress + ")";
}
gm_mgLabel1.mg_strText = TRANS("Address: ") + strHostName;
gm_mgLabel2.mg_strText = "";
} else {
CTString strConfig;
strConfig = TRANS("<not adjusted>");
extern CTString sam_strNetworkSettings;
if (sam_strNetworkSettings != "") {
LoadStringVar(CTFileName(sam_strNetworkSettings).NoExt() + ".des", strConfig);
strConfig.OnlyFirstLine();
}
gm_mgLabel1.mg_strText = TRANS("Connected to: ") + _pGame->gam_strJoinAddress;
gm_mgLabel2.mg_strText = TRANS("Connection: ") + strConfig;
}
}
CGameMenu::StartMenu();
}

46
Sources/SeriousSam/GUI/Menus/MInGame.h
View File

@ -1,46 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_INGAME_H
#define SE_INCL_GAME_MENU_INGAME_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CInGameMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgLabel1;
CMGButton gm_mgLabel2;
CMGButton gm_mgQuickLoad;
CMGButton gm_mgQuickSave;
CMGButton gm_mgLoad;
CMGButton gm_mgSave;
CMGButton gm_mgDemoRec;
CMGButton gm_mgHighScore;
CMGButton gm_mgOptions;
CMGButton gm_mgStop;
CMGButton gm_mgQuit;
void Initialize_t(void);
void StartMenu(void);
};
#endif /* include-once check. */

112
Sources/SeriousSam/GUI/Menus/MLevels.cpp
View File

@ -1,112 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "SeriousSam/LevelInfo.h"
#include "MLevels.h"
void CLevelsMenu::Initialize_t(void)
{
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("CHOOSE LEVEL");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
for (INDEX iLabel = 0; iLabel<LEVELS_ON_SCREEN; iLabel++)
{
INDEX iPrev = (LEVELS_ON_SCREEN + iLabel - 1) % LEVELS_ON_SCREEN;
INDEX iNext = (iLabel + 1) % LEVELS_ON_SCREEN;
// initialize label gadgets
gm_mgManualLevel[iLabel].mg_pmgUp = &gm_mgManualLevel[iPrev];
gm_mgManualLevel[iLabel].mg_pmgDown = &gm_mgManualLevel[iNext];
gm_mgManualLevel[iLabel].mg_boxOnScreen = BoxMediumRow(iLabel);
gm_mgManualLevel[iLabel].mg_pActivatedFunction = NULL; // never called!
gm_lhGadgets.AddTail(gm_mgManualLevel[iLabel].mg_lnNode);
}
gm_lhGadgets.AddTail(gm_mgArrowUp.mg_lnNode);
gm_lhGadgets.AddTail(gm_mgArrowDn.mg_lnNode);
gm_mgArrowUp.mg_adDirection = AD_UP;
gm_mgArrowDn.mg_adDirection = AD_DOWN;
gm_mgArrowUp.mg_boxOnScreen = BoxArrow(AD_UP);
gm_mgArrowDn.mg_boxOnScreen = BoxArrow(AD_DOWN);
gm_mgArrowUp.mg_pmgRight = gm_mgArrowUp.mg_pmgDown =
&gm_mgManualLevel[0];
gm_mgArrowDn.mg_pmgRight = gm_mgArrowDn.mg_pmgUp =
&gm_mgManualLevel[LEVELS_ON_SCREEN - 1];
gm_ctListVisible = LEVELS_ON_SCREEN;
gm_pmgArrowUp = &gm_mgArrowUp;
gm_pmgArrowDn = &gm_mgArrowDn;
gm_pmgListTop = &gm_mgManualLevel[0];
gm_pmgListBottom = &gm_mgManualLevel[LEVELS_ON_SCREEN - 1];
}
void CLevelsMenu::FillListItems(void)
{
// disable all items first
for (INDEX i = 0; i<LEVELS_ON_SCREEN; i++) {
gm_mgManualLevel[i].mg_bEnabled = FALSE;
gm_mgManualLevel[i].mg_strText = TRANS("<empty>");
gm_mgManualLevel[i].mg_iInList = -2;
}
BOOL bHasFirst = FALSE;
BOOL bHasLast = FALSE;
INDEX ctLabels = _lhFilteredLevels.Count();
INDEX iLabel = 0;
FOREACHINLIST(CLevelInfo, li_lnNode, _lhFilteredLevels, itli) {
CLevelInfo &li = *itli;
INDEX iInMenu = iLabel - gm_iListOffset;
if ((iLabel >= gm_iListOffset) &&
(iLabel<(gm_iListOffset + LEVELS_ON_SCREEN)))
{
bHasFirst |= (iLabel == 0);
bHasLast |= (iLabel == ctLabels - 1);
gm_mgManualLevel[iInMenu].mg_strText = li.li_strName;
gm_mgManualLevel[iInMenu].mg_fnmLevel = li.li_fnLevel;
gm_mgManualLevel[iInMenu].mg_bEnabled = TRUE;
gm_mgManualLevel[iInMenu].mg_iInList = iLabel;
}
iLabel++;
}
// enable/disable up/down arrows
gm_mgArrowUp.mg_bEnabled = !bHasFirst && ctLabels>0;
gm_mgArrowDn.mg_bEnabled = !bHasLast && ctLabels>0;
}
void CLevelsMenu::StartMenu(void)
{
// set default parameters for the list
gm_iListOffset = 0;
gm_ctListTotal = _lhFilteredLevels.Count();
gm_iListWantedItem = 0;
// for each level
INDEX i = 0;
FOREACHINLIST(CLevelInfo, li_lnNode, _lhFilteredLevels, itlid) {
CLevelInfo &lid = *itlid;
// if it is the chosen one
if (lid.li_fnLevel == _pGame->gam_strCustomLevel) {
// demand focus on it
gm_iListWantedItem = i;
break;
}
i++;
}
CGameMenu::StartMenu();
}

40
Sources/SeriousSam/GUI/Menus/MLevels.h
View File

@ -1,40 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_LEVELS_H
#define SE_INCL_GAME_MENU_LEVELS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGArrow.h"
#include "SeriousSam/GUI/Components/MGLevelButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CLevelsMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGLevelButton gm_mgManualLevel[LEVELS_ON_SCREEN];
CMGArrow gm_mgArrowUp;
CMGArrow gm_mgArrowDn;
void Initialize_t(void);
void FillListItems(void);
void StartMenu(void);
};
#endif /* include-once check. */

236
Sources/SeriousSam/GUI/Menus/MLoadSave.cpp
View File

@ -1,236 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MLoadSave.h"
void CLoadSaveMenu::Initialize_t(void)
{
gm_pgmNextMenu = NULL;
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgNotes.mg_boxOnScreen = BoxMediumRow(10.0);
gm_mgNotes.mg_bfsFontSize = BFS_MEDIUM;
gm_mgNotes.mg_iCenterI = -1;
gm_mgNotes.mg_bEnabled = FALSE;
gm_mgNotes.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgNotes.mg_lnNode);
for (INDEX iLabel = 0; iLabel<SAVELOAD_BUTTONS_CT; iLabel++)
{
INDEX iPrev = (SAVELOAD_BUTTONS_CT + iLabel - 1) % SAVELOAD_BUTTONS_CT;
INDEX iNext = (iLabel + 1) % SAVELOAD_BUTTONS_CT;
// initialize label gadgets
gm_amgButton[iLabel].mg_pmgUp = &gm_amgButton[iPrev];
gm_amgButton[iLabel].mg_pmgDown = &gm_amgButton[iNext];
gm_amgButton[iLabel].mg_boxOnScreen = BoxSaveLoad(iLabel);
gm_amgButton[iLabel].mg_pActivatedFunction = NULL; // never called!
gm_amgButton[iLabel].mg_iCenterI = -1;
gm_lhGadgets.AddTail(gm_amgButton[iLabel].mg_lnNode);
}
gm_lhGadgets.AddTail(gm_mgArrowUp.mg_lnNode);
gm_lhGadgets.AddTail(gm_mgArrowDn.mg_lnNode);
gm_mgArrowUp.mg_adDirection = AD_UP;
gm_mgArrowDn.mg_adDirection = AD_DOWN;
gm_mgArrowUp.mg_boxOnScreen = BoxArrow(AD_UP);
gm_mgArrowDn.mg_boxOnScreen = BoxArrow(AD_DOWN);
gm_mgArrowUp.mg_pmgRight = gm_mgArrowUp.mg_pmgDown = &gm_amgButton[0];
gm_mgArrowDn.mg_pmgRight = gm_mgArrowDn.mg_pmgUp = &gm_amgButton[SAVELOAD_BUTTONS_CT - 1];
gm_ctListVisible = SAVELOAD_BUTTONS_CT;
gm_pmgArrowUp = &gm_mgArrowUp;
gm_pmgArrowDn = &gm_mgArrowDn;
gm_pmgListTop = &gm_amgButton[0];
gm_pmgListBottom = &gm_amgButton[SAVELOAD_BUTTONS_CT - 1];
}
void CLoadSaveMenu::StartMenu(void)
{
gm_bNoEscape = FALSE;
// delete all file infos
FORDELETELIST(CFileInfo, fi_lnNode, gm_lhFileInfos, itfi) {
delete &itfi.Current();
}
// list the directory
CDynamicStackArray<CTFileName> afnmDir;
MakeDirList(afnmDir, gm_fnmDirectory, CTString(""), 0);
gm_iLastFile = -1;
// for each file in the directory
for (INDEX i = 0; i<afnmDir.Count(); i++) {
CTFileName fnm = afnmDir[i];
// if it can be parsed
CTString strName;
if (ParseFile(fnm, strName)) {
// create new info for that file
CFileInfo *pfi = new CFileInfo;
pfi->fi_fnFile = fnm;
pfi->fi_strName = strName;
// add it to list
gm_lhFileInfos.AddTail(pfi->fi_lnNode);
}
}
// sort if needed
switch (gm_iSortType) {
default: ASSERT(FALSE);
case LSSORT_NONE: break;
case LSSORT_NAMEUP:
gm_lhFileInfos.Sort(qsort_CompareFileInfos_NameUp, offsetof(CFileInfo, fi_lnNode));
break;
case LSSORT_NAMEDN:
gm_lhFileInfos.Sort(qsort_CompareFileInfos_NameDn, offsetof(CFileInfo, fi_lnNode));
break;
case LSSORT_FILEUP:
gm_lhFileInfos.Sort(qsort_CompareFileInfos_FileUp, offsetof(CFileInfo, fi_lnNode));
break;
case LSSORT_FILEDN:
gm_lhFileInfos.Sort(qsort_CompareFileInfos_FileDn, offsetof(CFileInfo, fi_lnNode));
break;
}
// if saving
if (gm_bSave) {
// add one info as empty slot
CFileInfo *pfi = new CFileInfo;
CTString strNumber;
strNumber.PrintF("%04d", gm_iLastFile + 1);
pfi->fi_fnFile = gm_fnmDirectory + gm_fnmBaseName + strNumber + gm_fnmExt;
pfi->fi_strName = EMPTYSLOTSTRING;
// add it to beginning
gm_lhFileInfos.AddHead(pfi->fi_lnNode);
}
// set default parameters for the list
gm_iListOffset = 0;
gm_ctListTotal = gm_lhFileInfos.Count();
// find which one should be selected
gm_iListWantedItem = 0;
if (gm_fnmSelected != "") {
INDEX i = 0;
FOREACHINLIST(CFileInfo, fi_lnNode, gm_lhFileInfos, itfi) {
CFileInfo &fi = *itfi;
if (fi.fi_fnFile == gm_fnmSelected) {
gm_iListWantedItem = i;
break;
}
i++;
}
}
CGameMenu::StartMenu();
}
void CLoadSaveMenu::EndMenu(void)
{
// delete all file infos
FORDELETELIST(CFileInfo, fi_lnNode, gm_lhFileInfos, itfi) {
delete &itfi.Current();
}
gm_pgmNextMenu = NULL;
CGameMenu::EndMenu();
}
void CLoadSaveMenu::FillListItems(void)
{
// disable all items first
for (INDEX i = 0; i<SAVELOAD_BUTTONS_CT; i++) {
gm_amgButton[i].mg_bEnabled = FALSE;
gm_amgButton[i].mg_strText = TRANS("<empty>");
gm_amgButton[i].mg_strTip = "";
gm_amgButton[i].mg_iInList = -2;
}
BOOL bHasFirst = FALSE;
BOOL bHasLast = FALSE;
INDEX ctLabels = gm_lhFileInfos.Count();
INDEX iLabel = 0;
FOREACHINLIST(CFileInfo, fi_lnNode, gm_lhFileInfos, itfi) {
CFileInfo &fi = *itfi;
INDEX iInMenu = iLabel - gm_iListOffset;
if ((iLabel >= gm_iListOffset) &&
(iLabel<(gm_iListOffset + SAVELOAD_BUTTONS_CT)))
{
bHasFirst |= (iLabel == 0);
bHasLast |= (iLabel == ctLabels - 1);
gm_amgButton[iInMenu].mg_iInList = iLabel;
gm_amgButton[iInMenu].mg_strDes = fi.fi_strName;
gm_amgButton[iInMenu].mg_fnm = fi.fi_fnFile;
gm_amgButton[iInMenu].mg_bEnabled = TRUE;
gm_amgButton[iInMenu].RefreshText();
if (gm_bSave) {
if (!FileExistsForWriting(gm_amgButton[iInMenu].mg_fnm)) {
gm_amgButton[iInMenu].mg_strTip = TRANS("Enter - save in new slot");
}
else {
gm_amgButton[iInMenu].mg_strTip = TRANS("Enter - save here, F2 - rename, Del - delete");
}
}
else if (gm_bManage) {
gm_amgButton[iInMenu].mg_strTip = TRANS("Enter - load this, F2 - rename, Del - delete");
}
else {
gm_amgButton[iInMenu].mg_strTip = TRANS("Enter - load this");
}
}
iLabel++;
}
// enable/disable up/down arrows
gm_mgArrowUp.mg_bEnabled = !bHasFirst && ctLabels>0;
gm_mgArrowDn.mg_bEnabled = !bHasLast && ctLabels>0;
}
// called to get info of a file from directory, or to skip it
BOOL CLoadSaveMenu::ParseFile(const CTFileName &fnm, CTString &strName)
{
if (fnm.FileExt() != gm_fnmExt) {
return FALSE;
}
CTFileName fnSaveGameDescription = fnm.NoExt() + ".des";
try {
strName.Load_t(fnSaveGameDescription);
} catch (char *strError) {
(void)strError;
strName = fnm.FileName();
if (fnm.FileExt() == ".ctl") {
INDEX iCtl = -1;
strName.ScanF("Controls%d", &iCtl);
if (iCtl >= 0 && iCtl <= 7) {
strName.PrintF(TRANS("From player: %s"), (const char *) _pGame->gm_apcPlayers[iCtl].GetNameForPrinting());
}
}
}
INDEX iFile = -1;
fnm.FileName().ScanF((const char*)(gm_fnmBaseName + "%d"), &iFile);
gm_iLastFile = Max(gm_iLastFile, iFile);
return TRUE;
}

80
Sources/SeriousSam/GUI/Menus/MLoadSave.h
View File

@ -1,80 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_LOADSAVE_H
#define SE_INCL_GAME_MENU_LOADSAVE_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGArrow.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGFileButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#define SAVELOAD_BUTTONS_CT 14
enum ELSSortType
{
LSSORT_NONE,
LSSORT_NAMEUP,
LSSORT_NAMEDN,
LSSORT_FILEUP,
LSSORT_FILEDN,
};
class CLoadSaveMenu : public CGameMenu {
public:
// settings adjusted before starting the menu
CGameMenu *gm_pgmNextMenu; // menu to go to after selecting a file (if null, use parent menu)
CTFileName gm_fnmSelected; // file that is selected initially
CTFileName gm_fnmDirectory; // directory that should be read
CTFileName gm_fnmBaseName; // base file name for saving (numbers are auto-added)
CTFileName gm_fnmExt; // accepted file extension
BOOL gm_bSave; // set when chosing file for saving
BOOL gm_bManage; // set if managing (rename/delet is enabled)
CTString gm_strSaveDes; // default description (if saving)
BOOL gm_bAllowThumbnails; // set when chosing file for saving
BOOL gm_bNoEscape; // forbid exiting with escape/rmb
INDEX gm_iSortType; // sort type
// function to activate when file is chosen
// return true if saving succeeded - description is saved automatically
// always return true for loading
BOOL(*gm_pAfterFileChosen)(const CTFileName &fnm);
// internal properties
CListHead gm_lhFileInfos; // all file infos to list
INDEX gm_iLastFile; // index of last saved file in numbered format
CMGTitle gm_mgTitle;
CMGButton gm_mgNotes;
CMGFileButton gm_amgButton[SAVELOAD_BUTTONS_CT];
CMGArrow gm_mgArrowUp;
CMGArrow gm_mgArrowDn;
// called to get info of a file from directory, or to skip it
BOOL ParseFile(const CTFileName &fnm, CTString &strName);
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void FillListItems(void);
};
#endif /* include-once check. */

130
Sources/SeriousSam/GUI/Menus/MMain.cpp
View File

@ -1,130 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MMain.h"
void CMainMenu::Initialize_t(void)
{
// intialize main menu
/*
gm_mgTitle.mg_strText = "SERIOUS SAM - BETA"; // nothing to see here, kazuya
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail( gm_mgTitle.mg_lnNode);
*/
extern CTString sam_strVersion;
gm_mgVersionLabel.mg_strText = sam_strVersion;
gm_mgVersionLabel.mg_boxOnScreen = BoxVersion();
gm_mgVersionLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgVersionLabel.mg_iCenterI = +1;
gm_mgVersionLabel.mg_bEnabled = FALSE;
gm_mgVersionLabel.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgVersionLabel.mg_lnNode);
extern CTString sam_strModName;
gm_mgModLabel.mg_strText = sam_strModName;
gm_mgModLabel.mg_boxOnScreen = BoxMediumRow(-2.0f);
gm_mgModLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgModLabel.mg_iCenterI = 0;
gm_mgModLabel.mg_bEnabled = FALSE;
gm_mgModLabel.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgModLabel.mg_lnNode);
gm_mgSingle.mg_strText = TRANS("SINGLE PLAYER");
gm_mgSingle.mg_bfsFontSize = BFS_LARGE;
gm_mgSingle.mg_boxOnScreen = BoxBigRow(0.0f);
gm_mgSingle.mg_strTip = TRANS("single player game menus");
gm_lhGadgets.AddTail(gm_mgSingle.mg_lnNode);
gm_mgSingle.mg_pmgUp = &gm_mgQuit;
gm_mgSingle.mg_pmgDown = &gm_mgNetwork;
gm_mgSingle.mg_pActivatedFunction = NULL;
gm_mgNetwork.mg_strText = TRANS("NETWORK");
gm_mgNetwork.mg_bfsFontSize = BFS_LARGE;
gm_mgNetwork.mg_boxOnScreen = BoxBigRow(1.0f);
gm_mgNetwork.mg_strTip = TRANS("LAN/iNet multiplayer menus");
gm_lhGadgets.AddTail(gm_mgNetwork.mg_lnNode);
gm_mgNetwork.mg_pmgUp = &gm_mgSingle;
gm_mgNetwork.mg_pmgDown = &gm_mgSplitScreen;
gm_mgNetwork.mg_pActivatedFunction = NULL;
gm_mgSplitScreen.mg_strText = TRANS("SPLIT SCREEN");
gm_mgSplitScreen.mg_bfsFontSize = BFS_LARGE;
gm_mgSplitScreen.mg_boxOnScreen = BoxBigRow(2.0f);
gm_mgSplitScreen.mg_strTip = TRANS("play with multiple players on one computer");
gm_lhGadgets.AddTail(gm_mgSplitScreen.mg_lnNode);
gm_mgSplitScreen.mg_pmgUp = &gm_mgNetwork;
gm_mgSplitScreen.mg_pmgDown = &gm_mgDemo;
gm_mgSplitScreen.mg_pActivatedFunction = NULL;
gm_mgDemo.mg_strText = TRANS("DEMO");
gm_mgDemo.mg_bfsFontSize = BFS_LARGE;
gm_mgDemo.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgDemo.mg_strTip = TRANS("play a game demo");
gm_lhGadgets.AddTail(gm_mgDemo.mg_lnNode);
gm_mgDemo.mg_pmgUp = &gm_mgSplitScreen;
gm_mgDemo.mg_pmgDown = &gm_mgMods;
gm_mgDemo.mg_pActivatedFunction = NULL;
gm_mgMods.mg_strText = TRANS("MODS");
gm_mgMods.mg_bfsFontSize = BFS_LARGE;
gm_mgMods.mg_boxOnScreen = BoxBigRow(4.0f);
gm_mgMods.mg_strTip = TRANS("run one of installed game modifications");
gm_lhGadgets.AddTail(gm_mgMods.mg_lnNode);
gm_mgMods.mg_pmgUp = &gm_mgDemo;
gm_mgMods.mg_pmgDown = &gm_mgHighScore;
gm_mgMods.mg_pActivatedFunction = NULL;
gm_mgHighScore.mg_strText = TRANS("HIGH SCORES");
gm_mgHighScore.mg_bfsFontSize = BFS_LARGE;
gm_mgHighScore.mg_boxOnScreen = BoxBigRow(5.0f);
gm_mgHighScore.mg_strTip = TRANS("view list of top ten best scores");
gm_lhGadgets.AddTail(gm_mgHighScore.mg_lnNode);
gm_mgHighScore.mg_pmgUp = &gm_mgMods;
gm_mgHighScore.mg_pmgDown = &gm_mgOptions;
gm_mgHighScore.mg_pActivatedFunction = NULL;
gm_mgOptions.mg_strText = TRANS("OPTIONS");
gm_mgOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgOptions.mg_boxOnScreen = BoxBigRow(6.0f);
gm_mgOptions.mg_strTip = TRANS("adjust video, audio and input options");
gm_lhGadgets.AddTail(gm_mgOptions.mg_lnNode);
gm_mgOptions.mg_pmgUp = &gm_mgHighScore;
gm_mgOptions.mg_pmgDown = &gm_mgQuit;
gm_mgOptions.mg_pActivatedFunction = NULL;
gm_mgQuit.mg_strText = TRANS("QUIT");
gm_mgQuit.mg_bfsFontSize = BFS_LARGE;
gm_mgQuit.mg_boxOnScreen = BoxBigRow(7.0f);
gm_mgQuit.mg_strTip = TRANS("exit game immediately");
gm_lhGadgets.AddTail(gm_mgQuit.mg_lnNode);
gm_mgQuit.mg_pmgUp = &gm_mgOptions;
gm_mgQuit.mg_pmgDown = &gm_mgSingle;
gm_mgQuit.mg_pActivatedFunction = NULL;
}
void CMainMenu::StartMenu(void)
{
gm_mgSingle.mg_bEnabled = IsMenuEnabled("Single Player");
gm_mgNetwork.mg_bEnabled = IsMenuEnabled("Network");
gm_mgSplitScreen.mg_bEnabled = IsMenuEnabled("Split Screen");
gm_mgHighScore.mg_bEnabled = IsMenuEnabled("High Score");
CGameMenu::StartMenu();
}

43
Sources/SeriousSam/GUI/Menus/MMain.h
View File

@ -1,43 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_MAIN_H
#define SE_INCL_GAME_MENU_MAIN_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
class CMainMenu : public CGameMenu {
public:
CMGButton gm_mgVersionLabel;
CMGButton gm_mgModLabel;
CMGButton gm_mgSingle;
CMGButton gm_mgNetwork;
CMGButton gm_mgSplitScreen;
CMGButton gm_mgDemo;
CMGButton gm_mgMods;
CMGButton gm_mgHighScore;
CMGButton gm_mgOptions;
CMGButton gm_mgQuit;
void Initialize_t(void);
void StartMenu(void);
};
#endif /* include-once check. */

69
Sources/SeriousSam/GUI/Menus/MNetwork.cpp
View File

@ -1,69 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MNetwork.h"
void CNetworkMenu::Initialize_t(void)
{
// intialize network menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("NETWORK");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgJoin.mg_bfsFontSize = BFS_LARGE;
gm_mgJoin.mg_boxOnScreen = BoxBigRow(1.0f);
gm_mgJoin.mg_pmgUp = &gm_mgLoad;
gm_mgJoin.mg_pmgDown = &gm_mgStart;
gm_mgJoin.mg_strText = TRANS("JOIN GAME");
gm_mgJoin.mg_strTip = TRANS("join a network game");
gm_lhGadgets.AddTail(gm_mgJoin.mg_lnNode);
gm_mgJoin.mg_pActivatedFunction = NULL;
gm_mgStart.mg_bfsFontSize = BFS_LARGE;
gm_mgStart.mg_boxOnScreen = BoxBigRow(2.0f);
gm_mgStart.mg_pmgUp = &gm_mgJoin;
gm_mgStart.mg_pmgDown = &gm_mgQuickLoad;
gm_mgStart.mg_strText = TRANS("START SERVER");
gm_mgStart.mg_strTip = TRANS("start a network game server");
gm_lhGadgets.AddTail(gm_mgStart.mg_lnNode);
gm_mgStart.mg_pActivatedFunction = NULL;
gm_mgQuickLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgQuickLoad.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgQuickLoad.mg_pmgUp = &gm_mgStart;
gm_mgQuickLoad.mg_pmgDown = &gm_mgLoad;
gm_mgQuickLoad.mg_strText = TRANS("QUICK LOAD");
gm_mgQuickLoad.mg_strTip = TRANS("load a quick-saved game (F9)");
gm_lhGadgets.AddTail(gm_mgQuickLoad.mg_lnNode);
gm_mgQuickLoad.mg_pActivatedFunction = NULL;
gm_mgLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgLoad.mg_boxOnScreen = BoxBigRow(4.0f);
gm_mgLoad.mg_pmgUp = &gm_mgQuickLoad;
gm_mgLoad.mg_pmgDown = &gm_mgJoin;
gm_mgLoad.mg_strText = TRANS("LOAD");
gm_mgLoad.mg_strTip = TRANS("start server and load a network game (server only)");
gm_lhGadgets.AddTail(gm_mgLoad.mg_lnNode);
gm_mgLoad.mg_pActivatedFunction = NULL;
}
void CNetworkMenu::StartMenu(void)
{
CGameMenu::StartMenu();
}

39
Sources/SeriousSam/GUI/Menus/MNetwork.h
View File

@ -1,39 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_NETWORK_H
#define SE_INCL_GAME_MENU_NETWORK_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CNetworkMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgJoin;
CMGButton gm_mgStart;
CMGButton gm_mgQuickLoad;
CMGButton gm_mgLoad;
void Initialize_t(void);
void StartMenu(void);
};
#endif /* include-once check. */

56
Sources/SeriousSam/GUI/Menus/MNetworkJoin.cpp
View File

@ -1,56 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MNetworkJoin.h"
void CNetworkJoinMenu::Initialize_t(void)
{
// title
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("JOIN GAME");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgLAN.mg_bfsFontSize = BFS_LARGE;
gm_mgLAN.mg_boxOnScreen = BoxBigRow(1.0f);
gm_mgLAN.mg_pmgUp = &gm_mgOpen;
gm_mgLAN.mg_pmgDown = &gm_mgNET;
gm_mgLAN.mg_strText = TRANS("SEARCH LAN");
gm_mgLAN.mg_strTip = TRANS("search local network for servers");
gm_lhGadgets.AddTail(gm_mgLAN.mg_lnNode);
gm_mgLAN.mg_pActivatedFunction = NULL;
gm_mgNET.mg_bfsFontSize = BFS_LARGE;
gm_mgNET.mg_boxOnScreen = BoxBigRow(2.0f);
gm_mgNET.mg_pmgUp = &gm_mgLAN;
gm_mgNET.mg_pmgDown = &gm_mgOpen;
gm_mgNET.mg_strText = TRANS("SEARCH INTERNET");
gm_mgNET.mg_strTip = TRANS("search internet for servers");
gm_lhGadgets.AddTail(gm_mgNET.mg_lnNode);
gm_mgNET.mg_pActivatedFunction = NULL;
gm_mgOpen.mg_bfsFontSize = BFS_LARGE;
gm_mgOpen.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgOpen.mg_pmgUp = &gm_mgNET;
gm_mgOpen.mg_pmgDown = &gm_mgLAN;
gm_mgOpen.mg_strText = TRANS("SPECIFY SERVER");
gm_mgOpen.mg_strTip = TRANS("type in server address to connect to");
gm_lhGadgets.AddTail(gm_mgOpen.mg_lnNode);
gm_mgOpen.mg_pActivatedFunction = NULL;
}

37
Sources/SeriousSam/GUI/Menus/MNetworkJoin.h
View File

@ -1,37 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_NETWORKJOIN_H
#define SE_INCL_GAME_MENU_NETWORKJOIN_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CNetworkJoinMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgLAN;
CMGButton gm_mgNET;
CMGButton gm_mgOpen;
void Initialize_t(void);
};
#endif /* include-once check. */

79
Sources/SeriousSam/GUI/Menus/MNetworkOpen.cpp
View File

@ -1,79 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MNetworkOpen.h"
void CNetworkOpenMenu::Initialize_t(void)
{
// intialize network join menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("JOIN");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgAddressLabel.mg_strText = TRANS("Address:");
gm_mgAddressLabel.mg_boxOnScreen = BoxMediumLeft(1);
gm_mgAddressLabel.mg_iCenterI = -1;
gm_lhGadgets.AddTail(gm_mgAddressLabel.mg_lnNode);
gm_mgAddress.mg_strText = _pGame->gam_strJoinAddress;
gm_mgAddress.mg_ctMaxStringLen = 20;
gm_mgAddress.mg_pstrToChange = &_pGame->gam_strJoinAddress;
gm_mgAddress.mg_boxOnScreen = BoxMediumMiddle(1);
gm_mgAddress.mg_bfsFontSize = BFS_MEDIUM;
gm_mgAddress.mg_iCenterI = -1;
gm_mgAddress.mg_pmgUp = &gm_mgJoin;
gm_mgAddress.mg_pmgDown = &gm_mgPort;
gm_mgAddress.mg_strTip = TRANS("specify server address");
gm_lhGadgets.AddTail(gm_mgAddress.mg_lnNode);
gm_mgPortLabel.mg_strText = TRANS("Port:");
gm_mgPortLabel.mg_boxOnScreen = BoxMediumLeft(2);
gm_mgPortLabel.mg_iCenterI = -1;
gm_lhGadgets.AddTail(gm_mgPortLabel.mg_lnNode);
gm_mgPort.mg_strText = "";
gm_mgPort.mg_ctMaxStringLen = 10;
gm_mgPort.mg_pstrToChange = &gm_strPort;
gm_mgPort.mg_boxOnScreen = BoxMediumMiddle(2);
gm_mgPort.mg_bfsFontSize = BFS_MEDIUM;
gm_mgPort.mg_iCenterI = -1;
gm_mgPort.mg_pmgUp = &gm_mgAddress;
gm_mgPort.mg_pmgDown = &gm_mgJoin;
gm_mgPort.mg_strTip = TRANS("specify server address");
gm_lhGadgets.AddTail(gm_mgPort.mg_lnNode);
gm_mgJoin.mg_boxOnScreen = BoxMediumMiddle(3);
gm_mgJoin.mg_pmgUp = &gm_mgPort;
gm_mgJoin.mg_pmgDown = &gm_mgAddress;
gm_mgJoin.mg_strText = TRANS("Join");
gm_lhGadgets.AddTail(gm_mgJoin.mg_lnNode);
gm_mgJoin.mg_pActivatedFunction = NULL;
}
void CNetworkOpenMenu::StartMenu(void)
{
gm_strPort = _pShell->GetValue("net_iPort");
gm_mgPort.mg_strText = gm_strPort;
}
void CNetworkOpenMenu::EndMenu(void)
{
_pShell->SetValue("net_iPort", gm_strPort);
}

44
Sources/SeriousSam/GUI/Menus/MNetworkOpen.h
View File

@ -1,44 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_NETWORKOPEN_H
#define SE_INCL_GAME_MENU_NETWORKOPEN_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGEdit.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CNetworkOpenMenu : public CGameMenu {
public:
CTString gm_strPort;
CMGTitle gm_mgTitle;
CMGButton gm_mgAddressLabel;
CMGEdit gm_mgAddress;
CMGButton gm_mgPortLabel;
CMGEdit gm_mgPort;
CMGButton gm_mgJoin;
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
#endif /* include-once check. */

147
Sources/SeriousSam/GUI/Menus/MNetworkStart.cpp
View File

@ -1,147 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "SeriousSam/LevelInfo.h"
#include "MenuStuff.h"
#include "MNetworkStart.h"
extern void UpdateNetworkLevel(INDEX iDummy);
void CNetworkStartMenu::Initialize_t(void)
{
// title
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("START SERVER");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
// session name edit box
gm_mgSessionName.mg_strText = _pGame->gam_strSessionName;
gm_mgSessionName.mg_strLabel = TRANS("Session name:");
gm_mgSessionName.mg_ctMaxStringLen = 25;
gm_mgSessionName.mg_pstrToChange = &_pGame->gam_strSessionName;
gm_mgSessionName.mg_boxOnScreen = BoxMediumRow(1);
gm_mgSessionName.mg_bfsFontSize = BFS_MEDIUM;
gm_mgSessionName.mg_iCenterI = -1;
gm_mgSessionName.mg_pmgUp = &gm_mgStart;
gm_mgSessionName.mg_pmgDown = &gm_mgGameType;
gm_mgSessionName.mg_strTip = TRANS("name the session to start");
gm_lhGadgets.AddTail(gm_mgSessionName.mg_lnNode);
// game type trigger
TRIGGER_MG(gm_mgGameType, 2,
gm_mgSessionName, gm_mgDifficulty, TRANS("Game type:"), astrGameTypeRadioTexts);
gm_mgGameType.mg_ctTexts = ctGameTypeRadioTexts;
gm_mgGameType.mg_strTip = TRANS("choose type of multiplayer game");
gm_mgGameType.mg_pOnTriggerChange = &UpdateNetworkLevel;
// difficulty trigger
TRIGGER_MG(gm_mgDifficulty, 3,
gm_mgGameType, gm_mgLevel, TRANS("Difficulty:"), astrDifficultyRadioTexts);
gm_mgDifficulty.mg_strTip = TRANS("choose difficulty level");
// level name
gm_mgLevel.mg_strText = "";
gm_mgLevel.mg_strLabel = TRANS("Level:");
gm_mgLevel.mg_boxOnScreen = BoxMediumRow(4);
gm_mgLevel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgLevel.mg_iCenterI = -1;
gm_mgLevel.mg_pmgUp = &gm_mgDifficulty;
gm_mgLevel.mg_pmgDown = &gm_mgMaxPlayers;
gm_mgLevel.mg_strTip = TRANS("choose the level to start");
gm_mgLevel.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgLevel.mg_lnNode);
// max players trigger
TRIGGER_MG(gm_mgMaxPlayers, 5,
gm_mgLevel, gm_mgWaitAllPlayers, TRANS("Max players:"), astrMaxPlayersRadioTexts);
gm_mgMaxPlayers.mg_strTip = TRANS("choose maximum allowed number of players");
// wait all players trigger
TRIGGER_MG(gm_mgWaitAllPlayers, 6,
gm_mgMaxPlayers, gm_mgVisible, TRANS("Wait for all players:"), astrNoYes);
gm_mgWaitAllPlayers.mg_strTip = TRANS("if on, game won't start until all players have joined");
// server visible trigger
TRIGGER_MG(gm_mgVisible, 7,
gm_mgMaxPlayers, gm_mgGameOptions, TRANS("Server visible:"), astrNoYes);
gm_mgVisible.mg_strTip = TRANS("invisible servers are not listed, cleints have to join manually");
// options button
gm_mgGameOptions.mg_strText = TRANS("Game options");
gm_mgGameOptions.mg_boxOnScreen = BoxMediumRow(8);
gm_mgGameOptions.mg_bfsFontSize = BFS_MEDIUM;
gm_mgGameOptions.mg_iCenterI = 0;
gm_mgGameOptions.mg_pmgUp = &gm_mgVisible;
gm_mgGameOptions.mg_pmgDown = &gm_mgStart;
gm_mgGameOptions.mg_strTip = TRANS("adjust game rules");
gm_mgGameOptions.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgGameOptions.mg_lnNode);
// start button
gm_mgStart.mg_bfsFontSize = BFS_LARGE;
gm_mgStart.mg_boxOnScreen = BoxBigRow(7);
gm_mgStart.mg_pmgUp = &gm_mgGameOptions;
gm_mgStart.mg_pmgDown = &gm_mgSessionName;
gm_mgStart.mg_strText = TRANS("START");
gm_lhGadgets.AddTail(gm_mgStart.mg_lnNode);
gm_mgStart.mg_pActivatedFunction = NULL;
}
void CNetworkStartMenu::StartMenu(void)
{
extern INDEX sam_bMentalActivated;
gm_mgDifficulty.mg_ctTexts = sam_bMentalActivated ? 6 : 5;
gm_mgGameType.mg_iSelected = Clamp(_pShell->GetINDEX("gam_iStartMode"), 0L, ctGameTypeRadioTexts - 1L);
gm_mgGameType.ApplyCurrentSelection();
gm_mgDifficulty.mg_iSelected = _pShell->GetINDEX("gam_iStartDifficulty") + 1;
gm_mgDifficulty.ApplyCurrentSelection();
_pShell->SetINDEX("gam_iStartMode", CSessionProperties::GM_COOPERATIVE);
INDEX ctMaxPlayers = _pShell->GetINDEX("gam_ctMaxPlayers");
if (ctMaxPlayers<2 || ctMaxPlayers>16) {
ctMaxPlayers = 2;
_pShell->SetINDEX("gam_ctMaxPlayers", ctMaxPlayers);
}
gm_mgMaxPlayers.mg_iSelected = ctMaxPlayers - 2;
gm_mgMaxPlayers.ApplyCurrentSelection();
gm_mgWaitAllPlayers.mg_iSelected = Clamp(_pShell->GetINDEX("gam_bWaitAllPlayers"), 0L, 1L);
gm_mgWaitAllPlayers.ApplyCurrentSelection();
gm_mgVisible.mg_iSelected = _pShell->GetINDEX("ser_bEnumeration");
gm_mgVisible.ApplyCurrentSelection();
UpdateNetworkLevel(0);
CGameMenu::StartMenu();
}
void CNetworkStartMenu::EndMenu(void)
{
_pShell->SetINDEX("gam_iStartDifficulty", gm_mgDifficulty.mg_iSelected - 1);
_pShell->SetINDEX("gam_iStartMode", gm_mgGameType.mg_iSelected);
_pShell->SetINDEX("gam_bWaitAllPlayers", gm_mgWaitAllPlayers.mg_iSelected);
_pShell->SetINDEX("gam_ctMaxPlayers", gm_mgMaxPlayers.mg_iSelected + 2);
_pShell->SetINDEX("ser_bEnumeration", gm_mgVisible.mg_iSelected);
CGameMenu::EndMenu();
}

47
Sources/SeriousSam/GUI/Menus/MNetworkStart.h
View File

@ -1,47 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_NETWORKSTART_H
#define SE_INCL_GAME_MENU_NETWORKSTART_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGEdit.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#include "SeriousSam/GUI/Components/MGTrigger.h"
class CNetworkStartMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGEdit gm_mgSessionName;
CMGTrigger gm_mgGameType;
CMGTrigger gm_mgDifficulty;
CMGButton gm_mgLevel;
CMGTrigger gm_mgMaxPlayers;
CMGTrigger gm_mgWaitAllPlayers;
CMGTrigger gm_mgVisible;
CMGButton gm_mgGameOptions;
CMGButton gm_mgStart;
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
#endif /* include-once check. */

82
Sources/SeriousSam/GUI/Menus/MOptions.cpp
View File

@ -1,82 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MOptions.h"
void COptionsMenu::Initialize_t(void)
{
// intialize options menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("OPTIONS");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgVideoOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgVideoOptions.mg_boxOnScreen = BoxBigRow(0.0f);
gm_mgVideoOptions.mg_pmgUp = &gm_mgAddonOptions;
gm_mgVideoOptions.mg_pmgDown = &gm_mgAudioOptions;
gm_mgVideoOptions.mg_strText = TRANS("VIDEO OPTIONS");
gm_mgVideoOptions.mg_strTip = TRANS("set video mode and driver");
gm_lhGadgets.AddTail(gm_mgVideoOptions.mg_lnNode);
gm_mgVideoOptions.mg_pActivatedFunction = NULL;
gm_mgAudioOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgAudioOptions.mg_boxOnScreen = BoxBigRow(1.0f);
gm_mgAudioOptions.mg_pmgUp = &gm_mgVideoOptions;
gm_mgAudioOptions.mg_pmgDown = &gm_mgPlayerProfileOptions;
gm_mgAudioOptions.mg_strText = TRANS("AUDIO OPTIONS");
gm_mgAudioOptions.mg_strTip = TRANS("set audio quality and volume");
gm_lhGadgets.AddTail(gm_mgAudioOptions.mg_lnNode);
gm_mgAudioOptions.mg_pActivatedFunction = NULL;
gm_mgPlayerProfileOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgPlayerProfileOptions.mg_boxOnScreen = BoxBigRow(2.0f);
gm_mgPlayerProfileOptions.mg_pmgUp = &gm_mgAudioOptions;
gm_mgPlayerProfileOptions.mg_pmgDown = &gm_mgNetworkOptions;
gm_mgPlayerProfileOptions.mg_strText = TRANS("PLAYERS AND CONTROLS");
gm_mgPlayerProfileOptions.mg_strTip = TRANS("change currently active player or adjust controls");
gm_lhGadgets.AddTail(gm_mgPlayerProfileOptions.mg_lnNode);
gm_mgPlayerProfileOptions.mg_pActivatedFunction = NULL;
gm_mgNetworkOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgNetworkOptions.mg_boxOnScreen = BoxBigRow(3);
gm_mgNetworkOptions.mg_pmgUp = &gm_mgPlayerProfileOptions;
gm_mgNetworkOptions.mg_pmgDown = &gm_mgCustomOptions;
gm_mgNetworkOptions.mg_strText = TRANS("NETWORK CONNECTION");
gm_mgNetworkOptions.mg_strTip = TRANS("choose your connection parameters");
gm_lhGadgets.AddTail(gm_mgNetworkOptions.mg_lnNode);
gm_mgNetworkOptions.mg_pActivatedFunction = NULL;
gm_mgCustomOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgCustomOptions.mg_boxOnScreen = BoxBigRow(4);
gm_mgCustomOptions.mg_pmgUp = &gm_mgNetworkOptions;
gm_mgCustomOptions.mg_pmgDown = &gm_mgAddonOptions;
gm_mgCustomOptions.mg_strText = TRANS("ADVANCED OPTIONS");
gm_mgCustomOptions.mg_strTip = TRANS("for advanced users only");
gm_lhGadgets.AddTail(gm_mgCustomOptions.mg_lnNode);
gm_mgCustomOptions.mg_pActivatedFunction = NULL;
gm_mgAddonOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgAddonOptions.mg_boxOnScreen = BoxBigRow(5);
gm_mgAddonOptions.mg_pmgUp = &gm_mgCustomOptions;
gm_mgAddonOptions.mg_pmgDown = &gm_mgVideoOptions;
gm_mgAddonOptions.mg_strText = TRANS("EXECUTE ADDON");
gm_mgAddonOptions.mg_strTip = TRANS("choose from list of addons to execute");
gm_lhGadgets.AddTail(gm_mgAddonOptions.mg_lnNode);
gm_mgAddonOptions.mg_pActivatedFunction = NULL;
}

40
Sources/SeriousSam/GUI/Menus/MOptions.h
View File

@ -1,40 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_OPTIONS_H
#define SE_INCL_GAME_MENU_OPTIONS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class COptionsMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgVideoOptions;
CMGButton gm_mgAudioOptions;
CMGButton gm_mgPlayerProfileOptions;
CMGButton gm_mgNetworkOptions;
CMGButton gm_mgCustomOptions;
CMGButton gm_mgAddonOptions;
void Initialize_t(void);
};
#endif /* include-once check. */

307
Sources/SeriousSam/GUI/Menus/MPlayerProfile.cpp
View File

@ -1,307 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MPlayerProfile.h"
#include "SeriousSam/GUI/Menus/MenuManager.h"
#define ADD_SELECT_PLAYER_MG( index, mg, mgprev, mgnext, me)\
mg.mg_iIndex = index; \
mg.mg_bfsFontSize = BFS_MEDIUM; \
mg.mg_boxOnScreen = BoxNoUp(index); \
mg.mg_bRectangle = TRUE; \
mg.mg_pmgLeft = &mgprev; \
mg.mg_pmgRight = &mgnext; \
mg.mg_pmgUp = &gm_mgCustomizeControls; \
mg.mg_pmgDown = &gm_mgNameField; \
mg.mg_pActivatedFunction = &PPOnPlayerSelect; \
mg.mg_strText = #index; \
mg.mg_strTip = TRANS("select new currently active player"); \
gm_lhGadgets.AddTail(mg.mg_lnNode);
extern BOOL _bPlayerMenuFromSinglePlayer;
extern CTString _strLastPlayerAppearance;
extern void PPOnPlayerSelect(void);
void CPlayerProfileMenu::Initialize_t(void)
{
// intialize player and controls menu
_bPlayerMenuFromSinglePlayer = FALSE;
gm_mgProfileTitle.mg_boxOnScreen = BoxTitle();
gm_mgProfileTitle.mg_strText = TRANS("PLAYER PROFILE");
gm_lhGadgets.AddTail(gm_mgProfileTitle.mg_lnNode);
gm_mgNoLabel.mg_strText = TRANS("PROFILE:");
gm_mgNoLabel.mg_boxOnScreen = BoxMediumLeft(0.0f);
gm_mgNoLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgNoLabel.mg_iCenterI = -1;
gm_lhGadgets.AddTail(gm_mgNoLabel.mg_lnNode);
ADD_SELECT_PLAYER_MG(0, gm_mgNumber[0], gm_mgNumber[7], gm_mgNumber[1], gm_mgNumber[0]);
ADD_SELECT_PLAYER_MG(1, gm_mgNumber[1], gm_mgNumber[0], gm_mgNumber[2], gm_mgNumber[1]);
ADD_SELECT_PLAYER_MG(2, gm_mgNumber[2], gm_mgNumber[1], gm_mgNumber[3], gm_mgNumber[2]);
ADD_SELECT_PLAYER_MG(3, gm_mgNumber[3], gm_mgNumber[2], gm_mgNumber[4], gm_mgNumber[3]);
ADD_SELECT_PLAYER_MG(4, gm_mgNumber[4], gm_mgNumber[3], gm_mgNumber[5], gm_mgNumber[4]);
ADD_SELECT_PLAYER_MG(5, gm_mgNumber[5], gm_mgNumber[4], gm_mgNumber[6], gm_mgNumber[5]);
ADD_SELECT_PLAYER_MG(6, gm_mgNumber[6], gm_mgNumber[5], gm_mgNumber[7], gm_mgNumber[6]);
ADD_SELECT_PLAYER_MG(7, gm_mgNumber[7], gm_mgNumber[6], gm_mgNumber[0], gm_mgNumber[7]);
gm_mgNumber[7].mg_pmgRight = &gm_mgModel;
gm_mgNameLabel.mg_strText = TRANS("NAME:");
gm_mgNameLabel.mg_boxOnScreen = BoxMediumLeft(1.25f);
gm_mgNameLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgNameLabel.mg_iCenterI = -1;
gm_lhGadgets.AddTail(gm_mgNameLabel.mg_lnNode);
// setup of player name button is done on start menu
gm_mgNameField.mg_strText = "<\?\?\?>";
gm_mgNameField.mg_ctMaxStringLen = 25;
gm_mgNameField.mg_boxOnScreen = BoxPlayerEdit(1.25);
gm_mgNameField.mg_bfsFontSize = BFS_MEDIUM;
gm_mgNameField.mg_iCenterI = -1;
gm_mgNameField.mg_pmgUp = &gm_mgNumber[0];
gm_mgNameField.mg_pmgDown = &gm_mgTeam;
gm_mgNameField.mg_pmgRight = &gm_mgModel;
gm_mgNameField.mg_strTip = TRANS("rename currently active player");
gm_lhGadgets.AddTail(gm_mgNameField.mg_lnNode);
gm_mgTeamLabel.mg_strText = TRANS("TEAM:");
gm_mgTeamLabel.mg_boxOnScreen = BoxMediumLeft(2.25f);
gm_mgTeamLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgTeamLabel.mg_iCenterI = -1;
gm_lhGadgets.AddTail(gm_mgTeamLabel.mg_lnNode);
// setup of player name button is done on start menu
gm_mgTeam.mg_strText = "<\?\?\?>";
gm_mgTeam.mg_ctMaxStringLen = 25;
gm_mgTeam.mg_boxOnScreen = BoxPlayerEdit(2.25f);
gm_mgTeam.mg_bfsFontSize = BFS_MEDIUM;
gm_mgTeam.mg_iCenterI = -1;
gm_mgTeam.mg_pmgUp = gm_mgNameField.mg_pmgUp = &gm_mgNumber[0];
gm_mgTeam.mg_pmgDown = &gm_mgCrosshair;
gm_mgTeam.mg_pmgRight = &gm_mgModel;
//gm_mgTeam.mg_strTip = TRANS("teamplay is disabled in this version");
gm_mgTeam.mg_strTip = TRANS("enter team name, if playing in team");
gm_lhGadgets.AddTail(gm_mgTeam.mg_lnNode);
TRIGGER_MG(gm_mgCrosshair, 4.0, gm_mgTeam, gm_mgWeaponSelect, TRANS("CROSSHAIR"), astrCrosshair);
gm_mgCrosshair.mg_bVisual = TRUE;
gm_mgCrosshair.mg_boxOnScreen = BoxPlayerSwitch(5.0f);
gm_mgCrosshair.mg_iCenterI = -1;
gm_mgCrosshair.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgWeaponSelect, 4.0, gm_mgCrosshair, gm_mgWeaponHide, TRANS("AUTO SELECT WEAPON"), astrWeapon);
gm_mgWeaponSelect.mg_boxOnScreen = BoxPlayerSwitch(6.0f);
gm_mgWeaponSelect.mg_iCenterI = -1;
gm_mgWeaponSelect.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgWeaponHide, 4.0, gm_mgWeaponSelect, gm_mg3rdPerson, TRANS("HIDE WEAPON MODEL"), astrNoYes);
gm_mgWeaponHide.mg_boxOnScreen = BoxPlayerSwitch(7.0f);
gm_mgWeaponHide.mg_iCenterI = -1;
gm_mgWeaponHide.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mg3rdPerson, 4.0, gm_mgWeaponHide, gm_mgQuotes, TRANS("PREFER 3RD PERSON VIEW"), astrNoYes);
gm_mg3rdPerson.mg_boxOnScreen = BoxPlayerSwitch(8.0f);
gm_mg3rdPerson.mg_iCenterI = -1;
gm_mg3rdPerson.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgQuotes, 4.0, gm_mg3rdPerson, gm_mgAutoSave, TRANS("VOICE QUOTES"), astrNoYes);
gm_mgQuotes.mg_boxOnScreen = BoxPlayerSwitch(9.0f);
gm_mgQuotes.mg_iCenterI = -1;
gm_mgQuotes.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgAutoSave, 4.0, gm_mgQuotes, gm_mgCompDoubleClick, TRANS("AUTO SAVE"), astrNoYes);
gm_mgAutoSave.mg_boxOnScreen = BoxPlayerSwitch(10.0f);
gm_mgAutoSave.mg_iCenterI = -1;
gm_mgAutoSave.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgCompDoubleClick, 4.0, gm_mgAutoSave, gm_mgSharpTurning, TRANS("INVOKE COMPUTER"), astrComputerInvoke);
gm_mgCompDoubleClick.mg_boxOnScreen = BoxPlayerSwitch(11.0f);
gm_mgCompDoubleClick.mg_iCenterI = -1;
gm_mgCompDoubleClick.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgSharpTurning, 4.0, gm_mgCompDoubleClick, gm_mgViewBobbing, TRANS("SHARP TURNING"), astrNoYes);
gm_mgSharpTurning.mg_boxOnScreen = BoxPlayerSwitch(12.0f);
gm_mgSharpTurning.mg_iCenterI = -1;
gm_mgSharpTurning.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgViewBobbing, 4.0, gm_mgSharpTurning, gm_mgCustomizeControls, TRANS("VIEW BOBBING"), astrNoYes);
gm_mgViewBobbing.mg_boxOnScreen = BoxPlayerSwitch(13.0f);
gm_mgViewBobbing.mg_iCenterI = -1;
gm_mgViewBobbing.mg_pOnTriggerChange = NULL;
gm_mgCustomizeControls.mg_strText = TRANS("CUSTOMIZE CONTROLS");
gm_mgCustomizeControls.mg_boxOnScreen = BoxMediumLeft(14.5f);
gm_mgCustomizeControls.mg_bfsFontSize = BFS_MEDIUM;
gm_mgCustomizeControls.mg_iCenterI = -1;
gm_mgCustomizeControls.mg_pmgUp = &gm_mgViewBobbing;
gm_mgCustomizeControls.mg_pActivatedFunction = NULL;
gm_mgCustomizeControls.mg_pmgDown = &gm_mgNumber[0];
gm_mgCustomizeControls.mg_pmgRight = &gm_mgModel;
gm_mgCustomizeControls.mg_strTip = TRANS("customize controls for this player");
gm_lhGadgets.AddTail(gm_mgCustomizeControls.mg_lnNode);
gm_mgModel.mg_boxOnScreen = BoxPlayerModel();
gm_mgModel.mg_pmgLeft = &gm_mgNameField;
gm_mgModel.mg_pActivatedFunction = NULL;
gm_mgModel.mg_pmgDown = &gm_mgNameField;
gm_mgModel.mg_pmgLeft = &gm_mgNameField;
gm_mgModel.mg_strTip = TRANS("change model for this player");
gm_lhGadgets.AddTail(gm_mgModel.mg_lnNode);
}
INDEX CPlayerProfileMenu::ComboFromPlayer(INDEX iPlayer)
{
return iPlayer;
}
INDEX CPlayerProfileMenu::PlayerFromCombo(INDEX iCombo)
{
return iCombo;
}
void CPlayerProfileMenu::SelectPlayer(INDEX iPlayer)
{
CPlayerCharacter &pc = _pGame->gm_apcPlayers[iPlayer];
for (INDEX iPl = 0; iPl<8; iPl++)
{
gm_mgNumber[iPl].mg_bHighlighted = FALSE;
}
gm_mgNumber[iPlayer].mg_bHighlighted = TRUE;
iPlayer = Clamp(iPlayer, INDEX(0), INDEX(7));
if (_iLocalPlayer >= 0 && _iLocalPlayer<4) {
_pGame->gm_aiMenuLocalPlayers[_iLocalPlayer] = iPlayer;
} else {
_pGame->gm_iSinglePlayer = iPlayer;
}
gm_mgNameField.mg_pstrToChange = &pc.pc_strName;
gm_mgNameField.SetText(*gm_mgNameField.mg_pstrToChange);
gm_mgTeam.mg_pstrToChange = &pc.pc_strTeam;
gm_mgTeam.SetText(*gm_mgTeam.mg_pstrToChange);
CPlayerSettings *pps = (CPlayerSettings *)pc.pc_aubAppearance;
gm_mgCrosshair.mg_iSelected = pps->ps_iCrossHairType + 1;
gm_mgCrosshair.ApplyCurrentSelection();
gm_mgWeaponSelect.mg_iSelected = pps->ps_iWeaponAutoSelect;
gm_mgWeaponSelect.ApplyCurrentSelection();
gm_mgWeaponHide.mg_iSelected = (pps->ps_ulFlags&PSF_HIDEWEAPON) ? 1 : 0;
gm_mgWeaponHide.ApplyCurrentSelection();
gm_mg3rdPerson.mg_iSelected = (pps->ps_ulFlags&PSF_PREFER3RDPERSON) ? 1 : 0;
gm_mg3rdPerson.ApplyCurrentSelection();
gm_mgQuotes.mg_iSelected = (pps->ps_ulFlags&PSF_NOQUOTES) ? 0 : 1;
gm_mgQuotes.ApplyCurrentSelection();
gm_mgAutoSave.mg_iSelected = (pps->ps_ulFlags&PSF_AUTOSAVE) ? 1 : 0;
gm_mgAutoSave.ApplyCurrentSelection();
gm_mgCompDoubleClick.mg_iSelected = (pps->ps_ulFlags&PSF_COMPSINGLECLICK) ? 0 : 1;
gm_mgCompDoubleClick.ApplyCurrentSelection();
gm_mgViewBobbing.mg_iSelected = (pps->ps_ulFlags&PSF_NOBOBBING) ? 0 : 1;
gm_mgViewBobbing.ApplyCurrentSelection();
gm_mgSharpTurning.mg_iSelected = (pps->ps_ulFlags&PSF_SHARPTURNING) ? 1 : 0;
gm_mgSharpTurning.ApplyCurrentSelection();
// get function that will set player appearance
CShellSymbol *pss = _pShell->GetSymbol("SetPlayerAppearance", /*bDeclaredOnly=*/ TRUE);
// if none
if (pss == NULL) {
// no model
gm_mgModel.mg_moModel.SetData(NULL);
// if there is some
} else {
// set the model
BOOL(*pFunc)(CModelObject *, CPlayerCharacter *, CTString &, BOOL) =
(BOOL(*)(CModelObject *, CPlayerCharacter *, CTString &, BOOL))pss->ss_pvValue;
CTString strName;
BOOL bSet;
if (_gmRunningGameMode != GM_SINGLE_PLAYER && !_bPlayerMenuFromSinglePlayer) {
bSet = pFunc(&gm_mgModel.mg_moModel, &pc, strName, TRUE);
gm_mgModel.mg_strTip = TRANS("change model for this player");
gm_mgModel.mg_bEnabled = TRUE;
}
else {
// cannot change player appearance in single player mode
bSet = pFunc(&gm_mgModel.mg_moModel, NULL, strName, TRUE);
gm_mgModel.mg_strTip = TRANS("cannot change model for single-player game");
gm_mgModel.mg_bEnabled = FALSE;
}
// ignore gender flags, if any
strName.RemovePrefix("#female#");
strName.RemovePrefix("#male#");
gm_mgModel.mg_plModel = CPlacement3D(FLOAT3D(0.1f, -1.0f, -3.5f), ANGLE3D(150, 0, 0));
gm_mgModel.mg_strText = strName;
CPlayerSettings *pps = (CPlayerSettings *)pc.pc_aubAppearance;
_strLastPlayerAppearance = pps->GetModelFilename();
try {
gm_mgModel.mg_moFloor.SetData_t(CTFILENAME("Models\\Computer\\Floor.mdl"));
gm_mgModel.mg_moFloor.mo_toTexture.SetData_t(CTFILENAME("Models\\Computer\\Floor.tex"));
}
catch (char *strError) {
(void)strError;
}
}
}
void CPlayerProfileMenu::StartMenu(void)
{
_pGUIM->gmPlayerProfile.gm_pmgSelectedByDefault = &gm_mgNameField;
if (_gmRunningGameMode == GM_NONE || _gmRunningGameMode == GM_DEMO) {
for (INDEX i = 0; i<8; i++) {
gm_mgNumber[i].mg_bEnabled = TRUE;
}
} else {
for (INDEX i = 0; i<8; i++) {
gm_mgNumber[i].mg_bEnabled = FALSE;
}
INDEX iFirstEnabled = 0;
{for (INDEX ilp = 0; ilp<4; ilp++) {
CLocalPlayer &lp = _pGame->gm_lpLocalPlayers[ilp];
if (lp.lp_bActive) {
gm_mgNumber[lp.lp_iPlayer].mg_bEnabled = TRUE;
if (iFirstEnabled == 0) {
iFirstEnabled = lp.lp_iPlayer;
}
}
}}
// backup to first player in case current player is disabled
if (!gm_mgNumber[*gm_piCurrentPlayer].mg_bEnabled) *gm_piCurrentPlayer = iFirstEnabled;
}
// done
SelectPlayer(*gm_piCurrentPlayer);
CGameMenu::StartMenu();
}
void CPlayerProfileMenu::EndMenu(void)
{
_pGame->SavePlayersAndControls();
CGameMenu::EndMenu();
}

62
Sources/SeriousSam/GUI/Menus/MPlayerProfile.h
View File

@ -1,62 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_PLAYERPROFILE_H
#define SE_INCL_GAME_MENU_PLAYERPROFILE_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGEdit.h"
#include "SeriousSam/GUI/Components/MGModel.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#include "SeriousSam/GUI/Components/MGTrigger.h"
class CPlayerProfileMenu : public CGameMenu {
public:
INDEX *gm_piCurrentPlayer;
CMGTitle gm_mgProfileTitle;
CMGButton gm_mgNoLabel;
CMGButton gm_mgNumber[8];
CMGButton gm_mgNameLabel;
CMGEdit gm_mgNameField;
CMGButton gm_mgTeamLabel;
CMGEdit gm_mgTeam;
CMGButton gm_mgCustomizeControls;
CMGTrigger gm_mgCrosshair;
CMGTrigger gm_mgWeaponSelect;
CMGTrigger gm_mgWeaponHide;
CMGTrigger gm_mg3rdPerson;
CMGTrigger gm_mgQuotes;
CMGTrigger gm_mgAutoSave;
CMGTrigger gm_mgCompDoubleClick;
CMGTrigger gm_mgViewBobbing;
CMGTrigger gm_mgSharpTurning;
CMGModel gm_mgModel;
void Initialize_t(void);
INDEX ComboFromPlayer(INDEX iPlayer);
INDEX PlayerFromCombo(INDEX iCombo);
void SelectPlayer(INDEX iPlayer);
void ApplyComboPlayer(INDEX iPlayer);
void StartMenu(void);
void EndMenu(void);
};
#endif /* include-once check. */

31
Sources/SeriousSam/GUI/Menus/MRenderingOptions.h
View File

@ -1,31 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_RENDERINGOPTIONS_H
#define SE_INCL_GAME_MENU_RENDERINGOPTIONS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
class CRenderingOptionsMenu : public CGameMenu {
public:
void StartMenu(void);
void EndMenu(void);
void Initialize_t(void);
};
#endif /* include-once check. */

118
Sources/SeriousSam/GUI/Menus/MSelectPlayers.cpp
View File

@ -1,118 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MSelectPlayers.h"
#define ADD_GADGET( gd, box, up, dn, lf, rt, txt) \
gd.mg_boxOnScreen = box; \
gd.mg_pmgUp = up; \
gd.mg_pmgDown = dn; \
gd.mg_pmgLeft = lf; \
gd.mg_pmgRight = rt; \
gd.mg_strText = txt; \
gm_lhGadgets.AddTail(gd.mg_lnNode);
extern CTString astrNoYes[2];
extern CTString astrSplitScreenRadioTexts[4];
extern void SelectPlayersFillMenu(void);
extern void SelectPlayersApplyMenu(void);
void CSelectPlayersMenu::Initialize_t(void)
{
// intialize split screen menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("SELECT PLAYERS");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
TRIGGER_MG(gm_mgDedicated, 0, gm_mgStart, gm_mgObserver, TRANS("Dedicated:"), astrNoYes);
gm_mgDedicated.mg_strTip = TRANS("select to start dedicated server");
gm_mgDedicated.mg_pOnTriggerChange = NULL;
TRIGGER_MG(gm_mgObserver, 1, gm_mgDedicated, gm_mgSplitScreenCfg, TRANS("Observer:"), astrNoYes);
gm_mgObserver.mg_strTip = TRANS("select to join in for observing, not for playing");
gm_mgObserver.mg_pOnTriggerChange = NULL;
// split screen config trigger
TRIGGER_MG(gm_mgSplitScreenCfg, 2, gm_mgObserver, gm_mgPlayer0Change, TRANS("Number of players:"), astrSplitScreenRadioTexts);
gm_mgSplitScreenCfg.mg_strTip = TRANS("choose more than one player to play in split screen");
gm_mgSplitScreenCfg.mg_pOnTriggerChange = NULL;
gm_mgPlayer0Change.mg_iCenterI = -1;
gm_mgPlayer1Change.mg_iCenterI = -1;
gm_mgPlayer2Change.mg_iCenterI = -1;
gm_mgPlayer3Change.mg_iCenterI = -1;
gm_mgPlayer0Change.mg_boxOnScreen = BoxMediumMiddle(4);
gm_mgPlayer1Change.mg_boxOnScreen = BoxMediumMiddle(5);
gm_mgPlayer2Change.mg_boxOnScreen = BoxMediumMiddle(6);
gm_mgPlayer3Change.mg_boxOnScreen = BoxMediumMiddle(7);
gm_mgPlayer0Change.mg_strTip =
gm_mgPlayer1Change.mg_strTip =
gm_mgPlayer2Change.mg_strTip =
gm_mgPlayer3Change.mg_strTip = TRANS("select profile for this player");
gm_lhGadgets.AddTail(gm_mgPlayer0Change.mg_lnNode);
gm_lhGadgets.AddTail(gm_mgPlayer1Change.mg_lnNode);
gm_lhGadgets.AddTail(gm_mgPlayer2Change.mg_lnNode);
gm_lhGadgets.AddTail(gm_mgPlayer3Change.mg_lnNode);
gm_mgNotes.mg_boxOnScreen = BoxMediumRow(9.0);
gm_mgNotes.mg_bfsFontSize = BFS_MEDIUM;
gm_mgNotes.mg_iCenterI = -1;
gm_mgNotes.mg_bEnabled = FALSE;
gm_mgNotes.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgNotes.mg_lnNode);
gm_mgNotes.mg_strText = "";
/* // options button
mgSplitOptions.mg_strText = TRANS("Game options");
mgSplitOptions.mg_boxOnScreen = BoxMediumRow(3);
mgSplitOptions.mg_bfsFontSize = BFS_MEDIUM;
mgSplitOptions.mg_iCenterI = 0;
mgSplitOptions.mg_pmgUp = &mgSplitLevel;
mgSplitOptions.mg_pmgDown = &mgSplitStartStart;
mgSplitOptions.mg_strTip = TRANS("adjust game rules");
mgSplitOptions.mg_pActivatedFunction = &StartGameOptionsFromSplitScreen;
gm_lhGadgets.AddTail( mgSplitOptions.mg_lnNode);*/
/* // start button
mgSplitStartStart.mg_bfsFontSize = BFS_LARGE;
mgSplitStartStart.mg_boxOnScreen = BoxBigRow(4);
mgSplitStartStart.mg_pmgUp = &mgSplitOptions;
mgSplitStartStart.mg_pmgDown = &mgSplitGameType;
mgSplitStartStart.mg_strText = TRANS("START");
gm_lhGadgets.AddTail( mgSplitStartStart.mg_lnNode);
mgSplitStartStart.mg_pActivatedFunction = &StartSelectPlayersMenuFromSplit;
*/
ADD_GADGET(gm_mgStart, BoxMediumRow(11), &gm_mgSplitScreenCfg, &gm_mgPlayer0Change, NULL, NULL, TRANS("START"));
gm_mgStart.mg_bfsFontSize = BFS_LARGE;
gm_mgStart.mg_iCenterI = 0;
}
void CSelectPlayersMenu::StartMenu(void)
{
CGameMenu::StartMenu();
SelectPlayersFillMenu();
SelectPlayersApplyMenu();
}
void CSelectPlayersMenu::EndMenu(void)
{
SelectPlayersApplyMenu();
CGameMenu::EndMenu();
}

54
Sources/SeriousSam/GUI/Menus/MSelectPlayers.h
View File

@ -1,54 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_SELECTPLAYERS_H
#define SE_INCL_GAME_MENU_SELECTPLAYERS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGChangePlayer.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#include "SeriousSam/GUI/Components/MGTrigger.h"
class CSelectPlayersMenu : public CGameMenu {
public:
BOOL gm_bAllowDedicated;
BOOL gm_bAllowObserving;
CMGTitle gm_mgTitle;
CMGTrigger gm_mgDedicated;
CMGTrigger gm_mgObserver;
CMGTrigger gm_mgSplitScreenCfg;
CMGChangePlayer gm_mgPlayer0Change;
CMGChangePlayer gm_mgPlayer1Change;
CMGChangePlayer gm_mgPlayer2Change;
CMGChangePlayer gm_mgPlayer3Change;
CMGButton gm_mgNotes;
CMGButton gm_mgStart;
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
#endif /* include-once check. */

110
Sources/SeriousSam/GUI/Menus/MServers.cpp
View File

@ -1,110 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MServers.h"
CTString _strServerFilter[7];
CMGButton mgServerColumn[7];
CMGEdit mgServerFilter[7];
void CServersMenu::Initialize_t(void)
{
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("CHOOSE SERVER");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgList.mg_boxOnScreen = FLOATaabbox2D(FLOAT2D(0, 0), FLOAT2D(1, 1));
gm_mgList.mg_pmgLeft = &gm_mgList; // make sure it can get focus
gm_mgList.mg_bEnabled = TRUE;
gm_lhGadgets.AddTail(gm_mgList.mg_lnNode);
ASSERT(ARRAYCOUNT(mgServerColumn) == ARRAYCOUNT(mgServerFilter));
for (INDEX i = 0; i<ARRAYCOUNT(mgServerFilter); i++) {
mgServerColumn[i].mg_strText = "";
mgServerColumn[i].mg_boxOnScreen = BoxPlayerEdit(5.0);
mgServerColumn[i].mg_bfsFontSize = BFS_SMALL;
mgServerColumn[i].mg_iCenterI = -1;
mgServerColumn[i].mg_pmgUp = &gm_mgList;
mgServerColumn[i].mg_pmgDown = &mgServerFilter[i];
gm_lhGadgets.AddTail(mgServerColumn[i].mg_lnNode);
mgServerFilter[i].mg_ctMaxStringLen = 25;
mgServerFilter[i].mg_boxOnScreen = BoxPlayerEdit(5.0);
mgServerFilter[i].mg_bfsFontSize = BFS_SMALL;
mgServerFilter[i].mg_iCenterI = -1;
mgServerFilter[i].mg_pmgUp = &mgServerColumn[i];
mgServerFilter[i].mg_pmgDown = &gm_mgList;
gm_lhGadgets.AddTail(mgServerFilter[i].mg_lnNode);
mgServerFilter[i].mg_pstrToChange = &_strServerFilter[i];
mgServerFilter[i].SetText(*mgServerFilter[i].mg_pstrToChange);
}
gm_mgRefresh.mg_strText = TRANS("REFRESH");
gm_mgRefresh.mg_boxOnScreen = BoxLeftColumn(15.0);
gm_mgRefresh.mg_bfsFontSize = BFS_SMALL;
gm_mgRefresh.mg_iCenterI = -1;
gm_mgRefresh.mg_pmgDown = &gm_mgList;
gm_mgRefresh.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgRefresh.mg_lnNode);
CTString astrColumns[7];
mgServerColumn[0].mg_strText = TRANS("Server");
mgServerColumn[1].mg_strText = TRANS("Map");
mgServerColumn[2].mg_strText = TRANS("Ping");
mgServerColumn[3].mg_strText = TRANS("Players");
mgServerColumn[4].mg_strText = TRANS("Game");
mgServerColumn[5].mg_strText = TRANS("Mod");
mgServerColumn[6].mg_strText = TRANS("Ver");
mgServerColumn[0].mg_pActivatedFunction = NULL;
mgServerColumn[1].mg_pActivatedFunction = NULL;
mgServerColumn[2].mg_pActivatedFunction = NULL;
mgServerColumn[3].mg_pActivatedFunction = NULL;
mgServerColumn[4].mg_pActivatedFunction = NULL;
mgServerColumn[5].mg_pActivatedFunction = NULL;
mgServerColumn[6].mg_pActivatedFunction = NULL;
mgServerColumn[0].mg_strTip = TRANS("sort by server");
mgServerColumn[1].mg_strTip = TRANS("sort by map");
mgServerColumn[2].mg_strTip = TRANS("sort by ping");
mgServerColumn[3].mg_strTip = TRANS("sort by players");
mgServerColumn[4].mg_strTip = TRANS("sort by game");
mgServerColumn[5].mg_strTip = TRANS("sort by mod");
mgServerColumn[6].mg_strTip = TRANS("sort by version");
mgServerFilter[0].mg_strTip = TRANS("filter by server");
mgServerFilter[1].mg_strTip = TRANS("filter by map");
mgServerFilter[2].mg_strTip = TRANS("filter by ping (ie. <200)");
mgServerFilter[3].mg_strTip = TRANS("filter by players (ie. >=2)");
mgServerFilter[4].mg_strTip = TRANS("filter by game (ie. coop)");
mgServerFilter[5].mg_strTip = TRANS("filter by mod");
mgServerFilter[6].mg_strTip = TRANS("filter by version");
}
void CServersMenu::StartMenu(void)
{
extern void RefreshServerList(void);
RefreshServerList();
CGameMenu::StartMenu();
}
void CServersMenu::Think(void)
{
if (!_pNetwork->ga_bEnumerationChange) {
return;
}
_pNetwork->ga_bEnumerationChange = FALSE;
}

42
Sources/SeriousSam/GUI/Menus/MServers.h
View File

@ -1,42 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_SERVERS_H
#define SE_INCL_GAME_MENU_SERVERS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGEdit.h"
#include "SeriousSam/GUI/Components/MGServerList.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CServersMenu : public CGameMenu {
public:
BOOL m_bInternet;
CMGTitle gm_mgTitle;
CMGServerList gm_mgList;
CMGButton gm_mgRefresh;
void Initialize_t(void);
void StartMenu(void);
void Think(void);
};
#endif /* include-once check. */

156
Sources/SeriousSam/GUI/Menus/MSinglePlayer.cpp
View File

@ -1,156 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MSinglePlayer.h"
void CSinglePlayerMenu::Initialize_t(void)
{
// intialize single player menu
gm_mgTitle.mg_strText = TRANS("SINGLE PLAYER");
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgPlayerLabel.mg_boxOnScreen = BoxBigRow(-1.0f);
gm_mgPlayerLabel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgPlayerLabel.mg_iCenterI = -1;
gm_mgPlayerLabel.mg_bEnabled = FALSE;
gm_mgPlayerLabel.mg_bLabel = TRUE;
gm_lhGadgets.AddTail(gm_mgPlayerLabel.mg_lnNode);
gm_mgNewGame.mg_strText = TRANS("NEW GAME");
gm_mgNewGame.mg_bfsFontSize = BFS_LARGE;
gm_mgNewGame.mg_boxOnScreen = BoxBigRow(0.0f);
gm_mgNewGame.mg_strTip = TRANS("start new game with current player");
gm_lhGadgets.AddTail(gm_mgNewGame.mg_lnNode);
gm_mgNewGame.mg_pmgUp = &gm_mgOptions;
gm_mgNewGame.mg_pmgDown = &gm_mgCustom;
gm_mgNewGame.mg_pActivatedFunction = NULL;
gm_mgCustom.mg_strText = TRANS("CUSTOM LEVEL");
gm_mgCustom.mg_bfsFontSize = BFS_LARGE;
gm_mgCustom.mg_boxOnScreen = BoxBigRow(1.0f);
gm_mgCustom.mg_strTip = TRANS("start new game on a custom level");
gm_lhGadgets.AddTail(gm_mgCustom.mg_lnNode);
gm_mgCustom.mg_pmgUp = &gm_mgNewGame;
gm_mgCustom.mg_pmgDown = &gm_mgQuickLoad;
gm_mgCustom.mg_pActivatedFunction = NULL;
gm_mgQuickLoad.mg_strText = TRANS("QUICK LOAD");
gm_mgQuickLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgQuickLoad.mg_boxOnScreen = BoxBigRow(2.0f);
gm_mgQuickLoad.mg_strTip = TRANS("load a quick-saved game (F9)");
gm_lhGadgets.AddTail(gm_mgQuickLoad.mg_lnNode);
gm_mgQuickLoad.mg_pmgUp = &gm_mgCustom;
gm_mgQuickLoad.mg_pmgDown = &gm_mgLoad;
gm_mgQuickLoad.mg_pActivatedFunction = NULL;
gm_mgLoad.mg_strText = TRANS("LOAD");
gm_mgLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgLoad.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgLoad.mg_strTip = TRANS("load a saved game of current player");
gm_lhGadgets.AddTail(gm_mgLoad.mg_lnNode);
gm_mgLoad.mg_pmgUp = &gm_mgQuickLoad;
gm_mgLoad.mg_pmgDown = &gm_mgTraining;
gm_mgLoad.mg_pActivatedFunction = NULL;
gm_mgTraining.mg_strText = TRANS("TRAINING");
gm_mgTraining.mg_bfsFontSize = BFS_LARGE;
gm_mgTraining.mg_boxOnScreen = BoxBigRow(4.0f);
gm_mgTraining.mg_strTip = TRANS("start training level - KarnakDemo");
gm_lhGadgets.AddTail(gm_mgTraining.mg_lnNode);
gm_mgTraining.mg_pmgUp = &gm_mgLoad;
gm_mgTraining.mg_pmgDown = &gm_mgTechTest;
gm_mgTraining.mg_pActivatedFunction = NULL;
gm_mgTechTest.mg_strText = TRANS("TECHNOLOGY TEST");
gm_mgTechTest.mg_bfsFontSize = BFS_LARGE;
gm_mgTechTest.mg_boxOnScreen = BoxBigRow(5.0f);
gm_mgTechTest.mg_strTip = TRANS("start technology testing level");
gm_lhGadgets.AddTail(gm_mgTechTest.mg_lnNode);
gm_mgTechTest.mg_pmgUp = &gm_mgTraining;
gm_mgTechTest.mg_pmgDown = &gm_mgPlayersAndControls;
gm_mgTechTest.mg_pActivatedFunction = NULL;
gm_mgPlayersAndControls.mg_bfsFontSize = BFS_LARGE;
gm_mgPlayersAndControls.mg_boxOnScreen = BoxBigRow(6.0f);
gm_mgPlayersAndControls.mg_pmgUp = &gm_mgTechTest;
gm_mgPlayersAndControls.mg_pmgDown = &gm_mgOptions;
gm_mgPlayersAndControls.mg_strText = TRANS("PLAYERS AND CONTROLS");
gm_mgPlayersAndControls.mg_strTip = TRANS("change currently active player or adjust controls");
gm_lhGadgets.AddTail(gm_mgPlayersAndControls.mg_lnNode);
gm_mgPlayersAndControls.mg_pActivatedFunction = NULL;
gm_mgOptions.mg_strText = TRANS("GAME OPTIONS");
gm_mgOptions.mg_bfsFontSize = BFS_LARGE;
gm_mgOptions.mg_boxOnScreen = BoxBigRow(7.0f);
gm_mgOptions.mg_strTip = TRANS("adjust miscellaneous game options");
gm_lhGadgets.AddTail(gm_mgOptions.mg_lnNode);
gm_mgOptions.mg_pmgUp = &gm_mgPlayersAndControls;
gm_mgOptions.mg_pmgDown = &gm_mgNewGame;
gm_mgOptions.mg_pActivatedFunction = NULL;
}
void CSinglePlayerMenu::StartMenu(void)
{
gm_mgTraining.mg_bEnabled = IsMenuEnabled("Training");
gm_mgTechTest.mg_bEnabled = IsMenuEnabled("Technology Test");
if (gm_mgTraining.mg_bEnabled) {
if (!gm_mgTraining.mg_lnNode.IsLinked()) {
gm_lhGadgets.AddTail(gm_mgTraining.mg_lnNode);
}
gm_mgLoad.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgLoad.mg_pmgUp = &gm_mgQuickLoad;
gm_mgLoad.mg_pmgDown = &gm_mgTraining;
gm_mgTraining.mg_boxOnScreen = BoxBigRow(4.0f);
gm_mgTraining.mg_pmgUp = &gm_mgLoad;
gm_mgTraining.mg_pmgDown = &gm_mgTechTest;
gm_mgTechTest.mg_boxOnScreen = BoxBigRow(5.0f);
gm_mgTechTest.mg_pmgUp = &gm_mgTraining;
gm_mgTechTest.mg_pmgDown = &gm_mgPlayersAndControls;
gm_mgPlayersAndControls.mg_boxOnScreen = BoxBigRow(6.0f);
gm_mgOptions.mg_boxOnScreen = BoxBigRow(7.0f);
} else {
if (gm_mgTraining.mg_lnNode.IsLinked()) {
gm_mgTraining.mg_lnNode.Remove();
}
gm_mgLoad.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgLoad.mg_pmgUp = &gm_mgQuickLoad;
gm_mgLoad.mg_pmgDown = &gm_mgTechTest;
gm_mgTechTest.mg_boxOnScreen = BoxBigRow(4.0f);
gm_mgTechTest.mg_pmgUp = &gm_mgLoad;
gm_mgTechTest.mg_pmgDown = &gm_mgPlayersAndControls;
gm_mgPlayersAndControls.mg_boxOnScreen = BoxBigRow(5.0f);
gm_mgOptions.mg_boxOnScreen = BoxBigRow(6.0f);
}
CGameMenu::StartMenu();
CPlayerCharacter &pc = _pGame->gm_apcPlayers[_pGame->gm_iSinglePlayer];
gm_mgPlayerLabel.mg_strText.PrintF(TRANS("Player: %s\n"), (const char *) pc.GetNameForPrinting());
}

44
Sources/SeriousSam/GUI/Menus/MSinglePlayer.h
View File

@ -1,44 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_SINGLEPLAYER_H
#define SE_INCL_GAME_MENU_SINGLEPLAYER_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CSinglePlayerMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgPlayerLabel;
CMGButton gm_mgNewGame;
CMGButton gm_mgCustom;
CMGButton gm_mgQuickLoad;
CMGButton gm_mgLoad;
CMGButton gm_mgTraining;
CMGButton gm_mgTechTest;
CMGButton gm_mgPlayersAndControls;
CMGButton gm_mgOptions;
void Initialize_t(void);
void StartMenu(void);
};
#endif /* include-once check. */

100
Sources/SeriousSam/GUI/Menus/MSinglePlayerNew.cpp
View File

@ -1,100 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MSinglePlayerNew.h"
void CSinglePlayerNewMenu::Initialize_t(void)
{
// intialize single player new menu
gm_mgTitle.mg_strText = TRANS("NEW GAME");
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgTourist.mg_strText = TRANS("TOURIST");
gm_mgTourist.mg_bfsFontSize = BFS_LARGE;
gm_mgTourist.mg_boxOnScreen = BoxBigRow(0.0f);
gm_mgTourist.mg_strTip = TRANS("for non-FPS players");
gm_lhGadgets.AddTail(gm_mgTourist.mg_lnNode);
gm_mgTourist.mg_pmgUp = &gm_mgSerious;
gm_mgTourist.mg_pmgDown = &gm_mgEasy;
gm_mgTourist.mg_pActivatedFunction = NULL;
gm_mgEasy.mg_strText = TRANS("EASY");
gm_mgEasy.mg_bfsFontSize = BFS_LARGE;
gm_mgEasy.mg_boxOnScreen = BoxBigRow(1.0f);
gm_mgEasy.mg_strTip = TRANS("for unexperienced FPS players");
gm_lhGadgets.AddTail(gm_mgEasy.mg_lnNode);
gm_mgEasy.mg_pmgUp = &gm_mgTourist;
gm_mgEasy.mg_pmgDown = &gm_mgMedium;
gm_mgEasy.mg_pActivatedFunction = NULL;
gm_mgMedium.mg_strText = TRANS("NORMAL");
gm_mgMedium.mg_bfsFontSize = BFS_LARGE;
gm_mgMedium.mg_boxOnScreen = BoxBigRow(2.0f);
gm_mgMedium.mg_strTip = TRANS("for experienced FPS players");
gm_lhGadgets.AddTail(gm_mgMedium.mg_lnNode);
gm_mgMedium.mg_pmgUp = &gm_mgEasy;
gm_mgMedium.mg_pmgDown = &gm_mgHard;
gm_mgMedium.mg_pActivatedFunction = NULL;
gm_mgHard.mg_strText = TRANS("HARD");
gm_mgHard.mg_bfsFontSize = BFS_LARGE;
gm_mgHard.mg_boxOnScreen = BoxBigRow(3.0f);
gm_mgHard.mg_strTip = TRANS("for experienced Serious Sam players");
gm_lhGadgets.AddTail(gm_mgHard.mg_lnNode);
gm_mgHard.mg_pmgUp = &gm_mgMedium;
gm_mgHard.mg_pmgDown = &gm_mgSerious;
gm_mgHard.mg_pActivatedFunction = NULL;
gm_mgSerious.mg_strText = TRANS("SERIOUS");
gm_mgSerious.mg_bfsFontSize = BFS_LARGE;
gm_mgSerious.mg_boxOnScreen = BoxBigRow(4.0f);
gm_mgSerious.mg_strTip = TRANS("are you serious?");
gm_lhGadgets.AddTail(gm_mgSerious.mg_lnNode);
gm_mgSerious.mg_pmgUp = &gm_mgHard;
gm_mgSerious.mg_pmgDown = &gm_mgTourist;
gm_mgSerious.mg_pActivatedFunction = NULL;
gm_mgMental.mg_strText = TRANS("MENTAL");
gm_mgMental.mg_bfsFontSize = BFS_LARGE;
gm_mgMental.mg_boxOnScreen = BoxBigRow(5.0f);
gm_mgMental.mg_strTip = TRANS("you are not serious!");
gm_lhGadgets.AddTail(gm_mgMental.mg_lnNode);
gm_mgMental.mg_pmgUp = &gm_mgSerious;
gm_mgMental.mg_pmgDown = &gm_mgTourist;
gm_mgMental.mg_pActivatedFunction = NULL;
gm_mgMental.mg_bMental = TRUE;
}
void CSinglePlayerNewMenu::StartMenu(void)
{
CGameMenu::StartMenu();
extern INDEX sam_bMentalActivated;
if (sam_bMentalActivated) {
gm_mgMental.Appear();
gm_mgSerious.mg_pmgDown = &gm_mgMental;
gm_mgTourist.mg_pmgUp = &gm_mgMental;
} else {
gm_mgMental.Disappear();
gm_mgSerious.mg_pmgDown = &gm_mgTourist;
gm_mgTourist.mg_pmgUp = &gm_mgSerious;
}
}

41
Sources/SeriousSam/GUI/Menus/MSinglePlayerNew.h
View File

@ -1,41 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_SINGLEPLAYERNEW_H
#define SE_INCL_GAME_MENU_SINGLEPLAYERNEW_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CSinglePlayerNewMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgTourist;
CMGButton gm_mgEasy;
CMGButton gm_mgMedium;
CMGButton gm_mgHard;
CMGButton gm_mgSerious;
CMGButton gm_mgMental;
void Initialize_t(void);
void StartMenu(void);
};
#endif /* include-once check. */

60
Sources/SeriousSam/GUI/Menus/MSplitScreen.cpp
View File

@ -1,60 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MSplitScreen.h"
void CSplitScreenMenu::Initialize_t(void)
{
// intialize split screen menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("SPLIT SCREEN");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
gm_mgStart.mg_bfsFontSize = BFS_LARGE;
gm_mgStart.mg_boxOnScreen = BoxBigRow(0);
gm_mgStart.mg_pmgUp = &gm_mgLoad;
gm_mgStart.mg_pmgDown = &gm_mgQuickLoad;
gm_mgStart.mg_strText = TRANS("NEW GAME");
gm_mgStart.mg_strTip = TRANS("start new split-screen game");
gm_lhGadgets.AddTail(gm_mgStart.mg_lnNode);
gm_mgStart.mg_pActivatedFunction = NULL;
gm_mgQuickLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgQuickLoad.mg_boxOnScreen = BoxBigRow(1);
gm_mgQuickLoad.mg_pmgUp = &gm_mgStart;
gm_mgQuickLoad.mg_pmgDown = &gm_mgLoad;
gm_mgQuickLoad.mg_strText = TRANS("QUICK LOAD");
gm_mgQuickLoad.mg_strTip = TRANS("load a quick-saved game (F9)");
gm_lhGadgets.AddTail(gm_mgQuickLoad.mg_lnNode);
gm_mgQuickLoad.mg_pActivatedFunction = NULL;
gm_mgLoad.mg_bfsFontSize = BFS_LARGE;
gm_mgLoad.mg_boxOnScreen = BoxBigRow(2);
gm_mgLoad.mg_pmgUp = &gm_mgQuickLoad;
gm_mgLoad.mg_pmgDown = &gm_mgStart;
gm_mgLoad.mg_strText = TRANS("LOAD");
gm_mgLoad.mg_strTip = TRANS("load a saved split-screen game");
gm_lhGadgets.AddTail(gm_mgLoad.mg_lnNode);
gm_mgLoad.mg_pActivatedFunction = NULL;
}
void CSplitScreenMenu::StartMenu(void)
{
CGameMenu::StartMenu();
}

38
Sources/SeriousSam/GUI/Menus/MSplitScreen.h
View File

@ -1,38 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_SPLITSCREEN_H
#define SE_INCL_GAME_MENU_SPLITSCREEN_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
class CSplitScreenMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGButton gm_mgStart;
CMGButton gm_mgQuickLoad;
CMGButton gm_mgLoad;
void Initialize_t(void);
void StartMenu(void);
};
#endif /* include-once check. */

101
Sources/SeriousSam/GUI/Menus/MSplitStart.cpp
View File

@ -1,101 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "SeriousSam/LevelInfo.h"
#include "MenuStuff.h"
#include "MSplitStart.h"
extern void UpdateSplitLevel(INDEX iDummy);
void CSplitStartMenu::Initialize_t(void)
{
// intialize split screen menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("START SPLIT SCREEN");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
// game type trigger
TRIGGER_MG(gm_mgGameType, 0,
gm_mgStart, gm_mgDifficulty, TRANS("Game type:"), astrGameTypeRadioTexts);
gm_mgGameType.mg_ctTexts = ctGameTypeRadioTexts;
gm_mgGameType.mg_strTip = TRANS("choose type of multiplayer game");
gm_mgGameType.mg_pOnTriggerChange = &UpdateSplitLevel;
// difficulty trigger
TRIGGER_MG(gm_mgDifficulty, 1,
gm_mgGameType, gm_mgLevel, TRANS("Difficulty:"), astrDifficultyRadioTexts);
gm_mgDifficulty.mg_strTip = TRANS("choose difficulty level");
// level name
gm_mgLevel.mg_strText = "";
gm_mgLevel.mg_strLabel = TRANS("Level:");
gm_mgLevel.mg_boxOnScreen = BoxMediumRow(2);
gm_mgLevel.mg_bfsFontSize = BFS_MEDIUM;
gm_mgLevel.mg_iCenterI = -1;
gm_mgLevel.mg_pmgUp = &gm_mgDifficulty;
gm_mgLevel.mg_pmgDown = &gm_mgOptions;
gm_mgLevel.mg_strTip = TRANS("choose the level to start");
gm_mgLevel.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgLevel.mg_lnNode);
// options button
gm_mgOptions.mg_strText = TRANS("Game options");
gm_mgOptions.mg_boxOnScreen = BoxMediumRow(3);
gm_mgOptions.mg_bfsFontSize = BFS_MEDIUM;
gm_mgOptions.mg_iCenterI = 0;
gm_mgOptions.mg_pmgUp = &gm_mgLevel;
gm_mgOptions.mg_pmgDown = &gm_mgStart;
gm_mgOptions.mg_strTip = TRANS("adjust game rules");
gm_mgOptions.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgOptions.mg_lnNode);
// start button
gm_mgStart.mg_bfsFontSize = BFS_LARGE;
gm_mgStart.mg_boxOnScreen = BoxBigRow(4);
gm_mgStart.mg_pmgUp = &gm_mgOptions;
gm_mgStart.mg_pmgDown = &gm_mgGameType;
gm_mgStart.mg_strText = TRANS("START");
gm_lhGadgets.AddTail(gm_mgStart.mg_lnNode);
gm_mgStart.mg_pActivatedFunction = NULL;
}
void CSplitStartMenu::StartMenu(void)
{
extern INDEX sam_bMentalActivated;
gm_mgDifficulty.mg_ctTexts = sam_bMentalActivated ? 6 : 5;
gm_mgGameType.mg_iSelected = Clamp(_pShell->GetINDEX("gam_iStartMode"), 0L, ctGameTypeRadioTexts - 1L);
gm_mgGameType.ApplyCurrentSelection();
gm_mgDifficulty.mg_iSelected = _pShell->GetINDEX("gam_iStartDifficulty") + 1;
gm_mgDifficulty.ApplyCurrentSelection();
// clamp maximum number of players to at least 4
_pShell->SetINDEX("gam_ctMaxPlayers", ClampDn(_pShell->GetINDEX("gam_ctMaxPlayers"), 4L));
UpdateSplitLevel(0);
CGameMenu::StartMenu();
}
void CSplitStartMenu::EndMenu(void)
{
_pShell->SetINDEX("gam_iStartDifficulty", gm_mgDifficulty.mg_iSelected - 1);
_pShell->SetINDEX("gam_iStartMode", gm_mgGameType.mg_iSelected);
CGameMenu::EndMenu();
}

42
Sources/SeriousSam/GUI/Menus/MSplitStart.h
View File

@ -1,42 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_SPLITSTART_H
#define SE_INCL_GAME_MENU_SPLITSTART_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#include "SeriousSam/GUI/Components/MGTrigger.h"
class CSplitStartMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGTrigger gm_mgGameType;
CMGTrigger gm_mgDifficulty;
CMGButton gm_mgLevel;
CMGButton gm_mgOptions;
CMGButton gm_mgStart;
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
#endif /* include-once check. */

134
Sources/SeriousSam/GUI/Menus/MVar.cpp
View File

@ -1,134 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "SeriousSam/VarList.h"
#include "SeriousSam/GUI/Menus/MVar.h"
extern BOOL _bVarChanged;
void CVarMenu::Initialize_t(void)
{
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = "";
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
for (INDEX iLabel = 0; iLabel<VARS_ON_SCREEN; iLabel++)
{
INDEX iPrev = (VARS_ON_SCREEN + iLabel - 1) % VARS_ON_SCREEN;
INDEX iNext = (iLabel + 1) % VARS_ON_SCREEN;
// initialize label gadgets
gm_mgVar[iLabel].mg_pmgUp = &gm_mgVar[iPrev];
gm_mgVar[iLabel].mg_pmgDown = &gm_mgVar[iNext];
gm_mgVar[iLabel].mg_pmgLeft = &gm_mgApply;
gm_mgVar[iLabel].mg_boxOnScreen = BoxMediumRow(iLabel);
gm_mgVar[iLabel].mg_pActivatedFunction = NULL; // never called!
gm_lhGadgets.AddTail(gm_mgVar[iLabel].mg_lnNode);
}
gm_mgApply.mg_boxOnScreen = BoxMediumRow(16.5f);
gm_mgApply.mg_bfsFontSize = BFS_LARGE;
gm_mgApply.mg_iCenterI = 1;
gm_mgApply.mg_pmgLeft =
gm_mgApply.mg_pmgRight =
gm_mgApply.mg_pmgUp =
gm_mgApply.mg_pmgDown = &gm_mgVar[0];
gm_mgApply.mg_strText = TRANS("APPLY");
gm_mgApply.mg_strTip = TRANS("apply changes");
gm_lhGadgets.AddTail(gm_mgApply.mg_lnNode);
gm_mgApply.mg_pActivatedFunction = NULL;
gm_lhGadgets.AddTail(gm_mgArrowUp.mg_lnNode);
gm_lhGadgets.AddTail(gm_mgArrowDn.mg_lnNode);
gm_mgArrowUp.mg_adDirection = AD_UP;
gm_mgArrowDn.mg_adDirection = AD_DOWN;
gm_mgArrowUp.mg_boxOnScreen = BoxArrow(AD_UP);
gm_mgArrowDn.mg_boxOnScreen = BoxArrow(AD_DOWN);
gm_mgArrowUp.mg_pmgRight = gm_mgArrowUp.mg_pmgDown =
&gm_mgVar[0];
gm_mgArrowDn.mg_pmgRight = gm_mgArrowDn.mg_pmgUp =
&gm_mgVar[VARS_ON_SCREEN - 1];
gm_ctListVisible = VARS_ON_SCREEN;
gm_pmgArrowUp = &gm_mgArrowUp;
gm_pmgArrowDn = &gm_mgArrowDn;
gm_pmgListTop = &gm_mgVar[0];
gm_pmgListBottom = &gm_mgVar[VARS_ON_SCREEN - 1];
}
void CVarMenu::FillListItems(void)
{
// disable all items first
for (INDEX i = 0; i<VARS_ON_SCREEN; i++) {
gm_mgVar[i].mg_bEnabled = FALSE;
gm_mgVar[i].mg_pvsVar = NULL;
gm_mgVar[i].mg_iInList = -2;
}
BOOL bHasFirst = FALSE;
BOOL bHasLast = FALSE;
INDEX ctLabels = _lhVarSettings.Count();
INDEX iLabel = 0;
FOREACHINLIST(CVarSetting, vs_lnNode, _lhVarSettings, itvs) {
CVarSetting &vs = *itvs;
INDEX iInMenu = iLabel - gm_iListOffset;
if ((iLabel >= gm_iListOffset) &&
(iLabel<(gm_iListOffset + VARS_ON_SCREEN)))
{
bHasFirst |= (iLabel == 0);
bHasLast |= (iLabel == ctLabels - 1);
gm_mgVar[iInMenu].mg_pvsVar = &vs;
gm_mgVar[iInMenu].mg_strTip = vs.vs_strTip;
gm_mgVar[iInMenu].mg_bEnabled = gm_mgVar[iInMenu].IsEnabled();
gm_mgVar[iInMenu].mg_iInList = iLabel;
}
iLabel++;
}
// enable/disable up/down arrows
gm_mgArrowUp.mg_bEnabled = !bHasFirst && ctLabels>0;
gm_mgArrowDn.mg_bEnabled = !bHasLast && ctLabels>0;
}
void CVarMenu::StartMenu(void)
{
LoadVarSettings(gm_fnmMenuCFG);
// set default parameters for the list
gm_iListOffset = 0;
gm_ctListTotal = _lhVarSettings.Count();
gm_iListWantedItem = 0;
CGameMenu::StartMenu();
}
void CVarMenu::EndMenu(void)
{
// disable all items first
for (INDEX i = 0; i<VARS_ON_SCREEN; i++) {
gm_mgVar[i].mg_bEnabled = FALSE;
gm_mgVar[i].mg_pvsVar = NULL;
gm_mgVar[i].mg_iInList = -2;
}
FlushVarSettings(FALSE);
_bVarChanged = FALSE;
}
void CVarMenu::Think(void)
{
gm_mgApply.mg_bEnabled = _bVarChanged;
extern void FixupBackButton(CGameMenu *pgm);
FixupBackButton(this);
}

46
Sources/SeriousSam/GUI/Menus/MVar.h
View File

@ -1,46 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_VAR_H
#define SE_INCL_GAME_MENU_VAR_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "SeriousSam/GUI/Components/MGArrow.h"
#include "SeriousSam/GUI/Components/MGButton.h"
#include "SeriousSam/GUI/Components/MGTitle.h"
#include "SeriousSam/GUI/Components/MGVarButton.h"
class CVarMenu : public CGameMenu {
public:
CTFileName gm_fnmMenuCFG;
CMGTitle gm_mgTitle;
CMGVarButton gm_mgVar[LEVELS_ON_SCREEN];
CMGButton gm_mgApply;
CMGArrow gm_mgArrowUp;
CMGArrow gm_mgArrowDn;
void Initialize_t(void);
void FillListItems(void);
void StartMenu(void);
void EndMenu(void);
void Think(void);
};
#endif /* include-once check. */

85
Sources/SeriousSam/GUI/Menus/MVideoOptions.cpp
View File

@ -1,85 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/CurrentVersion.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "MenuStuff.h"
#include "MVideoOptions.h"
extern void InitVideoOptionsButtons();
extern void UpdateVideoOptionsButtons(INDEX iSelected);
void CVideoOptionsMenu::Initialize_t(void)
{
// intialize video options menu
gm_mgTitle.mg_boxOnScreen = BoxTitle();
gm_mgTitle.mg_strText = TRANS("VIDEO");
gm_lhGadgets.AddTail(gm_mgTitle.mg_lnNode);
TRIGGER_MG(gm_mgDisplayAPITrigger, 0,
gm_mgApply, gm_mgDisplayAdaptersTrigger, TRANS("GRAPHICS API"), astrDisplayAPIRadioTexts);
gm_mgDisplayAPITrigger.mg_strTip = TRANS("choose graphics API to be used");
TRIGGER_MG(gm_mgDisplayAdaptersTrigger, 1,
gm_mgDisplayAPITrigger, gm_mgDisplayPrefsTrigger, TRANS("DISPLAY ADAPTER"), astrNoYes);
gm_mgDisplayAdaptersTrigger.mg_strTip = TRANS("choose display adapter to be used");
TRIGGER_MG(gm_mgDisplayPrefsTrigger, 2,
gm_mgDisplayAdaptersTrigger, gm_mgResolutionsTrigger, TRANS("PREFERENCES"), astrDisplayPrefsRadioTexts);
gm_mgDisplayPrefsTrigger.mg_strTip = TRANS("balance between speed and rendering quality, depending on your system");
TRIGGER_MG(gm_mgResolutionsTrigger, 3,
gm_mgDisplayPrefsTrigger, gm_mgFullScreenTrigger, TRANS("RESOLUTION"), astrNoYes);
gm_mgResolutionsTrigger.mg_strTip = TRANS("select video mode resolution");
TRIGGER_MG(gm_mgFullScreenTrigger, 4,
gm_mgResolutionsTrigger, gm_mgBitsPerPixelTrigger, TRANS("FULL SCREEN"), astrNoYes);
gm_mgFullScreenTrigger.mg_strTip = TRANS("make game run in a window or in full screen");
TRIGGER_MG(gm_mgBitsPerPixelTrigger, 5,
gm_mgFullScreenTrigger, gm_mgVideoRendering, TRANS("BITS PER PIXEL"), astrBitsPerPixelRadioTexts);
gm_mgBitsPerPixelTrigger.mg_strTip = TRANS("select number of colors used for display");
gm_mgDisplayPrefsTrigger.mg_pOnTriggerChange = NULL;
gm_mgDisplayAPITrigger.mg_pOnTriggerChange = NULL;
gm_mgDisplayAdaptersTrigger.mg_pOnTriggerChange = NULL;
gm_mgFullScreenTrigger.mg_pOnTriggerChange = NULL;
gm_mgResolutionsTrigger.mg_pOnTriggerChange = NULL;
gm_mgBitsPerPixelTrigger.mg_pOnTriggerChange = NULL;
gm_mgVideoRendering.mg_bfsFontSize = BFS_MEDIUM;
gm_mgVideoRendering.mg_boxOnScreen = BoxMediumRow(7.0f);
gm_mgVideoRendering.mg_pmgUp = &gm_mgBitsPerPixelTrigger;
gm_mgVideoRendering.mg_pmgDown = &gm_mgApply;
gm_mgVideoRendering.mg_strText = TRANS("RENDERING OPTIONS");
gm_mgVideoRendering.mg_strTip = TRANS("manually adjust rendering settings");
gm_lhGadgets.AddTail(gm_mgVideoRendering.mg_lnNode);
gm_mgVideoRendering.mg_pActivatedFunction = NULL;
gm_mgApply.mg_bfsFontSize = BFS_LARGE;
gm_mgApply.mg_boxOnScreen = BoxBigRow(5.5f);
gm_mgApply.mg_pmgUp = &gm_mgVideoRendering;
gm_mgApply.mg_pmgDown = &gm_mgDisplayAPITrigger;
gm_mgApply.mg_strText = TRANS("APPLY");
gm_mgApply.mg_strTip = TRANS("apply selected options");
gm_lhGadgets.AddTail(gm_mgApply.mg_lnNode);
gm_mgApply.mg_pActivatedFunction = NULL;
}
void CVideoOptionsMenu::StartMenu(void)
{
InitVideoOptionsButtons();
CGameMenu::StartMenu();
UpdateVideoOptionsButtons(-1);
}

41
Sources/SeriousSam/GUI/Menus/MVideoOptions.h
View File

@ -1,41 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_GAME_MENU_VIDEOOPTIONS_H
#define SE_INCL_GAME_MENU_VIDEOOPTIONS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/GUI/Menus/GameMenu.h"
class CVideoOptionsMenu : public CGameMenu {
public:
CMGTitle gm_mgTitle;
CMGTrigger gm_mgDisplayAPITrigger;
CMGTrigger gm_mgDisplayAdaptersTrigger;
CMGTrigger gm_mgFullScreenTrigger;
CMGTrigger gm_mgResolutionsTrigger;
CMGTrigger gm_mgDisplayPrefsTrigger;
CMGButton gm_mgVideoRendering;
CMGTrigger gm_mgBitsPerPixelTrigger;
CMGButton gm_mgApply;
void StartMenu(void);
void Initialize_t(void);
};
#endif /* include-once check. */

978
Sources/SeriousSam/GUI/Menus/Menu.cpp
View File

@ -1,978 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Build.h>
#include <sys/timeb.h>
#include <time.h>
#ifdef PLATFORM_WIN32
#include <io.h>
#endif
#include "SeriousSam/MainWindow.h"
#include <Engine/CurrentVersion.h>
#include <Engine/Templates/Stock_CSoundData.h>
#include <GameMP/LCDDrawing.h>
#include "SeriousSam/GUI/Menus/MenuPrinting.h"
#include "SeriousSam/LevelInfo.h"
#include "SeriousSam/VarList.h"
#include "SeriousSam/FileInfo.h"
#include "MenuManager.h"
#include "MenuActions.h"
#include "MenuStuff.h"
#include "MenuStarters.h"
// macros for translating radio button text arrays
#define TRANSLATERADIOARRAY(array) TranslateRadioTexts(array, ARRAYCOUNT(array))
extern BOOL bMenuActive;
extern BOOL bMenuRendering;
extern CTextureObject *_ptoLogoCT;
extern CTextureObject *_ptoLogoODI;
extern CTextureObject *_ptoLogoEAX;
INDEX _iLocalPlayer = -1;
BOOL _bPlayerMenuFromSinglePlayer = FALSE;
GameMode _gmMenuGameMode = GM_NONE;
GameMode _gmRunningGameMode = GM_NONE;
CListHead _lhServers;
void OnPlayerSelect(void);
// last tick done
TIME _tmMenuLastTickDone = -1;
// all possible menu entities
CListHead lhMenuEntities;
CTString _strLastPlayerAppearance = "";
extern CTString sam_strNetworkSettings;
// function to activate when level is chosen
void (*_pAfterLevelChosen)(void);
// functions for init actions
void FixupBackButton(CGameMenu *pgm);
// mouse cursor position
PIX _pixCursorPosI = 0;
PIX _pixCursorPosJ = 0;
PIX _pixCursorExternPosI = 0;
PIX _pixCursorExternPosJ = 0;
BOOL _bMouseUsedLast = FALSE;
CMenuGadget *_pmgUnderCursor = NULL;
extern BOOL _bDefiningKey;
extern BOOL _bEditingString;
// thumbnail for showing in menu
CTextureObject _toThumbnail;
BOOL _bThumbnailOn = FALSE;
CFontData _fdBig;
CFontData _fdMedium;
CFontData _fdSmall;
CFontData _fdTitle;
CSoundData *_psdSelect = NULL;
CSoundData *_psdPress = NULL;
CSoundObject *_psoMenuSound = NULL;
static CTextureObject _toPointer;
static CTextureObject _toLogoMenuA;
static CTextureObject _toLogoMenuB;
// -------------- All possible menu entities
#define BIG_BUTTONS_CT 6
#define CHANGETRIGGERARRAY(ltbmg, astr) \
ltbmg.mg_astrTexts = astr;\
ltbmg.mg_ctTexts = sizeof( astr)/sizeof( astr[0]);\
ltbmg.mg_iSelected = 0;\
ltbmg.mg_strText = astr[ltbmg.mg_iSelected];
#define PLACEMENT(x,y,z) CPlacement3D( FLOAT3D( x, y, z), \
ANGLE3D( AngleDeg(0.0f), AngleDeg(0.0f), AngleDeg(0.0f)))
// ptr to current menu
CGameMenu *pgmCurrentMenu = NULL;
// global back button
CMGButton mgBack;
// -------- console variable adjustment menu
BOOL _bVarChanged = FALSE;
extern void PlayMenuSound(CSoundData *psd)
{
if (_psoMenuSound!=NULL && !_psoMenuSound->IsPlaying()) {
_psoMenuSound->Play(psd, SOF_NONGAME);
}
}
// translate all texts in array for one radio button
void TranslateRadioTexts(CTString astr[], INDEX ct)
{
for (INDEX i=0; i<ct; i++) {
astr[i] = TranslateConst(astr[i], 4);
}
}
// set new thumbnail
void SetThumbnail(CTFileName fn)
{
_bThumbnailOn = TRUE;
try {
_toThumbnail.SetData_t(fn.NoExt()+"Tbn.tex");
} catch(char *strError) {
(void)strError;
try {
_toThumbnail.SetData_t(fn.NoExt()+".tbn");
} catch(char *strError) {
(void)strError;
_toThumbnail.SetData(NULL);
}
}
}
// remove thumbnail
void ClearThumbnail(void)
{
_bThumbnailOn = FALSE;
_toThumbnail.SetData(NULL);
_pShell->Execute( "FreeUnusedStock();");
}
void StartMenus(const char *str)
{
_tmMenuLastTickDone=_pTimer->GetRealTimeTick();
// disable printing of last lines
CON_DiscardLastLineTimes();
// stop all IFeel effects
IFeel_StopEffect(NULL);
if (pgmCurrentMenu == &_pGUIM->gmMainMenu || pgmCurrentMenu == &_pGUIM->gmInGameMenu) {
if (_gmRunningGameMode==GM_NONE) {
pgmCurrentMenu = &_pGUIM->gmMainMenu;
} else {
pgmCurrentMenu = &_pGUIM->gmInGameMenu;
}
}
// start main menu, or last active one
if (pgmCurrentMenu!=NULL) {
ChangeToMenu(pgmCurrentMenu);
} else {
if (_gmRunningGameMode==GM_NONE) {
ChangeToMenu(&_pGUIM->gmMainMenu);
} else {
ChangeToMenu(&_pGUIM->gmInGameMenu);
}
}
if (CTString(str)=="load") {
StartCurrentLoadMenu();
_pGUIM->gmLoadSaveMenu.gm_pgmParentMenu = NULL;
}
if (CTString(str)=="save") {
StartCurrentSaveMenu();
_pGUIM->gmLoadSaveMenu.gm_pgmParentMenu = NULL;
FixupBackButton(&_pGUIM->gmLoadSaveMenu);
}
if (CTString(str)=="controls") {
void StartControlsMenuFromOptions(void);
StartControlsMenuFromOptions();
_pGUIM->gmControls.gm_pgmParentMenu = NULL;
FixupBackButton(&_pGUIM->gmControls);
}
if (CTString(str)=="join") {
void StartSelectPlayersMenuFromOpen(void);
StartSelectPlayersMenuFromOpen();
_pGUIM->gmSelectPlayersMenu.gm_pgmParentMenu = &_pGUIM->gmMainMenu;
FixupBackButton(&_pGUIM->gmSelectPlayersMenu);
}
if (CTString(str)=="hiscore") {
ChangeToMenu(&_pGUIM->gmHighScoreMenu);
_pGUIM->gmHighScoreMenu.gm_pgmParentMenu = &_pGUIM->gmMainMenu;
FixupBackButton(&_pGUIM->gmHighScoreMenu);
}
bMenuActive = TRUE;
bMenuRendering = TRUE;
}
void StopMenus( BOOL bGoToRoot /*=TRUE*/)
{
ClearThumbnail();
if (pgmCurrentMenu!=NULL && bMenuActive) {
pgmCurrentMenu->EndMenu();
}
bMenuActive = FALSE;
if (bGoToRoot) {
if (_gmRunningGameMode==GM_NONE) {
pgmCurrentMenu = &_pGUIM->gmMainMenu;
} else {
pgmCurrentMenu = &_pGUIM->gmInGameMenu;
}
}
}
BOOL IsMenusInRoot(void)
{
return pgmCurrentMenu == NULL || pgmCurrentMenu == &_pGUIM->gmMainMenu || pgmCurrentMenu == &_pGUIM->gmInGameMenu;
}
// ------------------------ Global menu function implementation
void InitializeMenus(void)
{
_pGUIM = new CMenuManager();
try {
// initialize and load corresponding fonts
_fdSmall.Load_t( CTFILENAME( "Fonts\\Display3-narrow.fnt"));
_fdMedium.Load_t( CTFILENAME( "Fonts\\Display3-normal.fnt"));
_fdBig.Load_t( CTFILENAME( "Fonts\\Display3-caps.fnt"));
_fdTitle.Load_t( CTFILENAME( "Fonts\\Title2.fnt"));
_fdSmall.SetCharSpacing(-1);
_fdSmall.SetLineSpacing( 0);
_fdSmall.SetSpaceWidth(0.4f);
_fdMedium.SetCharSpacing(+1);
_fdMedium.SetLineSpacing( 0);
_fdMedium.SetSpaceWidth(0.4f);
_fdBig.SetCharSpacing(+1);
_fdBig.SetLineSpacing( 0);
_fdTitle.SetCharSpacing(+1);
_fdTitle.SetLineSpacing( 0);
// load menu sounds
_psdSelect = _pSoundStock->Obtain_t( CTFILENAME("Sounds\\Menu\\Select.wav"));
_psdPress = _pSoundStock->Obtain_t( CTFILENAME("Sounds\\Menu\\Press.wav"));
_psoMenuSound = new CSoundObject;
// initialize and load menu textures
_toPointer.SetData_t( CTFILENAME( "Textures\\General\\Pointer.tex"));
_toLogoMenuA.SetData_t( CTFILENAME( "Textures\\Logo\\sam_menulogo256a.tex"));
_toLogoMenuB.SetData_t( CTFILENAME( "Textures\\Logo\\sam_menulogo256b.tex"));
}
catch( char *strError) {
FatalError( strError);
}
// force logo textures to be of maximal size
((CTextureData*)_toLogoMenuA.GetData())->Force(TEX_CONSTANT);
((CTextureData*)_toLogoMenuB.GetData())->Force(TEX_CONSTANT);
// menu's relative placement
CPlacement3D plRelative = CPlacement3D( FLOAT3D( 0.0f, 0.0f, -9.0f),
ANGLE3D( AngleDeg(0.0f), AngleDeg(0.0f), AngleDeg(0.0f)));
try
{
TRANSLATERADIOARRAY(astrNoYes);
TRANSLATERADIOARRAY(astrComputerInvoke);
TRANSLATERADIOARRAY(astrDisplayAPIRadioTexts);
TRANSLATERADIOARRAY(astrDisplayPrefsRadioTexts);
TRANSLATERADIOARRAY(astrBitsPerPixelRadioTexts);
TRANSLATERADIOARRAY(astrFrequencyRadioTexts);
TRANSLATERADIOARRAY(astrSoundAPIRadioTexts);
TRANSLATERADIOARRAY(astrDifficultyRadioTexts);
TRANSLATERADIOARRAY(astrMaxPlayersRadioTexts);
TRANSLATERADIOARRAY(astrWeapon);
TRANSLATERADIOARRAY(astrSplitScreenRadioTexts);
// initialize game type strings table
InitGameTypes();
// ------------------- Initialize menus
_pGUIM->gmConfirmMenu.Initialize_t();
_pGUIM->gmConfirmMenu.gm_strName = "Confirm";
_pGUIM->gmConfirmMenu.gm_pmgSelectedByDefault = &_pGUIM->gmConfirmMenu.gm_mgConfirmYes;
_pGUIM->gmConfirmMenu.gm_pgmParentMenu = NULL;
InitActionsForConfirmMenu();
_pGUIM->gmMainMenu.Initialize_t();
_pGUIM->gmMainMenu.gm_strName = "Main";
_pGUIM->gmMainMenu.gm_pmgSelectedByDefault = &_pGUIM->gmMainMenu.gm_mgSingle;
_pGUIM->gmMainMenu.gm_pgmParentMenu = NULL;
InitActionsForMainMenu();
_pGUIM->gmInGameMenu.Initialize_t();
_pGUIM->gmInGameMenu.gm_strName = "InGame";
_pGUIM->gmInGameMenu.gm_pmgSelectedByDefault = &_pGUIM->gmInGameMenu.gm_mgQuickLoad;
_pGUIM->gmInGameMenu.gm_pgmParentMenu = NULL;
InitActionsForInGameMenu();
_pGUIM->gmSinglePlayerMenu.Initialize_t();
_pGUIM->gmSinglePlayerMenu.gm_strName = "SinglePlayer";
_pGUIM->gmSinglePlayerMenu.gm_pmgSelectedByDefault = &_pGUIM->gmSinglePlayerMenu.gm_mgNewGame;
_pGUIM->gmSinglePlayerMenu.gm_pgmParentMenu = &_pGUIM->gmMainMenu;
InitActionsForSinglePlayerMenu();
_pGUIM->gmSinglePlayerNewMenu.Initialize_t();
_pGUIM->gmSinglePlayerNewMenu.gm_strName = "SinglePlayerNew";
_pGUIM->gmSinglePlayerNewMenu.gm_pmgSelectedByDefault = &_pGUIM->gmSinglePlayerNewMenu.gm_mgMedium;
_pGUIM->gmSinglePlayerNewMenu.gm_pgmParentMenu = &_pGUIM->gmSinglePlayerMenu;
InitActionsForSinglePlayerNewMenu();
_pGUIM->gmDisabledFunction.Initialize_t();
_pGUIM->gmDisabledFunction.gm_strName = "DisabledFunction";
_pGUIM->gmDisabledFunction.gm_pmgSelectedByDefault = &_pGUIM->gmDisabledFunction.gm_mgButton;
_pGUIM->gmDisabledFunction.gm_pgmParentMenu = NULL;
_pGUIM->gmPlayerProfile.Initialize_t();
_pGUIM->gmPlayerProfile.gm_strName = "PlayerProfile";
_pGUIM->gmPlayerProfile.gm_pmgSelectedByDefault = &_pGUIM->gmPlayerProfile.gm_mgNameField;
InitActionsForPlayerProfileMenu();
_pGUIM->gmControls.Initialize_t();
_pGUIM->gmControls.gm_strName = "Controls";
_pGUIM->gmControls.gm_pmgSelectedByDefault = &_pGUIM->gmControls.gm_mgButtons;
InitActionsForControlsMenu();
// warning! parent menu has to be set inside button activate function from where
// Load/Save menu is called
_pGUIM->gmLoadSaveMenu.Initialize_t();
_pGUIM->gmLoadSaveMenu.gm_strName = "LoadSave";
_pGUIM->gmLoadSaveMenu.gm_pmgSelectedByDefault = &_pGUIM->gmLoadSaveMenu.gm_amgButton[0];
_pGUIM->gmHighScoreMenu.Initialize_t();
_pGUIM->gmHighScoreMenu.gm_strName = "HighScore";
_pGUIM->gmHighScoreMenu.gm_pmgSelectedByDefault = &mgBack;
_pGUIM->gmCustomizeKeyboardMenu.Initialize_t();
_pGUIM->gmCustomizeKeyboardMenu.gm_strName = "CustomizeKeyboard";
_pGUIM->gmCustomizeKeyboardMenu.gm_pmgSelectedByDefault = &_pGUIM->gmCustomizeKeyboardMenu.gm_mgKey[0];
_pGUIM->gmCustomizeKeyboardMenu.gm_pgmParentMenu = &_pGUIM->gmControls;
_pGUIM->gmCustomizeAxisMenu.Initialize_t();
_pGUIM->gmCustomizeAxisMenu.gm_strName = "CustomizeAxis";
_pGUIM->gmCustomizeAxisMenu.gm_pmgSelectedByDefault = &_pGUIM->gmCustomizeAxisMenu.gm_mgActionTrigger;
_pGUIM->gmCustomizeAxisMenu.gm_pgmParentMenu = &_pGUIM->gmControls;
InitActionsForCustomizeAxisMenu();
_pGUIM->gmOptionsMenu.Initialize_t();
_pGUIM->gmOptionsMenu.gm_strName = "Options";
_pGUIM->gmOptionsMenu.gm_pmgSelectedByDefault = &_pGUIM->gmOptionsMenu.gm_mgVideoOptions;
_pGUIM->gmOptionsMenu.gm_pgmParentMenu = &_pGUIM->gmMainMenu;
InitActionsForOptionsMenu();
_pGUIM->gmVideoOptionsMenu.Initialize_t();
_pGUIM->gmVideoOptionsMenu.gm_strName = "VideoOptions";
_pGUIM->gmVideoOptionsMenu.gm_pmgSelectedByDefault = &_pGUIM->gmVideoOptionsMenu.gm_mgDisplayAPITrigger;
_pGUIM->gmVideoOptionsMenu.gm_pgmParentMenu = &_pGUIM->gmOptionsMenu;
InitActionsForVideoOptionsMenu();
_pGUIM->gmAudioOptionsMenu.Initialize_t();
_pGUIM->gmAudioOptionsMenu.gm_strName = "AudioOptions";
_pGUIM->gmAudioOptionsMenu.gm_pmgSelectedByDefault = &_pGUIM->gmAudioOptionsMenu.gm_mgFrequencyTrigger;
_pGUIM->gmAudioOptionsMenu.gm_pgmParentMenu = &_pGUIM->gmOptionsMenu;
InitActionsForAudioOptionsMenu();
_pGUIM->gmLevelsMenu.Initialize_t();
_pGUIM->gmLevelsMenu.gm_strName = "Levels";
_pGUIM->gmLevelsMenu.gm_pmgSelectedByDefault = &_pGUIM->gmLevelsMenu.gm_mgManualLevel[0];
_pGUIM->gmLevelsMenu.gm_pgmParentMenu = &_pGUIM->gmSinglePlayerMenu;
_pGUIM->gmVarMenu.Initialize_t();
_pGUIM->gmVarMenu.gm_strName = "Var";
_pGUIM->gmVarMenu.gm_pmgSelectedByDefault = &_pGUIM->gmVarMenu.gm_mgVar[0];
_pGUIM->gmVarMenu.gm_pgmParentMenu = &_pGUIM->gmNetworkStartMenu;
InitActionsForVarMenu();
_pGUIM->gmServersMenu.Initialize_t();
_pGUIM->gmServersMenu.gm_strName = "Servers";
_pGUIM->gmServersMenu.gm_pmgSelectedByDefault = &_pGUIM->gmServersMenu.gm_mgList;
_pGUIM->gmServersMenu.gm_pgmParentMenu = &_pGUIM->gmNetworkOpenMenu;
InitActionsForServersMenu();
_pGUIM->gmNetworkMenu.Initialize_t();
_pGUIM->gmNetworkMenu.gm_strName = "Network";
_pGUIM->gmNetworkMenu.gm_pmgSelectedByDefault = &_pGUIM->gmNetworkMenu.gm_mgJoin;
_pGUIM->gmNetworkMenu.gm_pgmParentMenu = &_pGUIM->gmMainMenu;
InitActionsForNetworkMenu();
_pGUIM->gmNetworkStartMenu.Initialize_t();
_pGUIM->gmNetworkStartMenu.gm_strName = "NetworkStart";
_pGUIM->gmNetworkStartMenu.gm_pmgSelectedByDefault = &_pGUIM->gmNetworkStartMenu.gm_mgStart;
_pGUIM->gmNetworkStartMenu.gm_pgmParentMenu = &_pGUIM->gmNetworkMenu;
InitActionsForNetworkStartMenu();
_pGUIM->gmNetworkJoinMenu.Initialize_t();
_pGUIM->gmNetworkJoinMenu.gm_strName = "NetworkJoin";
_pGUIM->gmNetworkJoinMenu.gm_pmgSelectedByDefault = &_pGUIM->gmNetworkJoinMenu.gm_mgLAN;
_pGUIM->gmNetworkJoinMenu.gm_pgmParentMenu = &_pGUIM->gmNetworkMenu;
InitActionsForNetworkJoinMenu();
_pGUIM->gmSelectPlayersMenu.gm_bAllowDedicated = FALSE;
_pGUIM->gmSelectPlayersMenu.gm_bAllowObserving = FALSE;
_pGUIM->gmSelectPlayersMenu.Initialize_t();
_pGUIM->gmSelectPlayersMenu.gm_strName = "SelectPlayers";
_pGUIM->gmSelectPlayersMenu.gm_pmgSelectedByDefault = &_pGUIM->gmSelectPlayersMenu.gm_mgStart;
InitActionsForSelectPlayersMenu();
_pGUIM->gmNetworkOpenMenu.Initialize_t();
_pGUIM->gmNetworkOpenMenu.gm_strName = "NetworkOpen";
_pGUIM->gmNetworkOpenMenu.gm_pmgSelectedByDefault = &_pGUIM->gmNetworkOpenMenu.gm_mgJoin;
_pGUIM->gmNetworkOpenMenu.gm_pgmParentMenu = &_pGUIM->gmNetworkJoinMenu;
InitActionsForNetworkOpenMenu();
_pGUIM->gmSplitScreenMenu.Initialize_t();
_pGUIM->gmSplitScreenMenu.gm_strName = "SplitScreen";
_pGUIM->gmSplitScreenMenu.gm_pmgSelectedByDefault = &_pGUIM->gmSplitScreenMenu.gm_mgStart;
_pGUIM->gmSplitScreenMenu.gm_pgmParentMenu = &_pGUIM->gmMainMenu;
InitActionsForSplitScreenMenu();
_pGUIM->gmSplitStartMenu.Initialize_t();
_pGUIM->gmSplitStartMenu.gm_strName = "SplitStart";
_pGUIM->gmSplitStartMenu.gm_pmgSelectedByDefault = &_pGUIM->gmSplitStartMenu.gm_mgStart;
_pGUIM->gmSplitStartMenu.gm_pgmParentMenu = &_pGUIM->gmSplitScreenMenu;
InitActionsForSplitStartMenu();
}
catch( char *strError)
{
FatalError( strError);
}
}
void DestroyMenus( void)
{
_pGUIM->gmMainMenu.Destroy();
pgmCurrentMenu = NULL;
_pSoundStock->Release(_psdSelect);
_pSoundStock->Release(_psdPress);
delete _psoMenuSound;
_psdSelect = NULL;
_psdPress = NULL;
_psoMenuSound = NULL;
}
// go to parent menu if possible
void MenuGoToParent(void)
{
// if there is no parent menu
if( pgmCurrentMenu->gm_pgmParentMenu == NULL) {
// if in game
if (_gmRunningGameMode!=GM_NONE) {
// exit menus
StopMenus();
// if no game is running
} else {
// go to main menu
ChangeToMenu(&_pGUIM->gmMainMenu);
}
// if there is some parent menu
} else {
// go to parent menu
ChangeToMenu( pgmCurrentMenu->gm_pgmParentMenu);
}
}
void MenuOnKeyDown( int iVKey)
{
// check if mouse buttons used
_bMouseUsedLast = (iVKey==VK_LBUTTON || iVKey==VK_RBUTTON || iVKey==VK_MBUTTON
|| iVKey==10 || iVKey==11);
// ignore mouse when editing
if (_bEditingString && _bMouseUsedLast) {
_bMouseUsedLast = FALSE;
return;
}
// initially the message is not handled
BOOL bHandled = FALSE;
// if not a mouse button, or mouse is over some gadget
if (!_bMouseUsedLast || _pmgUnderCursor!=NULL) {
// ask current menu to handle the key
bHandled = pgmCurrentMenu->OnKeyDown( iVKey);
}
// if not handled
if(!bHandled) {
// if escape or right mouse pressed
if(iVKey==VK_ESCAPE || iVKey==VK_RBUTTON) {
if (pgmCurrentMenu==&_pGUIM->gmLoadSaveMenu && _pGUIM->gmLoadSaveMenu.gm_bNoEscape) {
return;
}
// go to parent menu if possible
MenuGoToParent();
}
}
}
void MenuOnChar(MSG msg)
{
// check if mouse buttons used
_bMouseUsedLast = FALSE;
// ask current menu to handle the key
pgmCurrentMenu->OnChar(msg);
}
void MenuOnMouseMove(PIX pixI, PIX pixJ)
{
static PIX pixLastI = 0;
static PIX pixLastJ = 0;
if (pixLastI==pixI && pixLastJ==pixJ) {
return;
}
pixLastI = pixI;
pixLastJ = pixJ;
_bMouseUsedLast = !_bEditingString && !_bDefiningKey && !_pInput->IsInputEnabled();
}
void MenuUpdateMouseFocus(void)
{
// get real cursor position
POINT pt;
GetCursorPos(&pt);
ScreenToClient(_hwndMain, &pt);
extern INDEX sam_bWideScreen;
extern CDrawPort *pdp;
if( sam_bWideScreen) {
const PIX pixHeight = pdp->GetHeight();
pt.y -= (pixHeight/0.75f-pixHeight)/2;
}
_pixCursorPosI += pt.x-_pixCursorExternPosI;
_pixCursorPosJ = _pixCursorExternPosJ;
_pixCursorExternPosI = pt.x;
_pixCursorExternPosJ = pt.y;
// if mouse not used last
if (!_bMouseUsedLast||_bDefiningKey||_bEditingString) {
// do nothing
return;
}
CMenuGadget *pmgActive = NULL;
// for all gadgets in menu
FOREACHINLIST( CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
CMenuGadget &mg = *itmg;
// if focused
if( itmg->mg_bFocused) {
// remember it
pmgActive = &itmg.Current();
}
}
// if there is some under cursor
if (_pmgUnderCursor!=NULL) {
_pmgUnderCursor->OnMouseOver(_pixCursorPosI, _pixCursorPosJ);
// if the one under cursor has no neighbours
if (_pmgUnderCursor->mg_pmgLeft ==NULL
&&_pmgUnderCursor->mg_pmgRight==NULL
&&_pmgUnderCursor->mg_pmgUp ==NULL
&&_pmgUnderCursor->mg_pmgDown ==NULL) {
// it cannot be focused
_pmgUnderCursor = NULL;
return;
}
// if the one under cursor is not active and not disappearing
if (pmgActive!=_pmgUnderCursor && _pmgUnderCursor->mg_bVisible) {
// change focus
if (pmgActive!=NULL) {
pmgActive->OnKillFocus();
}
_pmgUnderCursor->OnSetFocus();
}
}
}
static CTimerValue _tvInitialization;
static TIME _tmInitializationTick = -1;
extern TIME _tmMenuLastTickDone;
void SetMenuLerping(void)
{
CTimerValue tvNow = _pTimer->GetHighPrecisionTimer();
// if lerping was never set before
if (_tmInitializationTick<0) {
// initialize it
_tvInitialization = tvNow;
_tmInitializationTick = _tmMenuLastTickDone;
}
// get passed time from session state starting in precise time and in ticks
FLOAT tmRealDelta = FLOAT((tvNow-_tvInitialization).GetSeconds());
FLOAT tmTickDelta = _tmMenuLastTickDone-_tmInitializationTick;
// calculate factor
FLOAT fFactor = 1.0f-(tmTickDelta-tmRealDelta)/_pTimer->TickQuantum;
// if the factor starts getting below zero
if (fFactor<0) {
// clamp it
fFactor = 0.0f;
// readjust timers so that it gets better
_tvInitialization = tvNow;
_tmInitializationTick = _tmMenuLastTickDone-_pTimer->TickQuantum;
}
if (fFactor>1) {
// clamp it
fFactor = 1.0f;
// readjust timers so that it gets better
_tvInitialization = tvNow;
_tmInitializationTick = _tmMenuLastTickDone;
}
// set lerping factor and timer
_pTimer->SetCurrentTick(_tmMenuLastTickDone);
_pTimer->SetLerp(fFactor);
}
// render mouse cursor if needed
void RenderMouseCursor(CDrawPort *pdp)
{
// if mouse not used last
if (!_bMouseUsedLast|| _bDefiningKey || _bEditingString) {
// don't render cursor
return;
}
_pGame->LCDSetDrawport(pdp);
_pGame->LCDDrawPointer(_pixCursorPosI, _pixCursorPosJ);
}
BOOL DoMenu( CDrawPort *pdp)
{
pdp->Unlock();
CDrawPort dpMenu(pdp, TRUE);
dpMenu.Lock();
MenuUpdateMouseFocus();
// if in fullscreen
CDisplayMode dmCurrent;
_pGfx->GetCurrentDisplayMode(dmCurrent);
if (dmCurrent.IsFullScreen()) {
// clamp mouse pointer
_pixCursorPosI = Clamp(_pixCursorPosI, 0L, dpMenu.GetWidth());
_pixCursorPosJ = Clamp(_pixCursorPosJ, 0L, dpMenu.GetHeight());
// if in window
} else {
// use same mouse pointer as windows
_pixCursorPosI = _pixCursorExternPosI;
_pixCursorPosJ = _pixCursorExternPosJ;
}
pgmCurrentMenu->Think();
TIME tmTickNow = _pTimer->GetRealTimeTick();
while( _tmMenuLastTickDone<tmTickNow)
{
_pTimer->SetCurrentTick(_tmMenuLastTickDone);
// call think for all gadgets in menu
FOREACHINLIST( CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
itmg->Think();
}
_tmMenuLastTickDone+=_pTimer->TickQuantum;
}
SetMenuLerping();
PIX pixW = dpMenu.GetWidth();
PIX pixH = dpMenu.GetHeight();
// blend background if menu is on
if( bMenuActive)
{
// get current time
TIME tmNow = _pTimer->GetLerpedCurrentTick();
UBYTE ubH1 = (INDEX)(tmNow*08.7f) & 255;
UBYTE ubH2 = (INDEX)(tmNow*27.6f) & 255;
UBYTE ubH3 = (INDEX)(tmNow*16.5f) & 255;
UBYTE ubH4 = (INDEX)(tmNow*35.4f) & 255;
// clear screen with background texture
_pGame->LCDPrepare(1.0f);
_pGame->LCDSetDrawport(&dpMenu);
// do not allow game to show through
dpMenu.Fill(C_BLACK|255);
_pGame->LCDRenderClouds1();
_pGame->LCDRenderGrid();
_pGame->LCDRenderClouds2();
FLOAT fScaleW = (FLOAT)pixW / 640.0f;
FLOAT fScaleH = (FLOAT)pixH / 480.0f;
PIX pixI0, pixJ0, pixI1, pixJ1;
// put logo(s) to main menu (if logos exist)
if (pgmCurrentMenu == &_pGUIM->gmMainMenu)
{
if( _ptoLogoODI!=NULL) {
CTextureData &td = (CTextureData&)*_ptoLogoODI->GetData();
#define LOGOSIZE 50
const PIX pixLogoWidth = LOGOSIZE * dpMenu.dp_fWideAdjustment;
const PIX pixLogoHeight = LOGOSIZE* td.GetHeight() / td.GetWidth();
pixI0 = (640-pixLogoWidth -16)*fScaleW;
pixJ0 = (480-pixLogoHeight-16)*fScaleH;
pixI1 = pixI0+ pixLogoWidth *fScaleW;
pixJ1 = pixJ0+ pixLogoHeight*fScaleH;
dpMenu.PutTexture( _ptoLogoODI, PIXaabbox2D( PIX2D( pixI0, pixJ0),PIX2D( pixI1, pixJ1)));
#undef LOGOSIZE
}
if( _ptoLogoCT!=NULL) {
CTextureData &td = (CTextureData&)*_ptoLogoCT->GetData();
#define LOGOSIZE 50
const PIX pixLogoWidth = LOGOSIZE * dpMenu.dp_fWideAdjustment;
const PIX pixLogoHeight = LOGOSIZE* td.GetHeight() / td.GetWidth();
pixI0 = 12*fScaleW;
pixJ0 = (480-pixLogoHeight-16)*fScaleH;
pixI1 = pixI0+ pixLogoWidth *fScaleW;
pixJ1 = pixJ0+ pixLogoHeight*fScaleH;
dpMenu.PutTexture( _ptoLogoCT, PIXaabbox2D( PIX2D( pixI0, pixJ0),PIX2D( pixI1, pixJ1)));
#undef LOGOSIZE
}
{
FLOAT fResize = Min(dpMenu.GetWidth()/640.0f, dpMenu.GetHeight()/480.0f);
PIX pixSizeI = 256*fResize;
PIX pixSizeJ = 64*fResize;
PIX pixCenterI = dpMenu.GetWidth()/2;
PIX pixHeightJ = 10*fResize;
dpMenu.PutTexture(&_toLogoMenuA, PIXaabbox2D(
PIX2D( pixCenterI-pixSizeI, pixHeightJ),PIX2D( pixCenterI, pixHeightJ+pixSizeJ)));
dpMenu.PutTexture(&_toLogoMenuB, PIXaabbox2D(
PIX2D( pixCenterI, pixHeightJ),PIX2D( pixCenterI+pixSizeI, pixHeightJ+pixSizeJ)));
}
} else if (pgmCurrentMenu == &_pGUIM->gmAudioOptionsMenu) {
if( _ptoLogoEAX!=NULL) {
CTextureData &td = (CTextureData&)*_ptoLogoEAX->GetData();
const INDEX iSize = 95;
const PIX pixLogoWidth = iSize * dpMenu.dp_fWideAdjustment;
const PIX pixLogoHeight = iSize * td.GetHeight() / td.GetWidth();
pixI0 = (640-pixLogoWidth - 35)*fScaleW;
pixJ0 = (480-pixLogoHeight - 7)*fScaleH;
pixI1 = pixI0+ pixLogoWidth *fScaleW;
pixJ1 = pixJ0+ pixLogoHeight*fScaleH;
dpMenu.PutTexture( _ptoLogoEAX, PIXaabbox2D( PIX2D( pixI0, pixJ0),PIX2D( pixI1, pixJ1)));
}
}
#define THUMBW 96
#define THUMBH 96
// if there is a thumbnail
if( _bThumbnailOn) {
const FLOAT fThumbScaleW = fScaleW * dpMenu.dp_fWideAdjustment;
PIX pixOfs = 8*fScaleW;
pixI0 = 8*fScaleW;
pixJ0 = (240-THUMBW/2)*fScaleH;
pixI1 = pixI0+ THUMBW*fThumbScaleW;
pixJ1 = pixJ0+ THUMBH*fScaleH;
if( _toThumbnail.GetData()!=NULL)
{ // show thumbnail with shadow and border
dpMenu.Fill( pixI0+pixOfs, pixJ0+pixOfs, THUMBW*fThumbScaleW, THUMBH*fScaleH, C_BLACK|128);
dpMenu.PutTexture( &_toThumbnail, PIXaabbox2D( PIX2D( pixI0, pixJ0), PIX2D( pixI1, pixJ1)), C_WHITE|255);
dpMenu.DrawBorder( pixI0,pixJ0, THUMBW*fThumbScaleW,THUMBH*fScaleH, _pGame->LCDGetColor(C_mdGREEN|255, "thumbnail border"));
} else {
dpMenu.SetFont( _pfdDisplayFont);
dpMenu.SetTextScaling( fScaleW);
dpMenu.SetTextAspect( 1.0f);
dpMenu.PutTextCXY( TRANS("no thumbnail"), (pixI0+pixI1)/2, (pixJ0+pixJ1)/2, _pGame->LCDGetColor(C_GREEN|255, "no thumbnail"));
}
}
// assure we can listen to non-3d sounds
_pSound->UpdateSounds();
}
// if this is popup menu
if (pgmCurrentMenu->gm_bPopup) {
// render parent menu first
if (pgmCurrentMenu->gm_pgmParentMenu!=NULL) {
_pGame->MenuPreRenderMenu(pgmCurrentMenu->gm_pgmParentMenu->gm_strName);
FOREACHINLIST( CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_pgmParentMenu->gm_lhGadgets, itmg) {
if( itmg->mg_bVisible) {
itmg->Render( &dpMenu);
}
}
_pGame->MenuPostRenderMenu(pgmCurrentMenu->gm_pgmParentMenu->gm_strName);
}
// gray it out
dpMenu.Fill(C_BLACK|128);
// clear popup box
dpMenu.Unlock();
PIXaabbox2D box = FloatBoxToPixBox(&dpMenu, BoxPopup());
CDrawPort dpPopup(pdp, box);
dpPopup.Lock();
_pGame->LCDSetDrawport(&dpPopup);
dpPopup.Fill(C_BLACK|255);
_pGame->LCDRenderClouds1();
_pGame->LCDRenderGrid();
//_pGame->LCDRenderClouds2();
_pGame->LCDScreenBox(_pGame->LCDGetColor(C_GREEN|255, "popup box"));
dpPopup.Unlock();
dpMenu.Lock();
}
// no entity is under cursor initially
_pmgUnderCursor = NULL;
BOOL bStilInMenus = FALSE;
_pGame->MenuPreRenderMenu(pgmCurrentMenu->gm_strName);
// for each menu gadget
FOREACHINLIST( CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
// if gadget is visible
if( itmg->mg_bVisible) {
bStilInMenus = TRUE;
itmg->Render( &dpMenu);
if (FloatBoxToPixBox(&dpMenu, itmg->mg_boxOnScreen)>=PIX2D(_pixCursorPosI, _pixCursorPosJ)) {
_pmgUnderCursor = itmg;
}
}
}
_pGame->MenuPostRenderMenu(pgmCurrentMenu->gm_strName);
// no currently active gadget initially
CMenuGadget *pmgActive = NULL;
// if mouse was not active last
if (!_bMouseUsedLast) {
// find focused gadget
FOREACHINLIST( CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
CMenuGadget &mg = *itmg;
// if focused
if( itmg->mg_bFocused) {
// it is active
pmgActive = &itmg.Current();
break;
}
}
// if mouse was active last
} else {
// gadget under cursor is active
pmgActive = _pmgUnderCursor;
}
// if editing
if (_bEditingString && pmgActive!=NULL) {
// dim the menu bit
dpMenu.Fill(C_BLACK|0x40);
// render the edit gadget again
pmgActive->Render(&dpMenu);
}
// if there is some active gadget and it has tips
if (pmgActive!=NULL && (pmgActive->mg_strTip!="" || _bEditingString)) {
CTString strTip = pmgActive->mg_strTip;
if (_bEditingString) {
strTip = TRANS("Enter - OK, Escape - Cancel");
}
// print the tip
SetFontMedium(&dpMenu);
dpMenu.PutTextC(strTip,
pixW*0.5f, pixH*0.92f, _pGame->LCDGetColor(C_WHITE|255, "tool tip"));
}
_pGame->ConsolePrintLastLines(&dpMenu);
RenderMouseCursor(&dpMenu);
dpMenu.Unlock();
pdp->Lock();
return bStilInMenus;
}
void MenuBack(void)
{
MenuGoToParent();
}
extern void FixupBackButton(CGameMenu *pgm)
{
BOOL bResume = FALSE;
if (mgBack.mg_lnNode.IsLinked()) {
mgBack.mg_lnNode.Remove();
}
BOOL bHasBack = TRUE;
if (pgm->gm_bPopup) {
bHasBack = FALSE;
}
if (pgm->gm_pgmParentMenu==NULL) {
if (_gmRunningGameMode==GM_NONE) {
bHasBack = FALSE;
} else {
bResume = TRUE;
}
}
if (!bHasBack) {
mgBack.Disappear();
return;
}
if (bResume) {
mgBack.mg_strText = TRANS("RESUME");
mgBack.mg_strTip = TRANS("return to game");
} else {
if (_bVarChanged) {
mgBack.mg_strText = TRANS("CANCEL");
mgBack.mg_strTip = TRANS("cancel changes");
} else {
mgBack.mg_strText = TRANS("BACK");
mgBack.mg_strTip = TRANS("return to previous menu");
}
}
mgBack.mg_iCenterI = -1;
mgBack.mg_bfsFontSize = BFS_LARGE;
mgBack.mg_boxOnScreen = BoxBack();
mgBack.mg_boxOnScreen = BoxLeftColumn(16.5f);
pgm->gm_lhGadgets.AddTail( mgBack.mg_lnNode);
mgBack.mg_pmgLeft =
mgBack.mg_pmgRight =
mgBack.mg_pmgUp =
mgBack.mg_pmgDown = pgm->gm_pmgSelectedByDefault;
mgBack.mg_pActivatedFunction = &MenuBack;
mgBack.Appear();
}
void ChangeToMenu( CGameMenu *pgmNewMenu)
{
// auto-clear old thumbnail when going out of menu
ClearThumbnail();
if( pgmCurrentMenu != NULL) {
if (!pgmNewMenu->gm_bPopup) {
pgmCurrentMenu->EndMenu();
} else {
FOREACHINLIST(CMenuGadget, mg_lnNode, pgmCurrentMenu->gm_lhGadgets, itmg) {
itmg->OnKillFocus();
}
}
}
pgmNewMenu->StartMenu();
if (pgmNewMenu->gm_pmgSelectedByDefault) {
if (mgBack.mg_bFocused) {
mgBack.OnKillFocus();
}
pgmNewMenu->gm_pmgSelectedByDefault->OnSetFocus();
}
FixupBackButton(pgmNewMenu);
pgmCurrentMenu = pgmNewMenu;
}

69
Sources/SeriousSam/GUI/Menus/Menu.h
View File

@ -1,69 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_H
#define SE_INCL_MENU_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
// set new thumbnail
void SetThumbnail(CTFileName fn);
// remove thumbnail
void ClearThumbnail(void);
void InitializeMenus( void);
void DestroyMenus( void);
void MenuOnKeyDown( int iVKey);
void MenuOnChar(MSG msg);
void MenuOnMouseMove(PIX pixI, PIX pixJ);
void MenuOnLMBDown(void);
BOOL DoMenu( CDrawPort *pdp); // returns TRUE if still active, FALSE if should quit
void StartMenus( const char *str="");
void StopMenus(BOOL bGoToRoot =TRUE);
BOOL IsMenusInRoot(void);
void ChangeToMenu( class CGameMenu *pgmNew);
extern void PlayMenuSound(CSoundData *psd);
#define KEYS_ON_SCREEN 14
#define LEVELS_ON_SCREEN 16
#define SERVERS_ON_SCREEN 15
#define VARS_ON_SCREEN 14
extern CListHead _lhServers;
extern INDEX _iLocalPlayer;
enum GameMode {
GM_NONE = 0,
GM_SINGLE_PLAYER,
GM_NETWORK,
GM_SPLIT_SCREEN,
GM_DEMO,
GM_INTRO,
};
extern GameMode _gmMenuGameMode;
extern GameMode _gmRunningGameMode;
extern CGameMenu *pgmCurrentMenu;
#include "SeriousSam/GUI/Menus/GameMenu.h"
#include "MLoadSave.h"
#include "MPlayerProfile.h"
#include "MSelectPlayers.h"
#endif /* include-once check. */

1272
Sources/SeriousSam/GUI/Menus/MenuActions.cpp
View File

File diff suppressed because it is too large Load Diff

44
Sources/SeriousSam/GUI/Menus/MenuActions.h
View File

@ -1,44 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_ACTIONS_H
#define SE_INCL_MENU_ACTIONS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
void InitActionsForAudioOptionsMenu();
void InitActionsForConfirmMenu();
void InitActionsForControlsMenu();
void InitActionsForCustomizeAxisMenu();
void InitActionsForMainMenu();
void InitActionsForInGameMenu();
void InitActionsForNetworkMenu();
void InitActionsForNetworkJoinMenu();
void InitActionsForNetworkOpenMenu();
void InitActionsForNetworkStartMenu();
void InitActionsForOptionsMenu();
void InitActionsForPlayerProfileMenu();
void InitActionsForSelectPlayersMenu();
void InitActionsForServersMenu();
void InitActionsForSinglePlayerMenu();
void InitActionsForSinglePlayerNewMenu();
void InitActionsForSplitScreenMenu();
void InitActionsForSplitStartMenu();
void InitActionsForVideoOptionsMenu();
void InitActionsForVarMenu();
#endif /* include-once check. */

21
Sources/SeriousSam/GUI/Menus/MenuManager.cpp
View File

@ -1,21 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Build.h>
#include "MenuManager.h"
CMenuManager* _pGUIM = NULL;

80
Sources/SeriousSam/GUI/Menus/MenuManager.h
View File

@ -1,80 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENUMANAGER_H
#define SE_INCL_MENUMANAGER_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "MAudioOptions.h"
#include "MConfirm.h"
#include "MControls.h"
#include "MCustomizeAxis.h"
#include "MCustomizeKeyboard.h"
#include "MCredits.h"
#include "MDisabled.h"
#include "MHighScore.h"
#include "MInGame.h"
#include "MLevels.h"
#include "MMain.h"
#include "MNetwork.h"
#include "MNetworkJoin.h"
#include "MNetworkOpen.h"
#include "MNetworkStart.h"
#include "MOptions.h"
#include "MRenderingOptions.h"
#include "MServers.h"
#include "MSinglePlayer.h"
#include "MSinglePlayerNew.h"
#include "MSplitScreen.h"
#include "MSplitStart.h"
#include "MVar.h"
#include "MVideoOptions.h"
class CMenuManager {
public:
CConfirmMenu gmConfirmMenu;
CMainMenu gmMainMenu;
CInGameMenu gmInGameMenu;
CSinglePlayerMenu gmSinglePlayerMenu;
CSinglePlayerNewMenu gmSinglePlayerNewMenu;
CDisabledMenu gmDisabledFunction;
CLevelsMenu gmLevelsMenu;
CVarMenu gmVarMenu;
CPlayerProfileMenu gmPlayerProfile;
CControlsMenu gmControls;
CLoadSaveMenu gmLoadSaveMenu;
CHighScoreMenu gmHighScoreMenu;
CCustomizeKeyboardMenu gmCustomizeKeyboardMenu;
CServersMenu gmServersMenu;
CCustomizeAxisMenu gmCustomizeAxisMenu;
COptionsMenu gmOptionsMenu;
CVideoOptionsMenu gmVideoOptionsMenu;
CAudioOptionsMenu gmAudioOptionsMenu;
CNetworkMenu gmNetworkMenu;
CNetworkJoinMenu gmNetworkJoinMenu;
CNetworkStartMenu gmNetworkStartMenu;
CNetworkOpenMenu gmNetworkOpenMenu;
CSplitScreenMenu gmSplitScreenMenu;
CSplitStartMenu gmSplitStartMenu;
CSelectPlayersMenu gmSelectPlayersMenu;
};
extern CMenuManager *_pGUIM; // TODO: Make singleton!
#endif /* include-once check. */

860
Sources/SeriousSam/GUI/Menus/MenuStarters.cpp
View File

@ -1,860 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
/* This file contains starter fuctions for all menus. */
#include "SeriousSam/StdH.h"
#include <Engine/Build.h>
#include "MenuManager.h"
#include "MenuStarters.h"
#include "MenuStartersAF.h"
#include "MenuStuff.h"
#include "SeriousSam/LevelInfo.h"
extern void(*_pAfterLevelChosen)(void);
extern BOOL _bPlayerMenuFromSinglePlayer;
extern CTString _strLastPlayerAppearance;
extern CTString sam_strNetworkSettings;
extern CTFileName _fnmModSelected;
extern CTString _strModURLSelected;
extern CTString _strModServerSelected;
void StartVideoOptionsMenu(void)
{
ChangeToMenu(&_pGUIM->gmVideoOptionsMenu);
}
void StartAudioOptionsMenu(void)
{
ChangeToMenu(&_pGUIM->gmAudioOptionsMenu);
}
void StartSinglePlayerMenu(void)
{
ChangeToMenu(&_pGUIM->gmSinglePlayerMenu);
}
void StartNetworkMenu(void)
{
ChangeToMenu(&_pGUIM->gmNetworkMenu);
}
void StartNetworkJoinMenu(void)
{
ChangeToMenu(&_pGUIM->gmNetworkJoinMenu);
}
void StartNetworkStartMenu(void)
{
ChangeToMenu(&_pGUIM->gmNetworkStartMenu);
}
void StartNetworkOpenMenu(void)
{
ChangeToMenu(&_pGUIM->gmNetworkOpenMenu);
}
void StartSplitScreenMenu(void)
{
ChangeToMenu(&_pGUIM->gmSplitScreenMenu);
}
void StartSplitStartMenu(void)
{
ChangeToMenu(&_pGUIM->gmSplitStartMenu);
}
void StartSinglePlayerNewMenuCustom(void)
{
_pGUIM->gmSinglePlayerNewMenu.gm_pgmParentMenu = &_pGUIM->gmLevelsMenu;
ChangeToMenu(&_pGUIM->gmSinglePlayerNewMenu);
}
static void SetQuickLoadNotes(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
if (_pShell->GetINDEX("gam_iQuickSaveSlots") <= 8) {
gmCurrent.gm_mgNotes.mg_strText = TRANS(
"In-game QuickSave shortcuts:\n"
"F6 - save a new QuickSave\n"
"F9 - load the last QuickSave\n");
} else {
gmCurrent.gm_mgNotes.mg_strText = "";
}
}
extern CTString sam_strFirstLevel;
void StartSinglePlayerNewMenu(void)
{
CVarMenu &gmCurrent = _pGUIM->gmVarMenu;
_pGame->gam_strCustomLevel = sam_strFirstLevel;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmSinglePlayerMenu;
ChangeToMenu(&gmCurrent);
}
// game options var settings
void StartVarGameOptions(void)
{
CVarMenu &gmCurrent = _pGUIM->gmVarMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("GAME OPTIONS");
gmCurrent.gm_fnmMenuCFG = CTFILENAME("Scripts\\Menu\\GameOptions.cfg");
ChangeToMenu(&gmCurrent);
}
void StartSinglePlayerGameOptions(void)
{
CVarMenu &gmCurrent = _pGUIM->gmVarMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("GAME OPTIONS");
gmCurrent.gm_fnmMenuCFG = CTFILENAME("Scripts\\Menu\\SPOptions.cfg");
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmSinglePlayerMenu;
ChangeToMenu(&gmCurrent);
}
void StartGameOptionsFromNetwork(void)
{
StartVarGameOptions();
_pGUIM->gmVarMenu.gm_pgmParentMenu = &_pGUIM->gmNetworkStartMenu;
}
void StartGameOptionsFromSplitScreen(void)
{
StartVarGameOptions();
_pGUIM->gmVarMenu.gm_pgmParentMenu = &_pGUIM->gmSplitStartMenu;
}
// rendering options var settings
void StartRenderingOptionsMenu(void)
{
CVarMenu &gmCurrent = _pGUIM->gmVarMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("RENDERING OPTIONS");
gmCurrent.gm_fnmMenuCFG = CTFILENAME("Scripts\\Menu\\RenderingOptions.cfg");
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmVideoOptionsMenu;
ChangeToMenu(&gmCurrent);
}
void StartCustomizeKeyboardMenu(void)
{
ChangeToMenu(&_pGUIM->gmCustomizeKeyboardMenu);
}
void StartCustomizeAxisMenu(void)
{
ChangeToMenu(&_pGUIM->gmCustomizeAxisMenu);
}
void StartOptionsMenu(void)
{
_pGUIM->gmOptionsMenu.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&_pGUIM->gmOptionsMenu);
}
void StartCurrentLoadMenu()
{
if (_gmRunningGameMode == GM_NETWORK) {
void StartNetworkLoadMenu(void);
StartNetworkLoadMenu();
} else if (_gmRunningGameMode == GM_SPLIT_SCREEN) {
void StartSplitScreenLoadMenu(void);
StartSplitScreenLoadMenu();
} else {
void StartSinglePlayerLoadMenu(void);
StartSinglePlayerLoadMenu();
}
}
void StartCurrentSaveMenu()
{
if (_gmRunningGameMode == GM_NETWORK) {
void StartNetworkSaveMenu(void);
StartNetworkSaveMenu();
} else if (_gmRunningGameMode == GM_SPLIT_SCREEN) {
void StartSplitScreenSaveMenu(void);
StartSplitScreenSaveMenu();
} else {
void StartSinglePlayerSaveMenu(void);
StartSinglePlayerSaveMenu();
}
}
void StartCurrentQuickLoadMenu()
{
if (_gmRunningGameMode == GM_NETWORK) {
void StartNetworkQuickLoadMenu(void);
StartNetworkQuickLoadMenu();
} else if (_gmRunningGameMode == GM_SPLIT_SCREEN) {
void StartSplitScreenQuickLoadMenu(void);
StartSplitScreenQuickLoadMenu();
} else {
void StartSinglePlayerQuickLoadMenu(void);
StartSinglePlayerQuickLoadMenu();
}
}
void StartChangePlayerMenuFromOptions(void)
{
_bPlayerMenuFromSinglePlayer = FALSE;
_pGUIM->gmPlayerProfile.gm_piCurrentPlayer = &_pGame->gm_iSinglePlayer;
_pGUIM->gmPlayerProfile.gm_pgmParentMenu = &_pGUIM->gmOptionsMenu;
ChangeToMenu(&_pGUIM->gmPlayerProfile);
}
void StartChangePlayerMenuFromSinglePlayer(void)
{
_iLocalPlayer = -1;
_bPlayerMenuFromSinglePlayer = TRUE;
_pGUIM->gmPlayerProfile.gm_piCurrentPlayer = &_pGame->gm_iSinglePlayer;
_pGUIM->gmPlayerProfile.gm_pgmParentMenu = &_pGUIM->gmSinglePlayerMenu;
ChangeToMenu(&_pGUIM->gmPlayerProfile);
}
void StartControlsMenuFromPlayer(void)
{
_pGUIM->gmControls.gm_pgmParentMenu = &_pGUIM->gmPlayerProfile;
ChangeToMenu(&_pGUIM->gmControls);
}
void StartControlsMenuFromOptions(void)
{
_pGUIM->gmControls.gm_pgmParentMenu = &_pGUIM->gmOptionsMenu;
ChangeToMenu(&_pGUIM->gmControls);
}
void StartHighScoreMenu(void)
{
_pGUIM->gmHighScoreMenu.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&_pGUIM->gmHighScoreMenu);
}
void StartSplitScreenGame(void)
{
// _pGame->gm_MenuSplitScreenCfg = (enum CGame::SplitScreenCfg) mgSplitScreenCfg.mg_iSelected;
_pGame->gm_StartSplitScreenCfg = _pGame->gm_MenuSplitScreenCfg;
_pGame->gm_aiStartLocalPlayers[0] = _pGame->gm_aiMenuLocalPlayers[0];
_pGame->gm_aiStartLocalPlayers[1] = _pGame->gm_aiMenuLocalPlayers[1];
_pGame->gm_aiStartLocalPlayers[2] = _pGame->gm_aiMenuLocalPlayers[2];
_pGame->gm_aiStartLocalPlayers[3] = _pGame->gm_aiMenuLocalPlayers[3];
CTFileName fnWorld = _pGame->gam_strCustomLevel;
_pGame->gm_strNetworkProvider = "Local";
CUniversalSessionProperties sp;
_pGame->SetMultiPlayerSession(sp);
if (_pGame->NewGame(fnWorld.FileName(), fnWorld, sp))
{
StopMenus();
_gmRunningGameMode = GM_SPLIT_SCREEN;
} else {
_gmRunningGameMode = GM_NONE;
}
}
void StartNetworkGame(void)
{
// _pGame->gm_MenuSplitScreenCfg = (enum CGame::SplitScreenCfg) mgSplitScreenCfg.mg_iSelected;
_pGame->gm_StartSplitScreenCfg = _pGame->gm_MenuSplitScreenCfg;
_pGame->gm_aiStartLocalPlayers[0] = _pGame->gm_aiMenuLocalPlayers[0];
_pGame->gm_aiStartLocalPlayers[1] = _pGame->gm_aiMenuLocalPlayers[1];
_pGame->gm_aiStartLocalPlayers[2] = _pGame->gm_aiMenuLocalPlayers[2];
_pGame->gm_aiStartLocalPlayers[3] = _pGame->gm_aiMenuLocalPlayers[3];
CTFileName fnWorld = _pGame->gam_strCustomLevel;
_pGame->gm_strNetworkProvider = "TCP/IP Server";
CUniversalSessionProperties sp;
_pGame->SetMultiPlayerSession(sp);
if (_pGame->NewGame(_pGame->gam_strSessionName, fnWorld, sp))
{
StopMenus();
_gmRunningGameMode = GM_NETWORK;
// if starting a dedicated server
if (_pGame->gm_MenuSplitScreenCfg == CGame::SSC_DEDICATED) {
// pull down the console
extern INDEX sam_bToggleConsole;
sam_bToggleConsole = TRUE;
}
} else {
_gmRunningGameMode = GM_NONE;
}
}
void JoinNetworkGame(void)
{
// _pGame->gm_MenuSplitScreenCfg = (enum CGame::SplitScreenCfg) mgSplitScreenCfg.mg_iSelected;
_pGame->gm_StartSplitScreenCfg = _pGame->gm_MenuSplitScreenCfg;
_pGame->gm_aiStartLocalPlayers[0] = _pGame->gm_aiMenuLocalPlayers[0];
_pGame->gm_aiStartLocalPlayers[1] = _pGame->gm_aiMenuLocalPlayers[1];
_pGame->gm_aiStartLocalPlayers[2] = _pGame->gm_aiMenuLocalPlayers[2];
_pGame->gm_aiStartLocalPlayers[3] = _pGame->gm_aiMenuLocalPlayers[3];
_pGame->gm_strNetworkProvider = "TCP/IP Client";
if (_pGame->JoinGame(CNetworkSession(_pGame->gam_strJoinAddress)))
{
StopMenus();
_gmRunningGameMode = GM_NETWORK;
} else {
if (_pNetwork->ga_strRequiredMod != "") {
extern CTFileName _fnmModToLoad;
extern CTString _strModServerJoin;
char strModName[256] = { 0 };
char strModURL[256] = { 0 };
_pNetwork->ga_strRequiredMod.ScanF("%250[^\\]\\%s", &strModName, &strModURL);
_fnmModSelected = CTString(strModName);
_strModURLSelected = strModURL;
if (_strModURLSelected = "") {
_strModURLSelected = "http://www.croteam.com/mods/Old";
}
_strModServerSelected.PrintF("%s:%s", (const char *) _pGame->gam_strJoinAddress, (const char *) _pShell->GetValue("net_iPort"));
extern void ModConnectConfirm(void);
ModConnectConfirm();
}
_gmRunningGameMode = GM_NONE;
}
}
// -------- Servers Menu Functions
void StartSelectServerLAN(void)
{
CServersMenu &gmCurrent = _pGUIM->gmServersMenu;
gmCurrent.m_bInternet = FALSE;
ChangeToMenu(&gmCurrent);
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmNetworkJoinMenu;
}
void StartSelectServerNET(void)
{
CServersMenu &gmCurrent = _pGUIM->gmServersMenu;
gmCurrent.m_bInternet = TRUE;
ChangeToMenu(&gmCurrent);
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmNetworkJoinMenu;
}
// -------- Levels Menu Functions
void StartSelectLevelFromSingle(void)
{
CLevelsMenu &gmCurrent = _pGUIM->gmLevelsMenu;
FilterLevels(GetSpawnFlagsForGameType(-1));
_pAfterLevelChosen = StartSinglePlayerNewMenuCustom;
ChangeToMenu(&gmCurrent);
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmSinglePlayerMenu;
}
void StartSelectLevelFromSplit(void)
{
CLevelsMenu &gmCurrent = _pGUIM->gmLevelsMenu;
FilterLevels(GetSpawnFlagsForGameType(_pGUIM->gmSplitStartMenu.gm_mgGameType.mg_iSelected));
void StartSplitStartMenu(void);
_pAfterLevelChosen = StartSplitStartMenu;
ChangeToMenu(&gmCurrent);
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmSplitStartMenu;
}
void StartSelectLevelFromNetwork(void)
{
CLevelsMenu &gmCurrent = _pGUIM->gmLevelsMenu;
FilterLevels(GetSpawnFlagsForGameType(_pGUIM->gmNetworkStartMenu.gm_mgGameType.mg_iSelected));
void StartNetworkStartMenu(void);
_pAfterLevelChosen = StartNetworkStartMenu;
ChangeToMenu(&gmCurrent);
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmNetworkStartMenu;
}
// -------- Players Selection Menu Functions
void StartSelectPlayersMenuFromSplit(void)
{
CSelectPlayersMenu &gmCurrent = _pGUIM->gmSelectPlayersMenu;
gmCurrent.gm_bAllowDedicated = FALSE;
gmCurrent.gm_bAllowObserving = FALSE;
gmCurrent.gm_mgStart.mg_pActivatedFunction = &StartSplitScreenGame;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmSplitStartMenu;
ChangeToMenu(&gmCurrent);
}
void StartSelectPlayersMenuFromNetwork(void)
{
CSelectPlayersMenu &gmCurrent = _pGUIM->gmSelectPlayersMenu;
gmCurrent.gm_bAllowDedicated = TRUE;
gmCurrent.gm_bAllowObserving = TRUE;
gmCurrent.gm_mgStart.mg_pActivatedFunction = &StartNetworkGame;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmNetworkStartMenu;
ChangeToMenu(&gmCurrent);
}
void StartSelectPlayersMenuFromNetworkLoad(void)
{
CSelectPlayersMenu &gmCurrent = _pGUIM->gmSelectPlayersMenu;
gmCurrent.gm_bAllowDedicated = FALSE;
gmCurrent.gm_bAllowObserving = TRUE;
gmCurrent.gm_mgStart.mg_pActivatedFunction = &StartNetworkLoadGame;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmLoadSaveMenu;
ChangeToMenu(&gmCurrent);
}
void StartSelectPlayersMenuFromSplitScreenLoad(void)
{
CSelectPlayersMenu &gmCurrent = _pGUIM->gmSelectPlayersMenu;
gmCurrent.gm_bAllowDedicated = FALSE;
gmCurrent.gm_bAllowObserving = FALSE;
gmCurrent.gm_mgStart.mg_pActivatedFunction = &StartSplitScreenGameLoad;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmLoadSaveMenu;
ChangeToMenu(&gmCurrent);
}
void StartSelectPlayersMenuFromOpen(void)
{
CSelectPlayersMenu &gmCurrent = _pGUIM->gmSelectPlayersMenu;
gmCurrent.gm_bAllowDedicated = FALSE;
gmCurrent.gm_bAllowObserving = TRUE;
gmCurrent.gm_mgStart.mg_pActivatedFunction = &JoinNetworkGame;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmNetworkOpenMenu;
ChangeToMenu(&gmCurrent);
/*if (sam_strNetworkSettings=="")*/ {
void StartNetworkSettingsMenu(void);
StartNetworkSettingsMenu();
_pGUIM->gmLoadSaveMenu.gm_bNoEscape = TRUE;
_pGUIM->gmLoadSaveMenu.gm_pgmParentMenu = &_pGUIM->gmNetworkOpenMenu;
_pGUIM->gmLoadSaveMenu.gm_pgmNextMenu = &gmCurrent;
}
}
void StartSelectPlayersMenuFromServers(void)
{
CSelectPlayersMenu &gmCurrent = _pGUIM->gmSelectPlayersMenu;
gmCurrent.gm_bAllowDedicated = FALSE;
gmCurrent.gm_bAllowObserving = TRUE;
gmCurrent.gm_mgStart.mg_pActivatedFunction = &JoinNetworkGame;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmServersMenu;
ChangeToMenu(&gmCurrent);
/*if (sam_strNetworkSettings=="")*/ {
void StartNetworkSettingsMenu(void);
StartNetworkSettingsMenu();
_pGUIM->gmLoadSaveMenu.gm_bNoEscape = TRUE;
_pGUIM->gmLoadSaveMenu.gm_pgmParentMenu = &_pGUIM->gmServersMenu;
_pGUIM->gmLoadSaveMenu.gm_pgmNextMenu = &gmCurrent;
}
}
// -------- Save/Load Menu Calling Functions
void StartPlayerModelLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("CHOOSE MODEL");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEUP;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = FALSE;
gmCurrent.gm_fnmDirectory = CTString("Models\\Player\\");
gmCurrent.gm_fnmSelected = _strLastPlayerAppearance;
gmCurrent.gm_fnmExt = CTString(".amc");
gmCurrent.gm_pAfterFileChosen = &LSLoadPlayerModel;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmPlayerProfile;
ChangeToMenu(&gmCurrent);
}
void StartControlsLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("LOAD CONTROLS");
gmCurrent.gm_bAllowThumbnails = FALSE;
gmCurrent.gm_iSortType = LSSORT_FILEUP;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = FALSE;
gmCurrent.gm_fnmDirectory = CTString("Controls\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".ctl");
gmCurrent.gm_pAfterFileChosen = &LSLoadControls;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmControls;
ChangeToMenu(&gmCurrent);
}
void StartCustomLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("ADVANCED OPTIONS");
gmCurrent.gm_bAllowThumbnails = FALSE;
gmCurrent.gm_iSortType = LSSORT_NAMEUP;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = FALSE;
gmCurrent.gm_fnmDirectory = CTString("Scripts\\CustomOptions\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".cfg");
gmCurrent.gm_pAfterFileChosen = &LSLoadCustom;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmOptionsMenu;
ChangeToMenu(&gmCurrent);
}
void StartAddonsLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("EXECUTE ADDON");
gmCurrent.gm_bAllowThumbnails = FALSE;
gmCurrent.gm_iSortType = LSSORT_NAMEUP;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = FALSE;
gmCurrent.gm_fnmDirectory = CTString("Scripts\\Addons\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".ini");
gmCurrent.gm_pAfterFileChosen = &LSLoadAddon;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmOptionsMenu;
ChangeToMenu(&gmCurrent);
}
void StartModsLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("CHOOSE MOD");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_NAMEUP;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = FALSE;
gmCurrent.gm_fnmDirectory = CTString("Mods\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".des");
gmCurrent.gm_pAfterFileChosen = &LSLoadMod;
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmMainMenu;
ChangeToMenu(&gmCurrent);
}
void StartNetworkSettingsMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
gmCurrent.gm_mgTitle.mg_strText = TRANS("CONNECTION SETTINGS");
gmCurrent.gm_bAllowThumbnails = FALSE;
gmCurrent.gm_iSortType = LSSORT_FILEUP;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = FALSE;
gmCurrent.gm_fnmDirectory = CTString("Scripts\\NetSettings\\");
gmCurrent.gm_fnmSelected = sam_strNetworkSettings;
gmCurrent.gm_fnmExt = CTString(".ini");
gmCurrent.gm_pAfterFileChosen = &LSLoadNetSettings;
if (sam_strNetworkSettings == "") {
gmCurrent.gm_mgNotes.mg_strText = TRANS(
"Before joining a network game,\n"
"you have to adjust your connection parameters.\n"
"Choose one option from the list.\n"
"If you have problems with connection, you can adjust\n"
"these parameters again from the Options menu.\n"
);
} else {
gmCurrent.gm_mgNotes.mg_strText = "";
}
gmCurrent.gm_pgmParentMenu = &_pGUIM->gmOptionsMenu;
ChangeToMenu(&gmCurrent);
}
void StartSinglePlayerQuickLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_SINGLE_PLAYER;
gmCurrent.gm_mgTitle.mg_strText = TRANS("QUICK LOAD");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory.PrintF("SaveGame\\Player%d\\Quick\\", _pGame->gm_iSinglePlayer);
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSLoadSinglePlayer;
SetQuickLoadNotes();
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartSinglePlayerLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_SINGLE_PLAYER;
gmCurrent.gm_mgTitle.mg_strText = TRANS("LOAD");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory.PrintF("SaveGame\\Player%d\\", _pGame->gm_iSinglePlayer);
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSLoadSinglePlayer;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartSinglePlayerSaveMenu(void)
{
if (_gmRunningGameMode != GM_SINGLE_PLAYER) return;
// if no live players
if (_pGame->GetPlayersCount()>0 && _pGame->GetLivePlayersCount() <= 0) {
// do nothing
return;
}
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_SINGLE_PLAYER;
gmCurrent.gm_mgTitle.mg_strText = TRANS("SAVE");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = TRUE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory.PrintF("SaveGame\\Player%d\\", _pGame->gm_iSinglePlayer);
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmBaseName = CTString("SaveGame");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSSaveAnyGame;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_strSaveDes = _pGame->GetDefaultGameDescription(TRUE);
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartDemoLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_DEMO;
gmCurrent.gm_mgTitle.mg_strText = TRANS("PLAY DEMO");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("Demos\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".dem");
gmCurrent.gm_pAfterFileChosen = &LSLoadDemo;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartDemoSaveMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
if (_gmRunningGameMode == GM_NONE) return;
_gmMenuGameMode = GM_DEMO;
gmCurrent.gm_mgTitle.mg_strText = TRANS("RECORD DEMO");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEUP;
gmCurrent.gm_bSave = TRUE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("Demos\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmBaseName = CTString("Demo");
gmCurrent.gm_fnmExt = CTString(".dem");
gmCurrent.gm_pAfterFileChosen = &LSSaveDemo;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_strSaveDes = _pGame->GetDefaultGameDescription(FALSE);
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartNetworkQuickLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_NETWORK;
gmCurrent.gm_mgTitle.mg_strText = TRANS("QUICK LOAD");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("SaveGame\\Network\\Quick\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSLoadNetwork;
SetQuickLoadNotes();
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartNetworkLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_NETWORK;
gmCurrent.gm_mgTitle.mg_strText = TRANS("LOAD");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("SaveGame\\Network\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSLoadNetwork;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartNetworkSaveMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
if (_gmRunningGameMode != GM_NETWORK) return;
_gmMenuGameMode = GM_NETWORK;
gmCurrent.gm_mgTitle.mg_strText = TRANS("SAVE");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = TRUE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("SaveGame\\Network\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmBaseName = CTString("SaveGame");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSSaveAnyGame;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_strSaveDes = _pGame->GetDefaultGameDescription(TRUE);
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartSplitScreenQuickLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_SPLIT_SCREEN;
gmCurrent.gm_mgTitle.mg_strText = TRANS("QUICK LOAD");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("SaveGame\\SplitScreen\\Quick\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSLoadSplitScreen;
SetQuickLoadNotes();
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartSplitScreenLoadMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
_gmMenuGameMode = GM_SPLIT_SCREEN;
gmCurrent.gm_mgTitle.mg_strText = TRANS("LOAD");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = FALSE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("SaveGame\\SplitScreen\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSLoadSplitScreen;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
void StartSplitScreenSaveMenu(void)
{
CLoadSaveMenu &gmCurrent = _pGUIM->gmLoadSaveMenu;
if (_gmRunningGameMode != GM_SPLIT_SCREEN) return;
_gmMenuGameMode = GM_SPLIT_SCREEN;
gmCurrent.gm_mgTitle.mg_strText = TRANS("SAVE");
gmCurrent.gm_bAllowThumbnails = TRUE;
gmCurrent.gm_iSortType = LSSORT_FILEDN;
gmCurrent.gm_bSave = TRUE;
gmCurrent.gm_bManage = TRUE;
gmCurrent.gm_fnmDirectory = CTString("SaveGame\\SplitScreen\\");
gmCurrent.gm_fnmSelected = CTString("");
gmCurrent.gm_fnmBaseName = CTString("SaveGame");
gmCurrent.gm_fnmExt = CTString(".sav");
gmCurrent.gm_pAfterFileChosen = &LSSaveAnyGame;
gmCurrent.gm_mgNotes.mg_strText = "";
gmCurrent.gm_strSaveDes = _pGame->GetDefaultGameDescription(TRUE);
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
ChangeToMenu(&gmCurrent);
}
// -------- Disabled Menu Calling Function
void DisabledFunction(void)
{
CDisabledMenu &gmCurrent = _pGUIM->gmDisabledFunction;
gmCurrent.gm_pgmParentMenu = pgmCurrentMenu;
gmCurrent.gm_mgButton.mg_strText = TRANS("The feature is not available in this version!");
gmCurrent.gm_mgTitle.mg_strText = TRANS("DISABLED");
ChangeToMenu(&gmCurrent);
}

81
Sources/SeriousSam/GUI/Menus/MenuStarters.h
View File

@ -1,81 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_STARTERS_H
#define SE_INCL_MENU_STARTERS_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
void StartVideoOptionsMenu(void);
void StartAudioOptionsMenu(void);
void StartNetworkMenu(void);
void StartNetworkJoinMenu(void);
void StartNetworkStartMenu(void);
void StartNetworkOpenMenu(void);
void StartSplitScreenMenu(void);
void StartSplitStartMenu(void);
void StartSinglePlayerNewMenuCustom(void);
void StartSinglePlayerNewMenu(void);
void StartSinglePlayerQuickLoadMenu(void);
void StartSinglePlayerLoadMenu(void);
void StartSinglePlayerSaveMenu(void);
void StartDemoLoadMenu(void);
void StartDemoSaveMenu(void);
void StartNetworkQuickLoadMenu(void);
void StartNetworkLoadMenu(void);
void StartNetworkSaveMenu(void);
void StartSplitScreenQuickLoadMenu(void);
void StartSplitScreenLoadMenu(void);
void StartSplitScreenSaveMenu(void);
void StartVarGameOptions(void);
void StartSinglePlayerGameOptions(void);
void StartGameOptionsFromNetwork(void);
void StartGameOptionsFromSplitScreen(void);
void StartRenderingOptionsMenu(void);
void StartCustomizeKeyboardMenu(void);
void StartCustomizeAxisMenu(void);
void StartOptionsMenu(void);
void StartCurrentLoadMenu();
void StartCurrentSaveMenu();
void StartCurrentQuickLoadMenu();
void StartChangePlayerMenuFromOptions(void);
void StartChangePlayerMenuFromSinglePlayer(void);
void StartControlsMenuFromPlayer(void);
void StartControlsMenuFromOptions(void);
void StartSelectLevelFromSingle(void);
void StartHighScoreMenu(void);
void StartSelectPlayersMenuFromSplit(void);
void StartSelectPlayersMenuFromNetwork(void);
void StartSelectPlayersMenuFromOpen(void);
void StartSelectPlayersMenuFromServers(void);
void StartSelectServerLAN(void);
void StartSelectServerNET(void);
void StartSelectLevelFromSplit(void);
void StartSelectLevelFromNetwork(void);
void StartSelectPlayersMenuFromSplitScreen(void);
void StartSelectPlayersMenuFromNetworkLoad(void);
void StartSelectPlayersMenuFromSplitScreenLoad(void);
void StartPlayerModelLoadMenu(void);
void StartControlsLoadMenu(void);
void StartCustomLoadMenu(void);
void StartAddonsLoadMenu(void);
void StartModsLoadMenu(void);
void StartNetworkSettingsMenu(void);
void StartSinglePlayerMenu(void);
void DisabledFunction(void);
#endif /* include-once check. */

230
Sources/SeriousSam/GUI/Menus/MenuStartersAF.cpp
View File

@ -1,230 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
/* This file contains additional functions called from starters. */
#include "SeriousSam/StdH.h"
#include <Engine/Build.h>
#include "MenuManager.h"
#include "MenuStartersAF.h"
#include "MenuStarters.h"
#include "MenuStuff.h"
static CTFileName _fnDemoToPlay;
static CTFileName _fnGameToLoad;
extern CTString sam_strNetworkSettings;
extern CTFileName _fnmModSelected;
extern CTString _strModURLSelected;
extern CTString _strModServerSelected;
BOOL LSLoadSinglePlayer(const CTFileName &fnm)
{
_pGame->gm_StartSplitScreenCfg = CGame::SSC_PLAY1;
_pGame->gm_aiStartLocalPlayers[0] = _pGame->gm_iSinglePlayer;
_pGame->gm_aiStartLocalPlayers[1] = -1;
_pGame->gm_aiStartLocalPlayers[2] = -1;
_pGame->gm_aiStartLocalPlayers[3] = -1;
_pGame->gm_strNetworkProvider = "Local";
if (_pGame->LoadGame(fnm)) {
StopMenus();
_gmRunningGameMode = GM_SINGLE_PLAYER;
}
else {
_gmRunningGameMode = GM_NONE;
}
return TRUE;
}
BOOL LSLoadNetwork(const CTFileName &fnm)
{
// call local players menu
_fnGameToLoad = fnm;
StartSelectPlayersMenuFromNetworkLoad();
return TRUE;
}
BOOL LSLoadSplitScreen(const CTFileName &fnm)
{
// call local players menu
_fnGameToLoad = fnm;
StartSelectPlayersMenuFromSplitScreenLoad();
return TRUE;
}
void StartDemoPlay(void)
{
_pGame->gm_StartSplitScreenCfg = CGame::SSC_OBSERVER;
// play the demo
_pGame->gm_strNetworkProvider = "Local";
if (_pGame->StartDemoPlay(_fnDemoToPlay))
{
// exit menu and pull up the console
StopMenus();
if (_pGame->gm_csConsoleState != CS_OFF) _pGame->gm_csConsoleState = CS_TURNINGOFF;
_gmRunningGameMode = GM_DEMO;
}
else {
_gmRunningGameMode = GM_NONE;
}
}
extern BOOL LSLoadDemo(const CTFileName &fnm)
{
// call local players menu
_fnDemoToPlay = fnm;
StartDemoPlay();
return TRUE;
}
BOOL LSLoadPlayerModel(const CTFileName &fnm)
{
// get base filename
CTString strBaseName = fnm.FileName();
// set it for current player
CPlayerCharacter &pc = _pGame->gm_apcPlayers[*_pGUIM->gmPlayerProfile.gm_piCurrentPlayer];
CPlayerSettings *pps = (CPlayerSettings *)pc.pc_aubAppearance;
memset(pps->ps_achModelFile, 0, sizeof(pps->ps_achModelFile));
strncpy(pps->ps_achModelFile, strBaseName, sizeof(pps->ps_achModelFile));
void MenuGoToParent(void);
MenuGoToParent();
return TRUE;
}
BOOL LSLoadControls(const CTFileName &fnm)
{
try {
ControlsMenuOn();
_pGame->gm_ctrlControlsExtra->Load_t(fnm);
ControlsMenuOff();
}
catch (char *strError) {
CPrintF("%s", strError);
}
void MenuGoToParent(void);
MenuGoToParent();
return TRUE;
}
BOOL LSLoadAddon(const CTFileName &fnm)
{
extern INDEX _iAddonExecState;
extern CTFileName _fnmAddonToExec;
_iAddonExecState = 1;
_fnmAddonToExec = fnm;
return TRUE;
}
BOOL LSLoadMod(const CTFileName &fnm)
{
_fnmModSelected = fnm;
extern void ModConfirm(void);
ModConfirm();
return TRUE;
}
BOOL LSLoadCustom(const CTFileName &fnm)
{
_pGUIM->gmVarMenu.gm_mgTitle.mg_strText = TRANS("ADVANCED OPTIONS");
// LoadStringVar(fnm.NoExt()+".des", mgVarTitle.mg_strText);
// mgVarTitle.mg_strText.OnlyFirstLine();
_pGUIM->gmVarMenu.gm_fnmMenuCFG = fnm;
_pGUIM->gmVarMenu.gm_pgmParentMenu = &_pGUIM->gmLoadSaveMenu;
ChangeToMenu(&_pGUIM->gmVarMenu);
return TRUE;
}
BOOL LSLoadNetSettings(const CTFileName &fnm)
{
sam_strNetworkSettings = fnm;
CTString strCmd;
strCmd.PrintF("include \"%s\"", (const char*)sam_strNetworkSettings);
_pShell->Execute(strCmd);
void MenuGoToParent(void);
MenuGoToParent();
return TRUE;
}
// same function for saving in singleplay, network and splitscreen
BOOL LSSaveAnyGame(const CTFileName &fnm)
{
if (_pGame->SaveGame(fnm)) {
StopMenus();
return TRUE;
}
else {
return FALSE;
}
}
BOOL LSSaveDemo(const CTFileName &fnm)
{
// save the demo
if (_pGame->StartDemoRec(fnm)) {
StopMenus();
return TRUE;
}
else {
return FALSE;
}
}
void StartNetworkLoadGame(void)
{
// _pGame->gm_MenuSplitScreenCfg = (enum CGame::SplitScreenCfg) mgSplitScreenCfg.mg_iSelected;
_pGame->gm_StartSplitScreenCfg = _pGame->gm_MenuSplitScreenCfg;
_pGame->gm_aiStartLocalPlayers[0] = _pGame->gm_aiMenuLocalPlayers[0];
_pGame->gm_aiStartLocalPlayers[1] = _pGame->gm_aiMenuLocalPlayers[1];
_pGame->gm_aiStartLocalPlayers[2] = _pGame->gm_aiMenuLocalPlayers[2];
_pGame->gm_aiStartLocalPlayers[3] = _pGame->gm_aiMenuLocalPlayers[3];
_pGame->gm_strNetworkProvider = "TCP/IP Server";
if (_pGame->LoadGame(_fnGameToLoad))
{
StopMenus();
_gmRunningGameMode = GM_NETWORK;
}
else {
_gmRunningGameMode = GM_NONE;
}
}
void StartSplitScreenGameLoad(void)
{
// _pGame->gm_MenuSplitScreenCfg = (enum CGame::SplitScreenCfg) mgSplitScreenCfg.mg_iSelected;
_pGame->gm_StartSplitScreenCfg = _pGame->gm_MenuSplitScreenCfg;
_pGame->gm_aiStartLocalPlayers[0] = _pGame->gm_aiMenuLocalPlayers[0];
_pGame->gm_aiStartLocalPlayers[1] = _pGame->gm_aiMenuLocalPlayers[1];
_pGame->gm_aiStartLocalPlayers[2] = _pGame->gm_aiMenuLocalPlayers[2];
_pGame->gm_aiStartLocalPlayers[3] = _pGame->gm_aiMenuLocalPlayers[3];
_pGame->gm_strNetworkProvider = "Local";
if (_pGame->LoadGame(_fnGameToLoad)) {
StopMenus();
_gmRunningGameMode = GM_SPLIT_SCREEN;
}
else {
_gmRunningGameMode = GM_NONE;
}
}

39
Sources/SeriousSam/GUI/Menus/MenuStartersAF.h
View File

@ -1,39 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_STARTERSAF_H
#define SE_INCL_MENU_STARTERSAF_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
BOOL LSLoadSinglePlayer(const CTFileName &fnm);
BOOL LSLoadNetwork(const CTFileName &fnm);
BOOL LSLoadSplitScreen(const CTFileName &fnm);
BOOL LSLoadDemo(const CTFileName &fnm);
BOOL LSLoadPlayerModel(const CTFileName &fnm);
BOOL LSLoadControls(const CTFileName &fnm);
BOOL LSLoadAddon(const CTFileName &fnm);
BOOL LSLoadMod(const CTFileName &fnm);
BOOL LSLoadCustom(const CTFileName &fnm);
BOOL LSLoadNetSettings(const CTFileName &fnm);
BOOL LSSaveAnyGame(const CTFileName &fnm);
BOOL LSSaveDemo(const CTFileName &fnm);
void StartDemoPlay(void);
void StartNetworkLoadGame(void);
void StartSplitScreenGameLoad(void);
#endif /* include-once check. */

314
Sources/SeriousSam/GUI/Menus/MenuStuff.cpp
View File

@ -1,314 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include "SeriousSam/StdH.h"
#include <Engine/Build.h>
#include "MenuStuff.h"
#define RADIOTRANS(str) ("ETRS" str)
CTString astrNoYes[] = {
RADIOTRANS("No"),
RADIOTRANS("Yes"),
};
CTString astrComputerInvoke[] = {
RADIOTRANS("Use"),
RADIOTRANS("Double-click use"),
};
CTString astrWeapon[] = {
RADIOTRANS("Only if new"),
RADIOTRANS("Never"),
RADIOTRANS("Always"),
RADIOTRANS("Only if stronger"),
};
PIX apixWidths[][2] = {
320, 240,
400, 300,
512, 384,
640, 240,
640, 480,
720, 540,
800, 300,
800, 600,
960, 720,
1024, 384,
1024, 768,
1152, 864,
1280, 480,
1280, 960,
1600, 600,
1600, 1200,
1920, 720,
1920, 1440,
2048, 786,
2048, 1536,
};
CTString astrCrosshair[] = {
"",
"Textures\\Interface\\Crosshairs\\Crosshair1.tex",
"Textures\\Interface\\Crosshairs\\Crosshair2.tex",
"Textures\\Interface\\Crosshairs\\Crosshair3.tex",
"Textures\\Interface\\Crosshairs\\Crosshair4.tex",
"Textures\\Interface\\Crosshairs\\Crosshair5.tex",
"Textures\\Interface\\Crosshairs\\Crosshair6.tex",
"Textures\\Interface\\Crosshairs\\Crosshair7.tex",
};
CTString astrMaxPlayersRadioTexts[] = {
RADIOTRANS("2"),
RADIOTRANS("3"),
RADIOTRANS("4"),
RADIOTRANS("5"),
RADIOTRANS("6"),
RADIOTRANS("7"),
RADIOTRANS("8"),
RADIOTRANS("9"),
RADIOTRANS("10"),
RADIOTRANS("11"),
RADIOTRANS("12"),
RADIOTRANS("13"),
RADIOTRANS("14"),
RADIOTRANS("15"),
RADIOTRANS("16"),
};
// here, we just reserve space for up to 16 different game types
// actual names are added later
CTString astrGameTypeRadioTexts[] = {
"", "", "", "", "",
"", "", "", "", "",
"", "", "", "", "",
"", "", "", "", "",
};
INDEX ctGameTypeRadioTexts = 1;
CTString astrDifficultyRadioTexts[] = {
RADIOTRANS("Tourist"),
RADIOTRANS("Easy"),
RADIOTRANS("Normal"),
RADIOTRANS("Hard"),
RADIOTRANS("Serious"),
RADIOTRANS("Mental"),
};
CTString astrSplitScreenRadioTexts[] = {
RADIOTRANS("1"),
RADIOTRANS("2 - split screen"),
RADIOTRANS("3 - split screen"),
RADIOTRANS("4 - split screen"),
};
CTString astrDisplayPrefsRadioTexts[] = {
RADIOTRANS("Speed"),
RADIOTRANS("Normal"),
RADIOTRANS("Quality"),
RADIOTRANS("Custom"),
};
CTString astrDisplayAPIRadioTexts[] = {
RADIOTRANS("OpenGL"),
#ifdef SE1_D3D
RADIOTRANS("Direct3D"),
#endif
};
CTString astrBitsPerPixelRadioTexts[] = {
RADIOTRANS("Desktop"),
RADIOTRANS("16 BPP"),
RADIOTRANS("32 BPP"),
};
CTString astrFrequencyRadioTexts[] = {
RADIOTRANS("No sound"),
RADIOTRANS("11kHz"),
RADIOTRANS("22kHz"),
RADIOTRANS("44kHz"),
};
CTString astrSoundAPIRadioTexts[] = {
#ifdef PLATFORM_WIN32
RADIOTRANS("WaveOut"),
RADIOTRANS("DirectSound"),
RADIOTRANS("EAX"),
#else
RADIOTRANS("Simple Directmedia Layer"),
#endif
};
ULONG GetSpawnFlagsForGameType(INDEX iGameType)
{
if (iGameType == -1) return SPF_SINGLEPLAYER;
// get function that will provide us the flags
CShellSymbol *pss = _pShell->GetSymbol("GetSpawnFlagsForGameTypeSS", /*bDeclaredOnly=*/ TRUE);
// if none
if (pss == NULL) {
// error
ASSERT(FALSE);
return 0;
}
ULONG(*pFunc)(INDEX) = (ULONG(*)(INDEX))pss->ss_pvValue;
return pFunc(iGameType);
}
BOOL IsMenuEnabled(const CTString &strMenuName)
{
// get function that will provide us the flags
CShellSymbol *pss = _pShell->GetSymbol("IsMenuEnabledSS", /*bDeclaredOnly=*/ TRUE);
// if none
if (pss == NULL) {
// error
ASSERT(FALSE);
return TRUE;
}
BOOL(*pFunc)(const CTString &) = (BOOL(*)(const CTString &))pss->ss_pvValue;
return pFunc(strMenuName);
}
// initialize game type strings table
void InitGameTypes(void)
{
// get function that will provide us the info about gametype
CShellSymbol *pss = _pShell->GetSymbol("GetGameTypeNameSS", /*bDeclaredOnly=*/ TRUE);
// if none
if (pss == NULL) {
// error
astrGameTypeRadioTexts[0] = "<\?\?\?>";
ctGameTypeRadioTexts = 1;
return;
}
// for each mode
for (ctGameTypeRadioTexts = 0; ctGameTypeRadioTexts<ARRAYCOUNT(astrGameTypeRadioTexts); ctGameTypeRadioTexts++) {
// get the text
CTString(*pFunc)(INDEX) = (CTString(*)(INDEX))pss->ss_pvValue;
CTString strMode = pFunc(ctGameTypeRadioTexts);
// if no mode modes
if (strMode == "") {
// stop
break;
}
// add that mode
astrGameTypeRadioTexts[ctGameTypeRadioTexts] = strMode;
}
}
int qsort_CompareFileInfos_NameUp(const void *elem1, const void *elem2)
{
const CFileInfo &fi1 = **(CFileInfo **)elem1;
const CFileInfo &fi2 = **(CFileInfo **)elem2;
return strcmp(fi1.fi_strName, fi2.fi_strName);
}
int qsort_CompareFileInfos_NameDn(const void *elem1, const void *elem2)
{
const CFileInfo &fi1 = **(CFileInfo **)elem1;
const CFileInfo &fi2 = **(CFileInfo **)elem2;
return -strcmp(fi1.fi_strName, fi2.fi_strName);
}
int qsort_CompareFileInfos_FileUp(const void *elem1, const void *elem2)
{
const CFileInfo &fi1 = **(CFileInfo **)elem1;
const CFileInfo &fi2 = **(CFileInfo **)elem2;
return strcmp(fi1.fi_fnFile, fi2.fi_fnFile);
}
int qsort_CompareFileInfos_FileDn(const void *elem1, const void *elem2)
{
const CFileInfo &fi1 = **(CFileInfo **)elem1;
const CFileInfo &fi2 = **(CFileInfo **)elem2;
return -strcmp(fi1.fi_fnFile, fi2.fi_fnFile);
}
INDEX APIToSwitch(enum GfxAPIType gat)
{
switch (gat) {
case GAT_OGL: return 0;
#ifdef SE1_D3D
case GAT_D3D: return 1;
#endif // SE1_D3D
default: ASSERT(FALSE); return 0;
}
}
enum GfxAPIType SwitchToAPI(INDEX i)
{
switch (i) {
case 0: return GAT_OGL;
#ifdef SE1_D3D
case 1: return GAT_D3D;
#endif // SE1_D3D
default: ASSERT(FALSE); return GAT_OGL;
}
}
INDEX DepthToSwitch(enum DisplayDepth dd)
{
switch (dd) {
case DD_DEFAULT: return 0;
case DD_16BIT: return 1;
case DD_32BIT: return 2;
default: ASSERT(FALSE); return 0;
}
}
enum DisplayDepth SwitchToDepth(INDEX i)
{
switch (i) {
case 0: return DD_DEFAULT;
case 1: return DD_16BIT;
case 2: return DD_32BIT;
default: ASSERT(FALSE); return DD_DEFAULT;
}
}
// controls that are currently customized
CTFileName _fnmControlsToCustomize = CTString("");
void ControlsMenuOn()
{
_pGame->SavePlayersAndControls();
try {
_pGame->gm_ctrlControlsExtra->Load_t(_fnmControlsToCustomize);
}
catch (char *strError) {
WarningMessage(strError);
}
}
void ControlsMenuOff()
{
try {
if (_pGame->gm_ctrlControlsExtra->ctrl_lhButtonActions.Count()>0) {
_pGame->gm_ctrlControlsExtra->Save_t(_fnmControlsToCustomize);
}
}
catch (char *strError) {
FatalError(strError);
}
_pGame->gm_ctrlControlsExtra->DeleteAllButtonActions();
_pGame->LoadPlayersAndControls();
}

84
Sources/SeriousSam/GUI/Menus/MenuStuff.h
View File

@ -1,84 +0,0 @@
/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_MENU_STUFF_H
#define SE_INCL_MENU_STUFF_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include "SeriousSam/FileInfo.h"
#define TRIGGER_MG(mg, y, up, down, text, astr) \
mg.mg_pmgUp = &up; \
mg.mg_pmgDown = &down; \
mg.mg_boxOnScreen = BoxMediumRow(y); \
gm_lhGadgets.AddTail(mg.mg_lnNode); \
mg.mg_astrTexts = astr; \
mg.mg_ctTexts = sizeof(astr) / sizeof(astr[0]); \
mg.mg_iSelected = 0; \
mg.mg_strLabel = text; \
mg.mg_strValue = astr[0];
extern INDEX ctGameTypeRadioTexts;
extern CTString astrNoYes[2];
extern CTString astrWeapon[4];
extern CTString astrComputerInvoke[2];
extern CTString astrCrosshair[8];
extern CTString astrMaxPlayersRadioTexts[15];
extern CTString astrGameTypeRadioTexts[20];
extern CTString astrDifficultyRadioTexts[6];
extern CTString astrSplitScreenRadioTexts[4];
extern CTString astrDisplayPrefsRadioTexts[4];
// !!! FIXME: this sucks
#ifdef SE1_D3D
extern CTString astrDisplayAPIRadioTexts[2];
#else
extern CTString astrDisplayAPIRadioTexts[1];
#endif
extern CTString astrBitsPerPixelRadioTexts[3];
extern CTString astrFrequencyRadioTexts[4];
// !!! FIXME: this sucks
#if PLATFORM_WIN32
extern CTString astrSoundAPIRadioTexts[3];
#else
extern CTString astrSoundAPIRadioTexts[1];
#endif
extern PIX apixWidths[20][2];
ULONG GetSpawnFlagsForGameType(INDEX iGameType);
BOOL IsMenuEnabled(const CTString &strMenuName);
void InitGameTypes(void);
int qsort_CompareFileInfos_NameUp(const void *elem1, const void *elem2);
int qsort_CompareFileInfos_NameDn(const void *elem1, const void *elem2);
int qsort_CompareFileInfos_FileUp(const void *elem1, const void *elem2);
int qsort_CompareFileInfos_FileDn(const void *elem1, const void *elem2);
INDEX APIToSwitch(enum GfxAPIType gat);
enum GfxAPIType SwitchToAPI(INDEX i);
INDEX DepthToSwitch(enum DisplayDepth dd);
enum DisplayDepth SwitchToDepth(INDEX i);
void ControlsMenuOn();
void ControlsMenuOff();
#endif /* include-once check. */

6151
Sources/SeriousSam/Menu.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

306
Sources/SeriousSam/Menu.h Normal file
View File

@ -0,0 +1,306 @@
/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
// set new thumbnail
void SetThumbnail(CTFileName fn);
// remove thumbnail
void ClearThumbnail(void);
void InitializeMenus( void);
void DestroyMenus( void);
void MenuOnKeyDown( int iVKey);
void MenuOnChar(MSG msg);
void MenuOnMouseMove(PIX pixI, PIX pixJ);
void MenuOnLMBDown(void);
BOOL DoMenu( CDrawPort *pdp); // returns TRUE if still active, FALSE if should quit
void StartMenus( char *str="");
void StopMenus(BOOL bGoToRoot =TRUE);
BOOL IsMenusInRoot(void);
void ChangeToMenu( class CGameMenu *pgmNew);
extern void PlayMenuSound(CSoundData *psd);
#define KEYS_ON_SCREEN 14
#define LEVELS_ON_SCREEN 16
#define SERVERS_ON_SCREEN 15
#define VARS_ON_SCREEN 14
extern CListHead _lhServers;
extern class CPlayerProfileMenu gmPlayerProfile;
extern class CSelectPlayersMenu gmSelectPlayersMenu;
extern class CCustomizeAxisMenu gmCustomizeAxisMenu;
extern INDEX _iLocalPlayer;
enum GameMode {
GM_NONE = 0,
GM_SINGLE_PLAYER,
GM_NETWORK,
GM_SPLIT_SCREEN,
GM_DEMO,
GM_INTRO,
};
extern GameMode _gmMenuGameMode;
extern GameMode _gmRunningGameMode;
extern CGameMenu *pgmCurrentMenu;
class CGameMenu {
public:
CListHead gm_lhGadgets;
CGameMenu *gm_pgmParentMenu;
BOOL gm_bPopup;
const char *gm_strName; // menu name (for mod interface only)
class CMenuGadget *gm_pmgSelectedByDefault;
class CMenuGadget *gm_pmgArrowUp;
class CMenuGadget *gm_pmgArrowDn;
class CMenuGadget *gm_pmgListTop;
class CMenuGadget *gm_pmgListBottom;
INDEX gm_iListOffset;
INDEX gm_iListWantedItem; // item you want to focus initially
INDEX gm_ctListVisible;
INDEX gm_ctListTotal;
CGameMenu(void);
void ScrollList(INDEX iDir);
void KillAllFocuses(void);
virtual void Initialize_t(void);
virtual void Destroy(void);
virtual void StartMenu(void);
virtual void FillListItems(void);
virtual void EndMenu(void);
// return TRUE if handled
virtual BOOL OnKeyDown( int iVKey);
virtual BOOL OnChar(MSG msg);
virtual void Think(void);
};
class CConfirmMenu : public CGameMenu {
public:
void Initialize_t(void);
// return TRUE if handled
BOOL OnKeyDown( int iVKey);
void BeLarge(void);
void BeSmall(void);
};
class CMainMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
};
class CInGameMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
};
class CSinglePlayerMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
};
class CCreditsMenu : public CGameMenu {
public:
void Initialize_t(void);
};
class CDisabledMenu : public CGameMenu {
public:
void Initialize_t(void);
};
class CSinglePlayerNewMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
};
class CLevelsMenu : public CGameMenu {
public:
void Initialize_t(void);
void FillListItems(void);
void StartMenu(void);
};
class CVarMenu : public CGameMenu {
public:
CTFileName gm_fnmMenuCFG;
void Initialize_t(void);
void FillListItems(void);
void StartMenu(void);
void EndMenu(void);
void Think(void);
};
class CServersMenu : public CGameMenu {
public:
BOOL m_bInternet;
void Initialize_t(void);
void StartMenu(void);
void Think(void);
};
class CPlayerProfileMenu : public CGameMenu {
public:
INDEX *gm_piCurrentPlayer;
void Initialize_t(void);
INDEX ComboFromPlayer(INDEX iPlayer);
INDEX PlayerFromCombo(INDEX iCombo);
void SelectPlayer(INDEX iPlayer);
void ApplyComboPlayer(INDEX iPlayer);
void StartMenu(void);
void EndMenu(void);
};
class CControlsMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void ObtainActionSettings(void);
void ApplyActionSettings(void);
};
class CFileInfo {
public:
CListNode fi_lnNode;
CTFileName fi_fnFile;
CTString fi_strName;
};
class CLoadSaveMenu : public CGameMenu {
public:
// settings adjusted before starting the menu
CGameMenu *gm_pgmNextMenu; // menu to go to after selecting a file (if null, use parent menu)
CTFileName gm_fnmSelected; // file that is selected initially
CTFileName gm_fnmDirectory; // directory that should be read
CTFileName gm_fnmBaseName; // base file name for saving (numbers are auto-added)
CTFileName gm_fnmExt; // accepted file extension
BOOL gm_bSave; // set when chosing file for saving
BOOL gm_bManage; // set if managing (rename/delet is enabled)
CTString gm_strSaveDes; // default description (if saving)
BOOL gm_bAllowThumbnails; // set when chosing file for saving
BOOL gm_bNoEscape; // forbid exiting with escape/rmb
#define LSSORT_NONE 0
#define LSSORT_NAMEUP 1
#define LSSORT_NAMEDN 2
#define LSSORT_FILEUP 3
#define LSSORT_FILEDN 4
INDEX gm_iSortType; // sort type
// function to activate when file is chosen
// return true if saving succeeded - description is saved automatically
// always return true for loading
BOOL (*gm_pAfterFileChosen)(const CTFileName &fnm);
// internal properties
CListHead gm_lhFileInfos; // all file infos to list
INDEX gm_iLastFile; // index of last saved file in numbered format
// called to get info of a file from directory, or to skip it
BOOL ParseFile(const CTFileName &fnm, CTString &strName);
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void FillListItems(void);
};
extern CLoadSaveMenu gmLoadSaveMenu;
class CHighScoreMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
};
class CNetworkMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
};
class CNetworkStartMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
class CNetworkOpenMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
class CNetworkJoinMenu : public CGameMenu {
public:
void Initialize_t(void);
};
class CSplitScreenMenu: public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
};
class CSplitStartMenu: public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
class CSelectPlayersMenu: public CGameMenu {
public:
BOOL gm_bAllowDedicated;
BOOL gm_bAllowObserving;
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
};
class COptionsMenu : public CGameMenu {
public:
void Initialize_t(void);
};
class CVideoOptionsMenu : public CGameMenu {
public:
void StartMenu(void);
void Initialize_t(void);
};
class CRenderingOptionsMenu : public CGameMenu {
public:
void StartMenu(void);
void EndMenu(void);
void Initialize_t(void);
};
class CAudioOptionsMenu : public CGameMenu {
public:
void StartMenu(void);
void Initialize_t(void);
};
class CCustomizeKeyboardMenu : public CGameMenu {
public:
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void FillListItems(void);
};
class CCustomizeAxisMenu : public CGameMenu {
public:
~CCustomizeAxisMenu(void);
void Initialize_t(void);
void StartMenu(void);
void EndMenu(void);
void ObtainActionSettings(void);
void ApplyActionSettings(void);
};

1915
Sources/SeriousSam/MenuGadgets.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More