Improve MultiFileSystem to allow more file systems

src/file/MultiFileSystem.cpp

@@ -1,73 +1,110 @@
 #include "MultiFileSystem.h"
 
-MultiFileSystem::MultiFileSystem(cdc::FileSystem* pFS, cdc::FileSystem* pHookFS)
+#include "Hook.h"
+#include "modules/Log.h"
+
+MultiFileSystem::MultiFileSystem() : m_fileSystems()
 {
-	m_pFS = pFS;
-	m_pHookFS = pHookFS;
 }
 
-// Gets the best file system for a file simply by checking the hook file system first
-cdc::FileSystem* MultiFileSystem::GetBestFileSystem(const char* fileName)
+void MultiFileSystem::Add(cdc::FileSystem* fileSystem)
 {
-	// First check the hook file system, else fall back to default filesystem
-	if (m_pHookFS->FileExists(fileName))
+	m_fileSystems.push_back(fileSystem);
+
+#ifdef _DEBUG
+	Hook::GetInstance().GetModule<Log>()->WriteLine("Mounted new file system %p, number of systems: %d", fileSystem, m_fileSystems.size());
+#endif
+}
+
+void MultiFileSystem::Remove(cdc::FileSystem* fileSystem)
+{
+}
+
+cdc::FileSystem* MultiFileSystem::GetBestFileSystem(const char* fileName) const noexcept
+{
+	for (auto fileSystem : m_fileSystems)
 	{
-		return m_pHookFS;
+		if (fileSystem->FileExists(fileName))
+		{
+			return fileSystem;
+		}
 	}
 
-	return m_pFS;
+	return nullptr;
 }
 
 cdc::FileRequest* MultiFileSystem::RequestRead(cdc::FileReceiver* receiver, const char* fileName, unsigned int startOffset)
 {
-	auto pFS = GetBestFileSystem(fileName);
+	auto fileSystem = GetBestFileSystem(fileName);
 
-	return pFS->RequestRead(receiver, fileName, startOffset);
+	return fileSystem->RequestRead(receiver, fileName, startOffset);
 }
 
 cdc::File* MultiFileSystem::OpenFile(char const* fileName)
 {
-	auto pFS = GetBestFileSystem(fileName);
+	auto fileSystem = GetBestFileSystem(fileName);
 
-	return pFS->OpenFile(fileName);
+	return fileSystem->OpenFile(fileName);
 }
 
-bool MultiFileSystem::FileExists(char const* fileName)
+unsigned int MultiFileSystem::GetFileSize(char const* fileName)
 {
-	return m_pFS->FileExists(fileName) || m_pHookFS->FileExists(fileName);
+	auto fileSystem = GetBestFileSystem(fileName);
+
+	return fileSystem->GetFileSize(fileName);
 }
 
-unsigned int MultiFileSystem::GetFileSize(char const* fileName)
+bool MultiFileSystem::FileExists(char const* fileName)
 {
-	auto pFS = GetBestFileSystem(fileName);
+	for (auto fileSystem : m_fileSystems)
+	{
+		if (fileSystem->FileExists(fileName))
+		{
+			return true;
+		}
+	}
 
-	return pFS->GetFileSize(fileName);
+	return false;
 }
 
 void MultiFileSystem::SetSpecialisationMask(unsigned int specMask)
 {
-	m_pFS->SetSpecialisationMask(specMask);
-	m_pHookFS->SetSpecialisationMask(specMask);
+	for (auto fileSystem : m_fileSystems)
+	{
+		fileSystem->SetSpecialisationMask(specMask);
+	}
 }
 
 unsigned int MultiFileSystem::GetSpecialisationMask()
 {
-	return m_pFS->GetSpecialisationMask();
+	return m_fileSystems.empty() ? 0xFFFFFFFF : m_fileSystems[0]->GetSpecialisationMask();
 }
 
-// These only need to call the default file system, both will end at the same place
-
 cdc::FileSystem::Status MultiFileSystem::GetStatus()
 {
-	return m_pFS->GetStatus();
+	for (auto fileSystem : m_fileSystems)
+	{
+		if (fileSystem->GetStatus() == BUSY)
+		{
+			return BUSY;
+		}
+	}
+
+	return IDLE;
 }
 
 void MultiFileSystem::Update()
 {
-	m_pFS->Update();
+	for (auto fileSystem : m_fileSystems)
+	{
+		fileSystem->Update();
+	}
 }
 
 void MultiFileSystem::Synchronize()
 {
-	m_pFS->Synchronize();
+	for (auto fileSystem : m_fileSystems)
+	{
+		fileSystem->Synchronize();
+	}
 }

src/file/MultiFileSystem.h

@@ -1,21 +1,21 @@
 #pragma once
 
+#include <vector>
+
 #include "cdc/file/FileSystem.h"
 
-// Simplified version for cdc::MultiFileSystem since it does not exist in Legend and Anniversary
-// The real MultiFileSystem can dynamically add and re-order systems
-// 
-// This just checks the hook file system first and else falls back to the
-// original file system
 class MultiFileSystem : public cdc::FileSystem
 {
 private:
-	cdc::FileSystem* m_pFS;
-	cdc::FileSystem* m_pHookFS;
+	std::vector<cdc::FileSystem*> m_fileSystems;
+
+	cdc::FileSystem* GetBestFileSystem(const char* fileName) const noexcept;
 
-	cdc::FileSystem* GetBestFileSystem(const char* fileName);
 public:
-	MultiFileSystem(cdc::FileSystem* pFS, cdc::FileSystem* pHookFS);
+	MultiFileSystem();
+
+	void Add(cdc::FileSystem* fileSystem);
+	void Remove(cdc::FileSystem* fileSystem);
 
 	cdc::FileRequest* RequestRead(cdc::FileReceiver* receiver, const char* fileName, unsigned int startOffset);
 	cdc::File* OpenFile(const char* fileName);
@@ -26,12 +26,4 @@ class MultiFileSystem : public cdc::FileSystem
 	Status GetStatus();
 	void Update();
 	void Synchronize();
-
-#ifdef TR8
-	void Suspend() { }
-	bool Resume() { return false; }
-	bool IsSuspended() { return false; }
-	char* GetBufferPointer(cdc::FileRequest* request, unsigned int* bytesLocked) { return nullptr; }
-	void ResetBufferPointer(int value) { }
-#endif
 };

src/modules/ModLoader.cpp

@@ -43,7 +43,10 @@ static void InitArchive()
 
 	// Create our hook file system and multi file system
 	auto fileSystem = CreateHookFileSystem();
-	auto multiFileSystem = new MultiFileSystem(GetFS(), fileSystem);
+	auto multiFileSystem = new MultiFileSystem();
+
+	multiFileSystem->Add(fileSystem);
+	multiFileSystem->Add(GetFS());
 
 	// Overwrite the original file system with ours
 	*(cdc::FileSystem**)GET_ADDRESS(0x10E58BC, 0x83888C, 0x9CE278) = multiFileSystem;