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

Work on CWorldTransManager

This commit is contained in:
Jack Andersen 2016-08-15 10:58:07 -10:00
parent eb7ce0b84b
commit 0dacc2233c
19 changed files with 264 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Runtime/CGameState.cpp
View File

@ -7,6 +7,8 @@ namespace urde
CGameState::CGameState()
{
x98_playerState.reset(new CPlayerState());
x9c_transManager.reset(new CWorldTransManager());
x228_25_deferPowerupInit = true;
}

9
Runtime/CGameState.hpp
View File

@ -24,11 +24,12 @@ class CGameState
{
friend class CStateManager;
bool x0_[128] = {};
int m_stateFlag = -1;
ResId x84_mlvlId = -1;
std::vector<CWorldState> x88_worldStates;
CPlayerState x98_playerState;
CWorldTransManager x9c_transManager;
std::shared_ptr<CPlayerState> x98_playerState;
std::shared_ptr<CWorldTransManager> x9c_transManager;
float m_gameTime = 0.0;
CGameOptions m_gameOpts;
double xa0_playTime;
@ -46,10 +47,12 @@ public:
CGameState();
CGameState(CBitStreamReader& stream);
void SetCurrentWorldId(unsigned int id, const std::string& name);
CWorldTransManager& WorldTransitionManager() {return x9c_transManager;}
std::shared_ptr<CPlayerState> PlayerState() {return x98_playerState;}
std::shared_ptr<CWorldTransManager> WorldTransitionManager() {return x9c_transManager;}
void SetTotalPlayTime(float time);
CWorldState& StateForWorld(ResId mlvlId);
CWorldState& CurrentWorldState() { return StateForWorld(x84_mlvlId); }
ResId CurrentWorldAssetId() const { return x84_mlvlId; }
};
}

6
Runtime/CIOWin.hpp
View File

@ -13,7 +13,7 @@ class CArchitectureQueue;
class CIOWin
{
std::string m_name;
std::string x4_name;
size_t m_nameHash;
public:
enum class EMessageReturn
@ -24,12 +24,12 @@ public:
RemoveIOWin = 3
};
virtual ~CIOWin() {}
CIOWin(const char* name) : m_name(name) {m_nameHash = std::hash<std::string>()(m_name);}
CIOWin(const char* name) : x4_name(name) {m_nameHash = std::hash<std::string>()(x4_name);}
virtual EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&)=0;
virtual bool GetIsContinueDraw() const {return true;}
virtual void Draw() const {}
virtual void PreDraw() const {}
const std::string& GetName() const {return m_name;}
const std::string& GetName() const {return x4_name;}
size_t GetNameHash() const {return m_nameHash;}
};

16
Runtime/CObjectList.hpp
View File

@ -32,10 +32,24 @@ class CObjectList
};
SObjectListEntry m_list[1024];
EGameObjectList m_listEnum;
TUniqueId m_firstId = -1;
TUniqueId m_firstId = kInvalidUniqueId;
u16 m_count = 0;
int m_areaIdx = 0;
public:
class iterator
{
friend class CObjectList;
CObjectList& m_list;
TUniqueId m_id;
iterator(CObjectList& list, TUniqueId id) : m_list(list), m_id(id) {}
public:
iterator& operator++() { m_id = m_list.GetNextObjectIndex(m_id); return *this; }
bool operator!=(const iterator& other) const { return m_id != other.m_id; }
CEntity* operator*() const { return m_list.GetObjectById(m_id); }
};
iterator begin() { return iterator(*this, m_firstId); }
iterator end() { return iterator(*this, kInvalidUniqueId); }
CObjectList(EGameObjectList listEnum);
void AddObject(CEntity& entity);

13
Runtime/CStateManager.cpp
View File

@ -536,18 +536,12 @@ void CStateManager::InitializeState(ResId mlvlId, TAreaId aid, ResId mreaId)
x850_world->TravelToArea(x8cc_nextAreaId, *this, true);
UpdateRoomAcoustics(x8cc_nextAreaId);
TUniqueId entId = x80c_allObjs->GetFirstObjectIndex();
while (entId != kInvalidUniqueId)
{
CEntity* ent = x80c_allObjs->GetObjectById(entId);
for (CEntity* ent : *x80c_allObjs)
SendScriptMsg(ent, kInvalidUniqueId, EScriptObjectMessage::InternalMessage14);
entId = x80c_allObjs->GetNextObjectIndex(entId);
}
entId = x80c_allObjs->GetFirstObjectIndex();
while (entId != kInvalidUniqueId)
for (CEntity* ent : *x80c_allObjs)
{
CScriptSpawnPoint* sp = dynamic_cast<CScriptSpawnPoint*>(x80c_allObjs->GetObjectById(entId));
CScriptSpawnPoint* sp = dynamic_cast<CScriptSpawnPoint*>(ent);
if (sp && sp->x30_24_active && sp->FirstSpawn())
{
const zeus::CTransform& xf = sp->GetTransform();
@ -577,7 +571,6 @@ void CStateManager::InitializeState(ResId mlvlId, TAreaId aid, ResId mreaId)
x8b8_playerState->IncrPickup(iType, spawnPu - statePu);
}
}
entId = x80c_allObjs->GetNextObjectIndex(entId);
}
x84c_player->AsyncLoadSuit(*this);

7
Runtime/Camera/CCameraManager.cpp
View File

@ -139,16 +139,13 @@ const CGameCamera* CCameraManager::GetCurrentCamera(const CStateManager& stateMg
void CCameraManager::ResetCameras(CStateManager& mgr)
{
CGameCameraList& camList = mgr.GetCameraObjectList();
zeus::CTransform xf = mgr.GetPlayer().CreateTransformFromMovementDirection();
xf.origin = mgr.GetPlayer().GetEyePosition();
TUniqueId camId = camList.GetFirstObjectIndex();
while (camId != kInvalidUniqueId)
for (CEntity* ent : mgr.GetCameraObjectList())
{
CGameCamera* camObj = static_cast<CGameCamera*>(camList.GetObjectById(camId));
CGameCamera* camObj = static_cast<CGameCamera*>(ent);
camObj->Reset(xf, mgr);
camId = camList.GetNextObjectIndex(camId);
}
}

4
Runtime/GameGlobalObjects.cpp
View File

@ -2,6 +2,10 @@
namespace urde
{
namespace MP1
{
class CMain* g_Main = nullptr;
}
class CMemoryCardSys* g_MemoryCardSys = nullptr;
class IFactory* g_ResFactory = nullptr;

4
Runtime/GameGlobalObjects.hpp
View File

@ -10,6 +10,10 @@
namespace urde
{
namespace MP1
{
extern class CMain* g_Main;
}
extern class CMemoryCardSys* g_MemoryCardSys;
extern class IFactory* g_ResFactory;

10
Runtime/GuiSys/CGuiTextPane.cpp
View File

@ -48,13 +48,13 @@ void CGuiTextPane::Draw(const CGuiWidgetDrawParms& parms) const
zeus::CVector2f dims = GetDimensions();
if (x114_textSupport.x28_extentX)
dims.x /= float(x114_textSupport.x28_extentX);
if (x114_textSupport.x34_extentX)
dims.x /= float(x114_textSupport.x34_extentX);
else
dims.x = 0.f;
if (x114_textSupport.x2c_extentY)
dims.y /= float(x114_textSupport.x2c_extentY);
if (x114_textSupport.x38_extentY)
dims.y /= float(x114_textSupport.x38_extentY);
else
dims.y = 0.f;
@ -112,7 +112,7 @@ CGuiTextPane* CGuiTextPane::Create(CGuiFrame* frame, CInputStream& in, bool flag
bool vertical = in.readBool();
EJustification justification = EJustification(in.readUint32Big());
EVerticalJustification vJustification = EVerticalJustification(in.readUint32Big());
CGuiTextProperties props(wordWrap, vertical, false, justification, vJustification);
CGuiTextProperties props(wordWrap, vertical, justification, vJustification, ETextDirection::Horizontal);
zeus::CColor fontCol;
fontCol.readRGBABig(in);
zeus::CColor outlineCol;

2
Runtime/GuiSys/CGuiTextPane.hpp
View File

@ -20,7 +20,7 @@ public:
const CGuiTextSupport* GetTextSupport() const {return &x114_textSupport;}
void Update(float dt);
bool GetIsFinishedLoadingWidgetSpecific() const;
std::vector<ResId> GetFontAssets() const {return {x114_textSupport.x50_fontId};}
std::vector<ResId> GetFontAssets() const {return {x114_textSupport.x5c_fontId};}
void SetDimensions(const zeus::CVector2f& dim, bool initVBO);
void ScaleDimensions(const zeus::CVector3f& scale);
void Draw(const CGuiWidgetDrawParms& parms) const;

80
Runtime/GuiSys/CGuiTextSupport.cpp
View File

@ -14,26 +14,26 @@ namespace urde
CGuiTextSupport::CGuiTextSupport(ResId fontId, const CGuiTextProperties& props,
const zeus::CColor& fontCol, const zeus::CColor& outlineCol,
const zeus::CColor& geomCol, s32 padX, s32 padY, CSimplePool* store)
: x10_props(props), x1c_fontColor(fontCol), x20_outlineColor(outlineCol),
x24_geometryColor(geomCol), x28_extentX(padX), x2c_extentY(padY)
: x14_props(props), x24_fontColor(fontCol), x28_outlineColor(outlineCol),
x2c_geometryColor(geomCol), x34_extentX(padX), x38_extentY(padY)
{
x2c0_font = store->GetObj({SBIG('FONT'), fontId});
x2cc_font = store->GetObj({SBIG('FONT'), fontId});
}
float CGuiTextSupport::GetCurrentAnimationOverAge() const
{
if (!x2ac_active || !x44_typeEnable)
if (!x2ac_active || !x50_typeEnable)
return 0.f;
if (x34_primStartTimes.size())
if (x44_primStartTimes.size())
{
float val = (x54_renderBuf->GetPrimitiveCount() - x34_primStartTimes.back().second) /
x4c_chRate + x34_primStartTimes.back().first;
float val = (x60_renderBuf->GetPrimitiveCount() - x44_primStartTimes.back().second) /
x58_chRate + x44_primStartTimes.back().first;
return std::max(0.f, val);
}
else
{
float val = x54_renderBuf->GetPrimitiveCount() / x4c_chRate;
float val = x60_renderBuf->GetPrimitiveCount() / x58_chRate;
return std::max(0.f, val);
}
}
@ -41,23 +41,23 @@ float CGuiTextSupport::GetCurrentAnimationOverAge() const
float CGuiTextSupport::GetNumCharsPrinted() const
{
if (x2ac_active)
return std::min(x30_curTime * x4c_chRate, float(x54_renderBuf->GetPrimitiveCount()));
return std::min(x3c_curTime * x58_chRate, float(x60_renderBuf->GetPrimitiveCount()));
return 0.f;
}
float CGuiTextSupport::GetTotalAnimationTime() const
{
if (!x2ac_active || !x44_typeEnable)
if (!x2ac_active || !x50_typeEnable)
return 0.f;
return x54_renderBuf->GetPrimitiveCount() / x4c_chRate;
return x60_renderBuf->GetPrimitiveCount() / x58_chRate;
}
void CGuiTextSupport::SetTypeWriteEffectOptions(bool enable, float chFadeTime, float chRate)
{
x44_typeEnable = enable;
x48_chFadeTime = std::max(chFadeTime, 0.0001f);
x4c_chRate = std::max(chRate, 1.f);
x50_typeEnable = enable;
x54_chFadeTime = std::max(chFadeTime, 0.0001f);
x58_chRate = std::max(chRate, 1.f);
}
void CGuiTextSupport::Update(float dt)
@ -65,12 +65,12 @@ void CGuiTextSupport::Update(float dt)
if (!x2ac_active)
return;
if (x44_typeEnable)
if (x50_typeEnable)
{
for (int i=0 ; i<x54_renderBuf->GetPrimitiveCount() ; ++i)
for (int i=0 ; i<x60_renderBuf->GetPrimitiveCount() ; ++i)
{
float chStartTime = 0.f;
for (const std::pair<float, int>& p : x34_primStartTimes)
for (const std::pair<float, int>& p : x44_primStartTimes)
{
if (p.second < i)
continue;
@ -85,18 +85,18 @@ void CGuiTextSupport::Update(float dt)
prim.x0_color1.a = std::min(std::max(0.f, (x30_curTime - chStartTime) / x48_chFadeTime), 1.f);
x54_renderBuf->SetPrimitive(prim, i);
#else
x54_renderBuf->SetPrimitiveOpacity(i,
std::min(std::max(0.f, (x30_curTime - chStartTime) / x48_chFadeTime), 1.f));
x60_renderBuf->SetPrimitiveOpacity(i,
std::min(std::max(0.f, (x3c_curTime - chStartTime) / x54_chFadeTime), 1.f));
#endif
}
}
x30_curTime += dt;
x3c_curTime += dt;
}
void CGuiTextSupport::ClearBuffer()
{
x54_renderBuf = std::experimental::nullopt;
x60_renderBuf = std::experimental::nullopt;
}
void CGuiTextSupport::CheckAndRebuildTextRenderBuffer()
@ -105,15 +105,15 @@ void CGuiTextSupport::CheckAndRebuildTextRenderBuffer()
return;
g_TextExecuteBuf->Clear();
g_TextExecuteBuf->x18_textState.x48_enableWordWrap = x10_props.x0_wordWrap;
g_TextExecuteBuf->BeginBlock(0, 0, x28_extentX, x2c_extentY, ETextDirection(x10_props.x1_vertical),
x10_props.x4_justification, x10_props.x8_vertJustification);
g_TextExecuteBuf->AddColor(EColorType::Main, x1c_fontColor);
g_TextExecuteBuf->AddColor(EColorType::Outline, x20_outlineColor);
g_TextExecuteBuf->x18_textState.x48_enableWordWrap = x14_props.x0_wordWrap;
g_TextExecuteBuf->BeginBlock(0, 0, x34_extentX, x38_extentY, ETextDirection(x14_props.x1_vertical),
x14_props.x4_justification, x14_props.x8_vertJustification);
g_TextExecuteBuf->AddColor(EColorType::Main, x24_fontColor);
g_TextExecuteBuf->AddColor(EColorType::Outline, x28_outlineColor);
std::wstring initStr;
if ((x50_fontId & 0xffff) != 0xffff)
initStr = hecl::WideFormat(L"&font=%08X;", u32(x50_fontId));
if ((x5c_fontId & 0xffff) != 0xffff)
initStr = hecl::WideFormat(L"&font=%08X;", u32(x5c_fontId));
initStr += x0_string;
g_TextParser->ParseText(*g_TextExecuteBuf, initStr.c_str(), initStr.size());
@ -123,7 +123,7 @@ void CGuiTextSupport::CheckAndRebuildTextRenderBuffer()
if (GetIsTextSupportFinishedLoading())
{
x54_renderBuf = g_TextExecuteBuf->CreateTextRenderBuffer();
x60_renderBuf = g_TextExecuteBuf->CreateTextRenderBuffer();
g_TextExecuteBuf->Clear();
}
@ -136,31 +136,31 @@ void CGuiTextSupport::Render() const
{
zeus::CTransform oldModel = CGraphics::g_GXModelMatrix;
CGraphics::SetModelMatrix(oldModel * zeus::CTransform::Scale(1.f, 1.f, -1.f));
x54_renderBuf->Render(x24_geometryColor, x30_curTime);
x60_renderBuf->Render(x2c_geometryColor, x3c_curTime);
CGraphics::SetModelMatrix(oldModel);
}
}
void CGuiTextSupport::SetGeometryColor(const zeus::CColor& col)
{
x24_geometryColor = col;
x2c_geometryColor = col;
}
void CGuiTextSupport::SetOutlineColor(const zeus::CColor& col)
{
if (col != x20_outlineColor)
if (col != x28_outlineColor)
{
ClearBuffer();
x20_outlineColor = col;
x28_outlineColor = col;
}
}
void CGuiTextSupport::SetFontColor(const zeus::CColor& col)
{
if (col != x1c_fontColor)
if (col != x24_fontColor)
{
ClearBuffer();
x1c_fontColor = col;
x24_fontColor = col;
}
}
@ -169,8 +169,8 @@ void CGuiTextSupport::AddText(const std::wstring& str)
if (x2ac_active)
{
float t = GetCurrentAnimationOverAge();
x34_primStartTimes.push_back(std::make_pair(std::max(t, x30_curTime),
x54_renderBuf->GetPrimitiveCount()));
x44_primStartTimes.push_back(std::make_pair(std::max(t, x3c_curTime),
x60_renderBuf->GetPrimitiveCount()));
}
x0_string += str;
ClearBuffer();
@ -180,8 +180,8 @@ void CGuiTextSupport::SetText(const std::wstring& str)
{
if (x0_string.compare(str))
{
x34_primStartTimes.clear();
x30_curTime = 0.f;
x44_primStartTimes.clear();
x3c_curTime = 0.f;
x0_string = str;
ClearBuffer();
}
@ -200,7 +200,7 @@ bool CGuiTextSupport::GetIsTextSupportFinishedLoading() const
if (!tok.IsLoaded())
return false;
}
return x2c0_font.IsLoaded();
return x2cc_font.IsLoaded();
}
}

48
Runtime/GuiSys/CGuiTextSupport.hpp
View File

@ -62,36 +62,46 @@ class CGuiTextProperties
friend class CGuiTextSupport;
bool x0_wordWrap;
bool x1_vertical;
bool x2_c;
EJustification x4_justification;
EVerticalJustification x8_vertJustification;
ETextDirection xc_direction;
public:
CGuiTextProperties(bool wordWrap, bool vertical, bool c, EJustification justification,
EVerticalJustification vertJustification)
: x0_wordWrap(wordWrap), x1_vertical(vertical), x2_c(c), x4_justification(justification),
x8_vertJustification(vertJustification) {}
CGuiTextProperties(bool wordWrap, bool vertical, EJustification justification,
EVerticalJustification vertJustification, ETextDirection dir)
: x0_wordWrap(wordWrap), x1_vertical(vertical), x4_justification(justification),
x8_vertJustification(vertJustification), xc_direction(dir) {}
};
class CGuiTextSupport
{
friend class CGuiTextPane;
std::wstring x0_string;
CGuiTextProperties x10_props;
zeus::CColor x1c_fontColor;
zeus::CColor x20_outlineColor;
zeus::CColor x24_geometryColor;
s32 x28_extentX;
s32 x2c_extentY;
float x30_curTime = 0.f;
std::vector<std::pair<float, int>> x34_primStartTimes;
bool x44_typeEnable = false;
float x48_chFadeTime = 0.1f;
float x4c_chRate = 10.0f;
ResId x50_fontId;
std::experimental::optional<CTextRenderBuffer> x54_renderBuf;
float x10_ = 0.f;
CGuiTextProperties x14_props;
zeus::CColor x24_fontColor;
zeus::CColor x28_outlineColor;
zeus::CColor x2c_geometryColor;
s32 x34_extentX;
s32 x38_extentY;
float x3c_curTime = 0.f;
std::vector<std::pair<float, int>> x44_primStartTimes;
bool x50_typeEnable = false;
float x54_chFadeTime = 0.1f;
float x58_chRate = 10.0f;
ResId x5c_fontId;
std::experimental::optional<CTextRenderBuffer> x60_renderBuf;
bool x2ac_active = false;
std::vector<CToken> x2b0_assets;
TLockedToken<CRasterFont> x2c0_font;
TLockedToken<CRasterFont> x2cc_font;
zeus::CVector2f x2dc_;
zeus::CVector2f x2e4_;
std::list<u8> x2f0_;
u32 x300_ = 0;
u32 x304_ = 0;
u32 x308_ = 0;
public:
CGuiTextSupport(ResId fontId, const CGuiTextProperties& props,
const zeus::CColor& fontCol, const zeus::CColor& outlineCol,

24
Runtime/MP1/CMFGame.cpp
View File

@ -2,20 +2,40 @@
#include "CArchitectureQueue.hpp"
#include "GameGlobalObjects.hpp"
#include "CGameState.hpp"
#include "MP1.hpp"
namespace urde
{
namespace MP1
{
CMFGameLoader::CMFGameLoader()
: CMFGameLoaderBase("CMFGameLoader")
{
switch (g_Main->GetFlowState())
{
case CMain::FlowState::Five:
case CMain::FlowState::Six:
{
ResId mlvlId = g_GameState->CurrentWorldAssetId();
//g_GameState->WorldTransitionManager()->
//g_MemoryCardSys->
}
default:
{
}
}
}
CIOWin::EMessageReturn CMFGameLoader::OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue)
{
std::shared_ptr<CWorldTransManager> wtMgr = g_GameState->WorldTransitionManager();
switch (msg.GetType())
{
case EArchMsgType::TimerTick:
{
const CArchMsgParmReal32& tick = MakeMsg::GetParmTimerTick(msg);
g_GameState->WorldTransitionManager();
}
default: break;
}
@ -24,7 +44,7 @@ CIOWin::EMessageReturn CMFGameLoader::OnMessage(const CArchitectureMessage& msg,
void CMFGameLoader::Draw() const
{
g_GameState->WorldTransitionManager().Draw();
g_GameState->WorldTransitionManager()->Draw();
}
}

20
Runtime/MP1/CMFGame.hpp
View File

@ -5,6 +5,10 @@
namespace urde
{
class CStateManager;
class CInGameGuiManager;
class CToken;
namespace MP1
{
@ -18,8 +22,22 @@ public:
class CMFGameLoader : public CMFGameLoaderBase
{
std::shared_ptr<CStateManager> x14_stateMgr;
std::shared_ptr<CInGameGuiManager> x18_guiMgr;
std::vector<CToken> x1c_;
union
{
struct
{
bool x2c_24_ : 1;
bool x2c_25_ : 1;
};
u8 _dummy = 0;
};
public:
CMFGameLoader() : CMFGameLoaderBase("CMFGameLoader") {}
CMFGameLoader();
EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
void Draw() const;
};

10
Runtime/MP1/CMainFlow.cpp
View File

@ -35,9 +35,9 @@ void CMainFlow::SetGameState(EClientFlowStates state, CArchitectureQueue& queue)
{
case EClientFlowStates::FrontEnd:
{
if (g_main->GetGameplayResult() == EGameplayResult::None)
if (g_Main->GetGameplayResult() == EGameplayResult::None)
{
g_main->SetGameplayResult(EGameplayResult::Playing);
g_Main->SetGameplayResult(EGameplayResult::Playing);
break;
}
/* TODO: URDE handling
@ -45,8 +45,8 @@ void CMainFlow::SetGameState(EClientFlowStates state, CArchitectureQueue& queue)
while (!loader.AreAllPaksLoaded())
loader.AsyncIdlePakLoading();
*/
g_main->LoadAudio();
g_main->RegisterResourceTweaks();
g_Main->LoadAudio();
g_Main->RegisterResourceTweaks();
queue.Push(std::move(MakeMsg::CreateCreateIOWin(EArchMsgTarget::IOWinManager, 12, 11, new CFrontEndUI())));
break;
}
@ -57,7 +57,7 @@ void CMainFlow::SetGameState(EClientFlowStates state, CArchitectureQueue& queue)
}
case EClientFlowStates::MoviePlay:
{
switch (g_main->GetGameplayResult())
switch (g_Main->GetGameplayResult())
{
case EGameplayResult::Win:
queue.Push(std::move(MakeMsg::CreateCreateIOWin(EArchMsgTarget::IOWinManager, 12, 11, new CPlayMovie(CPlayMovie::EWhichMovie::WinGame))));

7
Runtime/MP1/MP1.cpp
View File

@ -12,13 +12,12 @@ URDE_DECL_SPECIALIZE_SHADER(CSpaceWarpFilter)
namespace MP1
{
class CMain* g_main = nullptr;
CMain::CMain(IFactory& resFactory, CSimplePool& resStore)
: m_globalObjects(resFactory, resStore)
: x128_globalObjects(resFactory, resStore)
{
g_main = this;
xe4_gameplayResult = EGameplayResult::Playing;
g_Main = this;
}
void CMain::RegisterResourceTweaks()
@ -60,7 +59,7 @@ void CMain::Init(boo::IGraphicsDataFactory* factory,
boo::IAudioVoiceEngine* voiceEngine)
{
InitializeSubsystems(factory, cc, renderTex, storeMgr, voiceEngine);
m_globalObjects.PostInitialize();
x128_globalObjects.PostInitialize();
x70_tweaks.RegisterTweaks();
//g_TweakManager->ReadFromMemoryCard("AudioTweaks");
FillInAssetIDs();

40
Runtime/MP1/MP1.hpp
View File

@ -207,6 +207,18 @@ class CMain
fprintf(stderr, "\n");
}
#endif
public:
enum class FlowState
{
Zero,
One,
Two,
Three,
Four,
Five,
Six,
};
private:
//CMemorySys x6c_memSys;
CTweaks x70_tweaks;
@ -214,9 +226,32 @@ class CMain
bool xe8_b24_finished = false;
/* urde addition: these are simply initialized along with everything else */
CGameGlobalObjects m_globalObjects;
CGameGlobalObjects x128_globalObjects;
CGameArchitectureSupport m_archSupport;
FlowState x12c_ = FlowState::Five;
u32 x130_[10] = { 1000000 };
union
{
struct
{
bool x160_24_ : 1;
bool x160_25_ : 1;
bool x160_26_ : 1;
bool x160_27_ : 1;
bool x160_28_ : 1;
bool x160_29_ : 1;
bool x160_30_ : 1;
bool x160_31_ : 1;
bool x161_24_ : 1;
};
u16 _dummy = 0;
};
u32 x164_ = 0;
void InitializeSubsystems(boo::IGraphicsDataFactory* factory,
boo::IGraphicsCommandQueue* cc,
boo::ITextureR* renderTex,
@ -248,9 +283,10 @@ public:
void ShutdownSubsystems();
EGameplayResult GetGameplayResult() const {return xe4_gameplayResult;}
void SetGameplayResult(EGameplayResult wl) {xe4_gameplayResult = wl;}
FlowState GetFlowState() const { return x12c_; }
};
extern CMain* g_main;
}
}

26
Runtime/World/CWorldTransManager.cpp
View File

@ -1,4 +1,7 @@
#include "CWorldTransManager.hpp"
#include "GuiSys/CGuiTextSupport.hpp"
#include "CSimplePool.hpp"
#include "GameGlobalObjects.hpp"
namespace urde
{
@ -11,4 +14,27 @@ void CWorldTransManager::DrawDisabled() const
{
}
void CWorldTransManager::StartTextTransition(ResId fontId, ResId stringId, bool b1, bool b2,
float chFadeTime, float chFadeRate, float f3)
{
x40_ = b1;
x38_ = f3;
x44_25_ = false;
x30_type = ETransType::Text;
x4_modelData.reset();
x44_27_ = b2;
CGuiTextProperties props(false, true, EJustification::Center,
EVerticalJustification::Center, ETextDirection::Horizontal);
x8_textData.reset(new CGuiTextSupport(fontId, props, zeus::CColor::skWhite,
zeus::CColor::skBlack, zeus::CColor::skWhite,
640, 448, g_SimplePool));
x8_textData->SetTypeWriteEffectOptions(true, chFadeTime, chFadeRate);
xc_strTable = g_SimplePool->GetObj(SObjectTag{FOURCC('STRG'), stringId});
x8_textData->SetText(L"");
StartTransition();
}
}

44
Runtime/World/CWorldTransManager.hpp
View File

@ -3,15 +3,42 @@
#include "RetroTypes.hpp"
#include "CRandom16.hpp"
#include "Character/CModelData.hpp"
#include "GuiSys/CGuiTextSupport.hpp"
namespace urde
{
class CSimplePool;
class CStringTable;
class CWorldTransManager
{
public:
enum class ETransType
{
Blank,
LiftScene,
Text
};
struct CWorldTransModelData
{
CModelData x1c_;
CModelData x68_;
CModelData xb4_;
CModelData x100_;
CToken x14c_;
CToken x158_;
CToken x164_;
std::vector<u32> x1a0_;
std::unique_ptr<u8> x1b0_;
};
private:
float x0_ = 0.f;
u32 x4_ = 0;
u32 x8_ = 0;
std::unique_ptr<CWorldTransModelData> x4_modelData;
std::unique_ptr<CGuiTextSupport> x8_textData;
TLockedToken<CStringTable> xc_strTable;
u8 x14_ = 0;
float x18_;
CRandom16 x20_ = CRandom16(99);
@ -19,8 +46,9 @@ class CWorldTransManager
u32 x28_ = 0;
u8 x2c_ = 127;
u8 x2d_ = 64;
u32 x30_ = 0;
ETransType x30_type = ETransType::Blank;
float x38_ = 0.f;
bool x40_;
union
{
struct
@ -48,11 +76,11 @@ public:
void sub_80209280() const {}
void Draw() const
{
if (x30_ == 0)
if (x30_type == ETransType::Blank)
DrawDisabled();
else if (x30_ == 1)
else if (x30_type == ETransType::LiftScene)
DrawEnabled();
else if (x30_ == 2)
else if (x30_type == ETransType::Text)
sub_80209280();
}
@ -61,9 +89,11 @@ public:
x0_ = 0.f;
x18_ = 0.f;
x44_24_ = false;
x44_24_ = true;
x44_28_ = true;
}
void StartTextTransition(ResId fontId, ResId stringId, bool, bool, float, float, float);
void EndTransition() {}
void PleaseStopSoon() {}
bool IsTransitionEnabled() const { return false; }