More class stubs

Runtime/CGameDebug.hpp

@@ -0,0 +1,56 @@
+#ifndef __RETRO_CGAMEDEBUG_HPP__
+#define __RETRO_CGAMEDEBUG_HPP__
+
+#include <string>
+
+namespace Retro
+{
+class CFinalInput;
+
+const char* StringForControlOption(int);
+
+enum EDebugMenu
+{
+};
+
+enum EDebugOptions
+{
+};
+
+enum EDebugMainMenu
+{
+};
+
+class CDebugOption
+{
+public:
+    CDebugOption(EDebugMenu, EDebugOptions, const std::string&, bool);
+    CDebugOption(EDebugMenu, EDebugOptions, const std::string&, float, float, float, float);
+};
+
+class CGameDebug
+{
+public:
+    enum EReturnValue
+    {
+    };
+
+    void DeactivateMenu();
+    void AddDebugOption(EDebugMenu, EDebugOptions, const char*, bool);
+    void AddDebugOption(EDebugMenu, EDebugOptions, const char*, float, float, float, float);
+    void SetCaptureMovieTimeLeft(float);
+    const std::string& GetCaptureMovieName();
+    void SetCaptureMovieName(const std::string&);
+    void AddDebugOptions();
+    void CopyDebugToTweaks();
+    void CopyTweaksToDebug();
+    void ProcessControllerInput(const CFinalInput&);
+    void Update(float);
+    void Draw(void) const;
+    void ActivateMenu(EDebugMainMenu, int);
+    void AddDebugOption(const CDebugOption&);
+};
+
+}
+
+#endif // __RETRO_CGAMEDEBUG_HPP__

Runtime/CIOWin.hpp

@@ -22,7 +22,7 @@ public:
         MsgRetRemoveIOWin = 3
     };
     virtual ~CIOWin() {}
-    CIOWin(const std::string& name) : m_name(name) {m_nameHash = std::hash<std::string>()(name);}
+    CIOWin(const char* name) : m_name(name) {m_nameHash = std::hash<std::string>()(m_name);}
     virtual EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&)=0;
     virtual bool GetIsContinueDraw() const {return true;}
     virtual void Draw() const {}

Runtime/CIOWinManager.cpp

@@ -70,16 +70,16 @@ bool CIOWinManager::DistributeOneMessage(const CArchitectureMessage& msg,
     while (node)
     {
         CIOWin* iow = node->GetIOWin();
-        CIOWin::EMessageReturn mret = iow->OnMessage(msg, x8_internalQueue);
+        CIOWin::EMessageReturn mret = iow->OnMessage(msg, x8_localGatherQueue);
 
-        while (x8_internalQueue)
+        while (x8_localGatherQueue)
         {
-            CArchitectureMessage msg = x8_internalQueue.Pop();
+            CArchitectureMessage msg = x8_localGatherQueue.Pop();
             if (msg.GetTarget() == TargetIOWinManager)
             {
                 if (OnIOWinMessage(msg))
                 {
-                    x8_internalQueue.Clear();
+                    x8_localGatherQueue.Clear();
                     queue.Clear();
                     return true;
                 }
@@ -238,6 +238,7 @@ void CIOWinManager::RemoveAllIOWins()
         node = node->x8_next;
         delete delNode;
     }
+    x0_drawRoot = nullptr;
     node = x4_pumpRoot;
     while (node)
     {
@@ -245,6 +246,7 @@ void CIOWinManager::RemoveAllIOWins()
         node = node->x8_next;
         delete delNode;
     }
+    x4_pumpRoot = nullptr;
 }
 
 void CIOWinManager::RemoveIOWin(CIOWin* chIow)

Runtime/CIOWinManager.hpp

@@ -25,7 +25,7 @@ class CIOWinManager
     };
     IOWinPQNode* x0_drawRoot = nullptr;
     IOWinPQNode* x4_pumpRoot = nullptr;
-    CArchitectureQueue x8_internalQueue;
+    CArchitectureQueue x8_localGatherQueue;
 public:
     bool OnIOWinMessage(const CArchitectureMessage& msg);
     void Draw() const;
@@ -39,8 +39,6 @@ public:
     void AddIOWin(rstl::ncrc_ptr<CIOWin> toAdd, int pumpPrio, int drawPrio);
 };
 
-
-
 }
 
 #endif // __RETRO_CIOWINMANAGER_HPP__

Runtime/CInGameTweakManagerBase.hpp

@@ -0,0 +1,20 @@
+#ifndef __RETRO_CINGAMETWEAKMANAGERBASE_HPP__
+#define __RETRO_CINGAMETWEAKMANAGERBASE_HPP__
+
+#include <string>
+
+namespace Retro
+{
+
+class CInGameTweakManagerBase
+{
+public:
+    bool ReadFromMemoryCard(const std::string& name)
+    {
+        return true;
+    }
+};
+
+}
+
+#endif // __RETRO_CINGAMETWEAKMANAGERBASE_HPP__

Runtime/CMFGame.hpp

@@ -1,19 +0,0 @@
-#ifndef __RETRO_CMFGAME_HPP__
-#define __RETRO_CMFGAME_HPP__
-
-#include "CIOWin.hpp"
-
-namespace Retro
-{
-
-class CMFGameLoader : public CIOWin
-{
-public:
-    CMFGameLoader() : CIOWin("CMFGameLoader") {}
-    EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
-    void Draw() const;
-};
-
-}
-
-#endif // __RETRO_CMFGAME_HPP__

Runtime/CMFGameBase.hpp

@@ -0,0 +1,23 @@
+#ifndef __RETRO_CMFGAMEBASE_HPP__
+#define __RETRO_CMFGAMEBASE_HPP__
+
+#include "CIOWin.hpp"
+
+namespace Retro
+{
+
+class CMFGameBase : public CIOWin
+{
+public:
+    CMFGameBase(const char* name) : CIOWin(name) {}
+};
+
+class CMFGameLoaderBase : public CIOWin
+{
+public:
+    CMFGameLoaderBase(const char* name) : CIOWin(name) {}
+};
+
+}
+
+#endif // __RETRO_CMFGAMEBASE_HPP__

Runtime/CMainFlow.cpp

@@ -1,39 +0,0 @@
-#include "CMainFlow.hpp"
-#include "CArchitectureQueue.hpp"
-#include "CMFGame.hpp"
-
-namespace Retro
-{
-
-void CMainFlow::AdvanceGameState(CArchitectureQueue& queue)
-{
-}
-void CMainFlow::SetGameState(EClientFlowStates state, CArchitectureQueue& queue)
-{
-    switch (state)
-    {
-    case StateGameLoad:
-        queue.Push(std::move(MakeMsg::CreateCreateIOWin(TargetIOWinManager, 10, 1000, new CMFGameLoader())));
-        break;
-    default: break;
-    }
-}
-CIOWin::EMessageReturn CMainFlow::OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue)
-{
-    switch (msg.GetType())
-    {
-    case MsgTimerTick:
-        AdvanceGameState(queue);
-        break;
-    case MsgSetGameState:
-    {
-        CArchMsgParmInt32 state = MakeMsg::GetParmNewGameflowState(msg);
-        SetGameState(EClientFlowStates(state.x4_parm), queue);
-        return MsgRetExit;
-    }
-    default: break;
-    }
-    return MsgRetNormal;
-}
-
-}

Runtime/CMainFlowBase.cpp

@@ -0,0 +1,43 @@
+#include "CMainFlowBase.hpp"
+#include "CArchitectureMessage.hpp"
+
+namespace Retro
+{
+
+CIOWin::EMessageReturn CMainFlowBase::OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue)
+{
+    switch (msg.GetType())
+    {
+    case MsgTimerTick:
+        AdvanceGameState(queue);
+        break;
+    case MsgSetGameState:
+    {
+        const CArchMsgParmInt32& state = MakeMsg::GetParmNewGameflowState(msg);
+        x14_gameState = EClientFlowStates(state.x4_parm);
+        SetGameState(x14_gameState, queue);
+        return MsgRetExit;
+    }
+    default: break;
+    }
+    return MsgRetNormal;
+}
+
+void CMainFlowBase::AdvanceGameState(CArchitectureQueue& queue)
+{
+    switch (x14_gameState)
+    {
+    case ClientStateFrontEnd:
+        SetGameState(ClientStateGameLoad, queue);
+        break;
+    case ClientStateUnspecified:
+    case ClientStateGameLoad:
+        SetGameState(ClientStateMoviePlay, queue);
+        break;
+    case ClientStateMoviePlay:
+        SetGameState(ClientStateFrontEnd, queue);
+        break;
+    }
+}
+
+}

Runtime/CMainFlowBase.hpp

@@ -0,0 +1,30 @@
+#ifndef __RETRO_CMAINFLOWBASE_HPP__
+#define __RETRO_CMAINFLOWBASE_HPP__
+
+#include "CIOWin.hpp"
+
+namespace Retro
+{
+
+enum EClientFlowStates
+{
+    ClientStateUnspecified = -1,
+    ClientStateFrontEnd = 7,
+    ClientStateGameLoad = 13,
+    ClientStateMoviePlay = 14
+};
+
+class CMainFlowBase : public CIOWin
+{
+protected:
+    EClientFlowStates x14_gameState;
+public:
+    CMainFlowBase(const char* name) : CIOWin(name) {}
+    EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
+    void AdvanceGameState(CArchitectureQueue& queue);
+    virtual void SetGameState(EClientFlowStates state, CArchitectureQueue& queue)=0;
+};
+
+}
+
+#endif // __RETRO_CMAINFLOWBASE_HPP__

Runtime/CMakeLists.txt

@@ -17,13 +17,12 @@ endif()
 
 add_library(RuntimeCommon
             COsContext.hpp COsContextBoo.cpp
-            CMainFlow.hpp CMainFlow.cpp
             CMemory.hpp CMemory.cpp
             CMemoryCardSys.hpp
             IAllocator.hpp IAllocator.cpp
             CGameAllocator.hpp CGameAllocator.cpp
             CBasics.hpp CBasicsPC.cpp
-            CIOWin.hpp CIOWin.cpp
+            CIOWin.hpp
             CIOWinManager.hpp CIOWinManager.cpp
             CStateManager.hpp CStateManager.cpp
             CGameState.hpp CGameState.cpp
@@ -46,8 +45,6 @@ add_library(RuntimeCommon
             IFactory.hpp
             ScriptObjectSupport.hpp ScriptObjectSupport.cpp
             CObjectList.hpp
-            CMFGame.hpp CMFGame.cpp
-            CMainFlow.hpp CMainFlow.cpp
             CArchitectureMessage.hpp
             CArchitectureQueue.hpp CArchitectureQueue.cpp
             IObj.hpp
@@ -61,6 +58,12 @@ add_library(RuntimeCommon
             CStringExtras.hpp
             CCallStack.hpp
             IOStreams.hpp IOStreams.cpp
+            CMainFlowBase.hpp CMainFlowBase.cpp
+            CMFGameBase.hpp
+            CInGameTweakManagerBase.hpp
+            CPlayMovieBase.hpp
+            CMoviePlayer.hpp CMoviePlayer.cpp
+            CGameDebug.hpp CGameDebug.cpp
             rstl.hpp rstl.cpp
             GameGlobalObjects.hpp
             RetroTypes.hpp

Runtime/CMoviePlayer.cpp

@@ -0,0 +1,71 @@
+#include "CMoviePlayer.hpp"
+
+namespace Retro
+{
+
+CMoviePlayer::CMoviePlayer(const char* path, float startTime, bool flag)
+: CDvdFile(path)
+{
+}
+
+void CMoviePlayer::VerifyCallbackStatus()
+{
+}
+void CMoviePlayer::DisableStaticAudio()
+{
+}
+void CMoviePlayer::SetStaticAudioVolume(int vol)
+{
+}
+void CMoviePlayer::SetStaticAudio(const void* data, u32 length, u32 loopStart, u32 loopEnd)
+{
+}
+void CMoviePlayer::MixAudio(short* out, const short* in, u32 length)
+{
+}
+void CMoviePlayer::MixStaticAudio(short* out, const short* in, u32 length)
+{
+}
+void CMoviePlayer::StaticMyAudioCallback()
+{
+}
+void CMoviePlayer::Rewind()
+{
+}
+
+bool CMoviePlayer::GetIsMovieFinishedPlaying() const
+{
+}
+bool CMoviePlayer::GetIsFullyCached() const
+{
+}
+float CMoviePlayer::GetPlayedSeconds() const
+{
+}
+float CMoviePlayer::GetTotalSeconds() const
+{
+}
+void CMoviePlayer::SetPlayMode(EPlayMode mode)
+{
+}
+void CMoviePlayer::DrawFrame(const CVector3f& a, const CVector3f& b,
+                             const CVector3f& c, const CVector3f& d)
+{
+}
+void CMoviePlayer::Update(float dt)
+{
+}
+void CMoviePlayer::DecodeFromRead(const void* data)
+{
+}
+void CMoviePlayer::ReadCompleted()
+{
+}
+void CMoviePlayer::PostDVDReadRequestIfNeeded()
+{
+}
+void CMoviePlayer::InitializeTextures()
+{
+}
+
+}

Runtime/CMoviePlayer.hpp

@@ -0,0 +1,44 @@
+#ifndef __RETRO_CMOVIEPLAYER_HPP__
+#define __RETRO_CMOVIEPLAYER_HPP__
+
+#include "RetroTypes.hpp"
+#include "CDvdFile.hpp"
+
+namespace Retro
+{
+class CVector3f;
+
+class CMoviePlayer : public CDvdFile
+{
+public:
+    enum EPlayMode
+    {
+    };
+
+    CMoviePlayer(const char* path, float startTime, bool flag);
+
+    static void VerifyCallbackStatus();
+    static void DisableStaticAudio();
+    static void SetStaticAudioVolume(int vol);
+    static void SetStaticAudio(const void* data, u32 length, u32 loopStart, u32 loopEnd);
+    void MixAudio(short* out, const short* in, u32 length);
+    static void MixStaticAudio(short* out, const short* in, u32 length);
+    static void StaticMyAudioCallback();
+    void Rewind();
+
+    bool GetIsMovieFinishedPlaying() const;
+    bool GetIsFullyCached() const;
+    float GetPlayedSeconds() const;
+    float GetTotalSeconds() const;
+    void SetPlayMode(EPlayMode);
+    void DrawFrame(const CVector3f& a, const CVector3f& b, const CVector3f& c, const CVector3f& d);
+    void Update(float dt);
+    void DecodeFromRead(const void* data);
+    void ReadCompleted();
+    void PostDVDReadRequestIfNeeded();
+    void InitializeTextures();
+};
+
+}
+
+#endif // __RETRO_CMOVIEPLAYER_HPP__

Runtime/CPlayMovieBase.hpp

@@ -0,0 +1,22 @@
+#ifndef __RETRO_CPLAYMOVIEBASE_HPP__
+#define __RETRO_CPLAYMOVIEBASE_HPP__
+
+#include "CIOWin.hpp"
+#include "CMoviePlayer.hpp"
+
+namespace Retro
+{
+
+class CPlayMovieBase : public CIOWin
+{
+    CMoviePlayer x18_moviePlayer;
+public:
+    CPlayMovieBase(const char* iowName, const char* path)
+    : CIOWin(iowName), x18_moviePlayer(path, 0.0, false) {}
+    EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) {}
+    void Draw() const {}
+};
+
+}
+
+#endif // __RETRO_CPLAYMOVIEBASE_HPP__

Runtime/CResFactory.hpp

@@ -25,6 +25,7 @@ private:
     std::unordered_map<SObjectTag, SLoadingData> m_loadList;
     void AddToLoadList(const SLoadingData& data) {m_loadList[data.tag] = data;}
 public:
+    CResLoader& GetLoader() {return x4_loader;}
     std::unique_ptr<IObj> Build(const SObjectTag&, const CVParamTransfer&);
     void BuildAsync(const SObjectTag&, const CVParamTransfer&, IObj**);
     void CancelBuild(const SObjectTag&);

Runtime/GameGlobalObjects.hpp

@@ -10,7 +10,7 @@ extern class CSimplePool* g_SimplePool;
 extern class CCharacterFactoryBuilder* g_CharFactoryBuilder;
 extern class CAiFuncMap* g_AiFuncMap;
 extern class CGameState* g_GameState;
-extern class CInGameTweakManager* g_TweakManager;
+extern class CInGameTweakManagerBase* g_TweakManager;
 extern class CBooRenderer* g_Renderer;
 
 }

Runtime/MP1/CFrontEndUI.cpp

@@ -0,0 +1,67 @@
+#include "CFrontEndUI.hpp"
+
+namespace Retro
+{
+namespace MP1
+{
+
+CFrontEndUI::CFrontEndUI(CArchitectureQueue& queue)
+: CIOWin("CFrontEnd")
+{}
+void CFrontEndUI::OnSliderSelectionChange(CGuiSliderGroup* grp, float)
+{}
+void CFrontEndUI::OnCheckBoxSelectionChange(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnOptionSubMenuCancel(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnOptionsMenuCancel(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnNewGameMenuCancel(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnFileMenuCancel(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnGenericMenuSelectionChange(CGuiTableGroup* grp, int, int)
+{}
+void CFrontEndUI::OnOptionsMenuAdvance(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnNewGameMenuAdvance(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnFileMenuAdvance(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::OnMainMenuAdvance(CGuiTableGroup* grp)
+{}
+const char* CFrontEndUI::GetAttractMovieFileName(int idx)
+{}
+const char* CFrontEndUI::GetNextAttractMovieFileName(int idx)
+{}
+void CFrontEndUI::SetCurrentMovie(EMenuMovie movie)
+{}
+void CFrontEndUI::StopAttractMovie()
+{}
+void CFrontEndUI::StartAttractMovie(int idx)
+{}
+void CFrontEndUI::UpdateMenuHighlights(CGuiTableGroup* grp)
+{}
+void CFrontEndUI::CompleteStateTransition()
+{}
+bool CFrontEndUI::CanBuild(const SObjectTag& tag)
+{}
+void CFrontEndUI::StartStateTransition(EScreen screen)
+{}
+void CFrontEndUI::HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArchitectureQueue& queue)
+{}
+void CFrontEndUI::Draw() const
+{}
+void CFrontEndUI::UpdateMovies(float dt)
+{}
+void CFrontEndUI::Update(float dt, CArchitectureQueue& queue)
+{}
+CIOWin::EMessageReturn CFrontEndUI::OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue)
+{}
+void CFrontEndUI::StartGame()
+{}
+void CFrontEndUI::InitializeFrame()
+{}
+
+}
+}

Runtime/MP1/CFrontEndUI.hpp

@@ -0,0 +1,59 @@
+#ifndef __RETRO_CFRONTENDUI_HPP__
+#define __RETRO_CFRONTENDUI_HPP__
+
+#include "CIOWin.hpp"
+#include "CGameDebug.hpp"
+
+namespace Retro
+{
+class CGuiSliderGroup;
+class CGuiTableGroup;
+class SObjectTag;
+
+namespace MP1
+{
+
+class CFrontEndUI : public CIOWin
+{
+public:
+    enum EMenuMovie
+    {
+    };
+    enum EScreen
+    {
+    };
+
+    CFrontEndUI(CArchitectureQueue& queue);
+    void OnSliderSelectionChange(CGuiSliderGroup* grp, float);
+    void OnCheckBoxSelectionChange(CGuiTableGroup* grp);
+    void OnOptionSubMenuCancel(CGuiTableGroup* grp);
+    void OnOptionsMenuCancel(CGuiTableGroup* grp);
+    void OnNewGameMenuCancel(CGuiTableGroup* grp);
+    void OnFileMenuCancel(CGuiTableGroup* grp);
+    void OnGenericMenuSelectionChange(CGuiTableGroup* grp, int, int);
+    void OnOptionsMenuAdvance(CGuiTableGroup* grp);
+    void OnNewGameMenuAdvance(CGuiTableGroup* grp);
+    void OnFileMenuAdvance(CGuiTableGroup* grp);
+    void OnMainMenuAdvance(CGuiTableGroup* grp);
+    const char* GetAttractMovieFileName(int idx);
+    const char* GetNextAttractMovieFileName(int idx);
+    void SetCurrentMovie(EMenuMovie movie);
+    void StopAttractMovie();
+    void StartAttractMovie(int idx);
+    void UpdateMenuHighlights(CGuiTableGroup* grp);
+    void CompleteStateTransition();
+    bool CanBuild(const SObjectTag& tag);
+    void StartStateTransition(EScreen screen);
+    void HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArchitectureQueue& queue);
+    void Draw() const;
+    void UpdateMovies(float dt);
+    void Update(float dt, CArchitectureQueue& queue);
+    EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
+    void StartGame();
+    void InitializeFrame();
+};
+
+}
+}
+
+#endif // __RETRO_CFRONTENDUI_HPP__

Runtime/MP1/CInGameTweakManager.hpp

@@ -1,20 +1,20 @@
 #ifndef __RETRO_CINGAMETWEAKMANAGER_HPP__
 #define __RETRO_CINGAMETWEAKMANAGER_HPP__
 
-#include <string>
+#include "CInGameTweakManagerBase.hpp"
 
 namespace Retro
 {
+namespace MP1
+{
 
-class CInGameTweakManager
+class CInGameTweakManager : public CInGameTweakManagerBase
 {
 public:
-    bool ReadFromMemoryCard(const std::string& name)
+
-    {
-        return true;
-    }
 };
 
+}
 }
 
 #endif // __RETRO_CINGAMETWEAKMANAGER_HPP__

Runtime/MP1/CMFGame.cpp

@@ -5,6 +5,8 @@
 
 namespace Retro
 {
+namespace MP1
+{
 
 CIOWin::EMessageReturn CMFGameLoader::OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue)
 {
@@ -26,3 +28,4 @@ void CMFGameLoader::Draw() const
 }
 
 }
+}

Runtime/MP1/CMFGame.hpp

@@ -0,0 +1,30 @@
+#ifndef __RETRO_CMFGAME_HPP__
+#define __RETRO_CMFGAME_HPP__
+
+#include "CMFGameBase.hpp"
+
+namespace Retro
+{
+namespace MP1
+{
+
+class CMFGame : public CMFGameBase
+{
+public:
+    CMFGame() : CMFGameBase("CMFGame") {}
+    CIOWin::EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
+    void Draw() const;
+};
+
+class CMFGameLoader : public CMFGameLoaderBase
+{
+public:
+    CMFGameLoader() : CMFGameLoaderBase("CMFGameLoader") {}
+    EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
+    void Draw() const;
+};
+
+}
+}
+
+#endif // __RETRO_CMFGAME_HPP__

Runtime/MP1/CMain.hpp

@@ -0,0 +1,54 @@
+#ifndef __RETRO_CMAIN_HPP__
+#define __RETRO_CMAIN_HPP__
+
+#include "COsContext.hpp"
+#include "CMemory.hpp"
+#include "CTweaks.hpp"
+#include "CPlayMovie.hpp"
+
+namespace Retro
+{
+class CStopwatch;
+
+namespace MP1
+{
+
+enum EGameplayResult
+{
+    GameplayResultNone,
+    GameplayResultWin,
+    GameplayResultLose,
+    GameplayResultPlaying
+};
+
+class CMain : public COsContext
+{
+    CMemorySys x6c_memSys;
+    CTweaks x70_tweaks;
+    EGameplayResult xe4_gameplayResult;
+    bool xe8_finished = false;
+public:
+    CMain();
+    void RegisterResourceTweaks();
+    void ResetGameState();
+    void StreamNewGameState(CInputStream&);
+    void CheckTweakManagerDebugOptions() {}
+    void AddWorldPaks();
+    int RsMain(int argc, const char* argv[]);
+    bool CheckReset();
+    bool CheckTerminate() {return false;}
+    void DrawDebugMetrics(double, CStopwatch&) {}
+    void DoPredrawMetrics() {}
+    void FillInAssetIDs();
+    void LoadAudio();
+    void ShutdownSubsystems();
+    void InitializeSubsystems();
+    EGameplayResult GetGameplayResult() const {return xe4_gameplayResult;}
+    void SetGameplayResult(EGameplayResult wl) {xe4_gameplayResult = wl;}
+};
+
+extern CMain* g_main;
+}
+}
+
+#endif // __RETRO_CMAIN_HPP__

Runtime/MP1/CMainFlow.cpp

@@ -0,0 +1,61 @@
+#include "CMainFlow.hpp"
+#include "CArchitectureQueue.hpp"
+#include "CMFGame.hpp"
+#include "CMain.hpp"
+#include "CPlayMovie.hpp"
+#include "CResFactory.hpp"
+#include "CFrontEndUI.hpp"
+#include "GameGlobalObjects.hpp"
+
+namespace Retro
+{
+namespace MP1
+{
+
+
+
+void CMainFlow::SetGameState(EClientFlowStates state, CArchitectureQueue& queue)
+{
+    switch (state)
+    {
+    case ClientStateFrontEnd:
+    {
+        if (g_main->GetGameplayResult() == GameplayResultNone)
+        {
+            g_main->SetGameplayResult(GameplayResultPlaying);
+            break;
+        }
+        CResLoader& loader = g_ResFactory->GetLoader();
+        while (!loader.AreAllPaksLoaded())
+            loader.AsyncIdlePakLoading();
+        g_main->LoadAudio();
+        g_main->RegisterResourceTweaks();
+        queue.Push(std::move(MakeMsg::CreateCreateIOWin(TargetIOWinManager, 12, 11, new CFrontEndUI(queue))));
+        break;
+    }
+    case ClientStateGameLoad:
+    {
+        queue.Push(std::move(MakeMsg::CreateCreateIOWin(TargetIOWinManager, 10, 1000, new CMFGameLoader())));
+        break;
+    }
+    case ClientStateMoviePlay:
+    {
+        switch (g_main->GetGameplayResult())
+        {
+        case GameplayResultWin:
+            queue.Push(std::move(MakeMsg::CreateCreateIOWin(TargetIOWinManager, 12, 11, new CPlayMovie(CPlayMovie::MovieWinGame))));
+            break;
+        case GameplayResultLose:
+            queue.Push(std::move(MakeMsg::CreateCreateIOWin(TargetIOWinManager, 12, 11, new CPlayMovie(CPlayMovie::MovieLoseGame))));
+            break;
+        default: break;
+        }
+        break;
+    }
+    default: break;
+    }
+}
+
+
+}
+}

Runtime/MP1/CMainFlow.hpp

@@ -1,29 +1,27 @@
 #ifndef __RETRO_CMAINFLOW_HPP__
 #define __RETRO_CMAINFLOW_HPP__
 
-#include "CIOWin.hpp"
+#include "CMainFlowBase.hpp"
 
 namespace Retro
 {
 class CArchitectureMessage;
 class CArchitectureQueue;
 
-enum EClientFlowStates
+namespace MP1
 {
-    StateGameLoad = 13,
-};
 
-class CMainFlow : public CIOWin
+class CMainFlow : public CMainFlowBase
 {
 public:
-    CMainFlow() : CIOWin("CMainFlow") {}
+    CMainFlow() : CMainFlowBase("CMainFlow") {}
-    void AdvanceGameState(CArchitectureQueue& queue);
     void SetGameState(EClientFlowStates state, CArchitectureQueue& queue);
-    EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
     bool GetIsContinueDraw() const {return false;}
     void Draw() const {}
 };
 
 }
 
+}
+
 #endif // __RETRO_CMAINFLOW_HPP__

Runtime/MP1/CMakeLists.txt

@@ -3,6 +3,11 @@ add_executable(mp1
                CTweaks.hpp CTweaks.cpp
                CInGameTweakManager.hpp CInGameTweakManager.cpp
                CTweakParticle.hpp CTweakParticle.cpp
+               CMainFlow.hpp CMainFlow.cpp
+               CMFGame.hpp CMFGame.cpp
+               CPlayMovie.hpp CPlayMovie.cpp
+               CFrontEndUI.hpp CFrontEndUI.cpp
+               CMain.hpp
                main.cpp)
 target_link_libraries(mp1
                       RuntimeCommonCharacter

Runtime/MP1/CPlayMovie.cpp

@@ -0,0 +1,13 @@
+namespace Retro
+{
+namespace MP1
+{
+
+const char* kMovies[] =
+{
+    "Video/wingame.thp",
+    "Video/losegame.thp"
+};
+
+}
+}

Runtime/MP1/CPlayMovie.hpp

@@ -0,0 +1,30 @@
+#ifndef __RETRO_CPLAYMOVIE_HPP__
+#define __RETRO_CPLAYMOVIE_HPP__
+
+#include "CPlayMovieBase.hpp"
+
+namespace Retro
+{
+namespace MP1
+{
+
+extern const char* kMovies[];
+
+class CPlayMovie : public CPlayMovieBase
+{
+public:
+    enum EWhichMovie
+    {
+        MovieWinGame,
+        MovieLoseGame
+    };
+private:
+    EWhichMovie x14_which;
+public:
+    CPlayMovie(EWhichMovie which) : CPlayMovieBase("CPlayMovie", kMovies[which]), x14_which(which) {}
+};
+
+}
+}
+
+#endif // __RETRO_CPLAYMOVIE_HPP__

Runtime/MP1/CTweakParticle.cpp

@@ -2,6 +2,8 @@
 
 namespace Retro
 {
+namespace MP1
+{
 
 CTweakParticle::CTweakParticle(CInputStream&)
 {
@@ -9,3 +11,4 @@ CTweakParticle::CTweakParticle(CInputStream&)
 }
 
 }
+}

Runtime/MP1/CTweakParticle.hpp

@@ -6,6 +6,8 @@
 
 namespace Retro
 {
+namespace MP1
+{
 
 class CTweakParticle : DNAMP1::CTweakParticle
 {
@@ -13,6 +15,7 @@ public:
     CTweakParticle(CInputStream&);
 };
 
+}
 }
 
 #endif // __RETRO_CTWEAKPARTICLE_HPP__

Runtime/MP1/CTweaks.cpp

@@ -2,6 +2,8 @@
 
 namespace Retro
 {
+namespace MP1
+{
 
 void CTweaks::RegisterTweaks()
 {
@@ -12,3 +14,4 @@ void CTweaks::RegisterResourceTweaks()
 }
 
 }
+}

Runtime/MP1/CTweaks.hpp

@@ -6,6 +6,8 @@
 
 namespace Retro
 {
+namespace MP1
+{
 
 class CTweaks
 {
@@ -15,6 +17,7 @@ public:
     void RegisterResourceTweaks();
 };
 
+}
 }
 
 #endif // __RETRO_CTWEAKS_HPP__

Runtime/MP1/main.cpp

@@ -1,9 +1,6 @@
 #include <memory>
 #include <boo/boo.hpp>
-#include "COsContext.hpp"
 #include "CBasics.hpp"
-#include "CTweaks.hpp"
-#include "CMemory.hpp"
 #include "CMemoryCardSys.hpp"
 #include "CResFactory.hpp"
 #include "CSimplePool.hpp"
@@ -25,6 +22,7 @@
 #include "Audio/CAudioStateWin.hpp"
 #include "GameGlobalObjects.hpp"
 #include "CArchitectureQueue.hpp"
+#include "CMain.hpp"
 
 namespace Retro
 {
@@ -34,11 +32,12 @@ CSimplePool* g_SimplePool = nullptr;
 CCharacterFactoryBuilder* g_CharFactoryBuilder = nullptr;
 CAiFuncMap* g_AiFuncMap = nullptr;
 CGameState* g_GameState = nullptr;
-CInGameTweakManager* g_TweakManager = nullptr;
+CInGameTweakManagerBase* g_TweakManager = nullptr;
 CBooRenderer* g_Renderer = nullptr;
 
 namespace MP1
 {
+class CMain* g_main = nullptr;
 
 class CGameGlobalObjects
 {
@@ -109,46 +108,50 @@ public:
     }
 };
 
-class CMain : public COsContext
+CMain::CMain()
+: x6c_memSys(*this, CMemorySys::GetGameAllocator())
 {
-    CMemorySys m_memSys;
-    CTweaks m_tweaks;
-    bool m_finished = false;
-public:
-    CMain()
-    : m_memSys(*this, CMemorySys::GetGameAllocator())
-    {
     OpenWindow("", 0, 0, 640, 480);
-    }
+    g_main = this;
-    void InitializeSubsystems()
+    xe4_gameplayResult = GameplayResultPlaying;
-    {
+}
+void CMain::RegisterResourceTweaks()
+{
+}
+void CMain::ResetGameState()
+{
+}
+void CMain::InitializeSubsystems()
+{
     CElementGen::Initialize();
     CAnimData::InitializeCache();
     CDecalManager::Initialize();
-    }
+}
-    void AddWorldPaks()
+void CMain::AddWorldPaks()
-    {
+{
-    }
+}
-    void FillInAssetIDs()
+void CMain::FillInAssetIDs()
-    {
+{
-    }
+}
-    int RsMain(int argc, const char* argv[])
+void CMain::LoadAudio()
-    {
+{
+}
+int CMain::RsMain(int argc, const char* argv[])
+{
     TOneStatic<CGameGlobalObjects> globalObjs;
     InitializeSubsystems();
-        globalObjs->PostInitialize(*this, m_memSys);
+    globalObjs->PostInitialize(*this, x6c_memSys);
-        m_tweaks.RegisterTweaks();
+    x70_tweaks.RegisterTweaks();
     AddWorldPaks();
     g_TweakManager->ReadFromMemoryCard("AudioTweaks");
     FillInAssetIDs();
     TOneStatic<CGameArchitectureSupport> archSupport(*this);
-        while (!m_finished)
+    while (!xe8_finished)
     {
-            m_finished = archSupport->Update();
+        xe8_finished = archSupport->Update();
     }
     return 0;
-    }
+}
-};
 
 }
 }