mirror of https://github.com/AxioDL/metaforce.git
2801 lines
99 KiB
C++
2801 lines
99 KiB
C++
#include "CFrontEndUI.hpp"
|
|
#include "CArchitectureMessage.hpp"
|
|
#include "CArchitectureQueue.hpp"
|
|
#include "CDvdFile.hpp"
|
|
#include "CSimplePool.hpp"
|
|
#include "GameGlobalObjects.hpp"
|
|
#include "MP1.hpp"
|
|
#include "CSlideShow.hpp"
|
|
#include "Audio/CSfxManager.hpp"
|
|
#include "Graphics/CMoviePlayer.hpp"
|
|
#include "CSaveGameScreen.hpp"
|
|
#include "GuiSys/CGuiTextPane.hpp"
|
|
#include "GuiSys/CGuiFrame.hpp"
|
|
#include "GuiSys/CStringTable.hpp"
|
|
#include "GuiSys/CGuiTableGroup.hpp"
|
|
#include "GuiSys/CGuiSliderGroup.hpp"
|
|
#include "GuiSys/CGuiModel.hpp"
|
|
#include "CGameState.hpp"
|
|
#include "CDependencyGroup.hpp"
|
|
#include "Audio/CAudioGroupSet.hpp"
|
|
#include "GuiSys/CGuiWidgetDrawParms.hpp"
|
|
#include "CNESEmulator.hpp"
|
|
#include "CQuitGameScreen.hpp"
|
|
#include "Input/RumbleFxTable.hpp"
|
|
#include <ctime>
|
|
|
|
namespace urde::MP1
|
|
{
|
|
|
|
/* Music volume constants */
|
|
static const float FE1_VOL = 0.7421875f;
|
|
static const float FE2_VOL = 0.7421875f;
|
|
|
|
/* L/R Stereo transition cues */
|
|
static const u16 FETransitionBackSFX[3][2] =
|
|
{
|
|
{1090, 1097},
|
|
{1098, 1099},
|
|
{1100, 1101}
|
|
};
|
|
|
|
static const u16 FETransitionForwardSFX[3][2] =
|
|
{
|
|
{1102, 1103},
|
|
{1104, 1105},
|
|
{1106, 1107}
|
|
};
|
|
|
|
struct FEMovie
|
|
{
|
|
const char* path;
|
|
bool loop;
|
|
};
|
|
|
|
static const FEMovie FEMovies[] =
|
|
{
|
|
{"Video/00_first_start.thp", false},
|
|
{"Video/01_startloop.thp", true},
|
|
{"Video/02_start_fileselect_A.thp", false},
|
|
{"Video/03_fileselectloop.thp", true},
|
|
{"Video/04_fileselect_playgame_A.thp", false},
|
|
{"Video/06_fileselect_GBA.thp", false},
|
|
{"Video/07_GBAloop.thp", true},
|
|
{"Video/08_GBA_fileselect.thp", false},
|
|
{"Video/08_GBA_fileselect.thp", false},
|
|
};
|
|
|
|
SObjectTag g_DefaultWorldTag = {FOURCC('MLVL'), 0x158efe17};
|
|
|
|
void CFrontEndUI::PlayAdvanceSfx()
|
|
{
|
|
CSfxManager::SfxStart(1096, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
CSfxManager::SfxStart(1091, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
|
|
CFrontEndUI::SNewFileSelectFrame::SNewFileSelectFrame(CSaveGameScreen* sui, u32 rnd, CFrontEndUITouchBar& touchBar)
|
|
: x0_rnd(rnd), x4_saveUI(sui), m_touchBar(touchBar)
|
|
{
|
|
x10_frme = g_SimplePool->GetObj("FRME_NewFileSelect");
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::FinishedLoading()
|
|
{
|
|
x1c_loadedFrame->SetAspectConstraint(1.78f);
|
|
|
|
x20_tablegroup_fileselect = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_fileselect"));
|
|
x24_model_erase = static_cast<CGuiModel*>(x1c_loadedFrame->FindWidget("model_erase"));
|
|
xf8_model_erase_position = x24_model_erase->GetLocalPosition();
|
|
x28_textpane_erase = FindTextPanePair(x1c_loadedFrame, "textpane_erase");
|
|
x38_textpane_gba = FindTextPanePair(x1c_loadedFrame, "textpane_gba");
|
|
x30_textpane_cheats = FindTextPanePair(x1c_loadedFrame, "textpane_cheats");
|
|
x48_textpane_popupadvance = FindTextPanePair(x1c_loadedFrame, "textpane_popupadvance");
|
|
x50_textpane_popupcancel = FindTextPanePair(x1c_loadedFrame, "textpane_popupcancel");
|
|
x58_textpane_popupextra = FindTextPanePair(x1c_loadedFrame, "textpane_popupextra");
|
|
x40_tablegroup_popup = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_popup"));
|
|
x44_model_dash7 = static_cast<CGuiModel*>(x1c_loadedFrame->FindWidget("model_dash7"));
|
|
x60_textpane_cancel = static_cast<CGuiTextPane*>(x1c_loadedFrame->FindWidget("textpane_cancel"));
|
|
FindAndSetPairText(x1c_loadedFrame, "textpane_title", g_MainStringTable->GetString(97));
|
|
CGuiTextPane* proceed = static_cast<CGuiTextPane*>(x1c_loadedFrame->FindWidget("textpane_proceed"));
|
|
if (proceed)
|
|
proceed->TextSupport().SetText(g_MainStringTable->GetString(85));
|
|
x40_tablegroup_popup->SetIsVisible(false);
|
|
x40_tablegroup_popup->SetIsActive(false);
|
|
x40_tablegroup_popup->SetVertical(false);
|
|
CGuiWidget* worker = x40_tablegroup_popup->GetWorkerWidget(2);
|
|
worker->SetIsSelectable(false);
|
|
worker->SetVisibility(false, ETraversalMode::Children);
|
|
|
|
x20_tablegroup_fileselect->SetMenuAdvanceCallback(
|
|
std::bind(&SNewFileSelectFrame::DoFileMenuAdvance, this, std::placeholders::_1));
|
|
x20_tablegroup_fileselect->SetMenuSelectionChangeCallback(
|
|
std::bind(&SNewFileSelectFrame::DoSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
x20_tablegroup_fileselect->SetMenuCancelCallback(
|
|
std::bind(&SNewFileSelectFrame::DoFileMenuCancel, this, std::placeholders::_1));
|
|
|
|
x40_tablegroup_popup->SetMenuAdvanceCallback(
|
|
std::bind(&SNewFileSelectFrame::DoPopupAdvance, this, std::placeholders::_1));
|
|
x40_tablegroup_popup->SetMenuSelectionChangeCallback(
|
|
std::bind(&SNewFileSelectFrame::DoSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
x40_tablegroup_popup->SetMenuCancelCallback(
|
|
std::bind(&SNewFileSelectFrame::DoPopupCancel, this, std::placeholders::_1));
|
|
|
|
for (int i=0 ; i<3 ; ++i)
|
|
x64_fileSelections[i] = FindFileSelectOption(x1c_loadedFrame, i);
|
|
|
|
x104_rowPitch = (x64_fileSelections[1].x0_base->GetLocalPosition() -
|
|
x64_fileSelections[0].x0_base->GetLocalPosition()).z;
|
|
}
|
|
|
|
bool CFrontEndUI::SNewFileSelectFrame::PumpLoad()
|
|
{
|
|
if (x1c_loadedFrame)
|
|
return true;
|
|
if (x10_frme.IsLoaded())
|
|
{
|
|
if (x10_frme->GetIsFinishedLoading())
|
|
{
|
|
x1c_loadedFrame = x10_frme.GetObj();
|
|
FinishedLoading();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CFrontEndUI::SNewFileSelectFrame::IsTextDoneAnimating() const
|
|
{
|
|
if (x64_fileSelections[0].x28_curField != 4)
|
|
return false;
|
|
if (x64_fileSelections[1].x28_curField != 4)
|
|
return false;
|
|
if (x64_fileSelections[2].x28_curField != 4)
|
|
return false;
|
|
if (!x28_textpane_erase.x0_panes[0]->GetTextSupport().IsAnimationDone())
|
|
return false;
|
|
return x38_textpane_gba.x0_panes[0]->GetTextSupport().IsAnimationDone();
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::Update(float dt)
|
|
{
|
|
bool saveReady = x4_saveUI->GetUIType() == CSaveGameScreen::EUIType::SaveReady;
|
|
if (saveReady != x10c_saveReady)
|
|
{
|
|
if (saveReady)
|
|
{
|
|
ClearFrameContents();
|
|
}
|
|
else if (x8_subMenu != ESubMenu::Root)
|
|
{
|
|
ResetFrame();
|
|
DeactivateEraseGamePopup();
|
|
DeactivateNewGamePopup();
|
|
x8_subMenu = ESubMenu::Root;
|
|
}
|
|
x10c_saveReady = saveReady;
|
|
}
|
|
if (x10c_saveReady)
|
|
SetupFrameContents();
|
|
|
|
x1c_loadedFrame->Update(dt);
|
|
}
|
|
|
|
CFrontEndUI::SNewFileSelectFrame::EAction
|
|
CFrontEndUI::SNewFileSelectFrame::ProcessUserInput(const CFinalInput& input, CFrontEndUITouchBar::EAction tbAction)
|
|
{
|
|
xc_action = EAction::None;
|
|
|
|
if (x8_subMenu != ESubMenu::EraseGamePopup)
|
|
x4_saveUI->ProcessUserInput(input);
|
|
|
|
if (IsTextDoneAnimating())
|
|
x108_curTime = std::min(0.5f, x108_curTime + input.DeltaTime());
|
|
|
|
if (x108_curTime < 0.5f)
|
|
return xc_action;
|
|
|
|
if (x10c_saveReady)
|
|
{
|
|
x1c_loadedFrame->ProcessUserInput(input);
|
|
if (x8_subMenu == ESubMenu::Root || x8_subMenu == ESubMenu::EraseGame)
|
|
{
|
|
if (m_touchBar.GetPhase() != CFrontEndUITouchBar::EPhase::FileSelect)
|
|
HandleActiveChange(x20_tablegroup_fileselect);
|
|
|
|
if (tbAction >= CFrontEndUITouchBar::EAction::FileA &&
|
|
tbAction <= CFrontEndUITouchBar::EAction::ImageGallery)
|
|
{
|
|
x20_tablegroup_fileselect->SetUserSelection(int(tbAction) - int(CFrontEndUITouchBar::EAction::FileA));
|
|
HandleActiveChange(x20_tablegroup_fileselect);
|
|
DoFileMenuAdvance(x20_tablegroup_fileselect);
|
|
}
|
|
else if (tbAction == CFrontEndUITouchBar::EAction::Back)
|
|
{
|
|
DoFileMenuCancel(x20_tablegroup_fileselect);
|
|
}
|
|
}
|
|
else if (x8_subMenu == ESubMenu::EraseGamePopup)
|
|
{
|
|
if (m_touchBar.GetPhase() != CFrontEndUITouchBar::EPhase::EraseBack)
|
|
HandleActiveChange(x40_tablegroup_popup);
|
|
|
|
if (tbAction != CFrontEndUITouchBar::EAction::None)
|
|
{
|
|
if (tbAction == CFrontEndUITouchBar::EAction::Confirm)
|
|
x40_tablegroup_popup->SetUserSelection(1);
|
|
else
|
|
x40_tablegroup_popup->SetUserSelection(0);
|
|
HandleActiveChange(x40_tablegroup_popup);
|
|
DoPopupAdvance(x40_tablegroup_popup);
|
|
}
|
|
}
|
|
else if (x8_subMenu == ESubMenu::NewGamePopup)
|
|
{
|
|
if (m_touchBar.GetPhase() != CFrontEndUITouchBar::EPhase::StartOptions)
|
|
HandleActiveChange(x40_tablegroup_popup);
|
|
|
|
if (tbAction == CFrontEndUITouchBar::EAction::Back)
|
|
{
|
|
DoPopupCancel(x40_tablegroup_popup);
|
|
}
|
|
else if (tbAction != CFrontEndUITouchBar::EAction::None)
|
|
{
|
|
if (tbAction == CFrontEndUITouchBar::EAction::Options)
|
|
x40_tablegroup_popup->SetUserSelection(1);
|
|
else if (tbAction == CFrontEndUITouchBar::EAction::Start ||
|
|
tbAction == CFrontEndUITouchBar::EAction::Hard)
|
|
x40_tablegroup_popup->SetUserSelection(0);
|
|
else if (tbAction == CFrontEndUITouchBar::EAction::Normal)
|
|
x40_tablegroup_popup->SetUserSelection(2);
|
|
HandleActiveChange(x40_tablegroup_popup);
|
|
DoPopupAdvance(x40_tablegroup_popup);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (x10d_needsEraseToggle)
|
|
{
|
|
if (x40_tablegroup_popup->GetIsActive())
|
|
DeactivateEraseGamePopup();
|
|
else
|
|
ActivateEraseGamePopup();
|
|
x10d_needsEraseToggle = false;
|
|
}
|
|
|
|
if (x10e_needsNewToggle)
|
|
{
|
|
if (x40_tablegroup_popup->GetIsActive())
|
|
DeactivateNewGamePopup();
|
|
else
|
|
ActivateNewGamePopup();
|
|
x10e_needsNewToggle = false;
|
|
}
|
|
|
|
return xc_action;
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::Draw() const
|
|
{
|
|
if (x1c_loadedFrame && x10c_saveReady)
|
|
x1c_loadedFrame->Draw(CGuiWidgetDrawParms::Default);
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::HandleActiveChange(CGuiTableGroup* active)
|
|
{
|
|
if (!active)
|
|
return;
|
|
|
|
active->SetColors(zeus::CColor::skWhite,
|
|
zeus::CColor{0.627450f, 0.627450f, 0.627450f, 0.784313f});
|
|
|
|
if (active == x20_tablegroup_fileselect)
|
|
{
|
|
x24_model_erase->SetLocalTransform(zeus::CTransform::Translate(
|
|
zeus::CVector3f{0.f, 0.f, active->GetUserSelection() * x104_rowPitch} + xf8_model_erase_position));
|
|
|
|
/* Set Touch Bar contents here */
|
|
CFrontEndUITouchBar::SFileSelectDetail tbDetails[3] = {};
|
|
for (int i=0 ; i<3 ; ++i)
|
|
{
|
|
if (const CGameState::GameFileStateInfo* data = x4_saveUI->GetGameData(i))
|
|
{
|
|
tbDetails[i].state = data->x20_hardMode ? CFrontEndUITouchBar::EFileState::Hard :
|
|
CFrontEndUITouchBar::EFileState::Normal;
|
|
tbDetails[i].percent = data->x18_itemPercent;
|
|
}
|
|
}
|
|
m_touchBar.SetFileSelectPhase(tbDetails, x8_subMenu == ESubMenu::EraseGame,
|
|
CSlideShow::SlideShowGalleryFlags());
|
|
}
|
|
else if (active == x40_tablegroup_popup)
|
|
{
|
|
if (x8_subMenu == ESubMenu::EraseGamePopup)
|
|
m_touchBar.SetPhase(CFrontEndUITouchBar::EPhase::EraseBack);
|
|
else if (x8_subMenu == ESubMenu::NewGamePopup)
|
|
m_touchBar.SetStartOptionsPhase(g_GameState->SystemOptions().GetPlayerBeatNormalMode());
|
|
else
|
|
m_touchBar.SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
}
|
|
|
|
if (x8_subMenu == ESubMenu::Root || x8_subMenu == ESubMenu::NewGamePopup)
|
|
x24_model_erase->SetIsVisible(false);
|
|
else
|
|
x24_model_erase->SetIsVisible(true);
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::DeactivateEraseGamePopup()
|
|
{
|
|
x40_tablegroup_popup->SetIsActive(false);
|
|
x40_tablegroup_popup->SetIsVisible(false);
|
|
x20_tablegroup_fileselect->SetIsActive(true);
|
|
|
|
HandleActiveChange(x20_tablegroup_fileselect);
|
|
|
|
x64_fileSelections[x20_tablegroup_fileselect->GetUserSelection()].
|
|
x0_base->SetColor(zeus::CColor::skWhite);
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::ActivateEraseGamePopup()
|
|
{
|
|
x40_tablegroup_popup->SetIsActive(true);
|
|
x40_tablegroup_popup->SetIsVisible(true);
|
|
x40_tablegroup_popup->SetLocalTransform(
|
|
zeus::CTransform::Translate(0.f, 0.f, x20_tablegroup_fileselect->GetUserSelection() * x104_rowPitch) *
|
|
x40_tablegroup_popup->GetTransform());
|
|
x20_tablegroup_fileselect->SetIsActive(false);
|
|
|
|
x8_subMenu = ESubMenu::EraseGamePopup;
|
|
HandleActiveChange(x40_tablegroup_popup);
|
|
|
|
x48_textpane_popupadvance.SetPairText(g_MainStringTable->GetString(95));
|
|
x50_textpane_popupcancel.SetPairText(g_MainStringTable->GetString(38));
|
|
|
|
x64_fileSelections[x20_tablegroup_fileselect->GetUserSelection()].
|
|
x0_base->SetColor(zeus::CColor{1.f, 1.f, 1.f, 0.f});
|
|
x44_model_dash7->SetVisibility(false, ETraversalMode::Children);
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::DeactivateNewGamePopup()
|
|
{
|
|
x40_tablegroup_popup->SetIsActive(false);
|
|
x40_tablegroup_popup->SetIsVisible(false);
|
|
x20_tablegroup_fileselect->SetIsActive(true);
|
|
|
|
CGuiWidget* worker = x40_tablegroup_popup->GetWorkerWidget(2);
|
|
worker->SetIsSelectable(false);
|
|
worker->SetVisibility(false, ETraversalMode::Children);
|
|
|
|
x44_model_dash7->SetVisibility(false, ETraversalMode::Children);
|
|
|
|
HandleActiveChange(x20_tablegroup_fileselect);
|
|
|
|
x64_fileSelections[x20_tablegroup_fileselect->GetUserSelection()].
|
|
x0_base->SetColor(zeus::CColor::skWhite);
|
|
x60_textpane_cancel->TextSupport().SetText(u"");
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::ActivateNewGamePopup()
|
|
{
|
|
x40_tablegroup_popup->SetIsActive(true);
|
|
x40_tablegroup_popup->SetIsVisible(true);
|
|
x40_tablegroup_popup->SetUserSelection(0);
|
|
x40_tablegroup_popup->SetLocalTransform(
|
|
zeus::CTransform::Translate(0.f, 0.f, x20_tablegroup_fileselect->GetUserSelection() * x104_rowPitch) *
|
|
x40_tablegroup_popup->GetTransform());
|
|
x20_tablegroup_fileselect->SetIsActive(false);
|
|
|
|
x8_subMenu = ESubMenu::NewGamePopup;
|
|
HandleActiveChange(x40_tablegroup_popup);
|
|
x64_fileSelections[x20_tablegroup_fileselect->GetUserSelection()].
|
|
x0_base->SetColor(zeus::CColor{1.f, 1.f, 1.f, 0.f});
|
|
|
|
PlayAdvanceSfx();
|
|
|
|
if (g_GameState->SystemOptions().GetPlayerBeatNormalMode())
|
|
{
|
|
x48_textpane_popupadvance.SetPairText(g_MainStringTable->GetString(102));
|
|
x50_textpane_popupcancel.SetPairText(g_MainStringTable->GetString(94));
|
|
x58_textpane_popupextra.SetPairText(g_MainStringTable->GetString(101));
|
|
CGuiWidget* worker = x40_tablegroup_popup->GetWorkerWidget(2);
|
|
worker->SetIsSelectable(true);
|
|
worker->SetVisibility(true, ETraversalMode::Children);
|
|
x44_model_dash7->SetVisibility(true, ETraversalMode::Children);
|
|
}
|
|
else
|
|
{
|
|
x48_textpane_popupadvance.SetPairText(g_MainStringTable->GetString(67));
|
|
x50_textpane_popupcancel.SetPairText(g_MainStringTable->GetString(94));
|
|
x44_model_dash7->SetVisibility(false, ETraversalMode::Children);
|
|
}
|
|
x60_textpane_cancel->TextSupport().SetText(g_MainStringTable->GetString(82));
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::ResetFrame()
|
|
{
|
|
x8_subMenu = ESubMenu::Root;
|
|
|
|
x38_textpane_gba.x0_panes[0]->SetIsSelectable(true);
|
|
x38_textpane_gba.x0_panes[0]->TextSupport().SetFontColor(zeus::CColor::skWhite);
|
|
|
|
x30_textpane_cheats.x0_panes[0]->SetIsSelectable(true);
|
|
x30_textpane_cheats.x0_panes[0]->TextSupport().SetFontColor(zeus::CColor::skWhite);
|
|
|
|
ClearFrameContents();
|
|
|
|
for (int i=2 ; i>=0 ; --i)
|
|
x20_tablegroup_fileselect->GetWorkerWidget(i)->SetIsSelectable(true);
|
|
x60_textpane_cancel->TextSupport().SetText(u"");
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::ActivateErase()
|
|
{
|
|
x8_subMenu = ESubMenu::EraseGame;
|
|
x28_textpane_erase.x0_panes[0]->SetIsSelectable(false);
|
|
zeus::CColor color = zeus::CColor::skGrey;
|
|
color.a = 0.5f;
|
|
x28_textpane_erase.x0_panes[0]->TextSupport().SetFontColor(color);
|
|
x38_textpane_gba.x0_panes[0]->TextSupport().SetFontColor(color);
|
|
x30_textpane_cheats.x0_panes[0]->TextSupport().SetFontColor(color);
|
|
x38_textpane_gba.x0_panes[0]->SetIsSelectable(false);
|
|
x30_textpane_cheats.x0_panes[0]->SetIsSelectable(false);
|
|
|
|
for (int i=2 ; i>=0 ; --i)
|
|
{
|
|
SFileMenuOption& fileOpt = x64_fileSelections[i];
|
|
if (x4_saveUI->GetGameData(i))
|
|
{
|
|
fileOpt.x0_base->SetIsSelectable(true);
|
|
x20_tablegroup_fileselect->SetUserSelection(i);
|
|
}
|
|
else
|
|
{
|
|
fileOpt.x0_base->SetIsSelectable(false);
|
|
}
|
|
}
|
|
|
|
x60_textpane_cancel->TextSupport().SetText(g_MainStringTable->GetString(82));
|
|
HandleActiveChange(x20_tablegroup_fileselect);
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::ClearFrameContents()
|
|
{
|
|
x108_curTime = 0.f;
|
|
bool hasSave = false;
|
|
for (int i=0 ; i<3 ; ++i)
|
|
{
|
|
if (x4_saveUI->GetGameData(i))
|
|
hasSave = true;
|
|
SFileMenuOption& option = x64_fileSelections[i];
|
|
option.x2c_chRate = SFileMenuOption::ComputeRandom();
|
|
option.x28_curField = -1;
|
|
for (int j=0 ; j<4 ; ++j)
|
|
option.x4_textpanes[j].SetPairText(u"");
|
|
}
|
|
|
|
StartTextAnimating(x28_textpane_erase.x0_panes[0], g_MainStringTable->GetString(38), 60.f);
|
|
StartTextAnimating(x38_textpane_gba.x0_panes[0], g_MainStringTable->GetString(37), 60.f);
|
|
StartTextAnimating(x30_textpane_cheats.x0_panes[0], g_MainStringTable->GetString(96), 60.f);
|
|
|
|
StartTextAnimating(x28_textpane_erase.x0_panes[1], g_MainStringTable->GetString(38), 60.f);
|
|
StartTextAnimating(x38_textpane_gba.x0_panes[1], g_MainStringTable->GetString(37), 60.f);
|
|
StartTextAnimating(x30_textpane_cheats.x0_panes[1], g_MainStringTable->GetString(96), 60.f);
|
|
|
|
if (hasSave)
|
|
{
|
|
x28_textpane_erase.x0_panes[0]->SetIsSelectable(true);
|
|
x28_textpane_erase.x0_panes[0]->TextSupport().SetFontColor(zeus::CColor::skWhite);
|
|
}
|
|
else
|
|
{
|
|
x28_textpane_erase.x0_panes[0]->SetIsSelectable(false);
|
|
zeus::CColor color = zeus::CColor::skGrey;
|
|
color.a = 0.5f;
|
|
x28_textpane_erase.x0_panes[0]->TextSupport().SetFontColor(color);
|
|
}
|
|
|
|
x20_tablegroup_fileselect->SetUserSelection(0);
|
|
CGuiTextPane* cheats = static_cast<CGuiTextPane*>(x20_tablegroup_fileselect->GetWorkerWidget(5));
|
|
if (CSlideShow::SlideShowGalleryFlags())
|
|
{
|
|
cheats->SetIsSelectable(true);
|
|
x30_textpane_cheats.x0_panes[0]->TextSupport().SetFontColor(zeus::CColor::skWhite);
|
|
}
|
|
else
|
|
{
|
|
cheats->SetIsSelectable(false);
|
|
zeus::CColor color = zeus::CColor::skGrey;
|
|
color.a = 0.5f;
|
|
x30_textpane_cheats.x0_panes[0]->TextSupport().SetFontColor(color);
|
|
}
|
|
|
|
HandleActiveChange(x20_tablegroup_fileselect);
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::SetupFrameContents()
|
|
{
|
|
for (int i=0 ; i<3 ; ++i)
|
|
{
|
|
SFileMenuOption& option = x64_fileSelections[i];
|
|
if (option.x28_curField == 4)
|
|
continue;
|
|
SGuiTextPair* pair = (option.x28_curField == -1) ? nullptr : &option.x4_textpanes[option.x28_curField];
|
|
if (!pair ||
|
|
pair->x0_panes[0]->GetTextSupport().GetNumCharsPrinted() >=
|
|
pair->x0_panes[0]->GetTextSupport().GetNumCharsTotal())
|
|
{
|
|
if (++option.x28_curField < 4)
|
|
{
|
|
std::u16string str;
|
|
SGuiTextPair& populatePair = option.x4_textpanes[option.x28_curField];
|
|
const CGameState::GameFileStateInfo* data = x4_saveUI->GetGameData(i);
|
|
|
|
switch (option.x28_curField)
|
|
{
|
|
case 0:
|
|
// Completion percent
|
|
if (data)
|
|
{
|
|
std::u16string fileStr = g_MainStringTable->GetString(data->x20_hardMode ? 106 : 39);
|
|
str = fileStr + hecl::Char16Format(L" %02d%%", data->x18_itemPercent);
|
|
break;
|
|
}
|
|
str = g_MainStringTable->GetString(36);
|
|
break;
|
|
|
|
case 1:
|
|
// World name
|
|
if (data)
|
|
{
|
|
if (g_MemoryCardSys->HasSaveWorldMemory(data->x8_mlvlId))
|
|
{
|
|
const CSaveWorldMemory& wldMem = g_MemoryCardSys->GetSaveWorldMemory(data->x8_mlvlId);
|
|
str = wldMem.GetFrontEndName();
|
|
}
|
|
break;
|
|
}
|
|
str = g_MainStringTable->GetString(51);
|
|
break;
|
|
|
|
case 2:
|
|
// Formatted time
|
|
if (data)
|
|
{
|
|
auto pt = std::div(data->x0_playTime, 3600);
|
|
str = hecl::Char16Format(L"%02d:%02d", pt.quot, pt.rem / 60);
|
|
break;
|
|
}
|
|
str = g_MainStringTable->GetString(52);
|
|
break;
|
|
|
|
case 3:
|
|
// "Elapsed"
|
|
str = g_MainStringTable->GetString(data ? 54 : 53);
|
|
break;
|
|
|
|
default: break;
|
|
}
|
|
|
|
StartTextAnimating(populatePair.x0_panes[0], str, option.x2c_chRate);
|
|
StartTextAnimating(populatePair.x0_panes[1], str, option.x2c_chRate);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::DoPopupCancel(CGuiTableGroup* caller)
|
|
{
|
|
if (x8_subMenu == ESubMenu::EraseGamePopup)
|
|
{
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
x8_subMenu = ESubMenu::EraseGame;
|
|
x10d_needsEraseToggle = true;
|
|
}
|
|
else
|
|
{
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
x8_subMenu = ESubMenu::Root;
|
|
x10e_needsNewToggle = true;
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::DoPopupAdvance(CGuiTableGroup* caller)
|
|
{
|
|
if (x8_subMenu == ESubMenu::EraseGamePopup)
|
|
{
|
|
if (x40_tablegroup_popup->GetUserSelection() == 1)
|
|
{
|
|
x4_saveUI->EraseGame(x20_tablegroup_fileselect->GetUserSelection());
|
|
ResetFrame();
|
|
}
|
|
else
|
|
x8_subMenu = ESubMenu::EraseGame;
|
|
x10d_needsEraseToggle = true;
|
|
}
|
|
else
|
|
{
|
|
if (g_GameState->SystemOptions().GetPlayerBeatNormalMode())
|
|
{
|
|
if (x40_tablegroup_popup->GetUserSelection() == 1)
|
|
{
|
|
PlayAdvanceSfx();
|
|
xc_action = EAction::GameOptions;
|
|
return;
|
|
}
|
|
g_GameState->SetHardMode(!x40_tablegroup_popup->GetUserSelection());
|
|
x4_saveUI->StartGame(x20_tablegroup_fileselect->GetUserSelection());
|
|
}
|
|
else
|
|
{
|
|
if (x40_tablegroup_popup->GetUserSelection() == 1)
|
|
{
|
|
PlayAdvanceSfx();
|
|
xc_action = EAction::GameOptions;
|
|
return;
|
|
}
|
|
x4_saveUI->StartGame(x20_tablegroup_fileselect->GetUserSelection());
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::DoFileMenuCancel(CGuiTableGroup* caller)
|
|
{
|
|
if (x8_subMenu == ESubMenu::EraseGame)
|
|
{
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
ResetFrame();
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::DoSelectionChange(CGuiTableGroup* caller, int oldSel)
|
|
{
|
|
HandleActiveChange(caller);
|
|
CSfxManager::SfxStart(1093, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::DoFileMenuAdvance(CGuiTableGroup* caller)
|
|
{
|
|
int userSel = x20_tablegroup_fileselect->GetUserSelection();
|
|
if (userSel < 3)
|
|
{
|
|
if (x8_subMenu == ESubMenu::EraseGame)
|
|
{
|
|
if (x4_saveUI->GetGameData(userSel))
|
|
{
|
|
PlayAdvanceSfx();
|
|
x10d_needsEraseToggle = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (x4_saveUI->GetGameData(userSel))
|
|
{
|
|
m_touchBar.SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
x4_saveUI->StartGame(userSel);
|
|
}
|
|
else
|
|
x10e_needsNewToggle = true;
|
|
}
|
|
}
|
|
else if (userSel == 3)
|
|
{
|
|
PlayAdvanceSfx();
|
|
ActivateErase();
|
|
}
|
|
else if (userSel == 4)
|
|
{
|
|
xc_action = EAction::FusionBonus;
|
|
}
|
|
else if (userSel == 5)
|
|
{
|
|
xc_action = EAction::SlideShow;
|
|
}
|
|
}
|
|
|
|
CFrontEndUI::SFileMenuOption CFrontEndUI::SNewFileSelectFrame::FindFileSelectOption(CGuiFrame* frame, int idx)
|
|
{
|
|
SFileMenuOption ret;
|
|
ret.x0_base = frame->FindWidget(hecl::Format("basewidget_file%d", idx).c_str());
|
|
ret.x4_textpanes[0] = FindTextPanePair(frame, hecl::Format("textpane_filename%d", idx).c_str());
|
|
ret.x4_textpanes[1] = FindTextPanePair(frame, hecl::Format("textpane_world%d", idx).c_str());
|
|
ret.x4_textpanes[2] = FindTextPanePair(frame, hecl::Format("textpane_playtime%d", idx).c_str());
|
|
ret.x4_textpanes[3] = FindTextPanePair(frame, hecl::Format("textpane_date%d", idx).c_str());
|
|
return ret;
|
|
}
|
|
|
|
void CFrontEndUI::SNewFileSelectFrame::StartTextAnimating(CGuiTextPane* text, std::u16string_view str, float chRate)
|
|
{
|
|
text->TextSupport().SetText(str);
|
|
text->TextSupport().SetTypeWriteEffectOptions(true, 0.1f, chRate);
|
|
}
|
|
|
|
CFrontEndUI::SFusionBonusFrame::SFusionBonusFrame(CFrontEndUITouchBar& touchBar)
|
|
: m_touchBar(touchBar)
|
|
{
|
|
x4_gbaSupport = std::make_unique<CGBASupport>();
|
|
xc_gbaScreen = g_SimplePool->GetObj("FRME_GBAScreen");
|
|
x18_gbaLink = g_SimplePool->GetObj("FRME_GBALink");
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::SetUIText(EUIType tp)
|
|
{
|
|
int instructions = -1;
|
|
int yes = -1;
|
|
int no = -1;
|
|
|
|
bool cableVisible = false;
|
|
bool circleGcVisible = false;
|
|
bool circleGbaVisible = false;
|
|
bool circleStartVisible = false;
|
|
bool pakoutVisible = false;
|
|
bool gbaScreenVisible = false;
|
|
bool connectVisible = false;
|
|
|
|
switch (tp)
|
|
{
|
|
case EUIType::InsertPak:
|
|
instructions = 73; // Insert Game Pak
|
|
no = 82;
|
|
yes = 83;
|
|
pakoutVisible = true;
|
|
circleGbaVisible = true;
|
|
break;
|
|
case EUIType::ConnectSocket:
|
|
instructions = 68; // Connect socket
|
|
no = 82;
|
|
yes = 83;
|
|
cableVisible = true;
|
|
circleGcVisible = true;
|
|
circleGbaVisible = true;
|
|
break;
|
|
case EUIType::PressStartAndSelect:
|
|
instructions = 74; // Hold start and select
|
|
no = 82;
|
|
yes = 83;
|
|
cableVisible = true;
|
|
circleStartVisible = true;
|
|
gbaScreenVisible = true;
|
|
break;
|
|
case EUIType::BeginLink:
|
|
instructions = 75; // Begin link?
|
|
no = 82;
|
|
yes = 83;
|
|
cableVisible = true;
|
|
gbaScreenVisible = true;
|
|
break;
|
|
case EUIType::TurnOffGBA:
|
|
instructions = 76; // Turn off GBA
|
|
no = 82;
|
|
yes = 83;
|
|
cableVisible = true;
|
|
gbaScreenVisible = true;
|
|
circleStartVisible = true;
|
|
break;
|
|
case EUIType::Linking:
|
|
x4_gbaSupport->StartLink();
|
|
instructions = 72; // Linking
|
|
cableVisible = true;
|
|
gbaScreenVisible = true;
|
|
connectVisible = true;
|
|
break;
|
|
case EUIType::LinkFailed:
|
|
instructions = 69; // Link failed
|
|
no = 82;
|
|
yes = 83;
|
|
cableVisible = true;
|
|
circleGcVisible = true;
|
|
circleGbaVisible = true;
|
|
circleStartVisible = true;
|
|
gbaScreenVisible = true;
|
|
break;
|
|
case EUIType::LinkCompleteOrLinking:
|
|
yes = 83;
|
|
instructions = x40_linkInProgress + 71; // Complete or linking
|
|
cableVisible = true;
|
|
gbaScreenVisible = true;
|
|
break;
|
|
case EUIType::Complete:
|
|
case EUIType::Cancelled:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
std::u16string instructionsStr;
|
|
if (instructions != -1)
|
|
instructionsStr = g_MainStringTable->GetString(instructions);
|
|
xc_textpane_instructions.SetPairText(instructionsStr);
|
|
|
|
std::u16string yesStr;
|
|
if (yes != -1)
|
|
yesStr = g_MainStringTable->GetString(yes);
|
|
x14_textpane_yes->TextSupport().SetText(yesStr);
|
|
|
|
std::u16string noStr;
|
|
if (no != -1)
|
|
noStr = g_MainStringTable->GetString(no);
|
|
x18_textpane_no->TextSupport().SetText(noStr);
|
|
|
|
x1c_model_gc->SetVisibility(true, ETraversalMode::Children);
|
|
x20_model_gba->SetVisibility(true, ETraversalMode::Children);
|
|
x24_model_cable->SetVisibility(cableVisible, ETraversalMode::Children);
|
|
x28_model_circlegcport->SetVisibility(circleGcVisible, ETraversalMode::Children);
|
|
x2c_model_circlegbaport->SetVisibility(circleGbaVisible, ETraversalMode::Children);
|
|
x30_model_circlestartselect->SetVisibility(circleStartVisible, ETraversalMode::Children);
|
|
x34_model_pakout->SetVisibility(pakoutVisible, ETraversalMode::Children);
|
|
x38_model_gbascreen->SetVisibility(gbaScreenVisible, ETraversalMode::Children);
|
|
x3c_model_connect->SetVisibility(connectVisible, ETraversalMode::Children);
|
|
|
|
x0_uiType = tp;
|
|
}
|
|
|
|
static const CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType NextLinkUI[] =
|
|
{
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::ConnectSocket,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::PressStartAndSelect,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::BeginLink,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Linking,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Empty,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::TurnOffGBA,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Complete,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::InsertPak,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Empty,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Empty
|
|
};
|
|
|
|
static const CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType PrevLinkUI[] =
|
|
{
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Cancelled,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Cancelled,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Cancelled,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Cancelled,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Empty,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Cancelled,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Empty,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Cancelled,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Empty,
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EUIType::Empty
|
|
};
|
|
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::EAction
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::ProcessUserInput(const CFinalInput &input, bool linkInProgress,
|
|
CFrontEndUITouchBar::EAction tbAction)
|
|
{
|
|
if (linkInProgress != x40_linkInProgress)
|
|
{
|
|
x40_linkInProgress = linkInProgress;
|
|
SetUIText(x0_uiType);
|
|
}
|
|
|
|
switch (x0_uiType)
|
|
{
|
|
case EUIType::InsertPak:
|
|
case EUIType::ConnectSocket:
|
|
case EUIType::PressStartAndSelect:
|
|
case EUIType::BeginLink:
|
|
case EUIType::LinkFailed:
|
|
case EUIType::LinkCompleteOrLinking:
|
|
case EUIType::TurnOffGBA:
|
|
if (input.PA() || tbAction == CFrontEndUITouchBar::EAction::Confirm)
|
|
{
|
|
PlayAdvanceSfx();
|
|
SetUIText(NextLinkUI[int(x0_uiType)]);
|
|
}
|
|
else if (input.PB() || tbAction == CFrontEndUITouchBar::EAction::Back)
|
|
{
|
|
EUIType prevUi = PrevLinkUI[int(x0_uiType)];
|
|
if (prevUi == EUIType::Empty)
|
|
break;
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
SetUIText(prevUi);
|
|
}
|
|
break;
|
|
case EUIType::Linking:
|
|
if (x4_gbaSupport->GetPhase() == CGBASupport::EPhase::Complete)
|
|
{
|
|
if (x4_gbaSupport->IsFusionLinked())
|
|
g_GameState->SystemOptions().SetPlayerLinkedFusion(true);
|
|
if (x4_gbaSupport->IsFusionBeat())
|
|
g_GameState->SystemOptions().SetPlayerBeatFusion(true);
|
|
if (x4_gbaSupport->IsFusionLinked())
|
|
{
|
|
PlayAdvanceSfx();
|
|
SetUIText(EUIType::LinkCompleteOrLinking);
|
|
}
|
|
else
|
|
{
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
SetUIText(EUIType::LinkFailed);
|
|
}
|
|
}
|
|
else if (x4_gbaSupport->GetPhase() == CGBASupport::EPhase::Failed)
|
|
{
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
SetUIText(EUIType::LinkFailed);
|
|
}
|
|
break;
|
|
case EUIType::Complete:
|
|
return EAction::Complete;
|
|
case EUIType::Cancelled:
|
|
return EAction::Cancelled;
|
|
default: break;
|
|
}
|
|
|
|
return EAction::None;
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::Update(float dt)
|
|
{
|
|
x4_gbaSupport->Update(dt);
|
|
x8_frme->Update(dt);
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::FinishedLoading()
|
|
{
|
|
x8_frme->SetAspectConstraint(1.78f);
|
|
|
|
xc_textpane_instructions = FindTextPanePair(x8_frme, "textpane_instructions");
|
|
x14_textpane_yes = static_cast<CGuiTextPane*>(x8_frme->FindWidget("textpane_yes"));
|
|
x18_textpane_no = static_cast<CGuiTextPane*>(x8_frme->FindWidget("textpane_no"));
|
|
x1c_model_gc = static_cast<CGuiModel*>(x8_frme->FindWidget("model_gc"));
|
|
x20_model_gba = static_cast<CGuiModel*>(x8_frme->FindWidget("model_gba"));
|
|
x24_model_cable = static_cast<CGuiModel*>(x8_frme->FindWidget("model_cable"));
|
|
x28_model_circlegcport = static_cast<CGuiModel*>(x8_frme->FindWidget("model_circlegcport"));
|
|
x2c_model_circlegbaport = static_cast<CGuiModel*>(x8_frme->FindWidget("model_circlegbaport"));
|
|
x30_model_circlestartselect = static_cast<CGuiModel*>(x8_frme->FindWidget("model_circlestartselect"));
|
|
x34_model_pakout = static_cast<CGuiModel*>(x8_frme->FindWidget("model_pakout"));
|
|
x38_model_gbascreen = static_cast<CGuiModel*>(x8_frme->FindWidget("model_gbascreen"));
|
|
x3c_model_connect = static_cast<CGuiModel*>(x8_frme->FindWidget("model_connect"));
|
|
SetUIText(EUIType::InsertPak);
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::Draw()
|
|
{
|
|
x8_frme->Draw(CGuiWidgetDrawParms::Default);
|
|
}
|
|
|
|
CFrontEndUI::SFusionBonusFrame::SGBALinkFrame::SGBALinkFrame(CGuiFrame* linkFrame,
|
|
CGBASupport* support,
|
|
bool linkInProgress)
|
|
: x4_gbaSupport(support), x8_frme(linkFrame), x40_linkInProgress(linkInProgress)
|
|
{
|
|
support->InitializeSupport();
|
|
FinishedLoading();
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::FinishedLoading()
|
|
{
|
|
x24_loadedFrame->SetAspectConstraint(1.78f);
|
|
|
|
x28_tablegroup_options = static_cast<CGuiTableGroup*>(x24_loadedFrame->FindWidget("tablegroup_options"));
|
|
x2c_tablegroup_fusionsuit = static_cast<CGuiTableGroup*>(x24_loadedFrame->FindWidget("tablegroup_fusionsuit"));
|
|
x30_textpane_instructions = FindTextPanePair(x24_loadedFrame, "textpane_instructions");
|
|
|
|
FindAndSetPairText(x24_loadedFrame, "textpane_nes", g_MainStringTable->GetString(66));
|
|
FindAndSetPairText(x24_loadedFrame, "textpane_fusionsuit", g_MainStringTable->GetString(63));
|
|
FindAndSetPairText(x24_loadedFrame, "textpane_fusionsuitno", g_MainStringTable->GetString(65));
|
|
FindAndSetPairText(x24_loadedFrame, "textpane_fusionsuityes", g_MainStringTable->GetString(64));
|
|
FindAndSetPairText(x24_loadedFrame, "textpane_title", g_MainStringTable->GetString(100));
|
|
|
|
static_cast<CGuiTextPane*>(x24_loadedFrame->FindWidget("textpane_proceed"))->
|
|
TextSupport().SetText(g_MainStringTable->GetString(85));
|
|
static_cast<CGuiTextPane*>(x24_loadedFrame->FindWidget("textpane_cancel"))->
|
|
TextSupport().SetText(g_MainStringTable->GetString(82));
|
|
|
|
x2c_tablegroup_fusionsuit->SetIsActive(false);
|
|
x2c_tablegroup_fusionsuit->SetIsVisible(false);
|
|
x2c_tablegroup_fusionsuit->SetVertical(false);
|
|
x2c_tablegroup_fusionsuit->SetUserSelection(g_GameState->SystemOptions().GetPlayerFusionSuitActive());
|
|
|
|
SetTableColors(x28_tablegroup_options);
|
|
SetTableColors(x2c_tablegroup_fusionsuit);
|
|
|
|
x28_tablegroup_options->SetMenuAdvanceCallback(
|
|
std::bind(&SFusionBonusFrame::DoAdvance, this, std::placeholders::_1));
|
|
x28_tablegroup_options->SetMenuSelectionChangeCallback(
|
|
std::bind(&SFusionBonusFrame::DoSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
x28_tablegroup_options->SetMenuCancelCallback(
|
|
std::bind(&SFusionBonusFrame::DoCancel, this, std::placeholders::_1));
|
|
x2c_tablegroup_fusionsuit->SetMenuSelectionChangeCallback(
|
|
std::bind(&SFusionBonusFrame::DoSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
}
|
|
|
|
bool CFrontEndUI::SFusionBonusFrame::PumpLoad()
|
|
{
|
|
if (x24_loadedFrame)
|
|
return true;
|
|
if (!xc_gbaScreen.IsLoaded())
|
|
return false;
|
|
if (!x18_gbaLink.IsLoaded())
|
|
return false;
|
|
if (!x4_gbaSupport->IsReady())
|
|
return false;
|
|
if (!xc_gbaScreen->GetIsFinishedLoading())
|
|
return false;
|
|
x24_loadedFrame = xc_gbaScreen.GetObj();
|
|
FinishedLoading();
|
|
return true;
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::SetTableColors(CGuiTableGroup* tbgp) const
|
|
{
|
|
tbgp->SetColors(zeus::CColor::skWhite,
|
|
zeus::CColor{0.627450f, 0.627450f, 0.627450f, 0.784313f});
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::Update(float dt, CSaveGameScreen* saveUI)
|
|
{
|
|
bool doDraw = !saveUI || saveUI->GetUIType() == CSaveGameScreen::EUIType::SaveReady;
|
|
|
|
if (doDraw != x38_lastDoDraw)
|
|
{
|
|
x38_lastDoDraw = doDraw;
|
|
ResetCompletionFlags();
|
|
}
|
|
|
|
if (x0_gbaLinkFrame)
|
|
x0_gbaLinkFrame->Update(dt);
|
|
else if (x24_loadedFrame)
|
|
x24_loadedFrame->Update(dt);
|
|
|
|
bool showFusionSuit = g_GameState->SystemOptions().GetPlayerLinkedFusion() &&
|
|
g_GameState->SystemOptions().GetPlayerBeatNormalMode();
|
|
bool showFusionSuitProceed = showFusionSuit && x28_tablegroup_options->GetUserSelection() == 1;
|
|
x2c_tablegroup_fusionsuit->SetIsActive(showFusionSuitProceed);
|
|
x2c_tablegroup_fusionsuit->SetIsVisible(showFusionSuitProceed);
|
|
x24_loadedFrame->FindWidget("textpane_proceed")->SetIsVisible(showFusionSuitProceed);
|
|
|
|
std::u16string instructionStr;
|
|
x30_textpane_instructions.x0_panes[0]->TextSupport().SetFontColor(zeus::CColor::skWhite);
|
|
if (x28_tablegroup_options->GetUserSelection() == 1)
|
|
{
|
|
/* Fusion Suit */
|
|
if (x3a_mpNotComplete)
|
|
instructionStr = g_MainStringTable->GetString(80); // MP not complete
|
|
else if (!showFusionSuit)
|
|
instructionStr = g_MainStringTable->GetString(78); // To enable fusion suit
|
|
}
|
|
else
|
|
{
|
|
/* NES Metroid */
|
|
if (x39_fusionNotComplete)
|
|
instructionStr = g_MainStringTable->GetString(79); // You have not completed fusion
|
|
else if (!g_GameState->SystemOptions().GetPlayerBeatFusion())
|
|
instructionStr = g_MainStringTable->GetString(77); // To play NES Metroid
|
|
else
|
|
{
|
|
instructionStr = u"NES Emulator currently unsupported";
|
|
x30_textpane_instructions.x0_panes[0]->TextSupport().SetFontColor(zeus::CColor::skYellow);
|
|
}
|
|
}
|
|
|
|
x30_textpane_instructions.SetPairText(instructionStr);
|
|
}
|
|
|
|
CFrontEndUI::SFusionBonusFrame::EAction
|
|
CFrontEndUI::SFusionBonusFrame::ProcessUserInput(const CFinalInput& input, CSaveGameScreen* sui,
|
|
CFrontEndUITouchBar::EAction tbAction)
|
|
{
|
|
x8_action = EAction::None;
|
|
|
|
if (sui)
|
|
sui->ProcessUserInput(input);
|
|
|
|
if (x38_lastDoDraw)
|
|
{
|
|
if (x0_gbaLinkFrame)
|
|
{
|
|
if (m_touchBar.GetPhase() != CFrontEndUITouchBar::EPhase::ProceedBack)
|
|
m_touchBar.SetPhase(CFrontEndUITouchBar::EPhase::ProceedBack);
|
|
|
|
SGBALinkFrame::EAction action = x0_gbaLinkFrame->ProcessUserInput(input, sui, tbAction);
|
|
if (action != SGBALinkFrame::EAction::None)
|
|
{
|
|
x0_gbaLinkFrame.reset();
|
|
if (action == SGBALinkFrame::EAction::Complete)
|
|
{
|
|
if (x28_tablegroup_options->GetUserSelection() == 0 &&
|
|
!g_GameState->SystemOptions().GetPlayerBeatFusion())
|
|
x39_fusionNotComplete = true;
|
|
else if (sui)
|
|
sui->SaveNESState();
|
|
}
|
|
}
|
|
}
|
|
else if (x24_loadedFrame)
|
|
{
|
|
bool showFusionSuit = g_GameState->SystemOptions().GetPlayerLinkedFusion() &&
|
|
g_GameState->SystemOptions().GetPlayerBeatNormalMode();
|
|
if (m_touchBar.GetPhase() != CFrontEndUITouchBar::EPhase::FusionBonus)
|
|
{
|
|
m_touchBar.SetFusionBonusPhase(showFusionSuit &&
|
|
g_GameState->SystemOptions().GetPlayerFusionSuitActive());
|
|
}
|
|
|
|
x24_loadedFrame->ProcessUserInput(input);
|
|
|
|
switch (tbAction)
|
|
{
|
|
case CFrontEndUITouchBar::EAction::NESMetroid:
|
|
x28_tablegroup_options->SetUserSelection(0);
|
|
ResetCompletionFlags();
|
|
SetTableColors(x28_tablegroup_options);
|
|
DoAdvance(x28_tablegroup_options);
|
|
break;
|
|
case CFrontEndUITouchBar::EAction::FusionSuit:
|
|
x28_tablegroup_options->SetUserSelection(1);
|
|
ResetCompletionFlags();
|
|
SetTableColors(x28_tablegroup_options);
|
|
if (showFusionSuit)
|
|
{
|
|
if (x2c_tablegroup_fusionsuit->GetUserSelection() == 1)
|
|
{
|
|
x2c_tablegroup_fusionsuit->SetUserSelection(0);
|
|
DoSelectionChange(x2c_tablegroup_fusionsuit, 0);
|
|
}
|
|
else
|
|
{
|
|
x2c_tablegroup_fusionsuit->SetUserSelection(1);
|
|
DoSelectionChange(x2c_tablegroup_fusionsuit, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DoAdvance(x28_tablegroup_options);
|
|
}
|
|
break;
|
|
case CFrontEndUITouchBar::EAction::Back:
|
|
DoCancel(x28_tablegroup_options);
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return x8_action;
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::Draw() const
|
|
{
|
|
if (!x38_lastDoDraw)
|
|
return;
|
|
if (x0_gbaLinkFrame)
|
|
x0_gbaLinkFrame->Draw();
|
|
else if (x24_loadedFrame)
|
|
x24_loadedFrame->Draw(CGuiWidgetDrawParms::Default);
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::DoCancel(CGuiTableGroup* caller)
|
|
{
|
|
x8_action = EAction::GoBack;
|
|
x28_tablegroup_options->SetUserSelection(0);
|
|
x2c_tablegroup_fusionsuit->SetIsActive(false);
|
|
x30_textpane_instructions.SetPairText(u"");
|
|
SetTableColors(x28_tablegroup_options);
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::DoSelectionChange(CGuiTableGroup* caller, int oldSel)
|
|
{
|
|
if (caller == x28_tablegroup_options)
|
|
{
|
|
CSfxManager::SfxStart(1093, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
ResetCompletionFlags();
|
|
}
|
|
else
|
|
{
|
|
CSfxManager::SfxStart(1095, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
bool fusionActive = x2c_tablegroup_fusionsuit->GetUserSelection() == 1;
|
|
g_GameState->SystemOptions().SetPlayerFusionSuitActive(fusionActive);
|
|
g_GameState->GetPlayerState()->SetIsFusionEnabled(fusionActive);
|
|
m_touchBar.SetFusionBonusPhase(g_GameState->SystemOptions().GetPlayerFusionSuitActive());
|
|
}
|
|
SetTableColors(caller);
|
|
}
|
|
|
|
void CFrontEndUI::SFusionBonusFrame::DoAdvance(CGuiTableGroup* caller)
|
|
{
|
|
switch (x28_tablegroup_options->GetUserSelection())
|
|
{
|
|
case 1:
|
|
/* Fusion Suit */
|
|
if (x3a_mpNotComplete)
|
|
{
|
|
x3a_mpNotComplete = false;
|
|
PlayAdvanceSfx();
|
|
}
|
|
else if (g_GameState->SystemOptions().GetPlayerBeatNormalMode())
|
|
{
|
|
if (g_GameState->SystemOptions().GetPlayerLinkedFusion())
|
|
return;
|
|
x0_gbaLinkFrame = std::make_unique<SGBALinkFrame>(x18_gbaLink.GetObj(), x4_gbaSupport.get(), false);
|
|
PlayAdvanceSfx();
|
|
}
|
|
else
|
|
{
|
|
x3a_mpNotComplete = true;
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
break;
|
|
case 0:
|
|
/* NES Metroid */
|
|
if (x39_fusionNotComplete)
|
|
{
|
|
x39_fusionNotComplete = false;
|
|
PlayAdvanceSfx();
|
|
}
|
|
else if (g_GameState->SystemOptions().GetPlayerBeatFusion())
|
|
{
|
|
x8_action = EAction::None;
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
//x8_action = EAction::PlayNESMetroid;
|
|
}
|
|
else
|
|
{
|
|
x0_gbaLinkFrame = std::make_unique<SGBALinkFrame>(x18_gbaLink.GetObj(), x4_gbaSupport.get(), false);
|
|
PlayAdvanceSfx();
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SGuiTextPair::SetPairText(std::u16string_view str)
|
|
{
|
|
x0_panes[0]->TextSupport().SetText(str);
|
|
x0_panes[1]->TextSupport().SetText(str);
|
|
}
|
|
|
|
CFrontEndUI::SGuiTextPair CFrontEndUI::FindTextPanePair(CGuiFrame* frame, const char* name)
|
|
{
|
|
SGuiTextPair ret;
|
|
ret.x0_panes[0] = static_cast<CGuiTextPane*>(frame->FindWidget(name));
|
|
ret.x0_panes[1] = static_cast<CGuiTextPane*>(frame->FindWidget(hecl::Format("%sb", name).c_str()));
|
|
return ret;
|
|
}
|
|
|
|
void CFrontEndUI::FindAndSetPairText(CGuiFrame* frame, const char* name, std::u16string_view str)
|
|
{
|
|
CGuiTextPane* w1 = static_cast<CGuiTextPane*>(frame->FindWidget(name));
|
|
w1->TextSupport().SetText(str);
|
|
CGuiTextPane* w2 = static_cast<CGuiTextPane*>(frame->FindWidget(hecl::Format("%sb", name).c_str()));
|
|
w2->TextSupport().SetText(str);
|
|
}
|
|
|
|
void CFrontEndUI::SFrontEndFrame::FinishedLoading()
|
|
{
|
|
x14_loadedFrme->SetAspectConstraint(1.78f);
|
|
|
|
x18_tablegroup_mainmenu = static_cast<CGuiTableGroup*>(x14_loadedFrme->FindWidget("tablegroup_mainmenu"));
|
|
x1c_gbaPair = FindTextPanePair(x14_loadedFrme, "textpane_gba");
|
|
x1c_gbaPair.SetPairText(g_MainStringTable->GetString(37));
|
|
x24_cheatPair = FindTextPanePair(x14_loadedFrme, "textpane_cheats");
|
|
x24_cheatPair.SetPairText(g_MainStringTable->GetString(96));
|
|
|
|
FindAndSetPairText(x14_loadedFrme, "textpane_start", g_MainStringTable->GetString(67));
|
|
FindAndSetPairText(x14_loadedFrme, "textpane_options", g_MainStringTable->GetString(94));
|
|
FindAndSetPairText(x14_loadedFrme, "textpane_title", g_MainStringTable->GetString(98));
|
|
|
|
CGuiTextPane* proceed = static_cast<CGuiTextPane*>(x14_loadedFrme->FindWidget("textpane_proceed"));
|
|
if (proceed)
|
|
proceed->TextSupport().SetText(g_MainStringTable->GetString(85));
|
|
|
|
x18_tablegroup_mainmenu->SetMenuAdvanceCallback(
|
|
std::bind(&SFrontEndFrame::DoAdvance, this, std::placeholders::_1));
|
|
x18_tablegroup_mainmenu->SetMenuSelectionChangeCallback(
|
|
std::bind(&SFrontEndFrame::DoSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
x18_tablegroup_mainmenu->SetMenuCancelCallback(
|
|
std::bind(&SFrontEndFrame::DoCancel, this, std::placeholders::_1));
|
|
|
|
HandleActiveChange(x18_tablegroup_mainmenu);
|
|
}
|
|
|
|
bool CFrontEndUI::SFrontEndFrame::PumpLoad()
|
|
{
|
|
if (x14_loadedFrme)
|
|
return true;
|
|
if (x8_frme.IsLoaded())
|
|
{
|
|
if (CGuiFrame* frme = x8_frme.GetObj())
|
|
{
|
|
if (frme->GetIsFinishedLoading())
|
|
{
|
|
x14_loadedFrme = frme;
|
|
FinishedLoading();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CFrontEndUI::SFrontEndFrame::Update(float dt)
|
|
{
|
|
CGuiTextPane* imageGallery =
|
|
static_cast<CGuiTextPane*>(x18_tablegroup_mainmenu->GetWorkerWidget(3));
|
|
|
|
if (CSlideShow::SlideShowGalleryFlags())
|
|
{
|
|
imageGallery->SetIsSelectable(true);
|
|
x24_cheatPair.x0_panes[0]->TextSupport().SetFontColor(zeus::CColor::skWhite);
|
|
}
|
|
else
|
|
{
|
|
imageGallery->SetIsSelectable(false);
|
|
zeus::CColor color = zeus::CColor::skGrey;
|
|
color.a = 0.5f;
|
|
x24_cheatPair.x0_panes[0]->TextSupport().SetFontColor(color);
|
|
}
|
|
|
|
x14_loadedFrme->Update(dt);
|
|
}
|
|
|
|
CFrontEndUI::SFrontEndFrame::EAction
|
|
CFrontEndUI::SFrontEndFrame::ProcessUserInput(const CFinalInput& input,
|
|
CFrontEndUITouchBar::EAction tbAction)
|
|
{
|
|
if (m_touchBar.GetPhase() != CFrontEndUITouchBar::EPhase::NoCardSelect)
|
|
m_touchBar.SetNoCardSelectPhase(CSlideShow::SlideShowGalleryFlags());
|
|
|
|
x4_action = EAction::None;
|
|
x14_loadedFrme->ProcessUserInput(input);
|
|
|
|
switch (tbAction)
|
|
{
|
|
case CFrontEndUITouchBar::EAction::Start:
|
|
x18_tablegroup_mainmenu->SetUserSelection(0);
|
|
HandleActiveChange(x18_tablegroup_mainmenu);
|
|
DoAdvance(x18_tablegroup_mainmenu);
|
|
break;
|
|
case CFrontEndUITouchBar::EAction::FusionBonus:
|
|
x18_tablegroup_mainmenu->SetUserSelection(1);
|
|
HandleActiveChange(x18_tablegroup_mainmenu);
|
|
DoAdvance(x18_tablegroup_mainmenu);
|
|
break;
|
|
case CFrontEndUITouchBar::EAction::Options:
|
|
x18_tablegroup_mainmenu->SetUserSelection(2);
|
|
HandleActiveChange(x18_tablegroup_mainmenu);
|
|
DoAdvance(x18_tablegroup_mainmenu);
|
|
break;
|
|
case CFrontEndUITouchBar::EAction::ImageGallery:
|
|
x18_tablegroup_mainmenu->SetUserSelection(3);
|
|
HandleActiveChange(x18_tablegroup_mainmenu);
|
|
DoAdvance(x18_tablegroup_mainmenu);
|
|
break;
|
|
default: break;
|
|
}
|
|
|
|
return x4_action;
|
|
}
|
|
|
|
void CFrontEndUI::SFrontEndFrame::Draw() const
|
|
{
|
|
x14_loadedFrme->Draw(CGuiWidgetDrawParms::Default);
|
|
}
|
|
|
|
void CFrontEndUI::SFrontEndFrame::HandleActiveChange(CGuiTableGroup* active)
|
|
{
|
|
active->SetColors(zeus::CColor::skWhite,
|
|
zeus::CColor{0.627450f, 0.627450f, 0.627450f, 0.784313f});
|
|
}
|
|
|
|
void CFrontEndUI::SFrontEndFrame::DoCancel(CGuiTableGroup* caller)
|
|
{
|
|
/* Intentionally empty */
|
|
}
|
|
|
|
void CFrontEndUI::SFrontEndFrame::DoSelectionChange(CGuiTableGroup* caller, int oldSel)
|
|
{
|
|
CSfxManager::SfxStart(1093, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
HandleActiveChange(caller);
|
|
}
|
|
|
|
void CFrontEndUI::SFrontEndFrame::DoAdvance(CGuiTableGroup* caller)
|
|
{
|
|
switch (x18_tablegroup_mainmenu->GetUserSelection())
|
|
{
|
|
case 0:
|
|
CSfxManager::SfxStart(FETransitionForwardSFX[x0_rnd][0], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
CSfxManager::SfxStart(FETransitionForwardSFX[x0_rnd][1], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
x4_action = EAction::StartGame;
|
|
break;
|
|
case 1:
|
|
x4_action = EAction::FusionBonus;
|
|
break;
|
|
case 2:
|
|
PlayAdvanceSfx();
|
|
x4_action = EAction::GameOptions;
|
|
break;
|
|
case 3:
|
|
PlayAdvanceSfx();
|
|
x4_action = EAction::SlideShow;
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
CFrontEndUI::SFrontEndFrame::SFrontEndFrame(u32 rnd, CFrontEndUITouchBar& touchBar)
|
|
: x0_rnd(rnd), m_touchBar(touchBar)
|
|
{
|
|
x8_frme = g_SimplePool->GetObj("FRME_FrontEndPL");
|
|
}
|
|
|
|
CFrontEndUI::SNesEmulatorFrame::SNesEmulatorFrame()
|
|
{
|
|
x4_nesEmu = std::make_unique<CNESEmulator>();
|
|
|
|
const SObjectTag* deface = g_ResFactory->GetResourceIdByName("FONT_Deface14B");
|
|
CGuiTextProperties props(false, true, EJustification::Left,
|
|
EVerticalJustification::Center);
|
|
xc_textSupport = std::make_unique<CGuiTextSupport>(deface->id, props, zeus::CColor::skWhite,
|
|
zeus::CColor::skBlack, zeus::CColor::skWhite,
|
|
0, 0, g_SimplePool, CGuiWidget::EGuiModelDrawFlags::Alpha);
|
|
}
|
|
|
|
void CFrontEndUI::SNesEmulatorFrame::SetMode(EMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case EMode::Emulator:
|
|
x8_quitScreen.reset();
|
|
break;
|
|
case EMode::SaveProgress:
|
|
x8_quitScreen = std::make_unique<CQuitGameScreen>(EQuitType::SaveProgress);
|
|
break;
|
|
case EMode::ContinuePlaying:
|
|
x8_quitScreen = std::make_unique<CQuitGameScreen>(EQuitType::ContinuePlaying);
|
|
break;
|
|
case EMode::QuitNESMetroid:
|
|
x8_quitScreen = std::make_unique<CQuitGameScreen>(EQuitType::QuitNESMetroid);
|
|
break;
|
|
default: break;
|
|
}
|
|
x0_mode = mode;
|
|
}
|
|
|
|
void CFrontEndUI::SNesEmulatorFrame::ProcessUserInput(const CFinalInput& input, CSaveGameScreen* sui)
|
|
{
|
|
bool processInput = true;
|
|
if (sui && sui->GetUIType() != CSaveGameScreen::EUIType::SaveReady)
|
|
processInput = false;
|
|
if (sui)
|
|
sui->ProcessUserInput(input);
|
|
if (!processInput)
|
|
return;
|
|
|
|
switch (x0_mode)
|
|
{
|
|
case EMode::Emulator:
|
|
x4_nesEmu->ProcessUserInput(input, 4);
|
|
if (input.ControllerIdx() == 0 && input.PL())
|
|
SetMode(EMode::QuitNESMetroid);
|
|
break;
|
|
case EMode::SaveProgress:
|
|
case EMode::ContinuePlaying:
|
|
case EMode::QuitNESMetroid:
|
|
x8_quitScreen->ProcessUserInput(input);
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
bool CFrontEndUI::SNesEmulatorFrame::Update(float dt, CSaveGameScreen* saveUi)
|
|
{
|
|
bool doUpdate = (saveUi && saveUi->GetUIType() != CSaveGameScreen::EUIType::SaveReady) ? false : true;
|
|
x10_remTime = std::max(x10_remTime - dt, 0.f);
|
|
|
|
zeus::CColor geomCol(zeus::CColor::skWhite);
|
|
geomCol.a = std::min(x10_remTime, 1.f);
|
|
xc_textSupport->SetGeometryColor(geomCol);
|
|
if (xc_textSupport->GetIsTextSupportFinishedLoading())
|
|
{
|
|
xc_textSupport->AutoSetExtent();
|
|
xc_textSupport->ClearRenderBuffer();
|
|
}
|
|
|
|
if (!doUpdate)
|
|
return false;
|
|
|
|
switch (x0_mode)
|
|
{
|
|
case EMode::Emulator:
|
|
{
|
|
x4_nesEmu->Update();
|
|
if (!x4_nesEmu->WantsQuit())
|
|
x14_emulationSuspended = false;
|
|
if (x4_nesEmu->WantsQuit() && !x14_emulationSuspended)
|
|
{
|
|
x14_emulationSuspended = true;
|
|
if (saveUi && !saveUi->IsSavingDisabled())
|
|
{
|
|
SetMode(EMode::SaveProgress);
|
|
break;
|
|
}
|
|
SetMode(EMode::ContinuePlaying);
|
|
break;
|
|
}
|
|
if (x4_nesEmu->WantsLoad() && saveUi)
|
|
x4_nesEmu->LoadState(g_GameState->SystemOptions().GetNESState());
|
|
break;
|
|
}
|
|
|
|
case EMode::SaveProgress:
|
|
{
|
|
if (saveUi)
|
|
{
|
|
EQuitAction action = x8_quitScreen->Update(dt);
|
|
if (action == EQuitAction::Yes)
|
|
{
|
|
memmove(g_GameState->SystemOptions().GetNESState(), x4_nesEmu->GetSaveState(), 18);
|
|
saveUi->SaveNESState();
|
|
SetMode(EMode::ContinuePlaying);
|
|
}
|
|
else if (action == EQuitAction::No)
|
|
SetMode(EMode::ContinuePlaying);
|
|
}
|
|
else
|
|
SetMode(EMode::ContinuePlaying);
|
|
break;
|
|
}
|
|
|
|
case EMode::ContinuePlaying:
|
|
{
|
|
EQuitAction action = x8_quitScreen->Update(dt);
|
|
if (action == EQuitAction::Yes)
|
|
SetMode(EMode::Emulator);
|
|
else if (action == EQuitAction::No)
|
|
return true;
|
|
break;
|
|
}
|
|
|
|
case EMode::QuitNESMetroid:
|
|
{
|
|
EQuitAction action = x8_quitScreen->Update(dt);
|
|
if (action == EQuitAction::Yes)
|
|
return true;
|
|
else if (action == EQuitAction::No)
|
|
SetMode(EMode::Emulator);
|
|
break;
|
|
}
|
|
|
|
default: break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CFrontEndUI::SNesEmulatorFrame::Draw(CSaveGameScreen* saveUi) const
|
|
{
|
|
zeus::CColor mulColor = zeus::CColor::skWhite;
|
|
bool doDraw = (saveUi && saveUi->GetUIType() != CSaveGameScreen::EUIType::SaveReady) ? false : true;
|
|
|
|
if (doDraw)
|
|
mulColor = zeus::CColor::skBlack;
|
|
else if (x8_quitScreen)
|
|
mulColor = zeus::CColor{0.376470f, 0.376470f, 0.376470f, 1.f};
|
|
|
|
x4_nesEmu->Draw(mulColor, x15_enableFiltering);
|
|
if (!doDraw && x8_quitScreen)
|
|
x8_quitScreen->Draw();
|
|
|
|
if (x10_remTime >= 7.5f)
|
|
return;
|
|
if (x10_remTime <= 0.f)
|
|
return;
|
|
if (xc_textSupport->GetIsTextSupportFinishedLoading())
|
|
{
|
|
CGraphics::SetModelMatrix(zeus::CTransform::Translate(-280.f, 0.f, -160.f));
|
|
xc_textSupport->Render();
|
|
}
|
|
}
|
|
|
|
CFrontEndUI::SOptionsFrontEndFrame::SOptionsFrontEndFrame()
|
|
{
|
|
x4_frme = g_SimplePool->GetObj("FRME_OptionsFrontEnd");
|
|
x10_pauseScreen = g_SimplePool->GetObj("STRG_PauseScreen");
|
|
x134_24_visible = true;
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::DoSliderChange(CGuiSliderGroup* caller, float value)
|
|
{
|
|
if (x28_tablegroup_rightmenu->GetIsActive())
|
|
{
|
|
int leftSel = x24_tablegroup_leftmenu->GetUserSelection();
|
|
int rightSel = x28_tablegroup_rightmenu->GetUserSelection();
|
|
const auto& optionCategory = GameOptionsRegistry[leftSel];
|
|
const SGameOption& option = optionCategory.second[rightSel];
|
|
CGameOptions::SetOption(option.option, caller->GetGurVal());
|
|
m_touchBarValueDirty = true;
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::DoMenuCancel(CGuiTableGroup* caller)
|
|
{
|
|
if (x28_tablegroup_rightmenu == caller)
|
|
{
|
|
DeactivateRightMenu();
|
|
x24_tablegroup_leftmenu->SetIsActive(true);
|
|
x28_tablegroup_rightmenu->SetIsActive(false);
|
|
x28_tablegroup_rightmenu->SetUserSelection(0);
|
|
SetTableColors(x28_tablegroup_rightmenu);
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::DoMenuSelectionChange(CGuiTableGroup* caller, int oldSel)
|
|
{
|
|
SetTableColors(caller);
|
|
if (x24_tablegroup_leftmenu == caller)
|
|
{
|
|
SetRightUIText();
|
|
CSfxManager::SfxStart(1093, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
else if (x28_tablegroup_rightmenu == caller)
|
|
{
|
|
HandleRightSelectionChange();
|
|
CSfxManager::SfxStart(1093, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
else if (x2c_tablegroup_double == caller || x30_tablegroup_triple == caller)
|
|
{
|
|
if (x28_tablegroup_rightmenu->GetIsActive())
|
|
{
|
|
int leftSel = x24_tablegroup_leftmenu->GetUserSelection();
|
|
int rightSel = x28_tablegroup_rightmenu->GetUserSelection();
|
|
const auto& optionCategory = GameOptionsRegistry[leftSel];
|
|
const SGameOption& option = optionCategory.second[rightSel];
|
|
CGameOptions::SetOption(option.option, caller->GetUserSelection());
|
|
m_touchBarValueDirty = true;
|
|
CSfxManager::SfxStart(1095, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
|
|
if (option.option == EGameOption::Rumble && caller->GetUserSelection() > 0)
|
|
{
|
|
x40_rumbleGen.HardStopAll();
|
|
x40_rumbleGen.Rumble(RumbleFxTable[int(ERumbleFxId::PlayerBump)], 1.f,
|
|
ERumblePriority::One, EIOPort::Zero);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::DoLeftMenuAdvance(CGuiTableGroup* caller)
|
|
{
|
|
if (caller == x24_tablegroup_leftmenu)
|
|
{
|
|
HandleRightSelectionChange();
|
|
x28_tablegroup_rightmenu->SetUserSelection(0);
|
|
x24_tablegroup_leftmenu->SetIsActive(false);
|
|
x28_tablegroup_rightmenu->SetIsActive(true);
|
|
CSfxManager::SfxStart(1096, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
CSfxManager::SfxStart(1091, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::DeactivateRightMenu()
|
|
{
|
|
x2c_tablegroup_double->SetIsActive(false);
|
|
x30_tablegroup_triple->SetIsActive(false);
|
|
x34_slidergroup_slider->SetIsActive(false);
|
|
x2c_tablegroup_double->SetVisibility(false, ETraversalMode::Children);
|
|
x30_tablegroup_triple->SetVisibility(false, ETraversalMode::Children);
|
|
x34_slidergroup_slider->SetVisibility(false, ETraversalMode::Children);
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::HandleRightSelectionChange()
|
|
{
|
|
DeactivateRightMenu();
|
|
int leftSel = x24_tablegroup_leftmenu->GetUserSelection();
|
|
int rightSel = x28_tablegroup_rightmenu->GetUserSelection();
|
|
const auto& optionCategory = GameOptionsRegistry[leftSel];
|
|
const SGameOption& option = optionCategory.second[rightSel];
|
|
|
|
switch (option.type)
|
|
{
|
|
case EOptionType::Float:
|
|
x34_slidergroup_slider->SetIsActive(true);
|
|
x34_slidergroup_slider->SetVisibility(true, ETraversalMode::Children);
|
|
x34_slidergroup_slider->SetMinVal(option.minVal);
|
|
x34_slidergroup_slider->SetMaxVal(option.maxVal);
|
|
x34_slidergroup_slider->SetIncrement(option.increment);
|
|
x34_slidergroup_slider->SetCurVal(CGameOptions::GetOption(option.option));
|
|
x34_slidergroup_slider->SetLocalTransform(
|
|
zeus::CTransform::Translate(0.f, 0.f, rightSel * x38_rowPitch) *
|
|
x34_slidergroup_slider->GetTransform());
|
|
break;
|
|
|
|
case EOptionType::DoubleEnum:
|
|
x2c_tablegroup_double->SetUserSelection(CGameOptions::GetOption(option.option));
|
|
x2c_tablegroup_double->SetIsVisible(true);
|
|
x2c_tablegroup_double->SetIsActive(true);
|
|
x2c_tablegroup_double->SetLocalTransform(
|
|
zeus::CTransform::Translate(0.f, 0.f, rightSel * x38_rowPitch) *
|
|
x2c_tablegroup_double->GetTransform());
|
|
SetTableColors(x2c_tablegroup_double);
|
|
break;
|
|
|
|
case EOptionType::TripleEnum:
|
|
x30_tablegroup_triple->SetUserSelection(CGameOptions::GetOption(option.option));
|
|
x30_tablegroup_triple->SetIsVisible(true);
|
|
x30_tablegroup_triple->SetIsActive(true);
|
|
x30_tablegroup_triple->SetLocalTransform(
|
|
zeus::CTransform::Translate(0.f, 0.f, rightSel * x38_rowPitch) *
|
|
x30_tablegroup_triple->GetTransform());
|
|
SetTableColors(x30_tablegroup_triple);
|
|
break;
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::SetRightUIText()
|
|
{
|
|
int userSel = x24_tablegroup_leftmenu->GetUserSelection();
|
|
const std::pair<int, const SGameOption*>& options = GameOptionsRegistry[userSel];
|
|
|
|
for (int i=0 ; i<5 ; ++i)
|
|
{
|
|
char name[36];
|
|
snprintf(name, 36, "textpane_right%d", i);
|
|
if (i < options.first)
|
|
{
|
|
FindTextPanePair(x1c_loadedFrame, name).SetPairText(
|
|
x20_loadedPauseStrg->GetString(options.second[i].stringId));
|
|
x28_tablegroup_rightmenu->GetWorkerWidget(i)->SetIsSelectable(true);
|
|
}
|
|
else
|
|
{
|
|
FindTextPanePair(x1c_loadedFrame, name).SetPairText(u"");
|
|
x28_tablegroup_rightmenu->GetWorkerWidget(i)->SetIsSelectable(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::SetTableColors(CGuiTableGroup* tbgp) const
|
|
{
|
|
tbgp->SetColors(zeus::CColor::skWhite,
|
|
zeus::CColor{0.627450f, 0.627450f, 0.627450f, 0.784313f});
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::FinishedLoading()
|
|
{
|
|
x1c_loadedFrame->SetAspectConstraint(1.78f);
|
|
|
|
x24_tablegroup_leftmenu = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_leftmenu"));
|
|
x28_tablegroup_rightmenu = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_rightmenu"));
|
|
x2c_tablegroup_double = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_double"));
|
|
x30_tablegroup_triple = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_triple"));
|
|
x34_slidergroup_slider = static_cast<CGuiSliderGroup*>(x1c_loadedFrame->FindWidget("slidergroup_slider"));
|
|
|
|
x24_tablegroup_leftmenu->SetMenuAdvanceCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoLeftMenuAdvance, this, std::placeholders::_1));
|
|
x24_tablegroup_leftmenu->SetMenuSelectionChangeCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoMenuSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
|
|
x38_rowPitch = x24_tablegroup_leftmenu->GetWorkerWidget(1)->GetIdlePosition().z -
|
|
x24_tablegroup_leftmenu->GetWorkerWidget(0)->GetIdlePosition().z;
|
|
|
|
x28_tablegroup_rightmenu->SetMenuSelectionChangeCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoMenuSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
x28_tablegroup_rightmenu->SetMenuCancelCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoMenuCancel, this, std::placeholders::_1));
|
|
|
|
x2c_tablegroup_double->SetMenuSelectionChangeCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoMenuSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
x2c_tablegroup_double->SetMenuCancelCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoMenuCancel, this, std::placeholders::_1));
|
|
|
|
x30_tablegroup_triple->SetMenuSelectionChangeCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoMenuSelectionChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
x30_tablegroup_triple->SetMenuCancelCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoMenuCancel, this, std::placeholders::_1));
|
|
|
|
x34_slidergroup_slider->SetSelectionChangedCallback(
|
|
std::bind(&SOptionsFrontEndFrame::DoSliderChange, this, std::placeholders::_1, std::placeholders::_2));
|
|
|
|
FindTextPanePair(x1c_loadedFrame, "textpane_double0").SetPairText(x20_loadedPauseStrg->GetString(95)); // Off
|
|
FindTextPanePair(x1c_loadedFrame, "textpane_double1").SetPairText(x20_loadedPauseStrg->GetString(94)); // On
|
|
FindTextPanePair(x1c_loadedFrame, "textpane_triple0").SetPairText(x20_loadedPauseStrg->GetString(96)); // Mono
|
|
FindTextPanePair(x1c_loadedFrame, "textpane_triple1").SetPairText(x20_loadedPauseStrg->GetString(97)); // Stereo
|
|
FindTextPanePair(x1c_loadedFrame, "textpane_triple2").SetPairText(x20_loadedPauseStrg->GetString(98)); // Dolby
|
|
|
|
FindTextPanePair(x1c_loadedFrame, "textpane_title").SetPairText(g_MainStringTable->GetString(99)); // OPTIONS
|
|
|
|
if (CGuiTextPane* proceed = static_cast<CGuiTextPane*>(x1c_loadedFrame->FindWidget("textpane_proceed")))
|
|
proceed->TextSupport().SetText(g_MainStringTable->GetString(85));
|
|
|
|
if (CGuiTextPane* cancel = static_cast<CGuiTextPane*>(x1c_loadedFrame->FindWidget("textpane_cancel")))
|
|
cancel->TextSupport().SetText(g_MainStringTable->GetString(82));
|
|
|
|
// Visor, Display, Sound, Controller
|
|
for (int i=0 ; i<4 ;++i)
|
|
{
|
|
char name[36];
|
|
snprintf(name, 36, "textpane_filename%d", i);
|
|
FindTextPanePair(x1c_loadedFrame, name).SetPairText(x20_loadedPauseStrg->GetString(16+i));
|
|
}
|
|
|
|
x2c_tablegroup_double->SetVertical(false);
|
|
x30_tablegroup_triple->SetVertical(false);
|
|
|
|
x24_tablegroup_leftmenu->SetIsActive(true);
|
|
x28_tablegroup_rightmenu->SetIsActive(false);
|
|
|
|
SetTableColors(x24_tablegroup_leftmenu);
|
|
SetTableColors(x28_tablegroup_rightmenu);
|
|
SetTableColors(x2c_tablegroup_double);
|
|
SetTableColors(x30_tablegroup_triple);
|
|
|
|
SetRightUIText();
|
|
DeactivateRightMenu();
|
|
}
|
|
|
|
bool CFrontEndUI::SOptionsFrontEndFrame::PumpLoad()
|
|
{
|
|
if (x1c_loadedFrame)
|
|
return true;
|
|
if (!x4_frme.IsLoaded())
|
|
return false;
|
|
if (!x10_pauseScreen.IsLoaded())
|
|
return false;
|
|
if (!x4_frme->GetIsFinishedLoading())
|
|
return false;
|
|
x1c_loadedFrame = x4_frme.GetObj();
|
|
x20_loadedPauseStrg = x10_pauseScreen.GetObj();
|
|
m_touchBar = NewGameOptionsTouchBar();
|
|
FinishedLoading();
|
|
return true;
|
|
}
|
|
|
|
bool CFrontEndUI::SOptionsFrontEndFrame::ProcessUserInput(const CFinalInput& input, CSaveGameScreen* sui)
|
|
{
|
|
x134_25_exitOptions = false;
|
|
if (sui)
|
|
sui->ProcessUserInput(input);
|
|
if (x1c_loadedFrame && x134_24_visible)
|
|
{
|
|
if (input.PB() && x24_tablegroup_leftmenu->GetIsActive())
|
|
{
|
|
x134_25_exitOptions = true;
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
else
|
|
{
|
|
x1c_loadedFrame->ProcessUserInput(input);
|
|
int leftSel = x24_tablegroup_leftmenu->GetUserSelection();
|
|
int rightSel = x28_tablegroup_rightmenu->GetUserSelection();
|
|
CGameOptions::TryRestoreDefaults(input, leftSel, rightSel, true, false);
|
|
|
|
CGameOptionsTouchBar::EAction tbAction = m_touchBar->PopAction();
|
|
if (x28_tablegroup_rightmenu->GetIsActive())
|
|
{
|
|
if (tbAction == CGameOptionsTouchBar::EAction::Advance && !m_touchBarInValue)
|
|
{
|
|
int value;
|
|
m_touchBar->GetSelection(leftSel, rightSel, value);
|
|
x28_tablegroup_rightmenu->SetUserSelection(rightSel);
|
|
SetTableColors(x28_tablegroup_rightmenu);
|
|
HandleRightSelectionChange();
|
|
const auto& optionCategory = GameOptionsRegistry[leftSel];
|
|
const SGameOption& option = optionCategory.second[rightSel];
|
|
if (option.type != EOptionType::RestoreDefaults)
|
|
{
|
|
m_touchBarInValue = true;
|
|
m_touchBarValueDirty = true;
|
|
}
|
|
else
|
|
{
|
|
CGameOptions::TryRestoreDefaults(input, leftSel, rightSel, true, true);
|
|
}
|
|
}
|
|
else if (tbAction == CGameOptionsTouchBar::EAction::Back)
|
|
{
|
|
if (m_touchBarInValue)
|
|
m_touchBarInValue = false;
|
|
else
|
|
DoMenuCancel(x28_tablegroup_rightmenu);
|
|
}
|
|
else if (tbAction == CGameOptionsTouchBar::EAction::ValueChange)
|
|
{
|
|
int value;
|
|
m_touchBar->GetSelection(leftSel, rightSel, value);
|
|
const auto& optionCategory = GameOptionsRegistry[leftSel];
|
|
const SGameOption& option = optionCategory.second[rightSel];
|
|
CGameOptions::SetOption(option.option, value);
|
|
if (option.type != EOptionType::Float)
|
|
m_touchBarValueDirty = true;
|
|
HandleRightSelectionChange();
|
|
}
|
|
else
|
|
{
|
|
if (m_touchBarInValue)
|
|
{
|
|
if (m_touchBarValueDirty)
|
|
{
|
|
const auto& optionCategory = GameOptionsRegistry[leftSel];
|
|
const SGameOption& option = optionCategory.second[rightSel];
|
|
int value = CGameOptions::GetOption(option.option);
|
|
m_touchBar->SetSelection(leftSel, rightSel, value);
|
|
m_touchBarValueDirty = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_touchBar->SetSelection(leftSel, -1, -1);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (tbAction == CGameOptionsTouchBar::EAction::Advance)
|
|
{
|
|
int value;
|
|
m_touchBar->GetSelection(leftSel, rightSel, value);
|
|
x24_tablegroup_leftmenu->SetUserSelection(leftSel);
|
|
SetTableColors(x24_tablegroup_leftmenu);
|
|
SetRightUIText();
|
|
DoLeftMenuAdvance(x24_tablegroup_leftmenu);
|
|
}
|
|
if (tbAction == CGameOptionsTouchBar::EAction::Back)
|
|
{
|
|
x134_25_exitOptions = true;
|
|
CSfxManager::SfxStart(1094, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
else
|
|
{
|
|
m_touchBar->SetSelection(-1, -1, -1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return !x134_25_exitOptions;
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::Update(float dt, CSaveGameScreen* sui)
|
|
{
|
|
x40_rumbleGen.Update(dt);
|
|
x134_24_visible = !sui || sui->GetUIType() == CSaveGameScreen::EUIType::SaveReady;
|
|
|
|
if (!PumpLoad())
|
|
return;
|
|
|
|
x0_uiAlpha = std::min(1.f, x0_uiAlpha + dt);
|
|
x1c_loadedFrame->Update(dt);
|
|
|
|
bool isSliding = x34_slidergroup_slider->GetState() != CGuiSliderGroup::EState::None;
|
|
if (x3c_sliderSfx.operator bool() != isSliding)
|
|
{
|
|
if (isSliding)
|
|
{
|
|
x3c_sliderSfx = CSfxManager::SfxStart(1458, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
else
|
|
{
|
|
CSfxManager::SfxStop(x3c_sliderSfx);
|
|
x3c_sliderSfx.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::SOptionsFrontEndFrame::Draw() const
|
|
{
|
|
if (x1c_loadedFrame && x134_24_visible)
|
|
{
|
|
CGuiWidgetDrawParms params(x0_uiAlpha, zeus::CVector3f::skZero);
|
|
x1c_loadedFrame->Draw(params);
|
|
}
|
|
}
|
|
|
|
CFrontEndUI::CFrontEndUI()
|
|
: CIOWin("FrontEndUI")
|
|
{
|
|
CMain* m = static_cast<CMain*>(g_Main);
|
|
|
|
CRandom16 r(time(nullptr));
|
|
x18_rndA = r.Range(0, 2);
|
|
x1c_rndB = r.Range(0, 2);
|
|
|
|
x20_depsGroup = g_SimplePool->GetObj("FrontEnd_DGRP");
|
|
x38_pressStart = g_SimplePool->GetObj("TXTR_PressStart");
|
|
x44_frontendAudioGrp = g_SimplePool->GetObj("FrontEnd_AGSC");
|
|
|
|
xdc_saveUI = std::make_unique<CSaveGameScreen>(ESaveContext::FrontEnd, g_GameState->GetCardSerial());
|
|
|
|
m->ResetGameState();
|
|
g_GameState->SetCurrentWorldId(g_ResFactory->TranslateOriginalToNew(g_DefaultWorldTag.id));
|
|
g_GameState->GameOptions().ResetToDefaults();
|
|
g_GameState->WriteBackupBuf();
|
|
|
|
for (int i=0 ; CDvdFile::FileExists(GetAttractMovieFileName(i).c_str()) ; ++i)
|
|
++xc0_attractCount;
|
|
|
|
m_touchBar = NewFrontEndUITouchBar();
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
|
|
x14_phase = EPhase::ExitFrontEnd;
|
|
}
|
|
|
|
void CFrontEndUI::StartSlideShow(CArchitectureQueue& queue)
|
|
{
|
|
xf4_curAudio->StopMixing();
|
|
queue.Push(MakeMsg::CreateCreateIOWin(EArchMsgTarget::IOWinManager, 12, 11,
|
|
std::make_shared<CSlideShow>()));
|
|
}
|
|
|
|
std::string CFrontEndUI::GetAttractMovieFileName(int idx)
|
|
{
|
|
return hecl::Format("Video/attract%d.thp", idx);
|
|
}
|
|
|
|
std::string CFrontEndUI::GetNextAttractMovieFileName()
|
|
{
|
|
std::string ret = GetAttractMovieFileName(xbc_nextAttract);
|
|
xbc_nextAttract = (xbc_nextAttract + 1) % xc0_attractCount;
|
|
return ret;
|
|
}
|
|
|
|
void CFrontEndUI::SetCurrentMovie(EMenuMovie movie)
|
|
{
|
|
if (xb8_curMovie == movie)
|
|
return;
|
|
StopAttractMovie();
|
|
|
|
if (xb8_curMovie != EMenuMovie::Stopped)
|
|
{
|
|
xcc_curMoviePtr->SetPlayMode(CMoviePlayer::EPlayMode::Stopped);
|
|
xcc_curMoviePtr->Rewind();
|
|
}
|
|
|
|
xb8_curMovie = movie;
|
|
|
|
if (xb8_curMovie != EMenuMovie::Stopped)
|
|
{
|
|
xcc_curMoviePtr = x70_menuMovies[int(xb8_curMovie)].get();
|
|
xcc_curMoviePtr->SetPlayMode(CMoviePlayer::EPlayMode::Playing);
|
|
}
|
|
else
|
|
xcc_curMoviePtr = nullptr;
|
|
}
|
|
|
|
void CFrontEndUI::StopAttractMovie()
|
|
{
|
|
if (!xc4_attractMovie)
|
|
return;
|
|
xc4_attractMovie.reset();
|
|
xcc_curMoviePtr = nullptr;
|
|
}
|
|
|
|
void CFrontEndUI::StartAttractMovie()
|
|
{
|
|
if (xc4_attractMovie)
|
|
return;
|
|
SetCurrentMovie(EMenuMovie::Stopped);
|
|
xc4_attractMovie = std::make_unique<CMoviePlayer>(GetNextAttractMovieFileName().c_str(), 0.f, false, true);
|
|
xcc_curMoviePtr = xc4_attractMovie.get();
|
|
}
|
|
|
|
void CFrontEndUI::StartStateTransition(EScreen screen)
|
|
{
|
|
switch (x50_curScreen)
|
|
{
|
|
case EScreen::Title:
|
|
if (screen != EScreen::FileSelect)
|
|
break;
|
|
SetCurrentMovie(EMenuMovie::StartFileSelectA);
|
|
SetFadeBlackTimer(xcc_curMoviePtr->GetTotalSeconds());
|
|
break;
|
|
case EScreen::FileSelect:
|
|
if (screen == EScreen::ToPlayGame)
|
|
{
|
|
SetCurrentMovie(EMenuMovie::FileSelectPlayGameA);
|
|
SetFadeBlackTimer(xcc_curMoviePtr->GetTotalSeconds());
|
|
}
|
|
else if (screen == EScreen::FusionBonus)
|
|
{
|
|
SetCurrentMovie(EMenuMovie::FileSelectGBA);
|
|
SetFadeBlackTimer(xcc_curMoviePtr->GetTotalSeconds());
|
|
CSfxManager::SfxStart(1108, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
CSfxManager::SfxStart(1109, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
break;
|
|
case EScreen::FusionBonus:
|
|
if (screen == EScreen::ToPlayGame)
|
|
{
|
|
SetCurrentMovie(EMenuMovie::GBAFileSelectB);
|
|
SetFadeBlackTimer(xcc_curMoviePtr->GetTotalSeconds());
|
|
}
|
|
else if (screen == EScreen::FileSelect)
|
|
{
|
|
SetCurrentMovie(EMenuMovie::GBAFileSelectA);
|
|
SetFadeBlackTimer(xcc_curMoviePtr->GetTotalSeconds());
|
|
CSfxManager::SfxStart(1110, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
CSfxManager::SfxStart(1111, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
}
|
|
default: break;
|
|
}
|
|
|
|
switch (screen)
|
|
{
|
|
case EScreen::OpenCredits:
|
|
case EScreen::Title:
|
|
SetCurrentMovie(EMenuMovie::FirstStart);
|
|
SetFadeBlackTimer(xcc_curMoviePtr->GetTotalSeconds());
|
|
break;
|
|
case EScreen::AttractMovie:
|
|
StartAttractMovie();
|
|
SetFadeBlackWithMovie();
|
|
default: break;
|
|
}
|
|
|
|
x54_nextScreen = screen;
|
|
}
|
|
|
|
void CFrontEndUI::CompleteStateTransition()
|
|
{
|
|
EScreen oldScreen = x50_curScreen;
|
|
x50_curScreen = x54_nextScreen;
|
|
|
|
switch (x50_curScreen)
|
|
{
|
|
case EScreen::AttractMovie:
|
|
x54_nextScreen = EScreen::OpenCredits;
|
|
x50_curScreen = EScreen::OpenCredits;
|
|
xd0_playerSkipToTitle = false;
|
|
StartStateTransition(EScreen::Title);
|
|
break;
|
|
|
|
case EScreen::Title:
|
|
SetCurrentMovie(EMenuMovie::StartLoop);
|
|
SetFadeBlackTimer(30.f);
|
|
break;
|
|
|
|
case EScreen::FileSelect:
|
|
SetCurrentMovie(EMenuMovie::FileSelectLoop);
|
|
if (oldScreen == EScreen::Title)
|
|
{
|
|
xf4_curAudio->StopMixing();
|
|
xf4_curAudio = xd8_audio2.get();
|
|
xf4_curAudio->StartMixing();
|
|
}
|
|
if (xdc_saveUI)
|
|
xdc_saveUI->ResetCardDriver();
|
|
break;
|
|
|
|
case EScreen::FusionBonus:
|
|
SetCurrentMovie(EMenuMovie::GBALoop);
|
|
break;
|
|
|
|
case EScreen::ToPlayGame:
|
|
x14_phase = EPhase::ExitFrontEnd;
|
|
break;
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArchitectureQueue& queue)
|
|
{}
|
|
|
|
void CFrontEndUI::Draw() const
|
|
{
|
|
if (x14_phase < EPhase::DisplayFrontEnd)
|
|
return;
|
|
|
|
if (xec_emuFrme)
|
|
{
|
|
xec_emuFrme->Draw(xdc_saveUI.get());
|
|
}
|
|
else
|
|
{
|
|
//g_Renderer->SetDepthReadWrite(false, false);
|
|
g_Renderer->SetViewportOrtho(false, -4096.f, 4096.f);
|
|
|
|
/* Correct movie aspect ratio */
|
|
float vpAspectRatio = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
|
float hPad, vPad;
|
|
if (vpAspectRatio >= 1.78f)
|
|
{
|
|
hPad = 1.78f / vpAspectRatio;
|
|
vPad = 1.78f / 1.33f;
|
|
}
|
|
else
|
|
{
|
|
hPad = 1.f;
|
|
vPad = vpAspectRatio / 1.33f;
|
|
}
|
|
|
|
if (xcc_curMoviePtr && xcc_curMoviePtr->GetIsFullyCached())
|
|
{
|
|
/* Render movie */
|
|
xcc_curMoviePtr->SetFrame({-hPad, vPad, 0.f}, {-hPad, -vPad, 0.f}, {hPad, -vPad, 0.f}, {hPad, vPad, 0.f});
|
|
xcc_curMoviePtr->DrawFrame();
|
|
}
|
|
|
|
if (x50_curScreen == EScreen::FileSelect && x54_nextScreen == EScreen::FileSelect)
|
|
{
|
|
/* Render active FileSelect UI */
|
|
if (xf0_optionsFrme)
|
|
xf0_optionsFrme->Draw();
|
|
else if (xe0_frontendCardFrme)
|
|
xe0_frontendCardFrme->Draw();
|
|
else
|
|
xe8_frontendNoCardFrme->Draw();
|
|
}
|
|
else if (x50_curScreen == EScreen::FusionBonus && x54_nextScreen == EScreen::FusionBonus)
|
|
{
|
|
/* Render Fusion bonus UI */
|
|
xe4_fusionBonusFrme->Draw();
|
|
}
|
|
|
|
if (x64_pressStartAlpha > 0.f && x38_pressStart.IsLoaded() && m_pressStartQuad)
|
|
{
|
|
/* Render "Press Start" */
|
|
zeus::CRectangle rect(0.5f - x38_pressStart->GetWidth() / 2.f / 640.f * hPad,
|
|
0.5f + (x38_pressStart->GetHeight() / 2.f - 240.f + 72.f) / 480.f * vPad,
|
|
x38_pressStart->GetWidth() / 640.f * hPad,
|
|
x38_pressStart->GetHeight() / 480.f * vPad);
|
|
zeus::CColor color = zeus::CColor::skWhite;
|
|
color.a = x64_pressStartAlpha;
|
|
const_cast<CTexturedQuadFilterAlpha&>(*m_pressStartQuad).draw(color, 1.f, rect);
|
|
}
|
|
|
|
if (xc0_attractCount > 0)
|
|
{
|
|
/* Render fade-to-black into attract movie */
|
|
if (((x50_curScreen == EScreen::Title && x54_nextScreen == EScreen::Title) ||
|
|
x54_nextScreen == EScreen::AttractMovie) && x58_fadeBlackTimer < 1.f)
|
|
{
|
|
/* To black */
|
|
zeus::CColor color = zeus::CColor::skBlack;
|
|
color.a = 1.f - x58_fadeBlackTimer;
|
|
const_cast<CColoredQuadFilter&>(m_fadeToBlack).draw(color);
|
|
}
|
|
}
|
|
|
|
if (xd0_playerSkipToTitle)
|
|
{
|
|
/* Render fade-through-black into title if player skips */
|
|
if (x50_curScreen == EScreen::OpenCredits && x54_nextScreen == EScreen::Title)
|
|
{
|
|
/* To black */
|
|
zeus::CColor color = zeus::CColor::skBlack;
|
|
color.a = zeus::clamp(0.f, 1.f - x58_fadeBlackTimer, 1.f);
|
|
const_cast<CColoredQuadFilter&>(m_fadeToBlack).draw(color);
|
|
}
|
|
else if (x50_curScreen == EScreen::Title && x54_nextScreen == EScreen::Title)
|
|
{
|
|
/* From black with 30-sec skip to title */
|
|
zeus::CColor color = zeus::CColor::skBlack;
|
|
color.a = 1.f - zeus::clamp(0.f, 30.f - x58_fadeBlackTimer, 1.f);
|
|
const_cast<CColoredQuadFilter&>(m_fadeToBlack).draw(color);
|
|
}
|
|
}
|
|
|
|
if (xdc_saveUI)
|
|
{
|
|
/* Render memory card feedback strings */
|
|
if ((CanShowSaveUI() && !xdc_saveUI->IsHiddenFromFrontEnd()) ||
|
|
((x50_curScreen == EScreen::FileSelect && x54_nextScreen == EScreen::FileSelect) ||
|
|
(x50_curScreen == EScreen::FusionBonus && x54_nextScreen == EScreen::FusionBonus)))
|
|
xdc_saveUI->Draw();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::UpdateMovies(float dt)
|
|
{
|
|
if (xcc_curMoviePtr && x5c_fadeBlackWithMovie)
|
|
{
|
|
/* Set fade-to-black timer to match attract movie */
|
|
x5c_fadeBlackWithMovie = false;
|
|
x58_fadeBlackTimer = xcc_curMoviePtr->GetTotalSeconds();
|
|
}
|
|
|
|
/* Advance playing menu movies */
|
|
for (auto& movie : x70_menuMovies)
|
|
if (movie)
|
|
movie->Update(dt);
|
|
|
|
/* Advance attract movie */
|
|
if (xc4_attractMovie)
|
|
xc4_attractMovie->Update(dt);
|
|
}
|
|
|
|
void CFrontEndUI::FinishedLoadingDepsGroup()
|
|
{
|
|
/* Transfer DGRP tokens into FrontEnd and lock */
|
|
const CDependencyGroup* dgrp = x20_depsGroup.GetObj();
|
|
x2c_deps.reserve(dgrp->GetObjectTagVector().size());
|
|
for (const SObjectTag& tag : dgrp->GetObjectTagVector())
|
|
{
|
|
x2c_deps.push_back(g_SimplePool->GetObj(tag));
|
|
x2c_deps.back().Lock();
|
|
}
|
|
x44_frontendAudioGrp.Lock();
|
|
}
|
|
|
|
bool CFrontEndUI::PumpLoad()
|
|
{
|
|
/* Poll all tokens for load completion */
|
|
for (CToken& tok : x2c_deps)
|
|
if (!tok.IsLoaded())
|
|
return false;
|
|
if (!x44_frontendAudioGrp.IsLoaded())
|
|
return false;
|
|
|
|
/* Ready to construct texture quads */
|
|
m_pressStartQuad.emplace(EFilterType::Add, x38_pressStart);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CFrontEndUI::PumpMovieLoad()
|
|
{
|
|
/* Prepare all FrontEnd movies and pause each */
|
|
if (xd1_moviesLoaded)
|
|
return true;
|
|
for (int i=0 ; i<9 ; ++i)
|
|
{
|
|
if (!x70_menuMovies[i])
|
|
{
|
|
const FEMovie& movie = FEMovies[i];
|
|
std::string path = movie.path;
|
|
if (i == int(EMenuMovie::StartFileSelectA))
|
|
{
|
|
auto pos = path.find("A.thp");
|
|
if (pos != std::string::npos)
|
|
path[pos] = 'A' + x18_rndA;
|
|
}
|
|
else if (i == int(EMenuMovie::FileSelectPlayGameA))
|
|
{
|
|
auto pos = path.find("A.thp");
|
|
if (pos != std::string::npos)
|
|
path[pos] = 'A' + x1c_rndB;
|
|
}
|
|
x70_menuMovies[i] = std::make_unique<CMoviePlayer>(path.c_str(), 0.05f, movie.loop, false);
|
|
x70_menuMovies[i]->SetPlayMode(CMoviePlayer::EPlayMode::Stopped);
|
|
return false;
|
|
}
|
|
}
|
|
xd1_moviesLoaded = true;
|
|
return true;
|
|
}
|
|
|
|
void CFrontEndUI::ProcessUserInput(const CFinalInput& input, CArchitectureQueue& queue)
|
|
{
|
|
if (static_cast<CMain*>(g_Main)->GetCardBusy())
|
|
return;
|
|
if (input.ControllerIdx() > 1)
|
|
return;
|
|
|
|
if (xec_emuFrme)
|
|
{
|
|
/* NES emulator pre-empts user input if active */
|
|
xec_emuFrme->ProcessUserInput(input, xdc_saveUI.get());
|
|
return;
|
|
}
|
|
|
|
/* Controllers other than first shall not pass */
|
|
if (x14_phase != EPhase::DisplayFrontEnd || input.ControllerIdx() != 0)
|
|
return;
|
|
|
|
/* Pop most recent action from Touch Bar */
|
|
CFrontEndUITouchBar::EAction touchBarAction = m_touchBar->PopAction();
|
|
|
|
if (x50_curScreen != x54_nextScreen)
|
|
{
|
|
if (x54_nextScreen == EScreen::AttractMovie && (input.PStart() || input.PA() ||
|
|
touchBarAction == CFrontEndUITouchBar::EAction::Start))
|
|
{
|
|
/* Player wants to return to opening credits from attract movie */
|
|
SetFadeBlackTimer(std::min(1.f, x58_fadeBlackTimer));
|
|
PlayAdvanceSfx();
|
|
return;
|
|
}
|
|
|
|
if (input.PA() || input.PStart() || touchBarAction == CFrontEndUITouchBar::EAction::Start)
|
|
{
|
|
if (x50_curScreen == EScreen::OpenCredits && x54_nextScreen == EScreen::Title &&
|
|
x58_fadeBlackTimer > 1.f)
|
|
{
|
|
/* Player is too impatient to view opening credits */
|
|
xd0_playerSkipToTitle = true;
|
|
SetFadeBlackTimer(1.f);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (x50_curScreen == EScreen::Title)
|
|
{
|
|
if (input.PStart() || input.PA() || touchBarAction == CFrontEndUITouchBar::EAction::Start)
|
|
{
|
|
if (x58_fadeBlackTimer < 30.f - g_tweakGame->GetPressStartDelay())
|
|
{
|
|
/* Proceed to file select UI */
|
|
CSfxManager::SfxStart(FETransitionBackSFX[x18_rndA][0], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
CSfxManager::SfxStart(FETransitionBackSFX[x18_rndA][1], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
StartStateTransition(EScreen::FileSelect);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if (x50_curScreen == EScreen::FileSelect && x54_nextScreen == EScreen::FileSelect)
|
|
{
|
|
if (xf0_optionsFrme)
|
|
{
|
|
/* Control options UI */
|
|
if (xf0_optionsFrme->ProcessUserInput(input, xdc_saveUI.get()))
|
|
return;
|
|
/* Exit options UI */
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
xf0_optionsFrme.reset();
|
|
return;
|
|
}
|
|
else if (xe0_frontendCardFrme)
|
|
{
|
|
/* Control FrontEnd with memory card */
|
|
switch (xe0_frontendCardFrme->ProcessUserInput(input, touchBarAction))
|
|
{
|
|
case SNewFileSelectFrame::EAction::FusionBonus:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
StartStateTransition(EScreen::FusionBonus);
|
|
return;
|
|
case SNewFileSelectFrame::EAction::GameOptions:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
xf0_optionsFrme = std::make_unique<SOptionsFrontEndFrame>();
|
|
return;
|
|
case SNewFileSelectFrame::EAction::SlideShow:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
xd2_deferSlideShow = true;
|
|
StartSlideShow(queue);
|
|
return;
|
|
default: return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Control FrontEnd without memory card */
|
|
switch (xe8_frontendNoCardFrme->ProcessUserInput(input, touchBarAction))
|
|
{
|
|
case SFrontEndFrame::EAction::FusionBonus:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
StartStateTransition(EScreen::FusionBonus);
|
|
return;
|
|
case SFrontEndFrame::EAction::GameOptions:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
xf0_optionsFrme = std::make_unique<SOptionsFrontEndFrame>();
|
|
return;
|
|
case SFrontEndFrame::EAction::StartGame:
|
|
TransitionToGame();
|
|
return;
|
|
case SFrontEndFrame::EAction::SlideShow:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
xd2_deferSlideShow = true;
|
|
StartSlideShow(queue);
|
|
return;
|
|
default: return;
|
|
}
|
|
}
|
|
}
|
|
else if (x50_curScreen == EScreen::FusionBonus && x54_nextScreen == EScreen::FusionBonus)
|
|
{
|
|
/* Control Fusion bonus UI */
|
|
switch (xe4_fusionBonusFrme->ProcessUserInput(input, xdc_saveUI.get(), touchBarAction))
|
|
{
|
|
case SFusionBonusFrame::EAction::GoBack:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
StartStateTransition(EScreen::FileSelect);
|
|
return;
|
|
case SFusionBonusFrame::EAction::PlayNESMetroid:
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
xf4_curAudio->StopMixing();
|
|
xec_emuFrme = std::make_unique<SNesEmulatorFrame>();
|
|
if (xdc_saveUI)
|
|
xdc_saveUI->SetInGame(true);
|
|
return;
|
|
default: return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFrontEndUI::TransitionToGame()
|
|
{
|
|
if (x14_phase >= EPhase::ToPlayGame)
|
|
return;
|
|
|
|
const u16* sfx = FETransitionForwardSFX[x1c_rndB];
|
|
CSfxManager::SfxStart(sfx[0], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
CSfxManager::SfxStart(sfx[1], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
|
|
|
|
x14_phase = EPhase::ToPlayGame;
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::None);
|
|
StartStateTransition(EScreen::ToPlayGame);
|
|
}
|
|
|
|
void CFrontEndUI::UpdateMusicVolume()
|
|
{
|
|
float volMul = (xf4_curAudio == xd4_audio1.get()) ? FE1_VOL : FE2_VOL;
|
|
if (xf4_curAudio)
|
|
{
|
|
float vol = volMul * x68_musicVol * (g_GameState->GameOptions().GetMusicVolume() / 127.f);
|
|
xf4_curAudio->SetVolume(vol);
|
|
}
|
|
}
|
|
|
|
static const float AudioFadeTimeA[] =
|
|
{
|
|
0.44f, 5.41f, 3.41f
|
|
};
|
|
|
|
static const float AudioFadeTimeB[] =
|
|
{
|
|
4.2f, 6.1f, 6.1f
|
|
};
|
|
|
|
CIOWin::EMessageReturn CFrontEndUI::Update(float dt, CArchitectureQueue& queue)
|
|
{
|
|
if (xdc_saveUI && x50_curScreen >= EScreen::FileSelect)
|
|
{
|
|
switch (xdc_saveUI->Update(dt))
|
|
{
|
|
case EMessageReturn::Exit:
|
|
/* Memory card operation complete, transition to game */
|
|
TransitionToGame();
|
|
break;
|
|
case EMessageReturn::RemoveIOWinAndExit:
|
|
case EMessageReturn::RemoveIOWin:
|
|
/* No memory card available, fallback to non-save UI */
|
|
xe0_frontendCardFrme.reset();
|
|
xdc_saveUI.reset();
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
/* Set music fade volume */
|
|
UpdateMusicVolume();
|
|
|
|
switch (x14_phase)
|
|
{
|
|
case EPhase::LoadDepsGroup:
|
|
/* Poll DGRP load */
|
|
if (!x20_depsGroup.IsLoaded())
|
|
return EMessageReturn::Exit;
|
|
FinishedLoadingDepsGroup();
|
|
x20_depsGroup.Unlock();
|
|
x14_phase = EPhase::LoadDeps;
|
|
|
|
case EPhase::LoadDeps:
|
|
/* Poll loading DGRP resources */
|
|
if (PumpLoad())
|
|
{
|
|
xe0_frontendCardFrme = std::make_unique<SNewFileSelectFrame>(xdc_saveUI.get(), x1c_rndB, *m_touchBar);
|
|
xe4_fusionBonusFrme = std::make_unique<SFusionBonusFrame>(*m_touchBar);
|
|
xe8_frontendNoCardFrme = std::make_unique<SFrontEndFrame>(x1c_rndB, *m_touchBar);
|
|
x38_pressStart.GetObj();
|
|
CAudioSys::AddAudioGroup(x44_frontendAudioGrp->GetAudioGroupData());
|
|
xd4_audio1 = std::make_unique<CStaticAudioPlayer>("Audio/frontend_1.rsf", 416480, 1973664);
|
|
xd8_audio2 = std::make_unique<CStaticAudioPlayer>("Audio/frontend_2.rsf", 273556, 1636980);
|
|
x14_phase = EPhase::LoadFrames;
|
|
}
|
|
if (x14_phase == EPhase::LoadDeps)
|
|
return EMessageReturn::Exit;
|
|
|
|
case EPhase::LoadFrames:
|
|
/* Poll loading music and FRME resources */
|
|
if (!xd4_audio1->IsReady() || !xd8_audio2->IsReady() ||
|
|
!xe0_frontendCardFrme->PumpLoad() || !xe4_fusionBonusFrme->PumpLoad() ||
|
|
!xe8_frontendNoCardFrme->PumpLoad() || !xdc_saveUI->PumpLoad())
|
|
return EMessageReturn::Exit;
|
|
xf4_curAudio = xd4_audio1.get();
|
|
xf4_curAudio->StartMixing();
|
|
x14_phase = EPhase::LoadMovies;
|
|
|
|
case EPhase::LoadMovies:
|
|
{
|
|
/* Poll loading movies */
|
|
bool moviesReady = true;
|
|
if (PumpMovieLoad())
|
|
{
|
|
/* Prime first frame of movies */
|
|
UpdateMovies(dt);
|
|
for (int i=0 ; i<9 ; ++i)
|
|
{
|
|
if (!x70_menuMovies[i]->GetIsFullyCached())
|
|
{
|
|
moviesReady = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
moviesReady = false;
|
|
|
|
if (moviesReady)
|
|
{
|
|
/* Ready to display FrontEnd */
|
|
x14_phase = EPhase::DisplayFrontEnd;
|
|
m_touchBar->SetPhase(CFrontEndUITouchBar::EPhase::PressStart);
|
|
StartStateTransition(EScreen::Title);
|
|
}
|
|
else
|
|
return EMessageReturn::Exit;
|
|
}
|
|
|
|
case EPhase::DisplayFrontEnd:
|
|
case EPhase::ToPlayGame:
|
|
/* Displaying frontend to user */
|
|
if (xec_emuFrme)
|
|
{
|
|
/* Update just the emulator if active */
|
|
if (xec_emuFrme->Update(dt, xdc_saveUI.get()))
|
|
{
|
|
/* Exit emulator */
|
|
xec_emuFrme.reset();
|
|
if (xdc_saveUI)
|
|
xdc_saveUI->SetInGame(false);
|
|
xf4_curAudio->StartMixing();
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (xd2_deferSlideShow)
|
|
{
|
|
/* Start mixing slideshow music */
|
|
xd2_deferSlideShow = false;
|
|
xf4_curAudio->StartMixing();
|
|
if (xdc_saveUI)
|
|
xdc_saveUI->ResetCardDriver();
|
|
}
|
|
|
|
if (x50_curScreen == EScreen::FileSelect && x54_nextScreen == EScreen::FileSelect)
|
|
{
|
|
/* Main FrontEnd UI tree active */
|
|
if (xf0_optionsFrme)
|
|
{
|
|
bool optionsActive = true;
|
|
if (xdc_saveUI && xdc_saveUI->GetUIType() != CSaveGameScreen::EUIType::SaveReady)
|
|
optionsActive = false;
|
|
|
|
if (optionsActive)
|
|
{
|
|
/* Update options UI */
|
|
xf0_optionsFrme->Update(dt, xdc_saveUI.get());
|
|
}
|
|
else
|
|
{
|
|
/* Save triggered; exit options UI here */
|
|
xf0_optionsFrme.reset();
|
|
}
|
|
}
|
|
else if (xe0_frontendCardFrme)
|
|
{
|
|
/* Update FrontEnd with memory card UI */
|
|
xe0_frontendCardFrme->Update(dt);
|
|
}
|
|
else
|
|
{
|
|
/* Update FrontEnd without memory card UI */
|
|
xe8_frontendNoCardFrme->Update(dt);
|
|
}
|
|
}
|
|
else if (x50_curScreen == EScreen::FusionBonus && x54_nextScreen == EScreen::FusionBonus)
|
|
{
|
|
/* Update Fusion bonus UI */
|
|
xe4_fusionBonusFrme->Update(dt, xdc_saveUI.get());
|
|
}
|
|
|
|
if (x50_curScreen != x54_nextScreen && xcc_curMoviePtr &&
|
|
(xcc_curMoviePtr->GetIsMovieFinishedPlaying() || xcc_curMoviePtr->IsLooping()))
|
|
{
|
|
/* Movie-based transition complete */
|
|
CompleteStateTransition();
|
|
}
|
|
|
|
if (x58_fadeBlackTimer > 0.f && !x5c_fadeBlackWithMovie)
|
|
{
|
|
SetFadeBlackTimer(std::max(0.f, x58_fadeBlackTimer - dt));
|
|
if (x58_fadeBlackTimer == 0.f)
|
|
{
|
|
if (x50_curScreen == EScreen::Title && x54_nextScreen == EScreen::Title)
|
|
{
|
|
if (xc0_attractCount > 0)
|
|
{
|
|
/* Screen black, start attract movie */
|
|
StartStateTransition(EScreen::AttractMovie);
|
|
}
|
|
}
|
|
else if (x54_nextScreen == EScreen::AttractMovie)
|
|
{
|
|
/* Attract movie done, play open credits again */
|
|
CompleteStateTransition();
|
|
}
|
|
else if (x50_curScreen != x54_nextScreen)
|
|
{
|
|
/* Fade-based transition complete */
|
|
CompleteStateTransition();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Advance active movies */
|
|
UpdateMovies(dt);
|
|
|
|
if (x50_curScreen == EScreen::Title && x54_nextScreen == EScreen::Title)
|
|
{
|
|
/* Update press-start pulsing */
|
|
if (x58_fadeBlackTimer < 30.f - g_tweakGame->GetPressStartDelay())
|
|
{
|
|
x60_pressStartTime = std::fmod(x60_pressStartTime + dt, 1.f);
|
|
if (x60_pressStartTime < 0.5f)
|
|
x64_pressStartAlpha = x60_pressStartTime / 0.5f;
|
|
else
|
|
x64_pressStartAlpha = (1.f - x60_pressStartTime) / 0.5f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Clear press-start pulsing */
|
|
x60_pressStartTime = 0.f;
|
|
x64_pressStartAlpha = 0.f;
|
|
}
|
|
|
|
if (x50_curScreen == EScreen::Title && x54_nextScreen == EScreen::FileSelect)
|
|
{
|
|
/* Fade out title music */
|
|
x68_musicVol = 1.f - zeus::clamp(0.f, (xcc_curMoviePtr->GetPlayedSeconds() -
|
|
AudioFadeTimeA[x18_rndA]) / 2.5f, 1.f);
|
|
}
|
|
else if (x54_nextScreen == EScreen::ToPlayGame)
|
|
{
|
|
/* Fade out menu music */
|
|
float delay = AudioFadeTimeB[x1c_rndB];
|
|
x68_musicVol = 1.f - zeus::clamp(0.f, (xcc_curMoviePtr->GetPlayedSeconds() - delay) /
|
|
(xcc_curMoviePtr->GetTotalSeconds() - delay), 1.f);
|
|
}
|
|
else
|
|
{
|
|
/* Full music volume */
|
|
x68_musicVol = 1.f;
|
|
}
|
|
|
|
return EMessageReturn::Exit;
|
|
|
|
case EPhase::ExitFrontEnd:
|
|
/* Remove FrontEnd IOWin and begin updating next IOWin */
|
|
return EMessageReturn::RemoveIOWin;
|
|
|
|
default: break;
|
|
}
|
|
|
|
return EMessageReturn::Exit;
|
|
}
|
|
|
|
CIOWin::EMessageReturn CFrontEndUI::OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue)
|
|
{
|
|
switch (msg.GetType())
|
|
{
|
|
case EArchMsgType::UserInput:
|
|
{
|
|
/* Forward user events */
|
|
const CArchMsgParmUserInput& input = MakeMsg::GetParmUserInput(msg);
|
|
ProcessUserInput(input.x4_parm, queue);
|
|
break;
|
|
}
|
|
case EArchMsgType::TimerTick:
|
|
{
|
|
/* Forward frame events */
|
|
float dt = MakeMsg::GetParmTimerTick(msg).x4_parm;
|
|
return Update(dt, queue);
|
|
}
|
|
case EArchMsgType::QuitGameplay:
|
|
{
|
|
/* Immediately exit FrontEnd */
|
|
x14_phase = EPhase::ExitFrontEnd;
|
|
break;
|
|
}
|
|
default: break;
|
|
}
|
|
return EMessageReturn::Normal;
|
|
}
|
|
|
|
}
|