OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

- everything compiles again, now to make it work again with all menu widgets 100% scripted.

Browse source
This commit is contained in:
Christoph Oelckers 2017-02-12 01:18:49 +01:00
commit ee1217c8c7
10 changed files with 636 additions and 1525 deletions
Download patch file Download diff file Expand all files Collapse all files

305
src/menu/listmenu.cpp
View file

@ -279,308 +279,3 @@ void DListMenu::Drawer ()
//
//=============================================================================
IMPLEMENT_CLASS(DMenuItemBase, true, false)
bool DMenuItemBase::CheckCoordinate(int x, int y)
{
return false;
}
void DMenuItemBase::Ticker()
{
}
void DMenuItemBase::Drawer(bool selected)
{
}
bool DMenuItemBase::Selectable()
{
return false;
}
void DMenuItemBase::DrawSelector(int xofs, int yofs, FTextureID tex)
{
if (tex.isNull())
{
if ((DMenu::MenuTime%8) < 6)
{
screen->DrawText(ConFont, OptionSettings.mFontColorSelection,
(mXpos + xofs - 160) * CleanXfac + screen->GetWidth() / 2,
(mYpos + yofs - 100) * CleanYfac + screen->GetHeight() / 2,
"\xd",
DTA_CellX, 8 * CleanXfac,
DTA_CellY, 8 * CleanYfac,
TAG_DONE);
}
}
else
{
screen->DrawTexture (TexMan(tex), mXpos + xofs, mYpos + yofs, DTA_Clean, true, TAG_DONE);
}
}
bool DMenuItemBase::Activate()
{
return false; // cannot be activated
}
FName DMenuItemBase::GetAction(int *pparam)
{
return mAction;
}
bool DMenuItemBase::SetString(int i, const char *s)
{
return false;
}
bool DMenuItemBase::GetString(int i, char *s, int len)
{
return false;
}
bool DMenuItemBase::SetValue(int i, int value)
{
return false;
}
bool DMenuItemBase::GetValue(int i, int *pvalue)
{
return false;
}
void DMenuItemBase::Enable(bool on)
{
mEnabled = on;
}
bool DMenuItemBase::MenuEvent(int mkey, bool fromcontroller)
{
return false;
}
DEFINE_ACTION_FUNCTION(DMenuItemBase, MenuEvent)
{
PARAM_SELF_PROLOGUE(DMenuItemBase);
PARAM_INT(key);
PARAM_BOOL(fromcontroller);
ACTION_RETURN_BOOL(self->MenuEvent(key, fromcontroller));
}
bool DMenuItemBase::MouseEvent(int type, int x, int y)
{
return false;
}
bool DMenuItemBase::CheckHotkey(int c)
{
return false;
}
int DMenuItemBase::GetWidth()
{
return 0;
}
//=============================================================================
//
// static patch
//
//=============================================================================
IMPLEMENT_CLASS(DListMenuItemStaticPatch_, false, false)
DListMenuItemStaticPatch_::DListMenuItemStaticPatch_(int x, int y, FTextureID patch, bool centered)
: DMenuItemBase(x, y)
{
mTexture = patch;
mCentered = centered;
}
void DListMenuItemStaticPatch_::Drawer(bool selected)
{
if (!mTexture.Exists())
{
return;
}
int x = mXpos;
FTexture *tex = TexMan(mTexture);
if (mYpos >= 0)
{
if (mCentered) x -= tex->GetScaledWidth()/2;
screen->DrawTexture (tex, x, mYpos, DTA_Clean, true, TAG_DONE);
}
else
{
int x = (mXpos - 160) * CleanXfac + (SCREENWIDTH>>1);
if (mCentered) x -= (tex->GetScaledWidth()*CleanXfac)/2;
screen->DrawTexture (tex, x, -mYpos*CleanYfac, DTA_CleanNoMove, true, TAG_DONE);
}
}
//=============================================================================
//
// static text
//
//=============================================================================
IMPLEMENT_CLASS(DListMenuItemStaticText_, false, false)
DListMenuItemStaticText_::DListMenuItemStaticText_(int x, int y, const char *text, FFont *font, EColorRange color, bool centered)
: DMenuItemBase(x, y)
{
mText = text;
mFont = font;
mColor = color;
mCentered = centered;
}
void DListMenuItemStaticText_::Drawer(bool selected)
{
if (mText.IsNotEmpty())
{
const char *text = mText;
if (*text == '$') text = GStrings(text+1);
if (mYpos >= 0)
{
int x = mXpos;
if (mCentered) x -= mFont->StringWidth(text)/2;
screen->DrawText(mFont, mColor, x, mYpos, text, DTA_Clean, true, TAG_DONE);
}
else
{
int x = (mXpos - 160) * CleanXfac + (SCREENWIDTH>>1);
if (mCentered) x -= (mFont->StringWidth(text)*CleanXfac)/2;
screen->DrawText (mFont, mColor, x, -mYpos*CleanYfac, text, DTA_CleanNoMove, true, TAG_DONE);
}
}
}
//=============================================================================
//
// base class for selectable items
//
//=============================================================================
IMPLEMENT_CLASS(DListMenuItemSelectable_, false, false)
DListMenuItemSelectable_::DListMenuItemSelectable_(int x, int y, int height, FName action, int param)
: DMenuItemBase(x, y, action)
{
mHeight = height;
mParam = param;
mHotkey = 0;
}
bool DListMenuItemSelectable_::CheckCoordinate(int x, int y)
{
return mEnabled && y >= mYpos && y < mYpos + mHeight; // no x check here
}
bool DListMenuItemSelectable_::Selectable()
{
return mEnabled;
}
bool DListMenuItemSelectable_::Activate()
{
M_SetMenu(mAction, mParam);
return true;
}
FName DListMenuItemSelectable_::GetAction(int *pparam)
{
if (pparam != NULL) *pparam = mParam;
return mAction;
}
bool DListMenuItemSelectable_::CheckHotkey(int c)
{
return c == tolower(mHotkey);
}
bool DListMenuItemSelectable_::MouseEvent(int type, int x, int y)
{
if (type == DMenu::MOUSE_Release)
{
if (NULL != DMenu::CurrentMenu && DMenu::CurrentMenu->MenuEvent(MKEY_Enter, true))
{
return true;
}
}
return false;
}
//=============================================================================
//
// text item
//
//=============================================================================
IMPLEMENT_CLASS(DListMenuItemText_, false, false)
DListMenuItemText_::DListMenuItemText_(int x, int y, int height, int hotkey, const char *text, FFont *font, EColorRange color, EColorRange color2, FName child, int param)
: DListMenuItemSelectable_(x, y, height, child, param)
{
mText = ncopystring(text);
mFont = font;
mColor = color;
mColorSelected = color2;
mHotkey = hotkey;
}
void DListMenuItemText_::OnDestroy()
{
if (mText != NULL)
{
delete [] mText;
}
}
void DListMenuItemText_::Drawer(bool selected)
{
const char *text = mText;
if (text != NULL)
{
if (*text == '$') text = GStrings(text+1);
screen->DrawText(mFont, selected ? mColorSelected : mColor, mXpos, mYpos, text, DTA_Clean, true, TAG_DONE);
}
}
int DListMenuItemText_::GetWidth()
{
const char *text = mText;
if (text != NULL)
{
if (*text == '$') text = GStrings(text+1);
return mFont->StringWidth(text);
}
return 1;
}
//=============================================================================
//
// patch item
//
//=============================================================================
IMPLEMENT_CLASS(DListMenuItemPatch_, false, false)
DListMenuItemPatch_::DListMenuItemPatch_(int x, int y, int height, int hotkey, FTextureID patch, FName child, int param)
: DListMenuItemSelectable_(x, y, height, child, param)
{
mHotkey = hotkey;
mTexture = patch;
}
void DListMenuItemPatch_::Drawer(bool selected)
{
screen->DrawTexture (TexMan(mTexture), mXpos, mYpos, DTA_Clean, true, TAG_DONE);
}
int DListMenuItemPatch_::GetWidth()
{
return mTexture.isValid()
? TexMan[mTexture]->GetScaledWidth()
: 0;
}

385
src/menu/menu.cpp
View file

@ -1150,16 +1150,377 @@ DEFINE_FIELD(FOptionMenuSettings, mLinespacing)
struct IJoystickConfig;
DMenuItemBase * CreateOptionMenuItemStaticText(const char *name, bool v);
DMenuItemBase * CreateOptionMenuSliderVar(const char *name, int index, double min, double max, double step, int showval);
DMenuItemBase * CreateOptionMenuItemCommand(const char * label, FName cmd);
DMenuItemBase * CreateOptionMenuItemOption(const char * label, FName cmd, FName values, FBaseCVar *graycheck, bool center);
DMenuItemBase * CreateOptionMenuItemJoyConfigMenu(const char *label, IJoystickConfig *joy);
DMenuItemBase * CreateOptionMenuItemJoyMap(const char *label, int axis, FName values, bool center);
DMenuItemBase * CreateOptionMenuSliderJoySensitivity(const char * label, double min, double max, double step, int showval);
DMenuItemBase * CreateOptionMenuSliderJoyScale(const char *label, int axis, double min, double max, double step, int showval);
DMenuItemBase * CreateOptionMenuItemInverter(const char *label, int axis, int center);
DMenuItemBase * CreateOptionMenuSliderJoyDeadZone(const char *label, int axis, double min, double max, double step, int showval);
DMenuItemBase * CreateOptionMenuItemStaticText(const char *name, bool v)
{
auto c = PClass::FindClass("OptionMenuItemStaticText");
auto p = c->CreateNew();
VMValue params[] = { p, FString(name), v };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuSliderVar(const char *name, int index, double min, double max, double step, int showval)
{
auto c = PClass::FindClass("OptionMenuItemSliderVar");
auto p = c->CreateNew();
VMValue params[] = { p, FString(name), index, min, max, step, showval };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuItemCommand(const char * label, FName cmd)
{
auto c = PClass::FindClass("OptionMenuItemCommand");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), cmd.GetIndex() };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuItemOption(const char * label, FName cmd, FName values, FBaseCVar *graycheck, bool center)
{
auto c = PClass::FindClass("OptionMenuItemOption");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), cmd.GetIndex(), values.GetIndex(), graycheck, center };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuItemJoyConfigMenu(const char *label, IJoystickConfig *joy)
{
auto c = PClass::FindClass("OptionMenuItemJoyConfigMenu");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), joy };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuItemJoyMap(const char *label, int axis, FName values, bool center)
{
auto c = PClass::FindClass("OptionMenuItemJoyMap");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), axis, values.GetIndex(), center };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuSliderJoySensitivity(const char * label, double min, double max, double step, int showval)
{
auto c = PClass::FindClass("OptionMenuSliderJoySensitivity");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), min, max, step, showval };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuSliderJoyScale(const char *label, int axis, double min, double max, double step, int showval)
{
auto c = PClass::FindClass("OptionMenuSliderJoyScale");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), min, max, step, showval };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuItemInverter(const char *label, int axis, int center)
{
auto c = PClass::FindClass("OptionMenuItemInverter");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), axis, center };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuSliderJoyDeadZone(const char *label, int axis, double min, double max, double step, int showval)
{
auto c = PClass::FindClass("OptionMenuSliderJoyDeadZone");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), min, max, step, showval };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuItemSubmenu(const char *label, FName cmd, int center)
{
auto c = PClass::FindClass("OptionMenuItemSubmenu");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), cmd.GetIndex(), center };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateOptionMenuItemControl(const char *label, FName cmd, FKeyBindings *bindings)
{
auto c = PClass::FindClass("OptionMenuItemControl");
auto p = c->CreateNew();
VMValue params[] = { p, FString(label), cmd.GetIndex(), bindings };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("Init", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateListMenuItemPatch(int x, int y, int height, int hotkey, FTextureID tex, FName command, int param)
{
auto c = PClass::FindClass("ListMenuItemPatch");
auto p = c->CreateNew();
VMValue params[] = { p, x, y, height, tex.GetIndex(), hotkey, command.GetIndex(), param };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("InitDirect", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
DMenuItemBase * CreateListMenuItemText(int x, int y, int height, int hotkey, const char *text, FFont *font, PalEntry color1, PalEntry color2, FName command, int param)
{
auto c = PClass::FindClass("ListMenuItemText");
auto p = c->CreateNew();
VMValue params[] = { p, x, y, height, hotkey, text, font, int(color1.d), int(color2.d), command.GetIndex(), param };
auto f = dyn_cast<PFunction>(c->Symbols.FindSymbol("InitDirect", false));
GlobalVMStack.Call(f->Variants[0].Implementation, params, countof(params), nullptr, 0);
return (DMenuItemBase*)p;
}
bool DMenuItemBase::CheckCoordinate(int x, int y)
{
IFVIRTUAL(DMenuItemBase, CheckCoordinate)
{
VMValue params[] = { (DObject*)this, x, y };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
void DMenuItemBase::Ticker()
{
IFVIRTUAL(DMenuItemBase, Ticker)
{
VMValue params[] = { (DObject*)this };
GlobalVMStack.Call(func, params, countof(params), nullptr, 0, nullptr);
}
}
void DMenuItemBase::Drawer(bool selected)
{
IFVIRTUAL(DMenuItemBase, Ticker)
{
VMValue params[] = { (DObject*)this, selected };
GlobalVMStack.Call(func, params, countof(params), nullptr, 0, nullptr);
}
}
bool DMenuItemBase::Selectable()
{
IFVIRTUAL(DMenuItemBase, Selectable)
{
VMValue params[] = { (DObject*)this };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
bool DMenuItemBase::Activate()
{
IFVIRTUAL(DMenuItemBase, Activate)
{
VMValue params[] = { (DObject*)this };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
FName DMenuItemBase::GetAction(int *pparam)
{
IFVIRTUAL(DMenuItemBase, GetAction)
{
VMValue params[] = { (DObject*)this };
int retval[2];
VMReturn ret[2]; ret[0].IntAt(&retval[0]); ret[1].IntAt(&retval[1]);
GlobalVMStack.Call(func, params, countof(params), ret, 2, nullptr);
return !!retval;
}
return NAME_None;
}
bool DMenuItemBase::SetString(int i, const char *s)
{
IFVIRTUAL(DMenuItemBase, SetString)
{
VMValue params[] = { (DObject*)this, i, FString(s) };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
bool DMenuItemBase::GetString(int i, char *s, int len)
{
IFVIRTUAL(DMenuItemBase, GetString)
{
VMValue params[] = { (DObject*)this, i };
int retval;
FString retstr;
VMReturn ret[2]; ret[0].IntAt(&retval); ret[1].StringAt(&retstr);
GlobalVMStack.Call(func, params, countof(params), ret, 2, nullptr);
strncpy(s, retstr, len);
return !!retval;
}
return false;
}
bool DMenuItemBase::SetValue(int i, int value)
{
IFVIRTUAL(DMenuItemBase, SetValue)
{
VMValue params[] = { (DObject*)this, i, value };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
bool DMenuItemBase::GetValue(int i, int *pvalue)
{
IFVIRTUAL(DMenuItemBase, GetValue)
{
VMValue params[] = { (DObject*)this };
int retval[2];
VMReturn ret[2]; ret[0].IntAt(&retval[0]); ret[1].IntAt(&retval[1]);
GlobalVMStack.Call(func, params, countof(params), ret, 2, nullptr);
*pvalue = retval[1];
return !!retval[0];
}
return false;
}
void DMenuItemBase::Enable(bool on)
{
IFVIRTUAL(DMenuItemBase, Enable)
{
VMValue params[] = { (DObject*)this, on };
GlobalVMStack.Call(func, params, countof(params), nullptr, 0, nullptr);
}
}
bool DMenuItemBase::MenuEvent(int mkey, bool fromcontroller)
{
IFVIRTUAL(DMenuItemBase, MenuEvent)
{
VMValue params[] = { (DObject*)this, mkey, fromcontroller };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
bool DMenuItemBase::MouseEvent(int type, int x, int y)
{
IFVIRTUAL(DMenuItemBase, MouseEvent)
{
VMValue params[] = { (DObject*)this, x, y };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
bool DMenuItemBase::CheckHotkey(int c)
{
IFVIRTUAL(DMenuItemBase, CheckHotkey)
{
VMValue params[] = { (DObject*)this, c };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return !!retval;
}
return false;
}
int DMenuItemBase::GetWidth()
{
IFVIRTUAL(DMenuItemBase, GetWidth)
{
VMValue params[] = { (DObject*)this };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return retval;
}
return false;
}
int DMenuItemBase::GetIndent()
{
IFVIRTUAL(DMenuItemBase, GetIndent)
{
VMValue params[] = { (DObject*)this };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return retval;
}
return false;
}
int DMenuItemBase::Draw(DOptionMenuDescriptor *desc, int y, int indent, bool selected)
{
IFVIRTUAL(DMenuItemBase, Draw)
{
VMValue params[] = { (DObject*)this, desc, y, indent, selected };
int retval;
VMReturn ret(&retval);
GlobalVMStack.Call(func, params, countof(params), &ret, 1, nullptr);
return retval;
}
return false;
}
void DMenuItemBase::DrawSelector(int xofs, int yofs, FTextureID tex)
{
if (tex.isNull())
{
if ((DMenu::MenuTime % 8) < 6)
{
screen->DrawText(ConFont, OptionSettings.mFontColorSelection,
(mXpos + xofs - 160) * CleanXfac + screen->GetWidth() / 2,
(mYpos + yofs - 100) * CleanYfac + screen->GetHeight() / 2,
"\xd",
DTA_CellX, 8 * CleanXfac,
DTA_CellY, 8 * CleanYfac,
TAG_DONE);
}
}
else
{
screen->DrawTexture(TexMan(tex), mXpos + xofs, mYpos + yofs, DTA_Clean, true, TAG_DONE);
}
}
DMenuItemBase * CreateOptionMenuItemSubmenu(const char *label, FName cmd, int center);
DMenuItemBase * CreateOptionMenuItemControl(const char *label, FName cmd, FKeyBindings *bindings);

296
src/menu/menu.h
View file

@ -302,259 +302,35 @@ class DMenuItemBase : public DObject
DECLARE_CLASS(DMenuItemBase, DObject)
public:
int mXpos, mYpos;
FName mAction;
FNameNoInit mAction;
bool mEnabled;
DMenuItemBase(int xpos = 0, int ypos = 0, FName action = NAME_None)
{
mXpos = xpos;
mYpos = ypos;
mAction = action;
mEnabled = true;
}
virtual bool CheckCoordinate(int x, int y);
virtual void Ticker();
virtual void Drawer(bool selected);
virtual bool Selectable();
virtual bool Activate();
virtual FName GetAction(int *pparam);
virtual bool SetString(int i, const char *s);
virtual bool GetString(int i, char *s, int len);
virtual bool SetValue(int i, int value);
virtual bool GetValue(int i, int *pvalue);
virtual void Enable(bool on);
virtual bool MenuEvent (int mkey, bool fromcontroller);
virtual bool MouseEvent(int type, int x, int y);
virtual bool CheckHotkey(int c);
virtual int GetWidth();
virtual int GetIndent() { return 0; }
virtual int Draw(DOptionMenuDescriptor *desc, int y, int indent, bool selected) { return indent; }
void DrawSelector(int xofs, int yofs, FTextureID tex);
bool CheckCoordinate(int x, int y);
void Ticker();
void Drawer(bool selected);
bool Selectable();
bool Activate();
FName GetAction(int *pparam);
bool SetString(int i, const char *s);
bool GetString(int i, char *s, int len);
bool SetValue(int i, int value);
bool GetValue(int i, int *pvalue);
void Enable(bool on);
bool MenuEvent (int mkey, bool fromcontroller);
bool MouseEvent(int type, int x, int y);
bool CheckHotkey(int c);
int GetWidth();
int GetIndent();
int Draw(DOptionMenuDescriptor *desc, int y, int indent, bool selected);
void OffsetPositionY(int ydelta) { mYpos += ydelta; }
int GetY() { return mYpos; }
int GetX() { return mXpos; }
void SetX(int x) { mXpos = x; }
void DrawSelector(int xofs, int yofs, FTextureID tex);
};
class DListMenuItemStaticPatch_ : public DMenuItemBase
{
DECLARE_CLASS(DListMenuItemStaticPatch_, DMenuItemBase)
protected:
FTextureID mTexture;
bool mCentered;
DListMenuItemStaticPatch_() {}
public:
DListMenuItemStaticPatch_(int x, int y, FTextureID patch, bool centered);
void Drawer(bool selected);
};
class DListMenuItemStaticText_ : public DMenuItemBase
{
DECLARE_CLASS(DListMenuItemStaticText_, DMenuItemBase)
protected:
FString mText;
FFont *mFont;
EColorRange mColor;
bool mCentered;
DListMenuItemStaticText_() {}
public:
DListMenuItemStaticText_(int x, int y, const char *text, FFont *font, EColorRange color, bool centered);
void Drawer(bool selected);
};
//=============================================================================
//
// the player sprite window
//
//=============================================================================
class DListMenuItemPlayerDisplay_ : public DMenuItemBase
{
DECLARE_CLASS(DListMenuItemPlayerDisplay_, DMenuItemBase)
DListMenuDescriptor *mOwner;
FTexture *mBackdrop;
FRemapTable mRemap;
FPlayerClass *mPlayerClass;
FState *mPlayerState;
int mPlayerTics;
bool mNoportrait;
BYTE mRotation;
BYTE mMode; // 0: automatic (used by class selection), 1: manual (used by player setup)
BYTE mTranslate;
int mSkin;
int mRandomClass;
int mRandomTimer;
int mClassNum;
void SetPlayerClass(int classnum, bool force = false);
bool UpdatePlayerClass();
void UpdateRandomClass();
void UpdateTranslation();
DListMenuItemPlayerDisplay_() {}
public:
enum
{
PDF_ROTATION = 0x10001,
PDF_SKIN = 0x10002,
PDF_CLASS = 0x10003,
PDF_MODE = 0x10004,
PDF_TRANSLATE = 0x10005,
};
DListMenuItemPlayerDisplay_(DListMenuDescriptor *menu, int x, int y, PalEntry c1, PalEntry c2, bool np, FName action);
void OnDestroy() override;
virtual void Ticker();
virtual void Drawer(bool selected);
bool SetValue(int i, int value);
};
//=============================================================================
//
// selectable items
//
//=============================================================================
class DListMenuItemSelectable_ : public DMenuItemBase
{
DECLARE_CLASS(DListMenuItemSelectable_, DMenuItemBase)
protected:
int mHotkey;
int mHeight;
int mParam;
DListMenuItemSelectable_() {}
public:
DListMenuItemSelectable_(int x, int y, int height, FName childmenu, int mParam = -1);
bool CheckCoordinate(int x, int y);
bool Selectable();
bool CheckHotkey(int c);
bool Activate();
bool MouseEvent(int type, int x, int y);
FName GetAction(int *pparam);
};
class DListMenuItemText_ : public DListMenuItemSelectable_
{
DECLARE_CLASS(DListMenuItemText_, DListMenuItemSelectable_)
const char *mText;
FFont *mFont;
EColorRange mColor;
EColorRange mColorSelected;
DListMenuItemText_() {}
public:
DListMenuItemText_(int x, int y, int height, int hotkey, const char *text, FFont *font, EColorRange color, EColorRange color2, FName child, int param = 0);
void OnDestroy() override;
void Drawer(bool selected);
int GetWidth();
};
class DListMenuItemPatch_ : public DListMenuItemSelectable_
{
DECLARE_CLASS(DListMenuItemPatch_, DListMenuItemSelectable_)
FTextureID mTexture;
DListMenuItemPatch_() {}
public:
DListMenuItemPatch_(int x, int y, int height, int hotkey, FTextureID patch, FName child, int param = 0);
void Drawer(bool selected);
int GetWidth();
};
//=============================================================================
//
// items for the player menu
//
//=============================================================================
class DPlayerNameBox_ : public DListMenuItemSelectable_
{
DECLARE_CLASS(DPlayerNameBox_, DListMenuItemSelectable_)
FString mText;
FFont *mFont;
EColorRange mFontColor;
int mFrameSize;
char mPlayerName[MAXPLAYERNAME+1];
char mEditName[MAXPLAYERNAME+2];
bool mEntering;
void DrawBorder (int x, int y, int len);
DPlayerNameBox_() {}
public:
DPlayerNameBox_(int x, int y, int height, int frameofs, const char *text, FFont *font, EColorRange color, FName action);
bool SetString(int i, const char *s);
bool GetString(int i, char *s, int len);
void Drawer(bool selected);
bool MenuEvent (int mkey, bool fromcontroller);
};
//=============================================================================
//
// items for the player menu
//
//=============================================================================
class DValueTextItem_ : public DListMenuItemSelectable_
{
DECLARE_CLASS(DValueTextItem_, DListMenuItemSelectable_)
TArray<FString> mSelections;
FString mText;
int mSelection;
FFont *mFont;
EColorRange mFontColor;
EColorRange mFontColor2;
DValueTextItem_() {}
public:
DValueTextItem_(int x, int y, int height, const char *text, FFont *font, EColorRange color, EColorRange valuecolor, FName action, FName values);
bool SetString(int i, const char *s);
bool SetValue(int i, int value);
bool GetValue(int i, int *pvalue);
bool MenuEvent (int mkey, bool fromcontroller);
void Drawer(bool selected);
};
//=============================================================================
//
// items for the player menu
//
//=============================================================================
class DSliderItem_ : public DListMenuItemSelectable_
{
DECLARE_CLASS(DSliderItem_, DListMenuItemSelectable_)
FString mText;
FFont *mFont;
EColorRange mFontColor;
int mMinrange, mMaxrange;
int mStep;
int mSelection;
void DrawSlider (int x, int y);
DSliderItem_() {}
public:
DSliderItem_(int x, int y, int height, const char *text, FFont *font, EColorRange color, FName action, int min, int max, int step);
bool SetValue(int i, int value);
bool GetValue(int i, int *pvalue);
bool MenuEvent (int mkey, bool fromcontroller);
void Drawer(bool selected);
bool MouseEvent(int type, int x, int y);
};
//=============================================================================
//
// list menu class runs a menu described by a DListMenuDescriptor
@ -594,36 +370,6 @@ public:
};
//=============================================================================
//
// base class for menu items
//
//=============================================================================
/*
class DMenuItemBase : public DMenuItemBase
{
DECLARE_ABSTRACT_CLASS(DMenuItemBase, DMenuItemBase)
public:
FString mLabel;
bool mCentered;
void drawLabel(int indent, int y, EColorRange color, bool grayed = false);
DMenuItemBase(const char *text = nullptr, FName action = NAME_None, bool center = false)
: DMenuItemBase(0, 0, action)
{
mLabel = text;
mCentered = center;
}
virtual int Draw(DOptionMenuDescriptor *desc, int y, int indent, bool selected);
virtual bool Selectable();
virtual int GetIndent();
virtual bool MouseEvent(int type, int x, int y);
};
*/
//=============================================================================
//
//
@ -762,5 +508,7 @@ DMenuItemBase * CreateOptionMenuSliderJoySensitivity(const char * label, double
DMenuItemBase * CreateOptionMenuSliderJoyScale(const char *label, int axis, double min, double max, double step, int showval);
DMenuItemBase * CreateOptionMenuItemInverter(const char *label, int axis, int center);
DMenuItemBase * CreateOptionMenuSliderJoyDeadZone(const char *label, int axis, double min, double max, double step, int showval);
DMenuItemBase * CreateListMenuItemPatch(int x, int y, int height, int hotkey, FTextureID tex, FName command, int param);
DMenuItemBase * CreateListMenuItemText(int x, int y, int height, int hotkey, const char *text, FFont *font, PalEntry color1, PalEntry color2, FName command, int param);
#endif

284
src/menu/menudef.cpp
View file

@ -336,87 +336,6 @@ static void ParseListMenuBody(FScanner &sc, DListMenuDescriptor *desc)
sc.MustGetNumber();
desc->mWRight = sc.Number;
}
else if (sc.Compare("StaticPatch") || sc.Compare("StaticPatchCentered"))
{
bool centered = sc.Compare("StaticPatchCentered");
sc.MustGetNumber();
int x = sc.Number;
sc.MustGetStringName(",");
sc.MustGetNumber();
int y = sc.Number;
sc.MustGetStringName(",");
sc.MustGetString();
FTextureID tex = GetMenuTexture(sc.String);
DMenuItemBase *it = new DListMenuItemStaticPatch_(x, y, tex, centered);
desc->mItems.Push(it);
}
else if (sc.Compare("StaticText") || sc.Compare("StaticTextCentered"))
{
bool centered = sc.Compare("StaticTextCentered");
sc.MustGetNumber();
int x = sc.Number;
sc.MustGetStringName(",");
sc.MustGetNumber();
int y = sc.Number;
sc.MustGetStringName(",");
sc.MustGetString();
FString label = sc.String;
EColorRange cr = desc->mFontColor;
if (sc.CheckString(","))
{
sc.MustGetString();
cr = V_FindFontColor(sc.String);
if (cr == CR_UNTRANSLATED && !sc.Compare("untranslated")) cr = desc->mFontColor;
}
DMenuItemBase *it = new DListMenuItemStaticText_(x, y, label, desc->mFont, cr, centered);
desc->mItems.Push(it);
}
else if (sc.Compare("PatchItem"))
{
sc.MustGetString();
FTextureID tex = GetMenuTexture(sc.String);
sc.MustGetStringName(",");
sc.MustGetString();
int hotkey = sc.String[0];
sc.MustGetStringName(",");
sc.MustGetString();
FName action = sc.String;
int param = 0;
if (sc.CheckString(","))
{
sc.MustGetNumber();
param = sc.Number;
}
DMenuItemBase *it = new DListMenuItemPatch_(desc->mXpos, desc->mYpos, desc->mLinespacing, hotkey, tex, action, param);
desc->mItems.Push(it);
desc->mYpos += desc->mLinespacing;
if (desc->mSelectedItem == -1) desc->mSelectedItem = desc->mItems.Size()-1;
}
else if (sc.Compare("TextItem"))
{
sc.MustGetString();
FString text = sc.String;
sc.MustGetStringName(",");
sc.MustGetString();
int hotkey = sc.String[0];
sc.MustGetStringName(",");
sc.MustGetString();
FName action = sc.String;
int param = 0;
if (sc.CheckString(","))
{
sc.MustGetNumber();
param = sc.Number;
}
DMenuItemBase *it = new DListMenuItemText_(desc->mXpos, desc->mYpos, desc->mLinespacing, hotkey, text, desc->mFont, desc->mFontColor, desc->mFontColor2, action, param);
desc->mItems.Push(it);
desc->mYpos += desc->mLinespacing;
if (desc->mSelectedItem == -1) desc->mSelectedItem = desc->mItems.Size()-1;
}
else if (sc.Compare("Font"))
{
sc.MustGetString();
@ -443,88 +362,124 @@ static void ParseListMenuBody(FScanner &sc, DListMenuDescriptor *desc)
sc.MustGetString();
desc->mNetgameMessage = sc.String;
}
else if (sc.Compare("PlayerDisplay"))
else
{
bool noportrait = false;
FName action = NAME_None;
sc.MustGetNumber();
int x = sc.Number;
sc.MustGetStringName(",");
sc.MustGetNumber();
int y = sc.Number;
sc.MustGetStringName(",");
sc.MustGetString();
PalEntry c1 = V_GetColor(nullptr, sc);
sc.MustGetStringName(",");
sc.MustGetString();
PalEntry c2 = V_GetColor(nullptr, sc);
if (sc.CheckString(","))
bool success = false;
FStringf buildname("ListMenuItem%s", sc.String);
PClass *cls = PClass::FindClass(buildname);
if (cls != nullptr && cls->IsDescendantOf("ListMenuItem"))
{
sc.MustGetNumber();
noportrait = !!sc.Number;
if (sc.CheckString(","))
auto func = dyn_cast<PFunction>(cls->Symbols.FindSymbol("Init", false));
if (func != nullptr && !(func->Variants[0].Flags & (VARF_Protected | VARF_Private))) // skip internal classes which have a protexted init method.
{
sc.MustGetString();
action = sc.String;
auto &args = func->Variants[0].Proto->ArgumentTypes;
TArray<VMValue> params;
int start = 1;
params.Push(0);
if (args.Size() > 1 && args[1] == NewPointer(PClass::FindClass("ListMenuDescriptor")))
{
params.Push(desc);
start = 2;
}
auto TypeCVar = NewPointer(NewNativeStruct("CVar", nullptr));
for (unsigned i = 1; i < args.Size(); i++)
{
sc.MustGetString();
if (args[i] == TypeString)
{
params.Push(sc.String);
}
else if (args[i] == TypeName)
{
params.Push(FName(sc.String).GetIndex());
}
else if (args[i] == TypeColor)
{
params.Push(V_GetColor(nullptr, sc));
}
else if (args[i] == TypeFont)
{
params.Push(FFont::FindFont(sc.String));
}
else if (args[i]->IsKindOf(RUNTIME_CLASS(PInt)))
{
char *endp;
int v = (int)strtoll(sc.String, &endp, 0);
if (*endp != 0)
{
// special check for font color ranges.
v = V_FindFontColor(sc.String);
if (v == CR_UNTRANSLATED && !sc.Compare("untranslated"))
{
// todo: check other data types that may get used.
sc.ScriptError("Integer expected, got %s", sc.String);
}
}
if (args[i] == TypeBool) v = !!v;
params.Push(v);
}
else if (args[i]->IsKindOf(RUNTIME_CLASS(PFloat)))
{
char *endp;
double v = strtod(sc.String, &endp);
if (*endp != 0)
{
sc.ScriptError("Float expected, got %s", sc.String);
}
params.Push(v);
}
else if (args[i] == TypeCVar)
{
auto cv = FindCVar(sc.String, nullptr);
if (cv == nullptr && *sc.String)
{
sc.ScriptError("Unknown CVar %s", sc.String);
}
params.Push(cv);
}
else
{
sc.ScriptError("Invalid parameter type %s for menu item", args[i]->DescriptiveName());
}
if (sc.CheckString(","))
{
if (i == args.Size() - 1)
{
sc.ScriptError("Too many parameters for %s", cls->TypeName.GetChars());
}
}
else
{
if (i < args.Size() - 1 && !(func->Variants[0].ArgFlags[i + 1] & VARF_Optional))
{
sc.ScriptError("Insufficient parameters for %s", cls->TypeName.GetChars());
}
break;
}
}
/*
DMenuItemBase *item = (DMenuItemBase*)cls->CreateNew();
params[0] = item;
GlobalVMStack.Call(func->Variants[0].Implementation, &params[0], params.Size(), nullptr, 0);
desc->mItems.Push((DMenuItemBase*)item);
*/
if (cls->IsDescendantOf("ListMenuItemSelectable"))
{
desc->mYpos += desc->mLinespacing;
if (desc->mSelectedItem == -1) desc->mSelectedItem = desc->mItems.Size() - 1;
}
success = true;
}
}
DListMenuItemPlayerDisplay_ *it = new DListMenuItemPlayerDisplay_(desc, x, y, c1, c2, noportrait, action);
desc->mItems.Push(it);
}
else if (sc.Compare("PlayerNameBox"))
{
sc.MustGetString();
FString text = sc.String;
sc.MustGetStringName(",");
sc.MustGetNumber();
int ofs = sc.Number;
sc.MustGetStringName(",");
sc.MustGetString();
DMenuItemBase *it = new DPlayerNameBox_(desc->mXpos, desc->mYpos, desc->mLinespacing, ofs, text, desc->mFont, desc->mFontColor, sc.String);
desc->mItems.Push(it);
desc->mYpos += desc->mLinespacing;
if (desc->mSelectedItem == -1) desc->mSelectedItem = desc->mItems.Size()-1;
}
else if (sc.Compare("ValueText"))
{
sc.MustGetString();
FString text = sc.String;
sc.MustGetStringName(",");
sc.MustGetString();
FName action = sc.String;
FName values;
if (sc.CheckString(","))
if (!success)
{
sc.MustGetString();
values = sc.String;
sc.ScriptError("Unknown keyword '%s'", sc.String);
}
DMenuItemBase *it = new DValueTextItem_(desc->mXpos, desc->mYpos, desc->mLinespacing, text, desc->mFont, desc->mFontColor, desc->mFontColor2, action, values);
desc->mItems.Push(it);
desc->mYpos += desc->mLinespacing;
if (desc->mSelectedItem == -1) desc->mSelectedItem = desc->mItems.Size()-1;
}
else if (sc.Compare("Slider"))
{
sc.MustGetString();
FString text = sc.String;
sc.MustGetStringName(",");
sc.MustGetString();
FString action = sc.String;
sc.MustGetStringName(",");
sc.MustGetNumber();
int min = sc.Number;
sc.MustGetStringName(",");
sc.MustGetNumber();
int max = sc.Number;
sc.MustGetStringName(",");
sc.MustGetNumber();
int step = sc.Number;
DMenuItemBase *it = new DSliderItem_(desc->mXpos, desc->mYpos, desc->mLinespacing, text, desc->mFont, desc->mFontColor, action, min, max, step);
desc->mItems.Push(it);
desc->mYpos += desc->mLinespacing;
if (desc->mSelectedItem == -1) desc->mSelectedItem = desc->mItems.Size()-1;
}
else
{
sc.ScriptError("Unknown keyword '%s'", sc.String);
}
@ -835,7 +790,7 @@ static void ParseOptionMenuBody(FScanner &sc, DOptionMenuDescriptor *desc)
if (args[i] == TypeBool) v = !!v;
params.Push(v);
}
else if (args[i]->IsKindOf(RUNTIME_CLASS(PInt)))
else if (args[i]->IsKindOf(RUNTIME_CLASS(PFloat)))
{
char *endp;
double v = strtod(sc.String, &endp);
@ -1060,12 +1015,11 @@ static void BuildEpisodeMenu()
if (AllEpisodes[i].mPicName.IsNotEmpty())
{
FTextureID tex = GetMenuTexture(AllEpisodes[i].mPicName);
it = new DListMenuItemPatch_(ld->mXpos, posy, ld->mLinespacing, AllEpisodes[i].mShortcut,
tex, NAME_Skillmenu, i);
it = CreateListMenuItemPatch(ld->mXpos, posy, ld->mLinespacing, AllEpisodes[i].mShortcut, tex, NAME_Skillmenu, i);
}
else
{
it = new DListMenuItemText_(ld->mXpos, posy, ld->mLinespacing, AllEpisodes[i].mShortcut,
it = CreateListMenuItemText(ld->mXpos, posy, ld->mLinespacing, AllEpisodes[i].mShortcut,
AllEpisodes[i].mEpisodeName, ld->mFont, ld->mFontColor, ld->mFontColor2, NAME_Skillmenu, i);
}
ld->mItems.Push(it);
@ -1158,7 +1112,7 @@ static void BuildPlayerclassMenu()
if (numclassitems <= 1)
{
// create a dummy item that auto-chooses the default class.
DListMenuItemText_ *it = new DListMenuItemText_(0, 0, 0, 'p', "player",
auto it = CreateListMenuItemText(0, 0, 0, 'p', "player",
ld->mFont,ld->mFontColor, ld->mFontColor2, NAME_Episodemenu, -1000);
ld->mAutoselect = ld->mItems.Push(it);
success = true;
@ -1184,7 +1138,7 @@ static void BuildPlayerclassMenu()
const char *pname = GetPrintableDisplayName(PlayerClasses[i].Type);
if (pname != nullptr)
{
DListMenuItemText_ *it = new DListMenuItemText_(ld->mXpos, ld->mYpos, ld->mLinespacing, *pname,
auto it = CreateListMenuItemText(ld->mXpos, ld->mYpos, ld->mLinespacing, *pname,
pname, ld->mFont,ld->mFontColor,ld->mFontColor2, NAME_Episodemenu, i);
ld->mItems.Push(it);
ld->mYpos += ld->mLinespacing;
@ -1194,7 +1148,7 @@ static void BuildPlayerclassMenu()
}
if (n > 1 && !gameinfo.norandomplayerclass)
{
DListMenuItemText_ *it = new DListMenuItemText_(ld->mXpos, ld->mYpos, ld->mLinespacing, 'r',
auto it = CreateListMenuItemText(ld->mXpos, ld->mYpos, ld->mLinespacing, 'r',
"$MNU_RANDOM", ld->mFont,ld->mFontColor,ld->mFontColor2, NAME_Episodemenu, -1);
ld->mItems.Push(it);
}
@ -1203,7 +1157,7 @@ static void BuildPlayerclassMenu()
const char *pname = GetPrintableDisplayName(PlayerClasses[0].Type);
if (pname != nullptr)
{
DListMenuItemText_ *it = new DListMenuItemText_(ld->mXpos, ld->mYpos, ld->mLinespacing, *pname,
auto it = CreateListMenuItemText(ld->mXpos, ld->mYpos, ld->mLinespacing, *pname,
pname, ld->mFont,ld->mFontColor,ld->mFontColor2, NAME_Episodemenu, 0);
ld->mItems.Push(it);
}
@ -1464,13 +1418,13 @@ void M_StartupSkillMenu(FGameStartup *gs)
if (skill.PicName.Len() != 0 && pItemText == nullptr)
{
FTextureID tex = GetMenuTexture(skill.PicName);
li = new DListMenuItemPatch_(ld->mXpos, y, ld->mLinespacing, skill.Shortcut, tex, action, i);
li = CreateListMenuItemPatch(ld->mXpos, y, ld->mLinespacing, skill.Shortcut, tex, action, i);
}
else
{
EColorRange color = (EColorRange)skill.GetTextColor();
if (color == CR_UNTRANSLATED) color = ld->mFontColor;
li = new DListMenuItemText_(x, y, ld->mLinespacing, skill.Shortcut,
li = CreateListMenuItemText(x, y, ld->mLinespacing, skill.Shortcut,
pItemText? *pItemText : skill.MenuName, ld->mFont, color,ld->mFontColor2, action, i);
}
ld->mItems.Push(li);

320
src/menu/playerdisplay.cpp
View file

@ -1,320 +0,0 @@
/*
** playerdisplay.cpp
** The player display for the player setup and class selection screen
**
**---------------------------------------------------------------------------
** Copyright 2010 Christoph Oelckers
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
#include "doomtype.h"
#include "doomstat.h"
#include "d_player.h"
#include "templates.h"
#include "menu/menu.h"
#include "colormatcher.h"
#include "textures/textures.h"
#include "w_wad.h"
#include "v_font.h"
#include "v_video.h"
#include "g_level.h"
#include "gi.h"
#include "r_defs.h"
#include "r_state.h"
#include "r_data/r_translate.h"
//=============================================================================
//
//
//
//=============================================================================
IMPLEMENT_CLASS(DListMenuItemPlayerDisplay_, false, false)
DListMenuItemPlayerDisplay_::DListMenuItemPlayerDisplay_(DListMenuDescriptor *menu, int x, int y, PalEntry c1, PalEntry c2, bool np, FName action)
: DMenuItemBase(x, y, action)
{
mOwner = menu;
FRemapTable *bdremap = translationtables[TRANSLATION_Players][MAXPLAYERS + 1];
for (int i = 0; i < 256; i++)
{
int r = c1.r + c2.r * i / 255;
int g = c1.g + c2.g * i / 255;
int b = c1.b + c2.b * i / 255;
bdremap->Remap[i] = ColorMatcher.Pick (r, g, b);
bdremap->Palette[i] = PalEntry(255, r, g, b);
}
auto id = TexMan.CheckForTexture("PlayerBackdrop", FTexture::TEX_MiscPatch);
mBackdrop = TexMan[id];
mPlayerClass = NULL;
mPlayerState = NULL;
mNoportrait = np;
mMode = 0;
mRotation = 0;
mTranslate = false;
mSkin = 0;
mRandomClass = 0;
mRandomTimer = 0;
mClassNum = -1;
}
//=============================================================================
//
//
//
//=============================================================================
void DListMenuItemPlayerDisplay_::OnDestroy()
{
}
//=============================================================================
//
//
//
//=============================================================================
void DListMenuItemPlayerDisplay_::UpdateRandomClass()
{
if (--mRandomTimer < 0)
{
if (++mRandomClass >= (int)PlayerClasses.Size ()) mRandomClass = 0;
mPlayerClass = &PlayerClasses[mRandomClass];
mPlayerState = GetDefaultByType (mPlayerClass->Type)->SeeState;
if (mPlayerState == NULL)
{ // No see state, so try spawn state.
mPlayerState = GetDefaultByType (mPlayerClass->Type)->SpawnState;
}
mPlayerTics = mPlayerState != NULL ? mPlayerState->GetTics() : -1;
mRandomTimer = 6;
// Since the newly displayed class may used a different translation
// range than the old one, we need to update the translation, too.
UpdateTranslation();
}
}
//=============================================================================
//
//
//
//=============================================================================
void DListMenuItemPlayerDisplay_::UpdateTranslation()
{
int PlayerColor = players[consoleplayer].userinfo.GetColor();
int PlayerSkin = players[consoleplayer].userinfo.GetSkin();
int PlayerColorset = players[consoleplayer].userinfo.GetColorSet();
if (mPlayerClass != NULL)
{
PlayerSkin = R_FindSkin (skins[PlayerSkin].name, int(mPlayerClass - &PlayerClasses[0]));
R_GetPlayerTranslation(PlayerColor, GetColorSet(mPlayerClass->Type, PlayerColorset),
&skins[PlayerSkin], translationtables[TRANSLATION_Players][MAXPLAYERS]);
}
}
//=============================================================================
//
//
//
//=============================================================================
void DListMenuItemPlayerDisplay_::SetPlayerClass(int classnum, bool force)
{
if (classnum < 0 || classnum >= (int)PlayerClasses.Size ())
{
if (mClassNum != -1)
{
mClassNum = -1;
mRandomTimer = 0;
UpdateRandomClass();
}
}
else if (mPlayerClass != &PlayerClasses[classnum] || force)
{
mPlayerClass = &PlayerClasses[classnum];
mPlayerState = GetDefaultByType (mPlayerClass->Type)->SeeState;
if (mPlayerState == NULL)
{ // No see state, so try spawn state.
mPlayerState = GetDefaultByType (mPlayerClass->Type)->SpawnState;
}
mPlayerTics = mPlayerState != NULL ? mPlayerState->GetTics() : -1;
mClassNum = classnum;
}
}
//=============================================================================
//
//
//
//=============================================================================
bool DListMenuItemPlayerDisplay_::UpdatePlayerClass()
{
if (mOwner->mSelectedItem >= 0)
{
int classnum;
FName seltype = mOwner->mItems[mOwner->mSelectedItem]->GetAction(&classnum);
if (seltype != NAME_Episodemenu) return false;
if (PlayerClasses.Size() == 0) return false;
SetPlayerClass(classnum);
return true;
}
return false;
}
//=============================================================================
//
//
//
//=============================================================================
bool DListMenuItemPlayerDisplay_::SetValue(int i, int value)
{
switch (i)
{
case PDF_MODE:
mMode = value;
return true;
case PDF_ROTATION:
mRotation = value;
return true;
case PDF_TRANSLATE:
mTranslate = value;
case PDF_CLASS:
SetPlayerClass(value, true);
break;
case PDF_SKIN:
mSkin = value;
break;
}
return false;
}
//=============================================================================
//
//
//
//=============================================================================
void DListMenuItemPlayerDisplay_::Ticker()
{
if (mClassNum < 0) UpdateRandomClass();
if (mPlayerState != NULL && mPlayerState->GetTics () != -1 && mPlayerState->GetNextState () != NULL)
{
if (--mPlayerTics <= 0)
{
mPlayerState = mPlayerState->GetNextState();
mPlayerTics = mPlayerState->GetTics();
}
}
}
//=============================================================================
//
//
//
//=============================================================================
void DListMenuItemPlayerDisplay_::Drawer(bool selected)
{
if (mMode == 0 && !UpdatePlayerClass())
{
return;
}
FName portrait = ((APlayerPawn*)GetDefaultByType(mPlayerClass->Type))->Portrait;
if (portrait != NAME_None && !mNoportrait)
{
FTextureID texid = TexMan.CheckForTexture(portrait.GetChars(), FTexture::TEX_MiscPatch);
if (texid.isValid())
{
FTexture *tex = TexMan(texid);
if (tex != NULL)
{
screen->DrawTexture (tex, mXpos, mYpos, DTA_Clean, true, TAG_DONE);
return;
}
}
}
int x = (mXpos - 160) * CleanXfac + (SCREENWIDTH>>1);
int y = (mYpos - 100) * CleanYfac + (SCREENHEIGHT>>1);
screen->DrawTexture(mBackdrop, x, y - 1,
DTA_DestWidth, 72 * CleanXfac,
DTA_DestHeight, 80 * CleanYfac,
DTA_TranslationIndex, TRANSLATION(TRANSLATION_Players, MAXPLAYERS + 1),
DTA_Masked, true,
TAG_DONE);
V_DrawFrame (x, y, 72*CleanXfac, 80*CleanYfac-1);
spriteframe_t *sprframe = NULL;
DVector2 Scale;
if (mPlayerState != NULL)
{
if (mSkin == 0)
{
sprframe = &SpriteFrames[sprites[mPlayerState->sprite].spriteframes + mPlayerState->GetFrame()];
Scale = GetDefaultByType(mPlayerClass->Type)->Scale;
}
else
{
sprframe = &SpriteFrames[sprites[skins[mSkin].sprite].spriteframes + mPlayerState->GetFrame()];
Scale = skins[mSkin].Scale;
}
}
if (sprframe != NULL)
{
FTexture *tex = TexMan(sprframe->Texture[mRotation]);
if (tex != NULL && tex->UseType != FTexture::TEX_Null)
{
int trans = mTranslate? TRANSLATION(TRANSLATION_Players, MAXPLAYERS) : 0;
screen->DrawTexture (tex,
x + 36*CleanXfac, y + 71*CleanYfac,
DTA_DestWidthF, tex->GetScaledWidthDouble() * CleanXfac * Scale.X,
DTA_DestHeightF, tex->GetScaledHeightDouble() * CleanYfac * Scale.Y,
DTA_TranslationIndex, trans,
DTA_FlipX, sprframe->Flip & (1 << mRotation),
TAG_DONE);
}
}
}

448
src/menu/playermenu.cpp
View file

@ -55,428 +55,6 @@ EXTERN_CVAR (Float, autoaim)
EXTERN_CVAR(Bool, neverswitchonpickup)
EXTERN_CVAR (Bool, cl_run)
//=============================================================================
//
// Player's name
//
//=============================================================================
IMPLEMENT_CLASS(DPlayerNameBox_, false, false)
DPlayerNameBox_::DPlayerNameBox_(int x, int y, int height, int frameofs, const char *text, FFont *font, EColorRange color, FName action)
: DListMenuItemSelectable_(x, y, height, action)
{
mText = text;
mFont = font;
mFontColor = color;
mFrameSize = frameofs;
mPlayerName[0] = 0;
mEntering = false;
}
//=============================================================================
//
//
//
//=============================================================================
bool DPlayerNameBox_::SetString(int i, const char *s)
{
if (i == 0)
{
strncpy(mPlayerName, s, MAXPLAYERNAME);
mPlayerName[MAXPLAYERNAME] = 0;
return true;
}
return false;
}
bool DPlayerNameBox_::GetString(int i, char *s, int len)
{
if (i == 0)
{
strncpy(s, mPlayerName, len);
s[len] = 0;
return true;
}
return false;
}
//=============================================================================
//
// [RH] Width of the border is variable
//
//=============================================================================
void DPlayerNameBox_::DrawBorder (int x, int y, int len)
{
FTexture *left = TexMan[TexMan.CheckForTexture("M_LSLEFT", FTexture::TEX_MiscPatch)];
FTexture *mid = TexMan[TexMan.CheckForTexture("M_LSCNTR", FTexture::TEX_MiscPatch)];
FTexture *right = TexMan[TexMan.CheckForTexture("M_LSRGHT", FTexture::TEX_MiscPatch)];
if (left != NULL && right != NULL && mid != NULL)
{
int i;
screen->DrawTexture (left, x-8, y+7, DTA_Clean, true, TAG_DONE);
for (i = 0; i < len; i++)
{
screen->DrawTexture (mid, x, y+7, DTA_Clean, true, TAG_DONE);
x += 8;
}
screen->DrawTexture (right, x, y+7, DTA_Clean, true, TAG_DONE);
}
else
{
FTexture *slot = TexMan[TexMan.CheckForTexture("M_FSLOT", FTexture::TEX_MiscPatch)];
if (slot != NULL)
{
screen->DrawTexture (slot, x, y+1, DTA_Clean, true, TAG_DONE);
}
else
{
screen->Clear(x, y, x + len, y + SmallFont->GetHeight() * 3/2, -1, 0);
}
}
}
//=============================================================================
//
//
//
//=============================================================================
void DPlayerNameBox_::Drawer(bool selected)
{
const char *text = mText;
if (text != NULL)
{
if (*text == '$') text = GStrings(text+1);
screen->DrawText(mFont, selected? OptionSettings.mFontColorSelection : mFontColor, mXpos, mYpos, text, DTA_Clean, true, TAG_DONE);
}
// Draw player name box
int x = mXpos + mFont->StringWidth(text) + 16 + mFrameSize;
DrawBorder (x, mYpos - mFrameSize, MAXPLAYERNAME+1);
if (!mEntering)
{
screen->DrawText (SmallFont, CR_UNTRANSLATED, x + mFrameSize, mYpos, mPlayerName,
DTA_Clean, true, TAG_DONE);
}
else
{
size_t l = strlen(mEditName);
mEditName[l] = SmallFont->GetCursor();
mEditName[l+1] = 0;
screen->DrawText (SmallFont, CR_UNTRANSLATED, x + mFrameSize, mYpos, mEditName,
DTA_Clean, true, TAG_DONE);
mEditName[l] = 0;
}
}
//=============================================================================
//
//
//
//=============================================================================
bool DPlayerNameBox_::MenuEvent(int mkey, bool fromcontroller)
{
if (mkey == MKEY_Enter)
{
S_Sound (CHAN_VOICE | CHAN_UI, "menu/choose", snd_menuvolume, ATTN_NONE);
strcpy(mEditName, mPlayerName);
mEntering = true;
DMenu *input = new DTextEnterMenu(DMenu::CurrentMenu, mEditName, MAXPLAYERNAME, 2, fromcontroller);
M_ActivateMenu(input);
return true;
}
else if (mkey == MKEY_Input)
{
strcpy(mPlayerName, mEditName);
mEntering = false;
return true;
}
else if (mkey == MKEY_Abort)
{
mEntering = false;
return true;
}
return false;
}
//=============================================================================
//
// items for the player menu
//
//=============================================================================
IMPLEMENT_CLASS(DValueTextItem_, false, false)
DValueTextItem_::DValueTextItem_(int x, int y, int height, const char *text, FFont *font, EColorRange color, EColorRange valuecolor, FName action, FName values)
: DListMenuItemSelectable_(x, y, height, action)
{
mText = text;
mFont = font;
mFontColor = color;
mFontColor2 = valuecolor;
mSelection = 0;
if (values != NAME_None)
{
FOptionValues **opt = OptionValues.CheckKey(values);
if (opt != NULL)
{
for(unsigned i=0;i<(*opt)->mValues.Size(); i++)
{
SetString(i, (*opt)->mValues[i].Text);
}
}
}
}
//=============================================================================
//
//
//
//=============================================================================
bool DValueTextItem_::SetString(int i, const char *s)
{
// should actually use the index...
FString str = s;
if (i==0) mSelections.Clear();
mSelections.Push(str);
return true;
}
//=============================================================================
//
//
//
//=============================================================================
bool DValueTextItem_::SetValue(int i, int value)
{
if (i == 0)
{
mSelection = value;
return true;
}
return false;
}
bool DValueTextItem_::GetValue(int i, int *pvalue)
{
if (i == 0)
{
*pvalue = mSelection;
return true;
}
return false;
}
//=============================================================================
//
//
//
//=============================================================================
bool DValueTextItem_::MenuEvent (int mkey, bool fromcontroller)
{
if (mSelections.Size() > 1)
{
if (mkey == MKEY_Left)
{
S_Sound (CHAN_VOICE | CHAN_UI, "menu/change", snd_menuvolume, ATTN_NONE);
if (--mSelection < 0) mSelection = mSelections.Size() - 1;
return true;
}
else if (mkey == MKEY_Right || mkey == MKEY_Enter)
{
S_Sound (CHAN_VOICE | CHAN_UI, "menu/change", snd_menuvolume, ATTN_NONE);
if (++mSelection >= (int)mSelections.Size()) mSelection = 0;
return true;
}
}
return (mkey == MKEY_Enter); // needs to eat enter keys so that Activate won't get called
}
//=============================================================================
//
//
//
//=============================================================================
void DValueTextItem_::Drawer(bool selected)
{
const char *text = mText;
if (*text == '$') text = GStrings(text+1);
screen->DrawText(mFont, selected? OptionSettings.mFontColorSelection : mFontColor, mXpos, mYpos, text, DTA_Clean, true, TAG_DONE);
int x = mXpos + mFont->StringWidth(text) + 8;
if (mSelections.Size() > 0)
{
const char *mOptValue = mSelections[mSelection];
if (*mOptValue == '$') mOptValue = GStrings(mOptValue + 1);
screen->DrawText(mFont, mFontColor2, x, mYpos, mOptValue, DTA_Clean, true, TAG_DONE);
}
}
//=============================================================================
//
// items for the player menu
//
//=============================================================================
IMPLEMENT_CLASS(DSliderItem_, false, false)
DSliderItem_::DSliderItem_(int x, int y, int height, const char *text, FFont *font, EColorRange color, FName action, int min, int max, int step)
: DListMenuItemSelectable_(x, y, height, action)
{
mText = text;
mFont = font;
mFontColor = color;
mSelection = 0;
mMinrange = min;
mMaxrange = max;
mStep = step;
}
//=============================================================================
//
//
//
//=============================================================================
bool DSliderItem_::SetValue(int i, int value)
{
if (i == 0)
{
mSelection = value;
return true;
}
return false;
}
bool DSliderItem_::GetValue(int i, int *pvalue)
{
if (i == 0)
{
*pvalue = mSelection;
return true;
}
return false;
}
//=============================================================================
//
//
//
//=============================================================================
bool DSliderItem_::MenuEvent (int mkey, bool fromcontroller)
{
if (mkey == MKEY_Left)
{
S_Sound (CHAN_VOICE | CHAN_UI, "menu/change", snd_menuvolume, ATTN_NONE);
if ((mSelection -= mStep) < mMinrange) mSelection = mMinrange;
return true;
}
else if (mkey == MKEY_Right || mkey == MKEY_Enter)
{
S_Sound (CHAN_VOICE | CHAN_UI, "menu/change", snd_menuvolume, ATTN_NONE);
if ((mSelection += mStep) > mMaxrange) mSelection = mMaxrange;
return true;
}
return false;
}
//=============================================================================
//
//
//
//=============================================================================
bool DSliderItem_::MouseEvent(int type, int x, int y)
{
DListMenu *lm = static_cast<DListMenu*>(DMenu::CurrentMenu);
if (type != DMenu::MOUSE_Click)
{
if (!lm->CheckFocus(this)) return false;
}
if (type == DMenu::MOUSE_Release)
{
lm->ReleaseFocus();
}
int slide_left = SmallFont->StringWidth ("Green") + 8 + mXpos;
int slide_right = slide_left + 12*8; // 12 char cells with 8 pixels each.
if (type == DMenu::MOUSE_Click)
{
if (x < slide_left || x >= slide_right) return true;
}
x = clamp(x, slide_left, slide_right);
int v = mMinrange + Scale(x - slide_left, mMaxrange - mMinrange, slide_right - slide_left);
if (v != mSelection)
{
mSelection = v;
S_Sound (CHAN_VOICE | CHAN_UI, "menu/change", snd_menuvolume, ATTN_NONE);
}
if (type == DMenu::MOUSE_Click)
{
lm->SetFocus(this);
}
return true;
}
//=============================================================================
//
//
//
//=============================================================================
void DSliderItem_::DrawSlider (int x, int y)
{
int range = mMaxrange - mMinrange;
int cur = mSelection - mMinrange;
x = (x - 160) * CleanXfac + screen->GetWidth() / 2;
y = (y - 100) * CleanYfac + screen->GetHeight() / 2;
screen->DrawText (ConFont, CR_WHITE, x, y,
"\x10\x11\x11\x11\x11\x11\x11\x11\x11\x11\x11\x12",
DTA_CellX, 8 * CleanXfac,
DTA_CellY, 8 * CleanYfac,
TAG_DONE);
screen->DrawText (ConFont, CR_ORANGE, x + (5 + (int)((cur * 78) / range)) * CleanXfac, y,
"\x13",
DTA_CellX, 8 * CleanXfac,
DTA_CellY, 8 * CleanYfac,
TAG_DONE);
}
//=============================================================================
//
//
//
//=============================================================================
void DSliderItem_::Drawer(bool selected)
{
const char *text = mText;
if (*text == '$') text = GStrings(text+1);
screen->DrawText(mFont, selected? OptionSettings.mFontColorSelection : mFontColor, mXpos, mYpos, text, DTA_Clean, true, TAG_DONE);
int x = SmallFont->StringWidth ("Green") + 8 + mXpos;
int x2 = SmallFont->StringWidth (text) + 8 + mXpos;
DrawSlider (MAX(x2, x), mYpos);
}
//=============================================================================
//
//
@ -524,6 +102,14 @@ IMPLEMENT_CLASS(DPlayerMenu, false, false)
//
//
//=============================================================================
enum EPDFlags
{
ListMenuItemPlayerDisplay_PDF_ROTATION = 0x10001,
ListMenuItemPlayerDisplay_PDF_SKIN = 0x10002,
ListMenuItemPlayerDisplay_PDF_CLASS = 0x10003,
ListMenuItemPlayerDisplay_PDF_MODE = 0x10004,
ListMenuItemPlayerDisplay_PDF_TRANSLATE = 0x10005,
};
void DPlayerMenu::Init(DMenu *parent, DListMenuDescriptor *desc)
{
@ -536,14 +122,14 @@ void DPlayerMenu::Init(DMenu *parent, DListMenuDescriptor *desc)
li = GetItem(NAME_Playerdisplay);
if (li != NULL)
{
li->SetValue(DListMenuItemPlayerDisplay_::PDF_ROTATION, 0);
li->SetValue(DListMenuItemPlayerDisplay_::PDF_MODE, 1);
li->SetValue(DListMenuItemPlayerDisplay_::PDF_TRANSLATE, 1);
li->SetValue(DListMenuItemPlayerDisplay_::PDF_CLASS, players[consoleplayer].userinfo.GetPlayerClassNum());
li->SetValue(ListMenuItemPlayerDisplay_PDF_ROTATION, 0);
li->SetValue(ListMenuItemPlayerDisplay_PDF_MODE, 1);
li->SetValue(ListMenuItemPlayerDisplay_PDF_TRANSLATE, 1);
li->SetValue(ListMenuItemPlayerDisplay_PDF_CLASS, players[consoleplayer].userinfo.GetPlayerClassNum());
if (PlayerClass != NULL && !(GetDefaultByType (PlayerClass->Type)->flags4 & MF4_NOSKIN) &&
players[consoleplayer].userinfo.GetPlayerClassNum() != -1)
{
li->SetValue(DListMenuItemPlayerDisplay_::PDF_SKIN, players[consoleplayer].userinfo.GetSkin());
li->SetValue(ListMenuItemPlayerDisplay_PDF_SKIN, players[consoleplayer].userinfo.GetSkin());
}
}
@ -658,7 +244,7 @@ bool DPlayerMenu::Responder (event_t *ev)
DMenuItemBase *li = GetItem(NAME_Playerdisplay);
if (li != NULL)
{
li->SetValue(DListMenuItemPlayerDisplay_::PDF_ROTATION, mRotation);
li->SetValue(ListMenuItemPlayerDisplay_PDF_ROTATION, mRotation);
}
return true;
}
@ -812,7 +398,7 @@ void DPlayerMenu::UpdateSkins()
li = GetItem(NAME_Playerdisplay);
if (li != NULL)
{
li->SetValue(DListMenuItemPlayerDisplay_::PDF_SKIN, skin);
li->SetValue(ListMenuItemPlayerDisplay_PDF_SKIN, skin);
}
}
UpdateTranslation();
@ -908,7 +494,7 @@ void DPlayerMenu::ClassChanged (DMenuItemBase *li)
li = GetItem(NAME_Playerdisplay);
if (li != NULL)
{
li->SetValue(DListMenuItemPlayerDisplay_::PDF_CLASS, players[consoleplayer].userinfo.GetPlayerClassNum());
li->SetValue(ListMenuItemPlayerDisplay_PDF_CLASS, players[consoleplayer].userinfo.GetPlayerClassNum());
}
}
}
@ -939,7 +525,7 @@ void DPlayerMenu::SkinChanged (DMenuItemBase *li)
li = GetItem(NAME_Playerdisplay);
if (li != NULL)
{
li->SetValue(DListMenuItemPlayerDisplay_::PDF_SKIN, sel);
li->SetValue(ListMenuItemPlayerDisplay_PDF_SKIN, sel);
}
}
}