AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Finish CLogBookScreen

This commit is contained in:
Jack Andersen 2017-05-14 09:58:44 -10:00
parent 9796ba9244
commit 5835e5173e
17 changed files with 541 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
DataSpec/DNACommon/SAVWCommon.hpp
View File

@ -13,7 +13,8 @@ enum class EScanCategory
Data,
Lore,
Creature,
Research
Research,
Artifact
};
struct Header : BigYAML

1
DataSpec/DNACommon/Tweaks/ITweakGui.hpp
View File

@ -105,6 +105,7 @@ struct ITweakGui : ITweak
virtual float GetScanSidesStartTime() const=0;
virtual float GetScanSidesEndTime() const=0;
virtual float GetScanSidesPositionStart() const=0;
virtual bool GetLatchArticleText() const=0;
virtual float GetWorldTransManagerCharsPerSfx() const=0;
virtual atUint32 GetXRayFogMode() const=0;
virtual float GetXRayFogNearZ() const=0;

3
DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
View File

@ -149,7 +149,7 @@ struct CTweakGui : ITweakGui
Value<float> x26c_;
Value<float> x270_scanSidesPositionStart;
Value<bool> x274_;
bool x275_ = true;
bool x275_latchArticleText = true;
Value<float> x278_wtMgrCharsPerSfx;
Value<atUint32> x27c_xrayFogMode;
Value<float> x280_xrayFogNearZ;
@ -266,6 +266,7 @@ struct CTweakGui : ITweakGui
float GetScanSidesStartTime() const { return x224_scanSidesStartTime; }
float GetScanSidesEndTime() const { return x228_scanSidesEndTime; }
float GetScanSidesPositionStart() const { return x270_scanSidesPositionStart; }
bool GetLatchArticleText() const { return x275_latchArticleText; }
float GetWorldTransManagerCharsPerSfx() const { return x278_wtMgrCharsPerSfx; }
atUint32 GetXRayFogMode() const { return x27c_xrayFogMode; }
float GetXRayFogNearZ() const { return x280_xrayFogNearZ; }

5
Runtime/CMemoryCardSys.cpp
View File

@ -106,6 +106,8 @@ CMemoryCardSys::CMemoryCardSys()
x1c_worldInter->emplace_back(mlvl.second, -1);
}
}
x30_scanCategoryCounts.resize(6);
}
bool CMemoryCardSys::InitializePump()
@ -154,7 +156,10 @@ bool CMemoryCardSys::InitializePump()
std::find_if(x20_scanStates.begin(), x20_scanStates.end(), [&](const auto& test)
{ return test.first == scan.x0_id && test.second == scan.x4_category; });
if (existingSearch == x20_scanStates.end())
{
x20_scanStates.emplace_back(scan.x0_id, scan.x4_category);
++x30_scanCategoryCounts[int(scan.x4_category)];
}
}
wldMemOut.x3c_saveWorld = std::move(world.x34_saveWorld);

2
Runtime/CMemoryCardSys.hpp
View File

@ -64,6 +64,7 @@ class CMemoryCardSys
std::vector<std::pair<ResId, CSaveWorldMemory>> xc_memoryWorlds; /* MLVL as key */
std::experimental::optional<std::vector<CSaveWorldIntermediate>> x1c_worldInter; /* used to be auto_ptr of vector */
std::vector<std::pair<ResId, CSaveWorld::EScanCategory>> x20_scanStates;
rstl::reserved_vector<u32, 6> x30_scanCategoryCounts;
public:
static kabufuda::SystemString ResolveDolphinCardPath(kabufuda::ECardSlot slot);
@ -91,6 +92,7 @@ public:
const std::vector<CGameHintInfo::CGameHint>& GetHints() const { return x0_hints->GetHints(); }
const std::vector<std::pair<ResId, CSaveWorldMemory>>& GetMemoryWorlds() const { return xc_memoryWorlds; }
const std::vector<std::pair<ResId, CSaveWorld::EScanCategory>>& GetScanStates() const { return x20_scanStates; }
u32 GetScanCategoryCount(CSaveWorld::EScanCategory cat) const { return x30_scanCategoryCounts[int(cat)]; }
bool HasSaveWorldMemory(ResId wldId) const;
const CSaveWorldMemory& GetSaveWorldMemory(ResId wldId) const;

30
Runtime/GuiSys/CAuiImagePane.cpp
View File

@ -1,14 +1,17 @@
#include "CAuiImagePane.hpp"
#include "CSimplePool.hpp"
namespace urde
{
CAuiImagePane::CAuiImagePane(const CGuiWidgetParms& parms, CSimplePool* sp, ResId, ResId,
CAuiImagePane::CAuiImagePane(const CGuiWidgetParms& parms, CSimplePool* sp, ResId tex0, ResId tex1,
rstl::reserved_vector<zeus::CVector3f, 4>&& coords,
rstl::reserved_vector<zeus::CVector2f, 4>&& uvs, bool)
: CGuiWidget(parms)
rstl::reserved_vector<zeus::CVector2f, 4>&& uvs, bool initTex)
: CGuiWidget(parms), xc8_tex0(tex0), xcc_tex1(tex1), xe0_coords(std::move(coords)),
x114_uvs(std::move(uvs))
{
if (initTex)
SetTextureID0(tex0, sp);
}
std::shared_ptr<CGuiWidget> CAuiImagePane::Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp)
@ -31,4 +34,23 @@ std::shared_ptr<CGuiWidget> CAuiImagePane::Create(CGuiFrame* frame, CInputStream
return ret;
}
void CAuiImagePane::SetTextureID0(ResId tex, CSimplePool* sp)
{
xc8_tex0 = tex;
if (!sp)
return;
if (xc8_tex0 != -1)
xb8_tex0Tok = sp->GetObj({FOURCC('TXTR'), xc8_tex0});
else
xb8_tex0Tok = TLockedToken<CTexture>();
}
void CAuiImagePane::SetAnimationParms(const zeus::CVector2f& vec, float interval, float duration)
{
x138_ = vec;
x140_interval = interval;
x144_ = 0.f;
x148_duration = duration;
}
}

22
Runtime/GuiSys/CAuiImagePane.hpp
View File

@ -2,19 +2,39 @@
#define __URDE_CAUIIMAGEPANE_HPP__
#include "CGuiWidget.hpp"
#include "CToken.hpp"
namespace urde
{
class CSimplePool;
class CTexture;
class CAuiImagePane : public CGuiWidget
{
TLockedToken<CTexture> xb8_tex0Tok; // Used to be optional
ResId xc8_tex0;
ResId xcc_tex1;
zeus::CVector2f xd0_;
zeus::CVector2f xd8_;
rstl::reserved_vector<zeus::CVector3f, 4> xe0_coords;
rstl::reserved_vector<zeus::CVector2f, 4> x114_uvs;
zeus::CVector2f x138_;
float x140_interval = 0.f;
float x144_ = 0.f;
float x148_duration = 0.f;
float x14c_invAlpha = 0.f;
float x150_interp = 0.f;
public:
CAuiImagePane(const CGuiWidgetParms& parms, CSimplePool* sp, ResId, ResId,
rstl::reserved_vector<zeus::CVector3f, 4>&& coords,
rstl::reserved_vector<zeus::CVector2f, 4>&& uvs, bool);
rstl::reserved_vector<zeus::CVector2f, 4>&& uvs, bool initTex);
FourCC GetWidgetTypeID() const { return FOURCC('IMGP'); }
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
void SetTextureID0(ResId tex, CSimplePool* sp);
void SetAnimationParms(const zeus::CVector2f& vec, float interval, float duration);
void SetInverseAlpha(float a) { x14c_invAlpha = a; }
void ResetInterp() { x150_interp = 0.f; }
};
}

1
Runtime/GuiSys/CStringTable.hpp
View File

@ -18,6 +18,7 @@ public:
void LoadStringTable(CInputStream& in);
const char16_t* GetString(s32) const;
u32 GetStringCount() const { return x0_stringCount; }
static void SetLanguage(s32);
};

3
Runtime/MP1/CArtifactDoll.cpp
View File

@ -95,6 +95,7 @@ void CArtifactDoll::Draw(float alpha, const CStateManager& mgr,
if (!IsLoaded())
return;
alpha *= x24_fader;
g_Renderer->SetPerspective(55.f, g_Viewport.x8_width, g_Viewport.xc_height, 0.2f, 4096.f);
CGraphics::SetViewPointMatrix(zeus::CTransform::Translate(0.f, -10.f, 0.f));
@ -139,6 +140,8 @@ void CArtifactDoll::Draw(float alpha, const CStateManager& mgr,
x20_actorLights->ActivateLights(model->GetInstance());
model->Draw(flags);
flags.x4_color = color;
flags.x4_color.a *= alpha;
flags.m_extendedShader = EExtendedShader::ForcedAdditive;
model->Draw(flags);
}

2
Runtime/MP1/CInventoryScreen.cpp
View File

@ -290,7 +290,7 @@ void CInventoryScreen::UpdateTextBody()
x174_textpane_body->TextSupport()->SetPage(0);
}
void CInventoryScreen::ChangedMode()
void CInventoryScreen::ChangedMode(EMode oldMode)
{
if (x10_mode == EMode::TextScroll)
{

2
Runtime/MP1/CInventoryScreen.hpp
View File

@ -40,7 +40,7 @@ public:
bool VReady() const;
void VActivate();
void RightTableSelectionChanged(int selBegin, int selEnd);
void ChangedMode();
void ChangedMode(EMode oldMode);
void UpdateRightTable();
bool ShouldLeftTableAdvance() const;
bool ShouldRightTableAdvance() const;

435
Runtime/MP1/CLogBookScreen.cpp
View File

@ -1,6 +1,8 @@
#include "CLogBookScreen.hpp"
#include "GuiSys/CGuiModel.hpp"
#include "GuiSys/CGuiTableGroup.hpp"
#include "GuiSys/CGuiTextPane.hpp"
#include "GuiSys/CAuiImagePane.hpp"
#include "MP1.hpp"
namespace urde
@ -12,6 +14,8 @@ CLogBookScreen::CLogBookScreen(const CStateManager& mgr, CGuiFrame& frame,
const CStringTable& pauseStrg)
: CPauseScreenBase(mgr, frame, pauseStrg)
{
x19c_scanCompletes.resize(5);
x200_viewScans.resize(5);
x258_artifactDoll = std::make_unique<CArtifactDoll>();
CMain::EnsureWorldPaksReady();
InitializeLogBook();
@ -25,9 +29,255 @@ CLogBookScreen::~CLogBookScreen()
CMain::EnsureWorldPakReady(g_GameState->CurrentWorldAssetId());
}
bool CLogBookScreen::IsScanComplete(CSaveWorld::EScanCategory category, ResId scan,
const CPlayerState& playerState)
{
float time = playerState.GetScanTime(scan);
if (category == CSaveWorld::EScanCategory::Artifact)
return time >= 0.5f;
else
return time >= 1.f;
}
void CLogBookScreen::InitializeLogBook()
{
for (int i=0 ; i<5 ; ++i)
x19c_scanCompletes[i].reserve(g_MemoryCardSys->GetScanCategoryCount(CSaveWorld::EScanCategory(i + 1)));
CPlayerState& playerState = *x4_mgr.GetPlayerState();
for (const std::pair<ResId, CSaveWorld::EScanCategory>& scanState : g_MemoryCardSys->GetScanStates())
{
if (scanState.second == CSaveWorld::EScanCategory::None)
continue;
bool complete = IsScanComplete(scanState.second, scanState.first, playerState);
x19c_scanCompletes[int(scanState.second) - 1].push_back(std::make_pair(scanState.first, complete));
}
std::sort(x19c_scanCompletes[4].begin(), x19c_scanCompletes[4].end(),
[](const std::pair<ResId, bool>& a, std::pair<ResId, bool>& b)
{
return CArtifactDoll::GetArtifactHeadScanIndex(a.first) <
CArtifactDoll::GetArtifactHeadScanIndex(b.first);
});
auto viewIt = x200_viewScans.begin();
for (std::vector<std::pair<ResId, bool>>& category : x19c_scanCompletes)
{
std::vector<std::pair<TLockedToken<CScannableObjectInfo>,
TLockedToken<CStringTable>>>& viewScans = *viewIt++;
size_t viewScanCount = std::min(category.size(), size_t(5));
viewScans.reserve(viewScanCount);
for (size_t i=0 ; i<viewScanCount ; ++i)
viewScans.push_back(std::make_pair(g_SimplePool->GetObj({FOURCC('SCAN'), category[i].first}),
TLockedToken<CStringTable>{}));
}
}
void CLogBookScreen::UpdateRightTitles()
{
std::vector<std::pair<ResId, bool>>& category =
x19c_scanCompletes[x70_tablegroup_leftlog->GetUserSelection()];
for (int i=0 ; xd8_textpane_titles.size() ; ++i)
{
std::u16string string;
size_t scanIndex = x18_firstViewRightSel + i;
if (scanIndex < x1f0_curViewScans.size())
{
std::pair<TCachedToken<CScannableObjectInfo>,
TCachedToken<CStringTable>>& scan = x1f0_curViewScans[scanIndex];
if (scan.second && scan.second.IsLoaded())
{
if (category[scanIndex].second)
{
if (scan.second->GetStringCount() > 1)
string = scan.second->GetString(1);
else
string = u"No Title!";
}
else
{
string = u"??????";
}
}
if (string.empty())
string = u"........";
}
xd8_textpane_titles[i]->TextSupport()->SetText(string);
}
int rightSelMod = x18_firstViewRightSel % 5;
int rightSelRem = 5 - rightSelMod;
for (int i=0 ; i<x144_model_titles.size() ; ++i)
{
float zOff = ((i >= rightSelMod) ? rightSelRem - 5 : rightSelRem) * x38_highlightPitch;
x144_model_titles[i]->SetLocalTransform(
zeus::CTransform::Translate(0.f, 0.f, zOff) * x144_model_titles[i]->GetTransform());
}
}
void CLogBookScreen::PumpArticleLoad()
{
x260_24_loaded = true;
for (std::vector<std::pair<TLockedToken<CScannableObjectInfo>,
TLockedToken<CStringTable>>>& category : x200_viewScans)
{
for (std::pair<TLockedToken<CScannableObjectInfo>,
TLockedToken<CStringTable>>& scan : category)
{
if (scan.first.IsLoaded())
{
if (!scan.second)
{
scan.second = g_SimplePool->GetObj({FOURCC('STRG'), scan.first->GetStringTableId()});
x260_24_loaded = false;
}
}
else
{
x260_24_loaded = false;
}
}
}
int rem = 6;
for (std::pair<TCachedToken<CScannableObjectInfo>,
TCachedToken<CStringTable>>& scan : x1f0_curViewScans)
{
if (scan.first.IsLoaded())
{
if (!scan.second)
{
scan.second = g_SimplePool->GetObj({FOURCC('STRG'), scan.first->GetStringTableId()});
scan.second.Lock();
}
}
if (--rem == 0)
break;
}
if (x1f0_curViewScans.size())
{
int articleIdx = x18_firstViewRightSel;
while (rem > 0)
{
x1f0_curViewScans[articleIdx].first.Lock();
articleIdx = NextSurroundingArticleIndex(articleIdx);
--rem;
}
}
for (std::pair<TCachedToken<CScannableObjectInfo>,
TCachedToken<CStringTable>>& scan : x1f0_curViewScans)
{
if (scan.first.IsLoaded())
{
if (scan.second && scan.second.IsLoaded())
{
UpdateRightTitles();
UpdateBodyText();
}
}
}
}
bool CLogBookScreen::IsScanCategoryReady(CSaveWorld::EScanCategory category) const
{
CPlayerState& playerState = *x4_mgr.GetPlayerState();
for (const std::pair<ResId, CSaveWorld::EScanCategory>& scanState : g_MemoryCardSys->GetScanStates())
{
if (scanState.second != category)
continue;
if (IsScanComplete(scanState.second, scanState.first, playerState))
return true;
}
return false;
}
void CLogBookScreen::UpdateBodyText()
{
if (x10_mode != EMode::TextScroll)
{
x174_textpane_body->TextSupport()->SetText(u"");
return;
}
TCachedToken<CStringTable>& str = x1f0_curViewScans[x1c_rightSel].second;
if (str && str.IsLoaded())
{
std::u16string accumStr = str->GetString(0);
if (str->GetStringCount() > 2)
{
accumStr += u"\n\n";
accumStr += str->GetString(2);
}
if (IsArtifactCategorySelected())
{
int headIdx = GetSelectedArtifactHeadScanIndex();
if (headIdx >= 0 && g_GameState->GetPlayerState()->HasPowerUp(CPlayerState::EItemType(headIdx + 29)))
accumStr = std::u16string(u"\n\n\n\n\n\n") + g_MainStringTable->GetString(105);
}
x174_textpane_body->TextSupport()->SetText(accumStr, true);
}
}
void CLogBookScreen::UpdateBodyImagesAndText()
{
const CScannableObjectInfo* scan = x1f0_curViewScans[x1c_rightSel].first.GetObj();
for (CAuiImagePane* pane : xf0_imagePanes)
{
pane->SetTextureID0(-1, g_SimplePool);
pane->SetAnimationParms(zeus::CVector2f::skZero, 0.f, 0.f);
}
for (int i=0 ; i<4 ; ++i)
{
const CScannableObjectInfo::SBucket& bucket = scan->GetBucket(i);
if (bucket.x8_imagePos == -1)
continue;
CAuiImagePane* pane = xf0_imagePanes[bucket.x8_imagePos];
if (bucket.x14_interval > 0.f)
{
pane->SetAnimationParms(zeus::CVector2f(bucket.xc_size.x, bucket.xc_size.y),
bucket.x14_interval, bucket.x18_fadeDuration);
}
pane->SetTextureID0(bucket.x0_texture, g_SimplePool);
pane->ResetInterp();
}
x260_26_exitTextScroll = false;
UpdateBodyText();
}
int CLogBookScreen::NextSurroundingArticleIndex(int cur) const
{
if (cur < x18_firstViewRightSel)
{
int tmp = x18_firstViewRightSel + (x18_firstViewRightSel - cur + 6);
if (tmp >= x1f0_curViewScans.size())
return cur - 1;
else
return tmp;
}
if (cur < x18_firstViewRightSel + 6)
{
if (cur + 1 < x1f0_curViewScans.size())
return cur + 1;
if (x18_firstViewRightSel == 0)
return -1;
return x18_firstViewRightSel - 1;
}
int tmp = x18_firstViewRightSel - (cur - (x18_firstViewRightSel + 5));
if (tmp >= 0)
return tmp;
if (cur >= x1f0_curViewScans.size() - 1)
return -1;
return cur + 1;
}
bool CLogBookScreen::IsArtifactCategorySelected() const
@ -35,6 +285,122 @@ bool CLogBookScreen::IsArtifactCategorySelected() const
return x70_tablegroup_leftlog->GetUserSelection() == 4;
}
int CLogBookScreen::GetSelectedArtifactHeadScanIndex() const
{
auto& category = x19c_scanCompletes[x70_tablegroup_leftlog->GetUserSelection()];
if (x1c_rightSel < category.size())
return CArtifactDoll::GetArtifactHeadScanIndex(category[x1c_rightSel].first);
return -1;
}
bool CLogBookScreen::InputDisabled() const
{
return x25c_leavePauseState == ELeavePauseState::LeavingPause;
}
void CLogBookScreen::TransitioningAway()
{
x25c_leavePauseState = ELeavePauseState::LeavingPause;
}
void CLogBookScreen::Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue)
{
CPauseScreenBase::Update(dt, rand, archQueue);
x258_artifactDoll->Update(dt, x4_mgr);
PumpArticleLoad();
if (x10_mode == EMode::TextScroll)
{
if (x260_25_inTextScroll)
x254_viewInterp = std::min(x254_viewInterp + 4.f * dt, 1.f);
else
x254_viewInterp = std::max(0.f, x254_viewInterp - 4.f * dt);
zeus::CColor color(1.f, x254_viewInterp);
x74_basewidget_leftguages->SetColor(color);
x88_basewidget_rightguages->SetColor(color);
zeus::CColor invColor(1.f, 1.f - x254_viewInterp);
x70_tablegroup_leftlog->SetColor(invColor);
x84_tablegroup_rightlog->SetColor(invColor);
x17c_model_textalpha->SetColor(invColor);
x174_textpane_body->SetColor(invColor);
for (CAuiImagePane* pane : xf0_imagePanes)
pane->SetInverseAlpha(1.f - x254_viewInterp);
if (x254_viewInterp == 0.f && x25c_leavePauseState == ELeavePauseState::InPause)
ChangeMode(EMode::RightTable);
}
if (x25c_leavePauseState == ELeavePauseState::LeavingPause && x254_viewInterp == 0.f)
x25c_leavePauseState = ELeavePauseState::LeftPause;
}
void CLogBookScreen::Touch()
{
CPauseScreenBase::Touch();
x258_artifactDoll->Touch();
}
void CLogBookScreen::ProcessControllerInput(const CFinalInput& input)
{
x260_25_inTextScroll = false;
if (x25c_leavePauseState == ELeavePauseState::LeftPause)
return;
if (x10_mode == EMode::TextScroll)
{
int oldPage = x174_textpane_body->TextSupport()->GetPageCounter();
int newPage = oldPage;
int pageCount = x174_textpane_body->TextSupport()->GetTotalPageCount();
bool lastPage = (pageCount - 1) == oldPage;
if (pageCount != -1)
{
if (input.PLAUp())
newPage = std::max(oldPage - 1, 0);
else if (input.PLADown() || (input.PA() && !lastPage))
newPage = std::min(oldPage + 1, pageCount - 1);
x174_textpane_body->TextSupport()->SetPage(newPage);
if (oldPage != newPage)
CSfxManager::SfxStart(1444, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
x198_28_pulseTextArrowTop = newPage > 1;
x198_29_pulseTextArrowBottom = !lastPage;
}
else
{
x198_29_pulseTextArrowBottom = false;
x198_28_pulseTextArrowTop = false;
}
if (!x260_26_exitTextScroll)
x260_26_exitTextScroll = input.PB() || (input.PA() && lastPage);
if (g_tweakGui->GetLatchArticleText())
x260_25_inTextScroll = !x260_26_exitTextScroll;
else
x260_25_inTextScroll = input.DA();
}
else
{
x198_29_pulseTextArrowBottom = false;
x198_28_pulseTextArrowTop = false;
}
if (x25c_leavePauseState == ELeavePauseState::LeavingPause)
x260_25_inTextScroll = false;
CPauseScreenBase::ProcessControllerInput(input);
}
void CLogBookScreen::Draw(float transInterp, float totalAlpha, float yOff)
{
CPauseScreenBase::Draw(transInterp, totalAlpha, yOff);
bool artifactSel = x10_mode == EMode::RightTable && IsArtifactCategorySelected();
x258_artifactDoll->Draw(transInterp * (1.f - x254_viewInterp), x4_mgr, artifactSel,
GetSelectedArtifactHeadScanIndex());
}
bool CLogBookScreen::VReady() const
{
return true;
@ -42,12 +408,79 @@ bool CLogBookScreen::VReady() const
void CLogBookScreen::VActivate()
{
for (int i=0 ; i<5 ; ++i)
{
if (IsScanCategoryReady(CSaveWorld::EScanCategory(i + 1)))
{
xa8_textpane_categories[i]->TextSupport()->SetText(xc_pauseStrg.GetString(i + 1));
}
else
{
xa8_textpane_categories[i]->TextSupport()->SetText(u"??????");
x70_tablegroup_leftlog->GetWorkerWidget(i)->SetIsSelectable(false);
}
}
x178_textpane_title->TextSupport()->SetText(xc_pauseStrg.GetString(0));
for (int i=0 ; i<5 ; ++i)
x70_tablegroup_leftlog->GetWorkerWidget(i)->SetIsSelectable(false);
}
void CLogBookScreen::RightTableSelectionChanged(int selBegin, int selEnd)
{
UpdateRightTitles();
}
void CLogBookScreen::ChangedMode(EMode oldMode)
{
if (oldMode == EMode::TextScroll)
{
x74_basewidget_leftguages->SetVisibility(false, ETraversalMode::Children);
x88_basewidget_rightguages->SetVisibility(false, ETraversalMode::Children);
UpdateBodyText();
x174_textpane_body->TextSupport()->SetPage(0);
}
else if (x10_mode == EMode::TextScroll)
{
x74_basewidget_leftguages->SetVisibility(true, ETraversalMode::Children);
x88_basewidget_rightguages->SetVisibility(true, ETraversalMode::Children);
x260_25_inTextScroll = true;
UpdateBodyImagesAndText();
}
}
void CLogBookScreen::UpdateRightTable()
{
CPauseScreenBase::UpdateRightTable();
x1f0_curViewScans.clear();
std::vector<std::pair<ResId, bool>>& category = x19c_scanCompletes[x70_tablegroup_leftlog->GetUserSelection()];
x1f0_curViewScans.reserve(category.size());
for (std::pair<ResId, bool>& scan : category)
x1f0_curViewScans.push_back(std::make_pair(g_SimplePool->GetObj({FOURCC('SCAN'), scan.first}),
TLockedToken<CStringTable>{}));
PumpArticleLoad();
UpdateRightTitles();
}
bool CLogBookScreen::ShouldLeftTableAdvance() const
{
if (!x260_24_loaded || x1f0_curViewScans.empty())
return false;
return IsScanCategoryReady(CSaveWorld::EScanCategory(x70_tablegroup_leftlog->GetUserSelection() + 1));
}
bool CLogBookScreen::ShouldRightTableAdvance() const
{
const std::pair<TLockedToken<CScannableObjectInfo>,
TLockedToken<CStringTable>>& scan = x1f0_curViewScans[x1c_rightSel];
return scan.first.IsLoaded() && scan.second.IsLoaded();
}
u32 CLogBookScreen::GetRightTableCount() const
{
return 0;
return x1f0_curViewScans.size();
}
}

47
Runtime/MP1/CLogBookScreen.hpp
View File

@ -12,33 +12,62 @@ namespace MP1
class CLogBookScreen : public CPauseScreenBase
{
rstl::reserved_vector<std::vector<u32>, 5> x19c_;
std::vector<u32> x1f0_;
rstl::reserved_vector<std::vector<u32>, 5> x200_;
float x254_ = 0.f;
rstl::reserved_vector<std::vector<std::pair<ResId, bool>>, 5> x19c_scanCompletes;
std::vector<std::pair<TCachedToken<CScannableObjectInfo>,
TCachedToken<CStringTable>>> x1f0_curViewScans;
rstl::reserved_vector<std::vector<std::pair<TLockedToken<CScannableObjectInfo>,
TLockedToken<CStringTable>>>, 5> x200_viewScans;
float x254_viewInterp = 0.f;
std::unique_ptr<CArtifactDoll> x258_artifactDoll;
u32 x25c_ = 0;
enum class ELeavePauseState
{
InPause = 0,
LeavingPause = 1,
LeftPause = 2
};
ELeavePauseState x25c_leavePauseState = ELeavePauseState::InPause;
union
{
struct
{
bool x260_24_ : 1;
bool x260_25_ : 1;
bool x260_26_ : 1;
bool x260_24_loaded : 1;
bool x260_25_inTextScroll : 1;
bool x260_26_exitTextScroll : 1;
};
s32 _dummy = 0;
};
void InitializeLogBook();
void UpdateRightTitles();
void PumpArticleLoad();
bool IsScanCategoryReady(CSaveWorld::EScanCategory category) const;
void UpdateBodyText();
void UpdateBodyImagesAndText();
int NextSurroundingArticleIndex(int cur) const;
bool IsArtifactCategorySelected() const;
int GetSelectedArtifactHeadScanIndex() const;
static bool IsScanComplete(CSaveWorld::EScanCategory category, ResId scan, const CPlayerState& playerState);
public:
CLogBookScreen(const CStateManager& mgr, CGuiFrame& frame, const CStringTable& pauseStrg);
~CLogBookScreen();
bool IsArtifactCategorySelected() const;
bool InputDisabled() const;
void TransitioningAway();
void Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue);
void Touch();
void ProcessControllerInput(const CFinalInput& input);
void Draw(float transInterp, float totalAlpha, float yOff);
bool VReady() const;
void VActivate();
void RightTableSelectionChanged(int selBegin, int selEnd);
void ChangedMode(EMode oldMode);
void UpdateRightTable();
bool ShouldLeftTableAdvance() const;
bool ShouldRightTableAdvance() const;
u32 GetRightTableCount() const;
};

2
Runtime/MP1/COptionsScreen.cpp
View File

@ -232,7 +232,7 @@ void COptionsScreen::RightTableSelectionChanged(int selBegin, int selEnd)
UpdateOptionView();
}
void COptionsScreen::ChangedMode()
void COptionsScreen::ChangedMode(EMode oldMode)
{
if (x10_mode == EMode::RightTable)
{

2
Runtime/MP1/COptionsScreen.hpp
View File

@ -37,7 +37,7 @@ public:
bool VReady() const;
void VActivate();
void RightTableSelectionChanged(int selBegin, int selEnd);
void ChangedMode();
void ChangedMode(EMode oldMode);
void UpdateRightTable();
bool ShouldLeftTableAdvance() const;
bool ShouldRightTableAdvance() const;

2
Runtime/MP1/CPauseScreenBase.cpp
View File

@ -211,7 +211,7 @@ void CPauseScreenBase::ChangeMode(EMode mode)
default: break;
}
ChangedMode();
ChangedMode(oldMode);
}
void CPauseScreenBase::UpdateSideTable(CGuiTableGroup* table)

2
Runtime/MP1/CPauseScreenBase.hpp
View File

@ -122,7 +122,7 @@ public:
virtual bool VReady() const=0;
virtual void VActivate()=0;
virtual void RightTableSelectionChanged(int selBegin, int selEnd) {}
virtual void ChangedMode() {}
virtual void ChangedMode(EMode oldMode) {}
virtual void UpdateRightTable();
virtual bool ShouldLeftTableAdvance() const { return true; }
virtual bool ShouldRightTableAdvance() const { return true; }