Update OoT and MM's cutscene names (#303)

* progress

* fixed non-matching issues

* moved the enums to their own file & improvements

* format

* split MM and OoT

* more cleanup

* initial MM update

* MM improvements

* format

* class/function name update

* reduce the amount of zeroes (match)

* enum rename

* format

* removed hardcoded enums for OoT

* review 1

* remove mm hardcoded enums

* format

* ActorCutscene -> CutsceneEntry
CutsceneEntry -> CutsceneScriptEntry

* format

* some changes in (actor) cutsceneentry

* config "CutsceneEnumData" -> "EnumData"

* add ``else if``s inside ``ConfigFunc_EnumData``

* more ``else if``s

* removed reference in ``~CutsceneCommand``

18 files changed, 1981 insertions, 1204 deletions

diff --git a/ZAPD/GameConfig.cpp b/ZAPD/GameConfig.cpp
index 6384808..fffa7f4 100644
--- a/ZAPD/GameConfig.cpp
+++ b/ZAPD/GameConfig.cpp
@@ -165,6 +165,80 @@ void GameConfig::ConfigFunc_ExternalFile(const tinyxml2::XMLElement& element)
 	externalFiles.push_back(ExternalFile(fs::path(xmlPathValue), fs::path(outPathValue)));
 }
 
+void GameConfig::ConfigFunc_EnumData(const tinyxml2::XMLElement& element)
+{
+	std::string path = Path::GetDirectoryName(configFilePath);
+	path = path.append("/").append(element.Attribute("File"));
+	tinyxml2::XMLDocument doc;
+	tinyxml2::XMLError eResult = doc.LoadFile(path.c_str());
+
+	if (eResult != tinyxml2::XML_SUCCESS)
+	{
+		throw std::runtime_error("Error: Unable to read cutscene data.");
+	}
+
+	tinyxml2::XMLNode* root = doc.FirstChild();
+
+	if (root == nullptr)
+		return;
+
+	for (tinyxml2::XMLElement* csEnum = root->FirstChildElement(); csEnum != nullptr;
+	     csEnum = csEnum->NextSiblingElement())
+	{
+		for (tinyxml2::XMLElement* item = csEnum->FirstChildElement(); item != nullptr;
+		     item = item->NextSiblingElement())
+		{
+			std::string enumKey = csEnum->Attribute("Key");
+			uint16_t itemIndex = atoi(item->Attribute("Index"));
+			const char* itemID = item->Attribute("ID");
+
+			// Common
+			if (enumKey == "cmd")
+				cutsceneData.cutsceneCmd[itemIndex] = itemID;
+
+			else if (enumKey == "miscType")
+				cutsceneData.miscType[itemIndex] = itemID;
+
+			else if (enumKey == "textType")
+				cutsceneData.textType[itemIndex] = itemID;
+
+			else if (enumKey == "fadeOutSeqPlayer")
+				cutsceneData.fadeOutSeqPlayer[itemIndex] = itemID;
+
+			else if (enumKey == "transitionType")
+				cutsceneData.transitionType[itemIndex] = itemID;
+
+			else if (enumKey == "destination")
+				cutsceneData.destination[itemIndex] = itemID;
+
+			// MM
+			else if (enumKey == "modifySeqType")
+				cutsceneData.modifySeqType[itemIndex] = itemID;
+
+			else if (enumKey == "chooseCreditsSceneType")
+				cutsceneData.chooseCreditsSceneType[itemIndex] = itemID;
+
+			else if (enumKey == "destinationType")
+				cutsceneData.destinationType[itemIndex] = itemID;
+
+			else if (enumKey == "motionBlurType")
+				cutsceneData.motionBlurType[itemIndex] = itemID;
+
+			else if (enumKey == "transitionGeneralType")
+				cutsceneData.transitionGeneralType[itemIndex] = itemID;
+
+			else if (enumKey == "rumbleType")
+				cutsceneData.rumbleType[itemIndex] = itemID;
+
+			else if (enumKey == "spawnFlag")
+				cutsceneData.spawnFlag[itemIndex] = itemID;
+
+			else if (enumKey == "endSfx")
+				cutsceneData.endSfx[itemIndex] = itemID;
+		}
+	}
+}
+
 void GameConfig::ReadConfigFile(const fs::path& argConfigFilePath)
 {
 	static const std::unordered_map<std::string, ConfigFunc> ConfigFuncDictionary = {
@@ -175,6 +249,7 @@ void GameConfig::ReadConfigFile(const fs::path& argConfigFilePath)
 		{"SpecialEntranceList", &GameConfig::ConfigFunc_specialEntranceList},
 		{"TexturePool", &GameConfig::ConfigFunc_TexturePool},
 		{"BGConfig", &GameConfig::ConfigFunc_BGConfig},
+		{"EnumData", &GameConfig::ConfigFunc_EnumData},
 		{"ExternalXMLFolder", &GameConfig::ConfigFunc_ExternalXMLFolder},
 		{"ExternalFile", &GameConfig::ConfigFunc_ExternalFile},
 	};
diff --git a/ZAPD/GameConfig.h b/ZAPD/GameConfig.h
index d650c6d..4278532 100644
--- a/ZAPD/GameConfig.h
+++ b/ZAPD/GameConfig.h
@@ -21,6 +21,31 @@ public:
 	ExternalFile(fs::path nXmlPath, fs::path nOutPath);
 };
 
+// Stores data from the XML file, the integer is the index (via ATOI) and the string is the value
+class CutsceneEnumData
+{
+public:
+	// Common
+	std::map<uint16_t, std::string> cutsceneCmd;
+	std::map<uint16_t, std::string> miscType;
+	std::map<uint16_t, std::string> fadeOutSeqPlayer;
+	std::map<uint16_t, std::string> transitionType;
+
+	// OoT
+	std::map<uint16_t, std::string> textType;
+	std::map<uint16_t, std::string> destination;
+
+	// MM
+	std::map<uint16_t, std::string> modifySeqType;
+	std::map<uint16_t, std::string> chooseCreditsSceneType;
+	std::map<uint16_t, std::string> destinationType;
+	std::map<uint16_t, std::string> motionBlurType;
+	std::map<uint16_t, std::string> transitionGeneralType;
+	std::map<uint16_t, std::string> rumbleType;
+	std::map<uint8_t, std::string> spawnFlag;
+	std::map<uint8_t, std::string> endSfx;
+};
+
 class ZFile;
 
 class GameConfig
@@ -34,6 +59,7 @@ public:
 	std::vector<std::string> entranceList;
 	std::vector<std::string> specialEntranceList;
 	std::map<uint32_t, TexturePoolEntry> texturePool;  // Key = CRC
+	CutsceneEnumData cutsceneData;
 
 	// ZBackground
 	uint32_t bgScreenWidth = 320, bgScreenHeight = 240;
@@ -59,6 +85,7 @@ public:
 	void ConfigFunc_BGConfig(const tinyxml2::XMLElement& element);
 	void ConfigFunc_ExternalXMLFolder(const tinyxml2::XMLElement& element);
 	void ConfigFunc_ExternalFile(const tinyxml2::XMLElement& element);
+	void ConfigFunc_EnumData(const tinyxml2::XMLElement& element);
 
 	void ReadConfigFile(const fs::path& configFilePath);
 };
diff --git a/ZAPD/OtherStructs/CutsceneMM_Commands.cpp b/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
index edefbc0..f0bd68a 100644
--- a/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
+++ b/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
@@ -1,40 +1,46 @@
 #include "CutsceneMM_Commands.h"
 
-#include <cassert>
 #include <unordered_map>
-
+#include "Globals.h"
 #include "Utils/BitConverter.h"
 #include "Utils/StringHelper.h"
 
+/**** GENERIC ****/
+
 // Specific for command lists where each entry has size 8 bytes
-const std::unordered_map<CutsceneMMCommands, CsCommandListDescriptor> csCommandsDescMM = {
-	{CutsceneMMCommands::CS_CMD_MISC, {"CS_MISC", "(0x%02X, %i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_SET_LIGHTING, {"CS_LIGHTING", "(0x%02X, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_SCENE_TRANS_FX, {"CS_SCENE_TRANS_FX", "(%i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_MOTIONBLUR, {"CS_MOTIONBLUR", "(%i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_GIVETATL, {"CS_GIVETATL", "(%i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_PLAYSEQ, {"CS_PLAYSEQ", "(0x%04X, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_130, {"CS_SCENE_UNK_130", "(0x%04X, %i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_131, {"CS_SCENE_UNK_131", "(0x%04X, %i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_132, {"CS_SCENE_UNK_132", "(%i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_STOPSEQ, {"CS_STOPSEQ", "(0x%04X, %i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_PLAYAMBIENCE, {"CS_PLAYAMBIENCE", "(0x%04X, %i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_FADEAMBIENCE, {"CS_FADEAMBIENCE", "(0x%04X, %i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_TERMINATOR, {"CS_TERMINATOR", "(%i, %i, %i)"}},
-	{CutsceneMMCommands::CS_CMD_CHOOSE_CREDITS_SCENES,
-     {"CS_CHOOSE_CREDITS_SCENES", "(%i, %i, %i)"}},
+const std::unordered_map<CutsceneMM_CommandType, CsCommandListDescriptor> csCommandsDescMM = {
+	{CutsceneMM_CommandType::CS_CMD_MISC, {"CS_MISC", "(%s, %i, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_LIGHT_SETTING, {"CS_LIGHT_SETTING", "(0x%02X, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_TRANSITION, {"CS_TRANSITION", "(%s, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_MOTION_BLUR, {"CS_MOTION_BLUR", "(%s, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_GIVE_TATL, {"CS_GIVE_TATL", "(%s, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_START_SEQ, {"CS_START_SEQ", "(0x%04X, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_SFX_REVERB_INDEX_2,
+     {"CS_SFX_REVERB_INDEX_2", "(0x%04X, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_SFX_REVERB_INDEX_1,
+     {"CS_SFX_REVERB_INDEX_1", "(0x%04X, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_MODIFY_SEQ, {"CS_MODIFY_SEQ", "(%s, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_STOP_SEQ, {"CS_STOP_SEQ", "(0x%04X, %i, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_START_AMBIENCE, {"CS_START_AMBIENCE", "(0x%04X, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_FADE_OUT_AMBIENCE,
+     {"CS_FADE_OUT_AMBIENCE", "(0x%04X, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_DESTINATION, {"CS_DESTINATION", "(%s, %i, %i)"}},
+	{CutsceneMM_CommandType::CS_CMD_CHOOSE_CREDITS_SCENES,
+     {"CS_CHOOSE_CREDITS_SCENES", "(%s, %i, %i)"}},
 };
 
-CutsceneSubCommandEntry_GenericMMCmd::CutsceneSubCommandEntry_GenericMMCmd(
-	const std::vector<uint8_t>& rawData, offset_t rawDataIndex, CutsceneMMCommands cmdId)
+CutsceneMMSubCommandEntry_GenericCmd::CutsceneMMSubCommandEntry_GenericCmd(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex, CutsceneMM_CommandType cmdId)
 	: CutsceneSubCommandEntry(rawData, rawDataIndex), commandId(cmdId)
 {
 }
 
-std::string CutsceneSubCommandEntry_GenericMMCmd::GetBodySourceCode() const
+std::string CutsceneMMSubCommandEntry_GenericCmd::GetBodySourceCode() const
 {
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
 	const auto& element = csCommandsDescMM.find(commandId);
 	std::string entryFmt = "CS_UNK_DATA(0x%02X, %i, %i, %i)";
+	std::string type = "";
 
 	if (element != csCommandsDescMM.end())
 	{
@@ -42,12 +48,50 @@ std::string CutsceneSubCommandEntry_GenericMMCmd::GetBodySourceCode() const
 		entryFmt += element->second.args;
 	}
 
+	if (commandId == CutsceneMM_CommandType::CS_CMD_MISC &&
+	    cutsceneData->miscType.find(base) != cutsceneData->miscType.end())
+		type = cutsceneData->miscType[base];
+
+	else if (commandId == CutsceneMM_CommandType::CS_CMD_TRANSITION &&
+	    cutsceneData->transitionType.find(base) != cutsceneData->transitionType.end())
+		type = cutsceneData->transitionType[base];
+
+	else if (commandId == CutsceneMM_CommandType::CS_CMD_MOTION_BLUR &&
+	    cutsceneData->motionBlurType.find(base) != cutsceneData->motionBlurType.end())
+		type = cutsceneData->motionBlurType[base];
+
+	else if (commandId == CutsceneMM_CommandType::CS_CMD_MODIFY_SEQ &&
+	    cutsceneData->modifySeqType.find(base) != cutsceneData->modifySeqType.end())
+		type = cutsceneData->modifySeqType[base];
+
+	else if (commandId == CutsceneMM_CommandType::CS_CMD_DESTINATION &&
+	    cutsceneData->destinationType.find(base) != cutsceneData->destinationType.end())
+		type = cutsceneData->destinationType[base];
+
+	else if (commandId == CutsceneMM_CommandType::CS_CMD_CHOOSE_CREDITS_SCENES &&
+	    cutsceneData->chooseCreditsSceneType.find(base) !=
+	        cutsceneData->chooseCreditsSceneType.end())
+		type = cutsceneData->chooseCreditsSceneType[base];
+
+	else if (commandId == CutsceneMM_CommandType::CS_CMD_GIVE_TATL)
+		type = base ? "true" : "false";
+
+	if (type != "")
+		return StringHelper::Sprintf(entryFmt.c_str(), type.c_str(), startFrame, endFrame, pad);
+
+	if (commandId == CutsceneMM_CommandType::CS_CMD_LIGHT_SETTING ||
+	    commandId == CutsceneMM_CommandType::CS_CMD_START_SEQ ||
+	    commandId == CutsceneMM_CommandType::CS_CMD_STOP_SEQ)
+	{
+		return StringHelper::Sprintf(entryFmt.c_str(), base - 1, startFrame, endFrame, pad);
+	}
+
 	return StringHelper::Sprintf(entryFmt.c_str(), base, startFrame, endFrame, pad);
 }
 
 CutsceneMMCommand_GenericCmd::CutsceneMMCommand_GenericCmd(const std::vector<uint8_t>& rawData,
                                                            offset_t rawDataIndex,
-                                                           CutsceneMMCommands cmdId)
+                                                           CutsceneMM_CommandType cmdId)
 	: CutsceneCommand(rawData, rawDataIndex)
 {
 	rawDataIndex += 4;
@@ -57,7 +101,7 @@ CutsceneMMCommand_GenericCmd::CutsceneMMCommand_GenericCmd(const std::vector<uin
 	entries.reserve(numEntries);
 	for (size_t i = 0; i < numEntries; i++)
 	{
-		auto* entry = new CutsceneSubCommandEntry_GenericMMCmd(rawData, rawDataIndex, cmdId);
+		auto* entry = new CutsceneMMSubCommandEntry_GenericCmd(rawData, rawDataIndex, cmdId);
 		entries.push_back(entry);
 		rawDataIndex += entry->GetRawSize();
 	}
@@ -65,7 +109,7 @@ CutsceneMMCommand_GenericCmd::CutsceneMMCommand_GenericCmd(const std::vector<uin
 
 std::string CutsceneMMCommand_GenericCmd::GetCommandMacro() const
 {
-	const auto& element = csCommandsDescMM.find(static_cast<CutsceneMMCommands>(commandID));
+	const auto& element = csCommandsDescMM.find(static_cast<CutsceneMM_CommandType>(commandID));
 
 	if (element != csCommandsDescMM.end())
 	{
@@ -75,6 +119,8 @@ std::string CutsceneMMCommand_GenericCmd::GetCommandMacro() const
 	return StringHelper::Sprintf("CS_UNK_DATA_LIST(0x%X, %i)", commandID, numEntries);
 }
 
+/**** CAMERA ****/
+
 CutsceneSubCommandEntry_Camera::CutsceneSubCommandEntry_Camera(const std::vector<uint8_t>& rawData,
                                                                offset_t rawDataIndex)
 	: CutsceneSubCommandEntry(rawData, rawDataIndex)
@@ -108,10 +154,12 @@ CutsceneMMCommand_Camera::CutsceneMMCommand_Camera(const std::vector<uint8_t>& r
 
 std::string CutsceneMMCommand_Camera::GetCommandMacro() const
 {
-	return StringHelper::Sprintf("CS_CAMERA_LIST(%i)", numEntries);
+	return StringHelper::Sprintf("CS_CAM_SPLINE_LIST(%i)", numEntries);
 }
 
-CutsceneSubCommandEntry_FadeScreen::CutsceneSubCommandEntry_FadeScreen(
+/**** TRANSITION GENERAL ****/
+
+CutsceneSubCommandEntry_TransitionGeneral::CutsceneSubCommandEntry_TransitionGeneral(
 	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
 	: CutsceneSubCommandEntry(rawData, rawDataIndex)
 {
@@ -123,19 +171,26 @@ CutsceneSubCommandEntry_FadeScreen::CutsceneSubCommandEntry_FadeScreen(
 	unk_0B = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x0B);
 }
 
-std::string CutsceneSubCommandEntry_FadeScreen::GetBodySourceCode() const
+std::string CutsceneSubCommandEntry_TransitionGeneral::GetBodySourceCode() const
 {
-	return StringHelper::Sprintf("CS_FADESCREEN(0x%02X, %i, %i, %i, %i, %i)", base, startFrame,
-	                             endFrame, unk_06, unk_07, unk_08);
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (cutsceneData->transitionGeneralType.find(base) != cutsceneData->transitionGeneralType.end())
+		return StringHelper::Sprintf("CS_TRANSITION_GENERAL(%s, %i, %i, %i, %i, %i)",
+		                             cutsceneData->transitionGeneralType[base].c_str(), startFrame,
+		                             endFrame, unk_06, unk_07, unk_08);
+
+	return StringHelper::Sprintf("CS_TRANSITION_GENERAL(0x%02X, %i, %i, %i, %i, %i)", base,
+	                             startFrame, endFrame, unk_06, unk_07, unk_08);
 }
 
-size_t CutsceneSubCommandEntry_FadeScreen::GetRawSize() const
+size_t CutsceneSubCommandEntry_TransitionGeneral::GetRawSize() const
 {
 	return 0x0C;
 }
 
-CutsceneMMCommand_FadeScreen::CutsceneMMCommand_FadeScreen(const std::vector<uint8_t>& rawData,
-                                                           offset_t rawDataIndex)
+CutsceneMMCommand_TransitionGeneral::CutsceneMMCommand_TransitionGeneral(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
 	: CutsceneCommand(rawData, rawDataIndex)
 {
 	rawDataIndex += 4;
@@ -143,36 +198,45 @@ CutsceneMMCommand_FadeScreen::CutsceneMMCommand_FadeScreen(const std::vector<uin
 	entries.reserve(numEntries);
 	for (size_t i = 0; i < numEntries; i++)
 	{
-		auto* entry = new CutsceneSubCommandEntry_FadeScreen(rawData, rawDataIndex);
+		auto* entry = new CutsceneSubCommandEntry_TransitionGeneral(rawData, rawDataIndex);
 		entries.push_back(entry);
 		rawDataIndex += entry->GetRawSize();
 	}
 }
 
-std::string CutsceneMMCommand_FadeScreen::GetCommandMacro() const
+std::string CutsceneMMCommand_TransitionGeneral::GetCommandMacro() const
 {
-	return StringHelper::Sprintf("CS_FADESCREEN_LIST(%i)", numEntries);
+	return StringHelper::Sprintf("CS_TRANSITION_GENERAL_LIST(%i)", numEntries);
 }
 
-CutsceneSubCommandEntry_FadeSeq::CutsceneSubCommandEntry_FadeSeq(
+CutsceneSubCommandEntry_FadeOutSeq::CutsceneSubCommandEntry_FadeOutSeq(
 	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
 	: CutsceneSubCommandEntry(rawData, rawDataIndex)
 {
 	unk_08 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
 }
 
-std::string CutsceneSubCommandEntry_FadeSeq::GetBodySourceCode() const
+/**** FADE OUT SEQUENCE ****/
+
+std::string CutsceneSubCommandEntry_FadeOutSeq::GetBodySourceCode() const
 {
-	return StringHelper::Sprintf("CS_FADESEQ(%i, %i, %i)", base, startFrame, endFrame);
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (cutsceneData->fadeOutSeqPlayer.find(base) != cutsceneData->fadeOutSeqPlayer.end())
+		return StringHelper::Sprintf("CS_FADE_OUT_SEQ(%s, %i, %i)",
+		                             cutsceneData->fadeOutSeqPlayer[base].c_str(), startFrame,
+		                             endFrame);
+
+	return StringHelper::Sprintf("CS_FADE_OUT_SEQ(%i, %i, %i)", base, startFrame, endFrame);
 }
 
-size_t CutsceneSubCommandEntry_FadeSeq::GetRawSize() const
+size_t CutsceneSubCommandEntry_FadeOutSeq::GetRawSize() const
 {
 	return 0x0C;
 }
 
-CutsceneMMCommand_FadeSeq::CutsceneMMCommand_FadeSeq(const std::vector<uint8_t>& rawData,
-                                                     offset_t rawDataIndex)
+CutsceneMMCommand_FadeOutSeq::CutsceneMMCommand_FadeOutSeq(const std::vector<uint8_t>& rawData,
+                                                           offset_t rawDataIndex)
 	: CutsceneCommand(rawData, rawDataIndex)
 {
 	rawDataIndex += 4;
@@ -180,17 +244,19 @@ CutsceneMMCommand_FadeSeq::CutsceneMMCommand_FadeSeq(const std::vector<uint8_t>&
 	entries.reserve(numEntries);
 	for (size_t i = 0; i < numEntries; i++)
 	{
-		auto* entry = new CutsceneSubCommandEntry_FadeSeq(rawData, rawDataIndex);
+		auto* entry = new CutsceneSubCommandEntry_FadeOutSeq(rawData, rawDataIndex);
 		entries.push_back(entry);
 		rawDataIndex += entry->GetRawSize();
 	}
 }
 
-std::string CutsceneMMCommand_FadeSeq::GetCommandMacro() const
+std::string CutsceneMMCommand_FadeOutSeq::GetCommandMacro() const
 {
-	return StringHelper::Sprintf("CS_FADESEQ_LIST(%i)", numEntries);
+	return StringHelper::Sprintf("CS_FADE_OUT_SEQ_LIST(%i)", numEntries);
 }
 
+/**** NON IMPLEMENTED ****/
+
 CutsceneSubCommandEntry_NonImplemented::CutsceneSubCommandEntry_NonImplemented(
 	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
 	: CutsceneSubCommandEntry(rawData, rawDataIndex)
@@ -211,3 +277,207 @@ CutsceneMMCommand_NonImplemented::CutsceneMMCommand_NonImplemented(
 		rawDataIndex += entry->GetRawSize();
 	}
 }
+
+/**** RUMBLE ****/
+
+CutsceneMMSubCommandEntry_Rumble::CutsceneMMSubCommandEntry_Rumble(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	intensity = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x06);
+	decayTimer = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x07);
+	decayStep = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x08);
+}
+
+std::string CutsceneMMSubCommandEntry_Rumble::GetBodySourceCode() const
+{
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (cutsceneData->rumbleType.find(base) != cutsceneData->rumbleType.end())
+		return StringHelper::Sprintf("CS_RUMBLE(%s, %i, %i, 0x%02X, 0x%02X, 0x%02X)",
+		                             cutsceneData->rumbleType[base].c_str(), startFrame, endFrame,
+		                             intensity, decayTimer, decayStep);
+
+	return StringHelper::Sprintf("CS_RUMBLE(0x%04X, %i, %i, 0x%02X, 0x%02X, 0x%02X)", base,
+	                             startFrame, endFrame, intensity, decayTimer, decayStep);
+}
+
+size_t CutsceneMMSubCommandEntry_Rumble::GetRawSize() const
+{
+	return 0x0C;
+}
+
+CutsceneMMCommand_Rumble::CutsceneMMCommand_Rumble(const std::vector<uint8_t>& rawData,
+                                                   offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	entries.reserve(numEntries);
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneMMSubCommandEntry_Rumble(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneMMCommand_Rumble::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_RUMBLE_LIST(%i)", numEntries);
+}
+
+/**** TEXT ****/
+
+CutsceneMMSubCommandEntry_Text::CutsceneMMSubCommandEntry_Text(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	type = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x6);
+	textId1 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x8);
+	textId2 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0xA);
+}
+
+std::string CutsceneMMSubCommandEntry_Text::GetBodySourceCode() const
+{
+	if (type == 0xFFFF)
+	{
+		return StringHelper::Sprintf("CS_TEXT_NONE(%i, %i)", startFrame, endFrame);
+	}
+
+	if (type == 2)
+	{
+		// TODO: set the enum name when it will be documented
+		// (https://github.com/Decompollaborate/mm/blob/3e1c568c084671c17836ced904714ea49d989621/include/z64ocarina.h#L35-L118)
+		return StringHelper::Sprintf("CS_TEXT_OCARINA_ACTION(%i, %i, %i, 0x%X)", base, startFrame,
+		                             endFrame, textId1);
+	}
+
+	switch (type)
+	{
+	case 0:
+		return StringHelper::Sprintf("CS_TEXT_DEFAULT(0x%X, %i, %i, 0x%X, 0x%X)", base, startFrame,
+		                             endFrame, textId1, textId2);
+
+	case 1:
+		return StringHelper::Sprintf("CS_TEXT_TYPE_1(0x%X, %i, %i, 0x%X, 0x%X)", base, startFrame,
+		                             endFrame, textId1, textId2);
+
+	case 3:
+		return StringHelper::Sprintf("CS_TEXT_TYPE_3(0x%X, %i, %i, 0x%X, 0x%X)", base, startFrame,
+		                             endFrame, textId1, textId2);
+
+	case 4:
+		return StringHelper::Sprintf("CS_TEXT_BOSSES_REMAINS(0x%X, %i, %i, 0x%X)", base, startFrame,
+		                             endFrame, textId1);
+
+	case 5:
+		return StringHelper::Sprintf("CS_TEXT_ALL_NORMAL_MASKS(0x%X, %i, %i, 0x%X)", base,
+		                             startFrame, endFrame, textId1);
+	}
+
+	return nullptr;
+}
+
+size_t CutsceneMMSubCommandEntry_Text::GetRawSize() const
+{
+	return 0x0C;
+}
+
+CutsceneMMCommand_Text::CutsceneMMCommand_Text(const std::vector<uint8_t>& rawData,
+                                               offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	entries.reserve(numEntries);
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneMMSubCommandEntry_Text(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneMMCommand_Text::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_TEXT_LIST(%i)", numEntries);
+}
+
+/**** ACTOR CUE ****/
+
+CutsceneMMSubCommandEntry_ActorCue::CutsceneMMSubCommandEntry_ActorCue(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	rotX = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x6);
+	rotY = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x8);
+	rotZ = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0xA);
+	startPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 0xC);
+	startPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x10);
+	startPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x14);
+	endPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x18);
+	endPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x1C);
+	endPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x20);
+	normalX = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x24);
+	normalY = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x28);
+	normalZ = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x2C);
+}
+
+std::string CutsceneMMSubCommandEntry_ActorCue::GetBodySourceCode() const
+{
+	std::string result;
+
+	if (static_cast<CutsceneMM_CommandType>(commandID) == CutsceneMM_CommandType::CS_CMD_PLAYER_CUE)
+	{
+		result = "CS_PLAYER_CUE";
+	}
+	else
+	{
+		result = "CS_ACTOR_CUE";
+	}
+
+	result +=
+		StringHelper::Sprintf("(%i, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, "
+	                          "%i, %i, %i, %i, %.8ef, %.8ef, %.8ef)",
+	                          base, startFrame, endFrame, rotX, rotY, rotZ, startPosX, startPosY,
+	                          startPosZ, endPosX, endPosY, endPosZ, normalX, normalY, normalZ);
+	return result;
+}
+
+size_t CutsceneMMSubCommandEntry_ActorCue::GetRawSize() const
+{
+	return 0x30;
+}
+
+CutsceneMMCommand_ActorCue::CutsceneMMCommand_ActorCue(const std::vector<uint8_t>& rawData,
+                                                       offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	entries.reserve(numEntries);
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneMMSubCommandEntry_ActorCue(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneMMCommand_ActorCue::GetCommandMacro() const
+{
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (static_cast<CutsceneMM_CommandType>(commandID) == CutsceneMM_CommandType::CS_CMD_PLAYER_CUE)
+	{
+		return StringHelper::Sprintf("CS_PLAYER_CUE_LIST(%i)", numEntries);
+	}
+
+	if (cutsceneData->cutsceneCmd.find(commandID) != cutsceneData->cutsceneCmd.end())
+	{
+		return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(%s, %i)",
+		                             cutsceneData->cutsceneCmd[commandID].c_str(), numEntries);
+	}
+	return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(0x%03X, %i)", commandID, numEntries);
+}
diff --git a/ZAPD/OtherStructs/CutsceneMM_Commands.h b/ZAPD/OtherStructs/CutsceneMM_Commands.h
index c8ae4eb..fb2f772 100644
--- a/ZAPD/OtherStructs/CutsceneMM_Commands.h
+++ b/ZAPD/OtherStructs/CutsceneMM_Commands.h
@@ -1,51 +1,256 @@
 #pragma once
 
-#include "Cutscene_Commands.h"
-
-enum class CutsceneMMCommands
-{
-	/* 0x00A */ CS_CMD_TEXTBOX = 0xA,
-	/* 0x05A */ CS_CMD_CAMERA = 0x5A,
-	/* 0x096 */ CS_CMD_MISC = 0x96,
-	/* 0x097 */ CS_CMD_SET_LIGHTING,
-	/* 0x098 */ CS_CMD_SCENE_TRANS_FX,
-	/* 0x099 */ CS_CMD_MOTIONBLUR,
-	/* 0x09A */ CS_CMD_GIVETATL,
-	/* 0x09B */ CS_CMD_FADESCREEN,
-	/* 0x09C */ CS_CMD_FADESEQ,
-	/* 0x09D */ CS_CMD_SETTIME,
-	/* 0x0C8 */ CS_CMD_SET_PLAYER_ACTION = 0xC8,
-	/* 0x0FA */ CS_CMD_UNK_FA = 0xFA,
-	/* 0x0FE */ CS_CMD_UNK_FE = 0xFE,
-	/* 0x0FF */ CS_CMD_UNK_FF,
-	/* 0x100 */ CS_CMD_UNK_100,
-	/* 0x101 */ CS_CMD_UNK_101,
-	/* 0x102 */ CS_CMD_UNK_102,
-	/* 0x103 */ CS_CMD_UNK_103,
-	/* 0x104 */ CS_CMD_UNK_104,
-	/* 0x105 */ CS_CMD_UNK_105,
-	/* 0x108 */ CS_CMD_UNK_108 = 0x108,
-	/* 0x109 */ CS_CMD_UNK_109,
-	/* 0x12C */ CS_CMD_PLAYSEQ = 0x12C,
-	/* 0x12D */ CS_CMD_UNK_12D,
-	/* 0x130 */ CS_CMD_130 = 0x130,
-	/* 0x131 */ CS_CMD_131 = 0x131,
-	/* 0x132 */ CS_CMD_132 = 0x132,
-	/* 0x133 */ CS_CMD_STOPSEQ,
-	/* 0x134 */ CS_CMD_PLAYAMBIENCE,
-	/* 0x135 */ CS_CMD_FADEAMBIENCE,
-	/* 0x15E */ CS_CMD_TERMINATOR = 0x15E,
+#include "Cutscene_Common.h"
+
+// https://github.com/zeldaret/mm/blob/0c7b90cf97f26483c8b6a98ae099a295f61e72ab/include/z64cutscene.h#L294-530
+enum class CutsceneMM_CommandType
+{
+	/*    -2 */ CS_CMD_ACTOR_CUE_POST_PROCESS = -2,
+	/*    -1 */ CS_CAM_STOP,
+	/* 0x00A */ CS_CMD_TEXT = 10,
+	/* 0x05A */ CS_CMD_CAMERA_SPLINE = 90,
+	/* 0x064 */ CS_CMD_ACTOR_CUE_100 = 100,
+	/* 0x065 */ CS_CMD_ACTOR_CUE_101,
+	/* 0x066 */ CS_CMD_ACTOR_CUE_102,
+	/* 0x067 */ CS_CMD_ACTOR_CUE_103,
+	/* 0x068 */ CS_CMD_ACTOR_CUE_104,
+	/* 0x069 */ CS_CMD_ACTOR_CUE_105,
+	/* 0x06A */ CS_CMD_ACTOR_CUE_106,
+	/* 0x06B */ CS_CMD_ACTOR_CUE_107,
+	/* 0x06C */ CS_CMD_ACTOR_CUE_108,
+	/* 0x06D */ CS_CMD_ACTOR_CUE_109,
+	/* 0x06E */ CS_CMD_ACTOR_CUE_110,
+	/* 0x06F */ CS_CMD_ACTOR_CUE_111,
+	/* 0x070 */ CS_CMD_ACTOR_CUE_112,
+	/* 0x071 */ CS_CMD_ACTOR_CUE_113,
+	/* 0x072 */ CS_CMD_ACTOR_CUE_114,
+	/* 0x073 */ CS_CMD_ACTOR_CUE_115,
+	/* 0x074 */ CS_CMD_ACTOR_CUE_116,
+	/* 0x075 */ CS_CMD_ACTOR_CUE_117,
+	/* 0x076 */ CS_CMD_ACTOR_CUE_118,
+	/* 0x077 */ CS_CMD_ACTOR_CUE_119,
+	/* 0x078 */ CS_CMD_ACTOR_CUE_120,
+	/* 0x079 */ CS_CMD_ACTOR_CUE_121,
+	/* 0x07A */ CS_CMD_ACTOR_CUE_122,
+	/* 0x07B */ CS_CMD_ACTOR_CUE_123,
+	/* 0x07C */ CS_CMD_ACTOR_CUE_124,
+	/* 0x07D */ CS_CMD_ACTOR_CUE_125,
+	/* 0x07E */ CS_CMD_ACTOR_CUE_126,
+	/* 0x07F */ CS_CMD_ACTOR_CUE_127,
+	/* 0x080 */ CS_CMD_ACTOR_CUE_128,
+	/* 0x081 */ CS_CMD_ACTOR_CUE_129,
+	/* 0x082 */ CS_CMD_ACTOR_CUE_130,
+	/* 0x083 */ CS_CMD_ACTOR_CUE_131,
+	/* 0x084 */ CS_CMD_ACTOR_CUE_132,
+	/* 0x085 */ CS_CMD_ACTOR_CUE_133,
+	/* 0x086 */ CS_CMD_ACTOR_CUE_134,
+	/* 0x087 */ CS_CMD_ACTOR_CUE_135,
+	/* 0x088 */ CS_CMD_ACTOR_CUE_136,
+	/* 0x089 */ CS_CMD_ACTOR_CUE_137,
+	/* 0x08A */ CS_CMD_ACTOR_CUE_138,
+	/* 0x08B */ CS_CMD_ACTOR_CUE_139,
+	/* 0x08C */ CS_CMD_ACTOR_CUE_140,
+	/* 0x08D */ CS_CMD_ACTOR_CUE_141,
+	/* 0x08E */ CS_CMD_ACTOR_CUE_142,
+	/* 0x08F */ CS_CMD_ACTOR_CUE_143,
+	/* 0x090 */ CS_CMD_ACTOR_CUE_144,
+	/* 0x091 */ CS_CMD_ACTOR_CUE_145,
+	/* 0x092 */ CS_CMD_ACTOR_CUE_146,
+	/* 0x093 */ CS_CMD_ACTOR_CUE_147,
+	/* 0x094 */ CS_CMD_ACTOR_CUE_148,
+	/* 0x095 */ CS_CMD_ACTOR_CUE_149,
+	/* 0x096 */ CS_CMD_MISC,
+	/* 0x097 */ CS_CMD_LIGHT_SETTING,
+	/* 0x098 */ CS_CMD_TRANSITION,
+	/* 0x099 */ CS_CMD_MOTION_BLUR,
+	/* 0x09A */ CS_CMD_GIVE_TATL,
+	/* 0x09B */ CS_CMD_TRANSITION_GENERAL,
+	/* 0x09C */ CS_CMD_FADE_OUT_SEQ,
+	/* 0x09D */ CS_CMD_TIME,
+	/* 0x0C8 */ CS_CMD_PLAYER_CUE = 200,
+	/* 0x0C9 */ CS_CMD_ACTOR_CUE_201,
+	/* 0x0FA */ CS_CMD_UNK_DATA_FA = 0xFA,
+	/* 0x0FE */ CS_CMD_UNK_DATA_FE = 0xFE,
+	/* 0x0FF */ CS_CMD_UNK_DATA_FF,
+	/* 0x100 */ CS_CMD_UNK_DATA_100,
+	/* 0x101 */ CS_CMD_UNK_DATA_101,
+	/* 0x102 */ CS_CMD_UNK_DATA_102,
+	/* 0x103 */ CS_CMD_UNK_DATA_103,
+	/* 0x104 */ CS_CMD_UNK_DATA_104,
+	/* 0x105 */ CS_CMD_UNK_DATA_105,
+	/* 0x108 */ CS_CMD_UNK_DATA_108 = 0x108,
+	/* 0x109 */ CS_CMD_UNK_DATA_109,
+	/* 0x12C */ CS_CMD_START_SEQ = 300,
+	/* 0x12D */ CS_CMD_STOP_SEQ,
+	/* 0x12E */ CS_CMD_START_AMBIENCE,
+	/* 0x12F */ CS_CMD_FADE_OUT_AMBIENCE,
+	/* 0x130 */ CS_CMD_SFX_REVERB_INDEX_2,
+	/* 0x131 */ CS_CMD_SFX_REVERB_INDEX_1,
+	/* 0x132 */ CS_CMD_MODIFY_SEQ,
+	/* 0x15E */ CS_CMD_DESTINATION = 350,
 	/* 0x15F */ CS_CMD_CHOOSE_CREDITS_SCENES,
-	/* 0x190 */ CS_CMD_RUMBLE = 0x190,
+	/* 0x190 */ CS_CMD_RUMBLE = 400,
+	/* 0x1C2 */ CS_CMD_ACTOR_CUE_450 = 450,
+	/* 0x1C3 */ CS_CMD_ACTOR_CUE_451,
+	/* 0x1C4 */ CS_CMD_ACTOR_CUE_452,
+	/* 0x1C5 */ CS_CMD_ACTOR_CUE_453,
+	/* 0x1C6 */ CS_CMD_ACTOR_CUE_454,
+	/* 0x1C7 */ CS_CMD_ACTOR_CUE_455,
+	/* 0x1C8 */ CS_CMD_ACTOR_CUE_456,
+	/* 0x1C9 */ CS_CMD_ACTOR_CUE_457,
+	/* 0x1CA */ CS_CMD_ACTOR_CUE_458,
+	/* 0x1CB */ CS_CMD_ACTOR_CUE_459,
+	/* 0x1CC */ CS_CMD_ACTOR_CUE_460,
+	/* 0x1CD */ CS_CMD_ACTOR_CUE_461,
+	/* 0x1CE */ CS_CMD_ACTOR_CUE_462,
+	/* 0x1CF */ CS_CMD_ACTOR_CUE_463,
+	/* 0x1D0 */ CS_CMD_ACTOR_CUE_464,
+	/* 0x1D1 */ CS_CMD_ACTOR_CUE_465,
+	/* 0x1D2 */ CS_CMD_ACTOR_CUE_466,
+	/* 0x1D3 */ CS_CMD_ACTOR_CUE_467,
+	/* 0x1D4 */ CS_CMD_ACTOR_CUE_468,
+	/* 0x1D5 */ CS_CMD_ACTOR_CUE_469,
+	/* 0x1D6 */ CS_CMD_ACTOR_CUE_470,
+	/* 0x1D7 */ CS_CMD_ACTOR_CUE_471,
+	/* 0x1D8 */ CS_CMD_ACTOR_CUE_472,
+	/* 0x1D9 */ CS_CMD_ACTOR_CUE_473,
+	/* 0x1DA */ CS_CMD_ACTOR_CUE_474,
+	/* 0x1DB */ CS_CMD_ACTOR_CUE_475,
+	/* 0x1DC */ CS_CMD_ACTOR_CUE_476,
+	/* 0x1DD */ CS_CMD_ACTOR_CUE_477,
+	/* 0x1DE */ CS_CMD_ACTOR_CUE_478,
+	/* 0x1DF */ CS_CMD_ACTOR_CUE_479,
+	/* 0x1E0 */ CS_CMD_ACTOR_CUE_480,
+	/* 0x1E1 */ CS_CMD_ACTOR_CUE_481,
+	/* 0x1E2 */ CS_CMD_ACTOR_CUE_482,
+	/* 0x1E3 */ CS_CMD_ACTOR_CUE_483,
+	/* 0x1E4 */ CS_CMD_ACTOR_CUE_484,
+	/* 0x1E5 */ CS_CMD_ACTOR_CUE_485,
+	/* 0x1E6 */ CS_CMD_ACTOR_CUE_486,
+	/* 0x1E7 */ CS_CMD_ACTOR_CUE_487,
+	/* 0x1E8 */ CS_CMD_ACTOR_CUE_488,
+	/* 0x1E9 */ CS_CMD_ACTOR_CUE_489,
+	/* 0x1EA */ CS_CMD_ACTOR_CUE_490,
+	/* 0x1EB */ CS_CMD_ACTOR_CUE_491,
+	/* 0x1EC */ CS_CMD_ACTOR_CUE_492,
+	/* 0x1ED */ CS_CMD_ACTOR_CUE_493,
+	/* 0x1EE */ CS_CMD_ACTOR_CUE_494,
+	/* 0x1EF */ CS_CMD_ACTOR_CUE_495,
+	/* 0x1F0 */ CS_CMD_ACTOR_CUE_496,
+	/* 0x1F1 */ CS_CMD_ACTOR_CUE_497,
+	/* 0x1F2 */ CS_CMD_ACTOR_CUE_498,
+	/* 0x1F3 */ CS_CMD_ACTOR_CUE_499,
+	/* 0x1F4 */ CS_CMD_ACTOR_CUE_500,
+	/* 0x1F5 */ CS_CMD_ACTOR_CUE_501,
+	/* 0x1F6 */ CS_CMD_ACTOR_CUE_502,
+	/* 0x1F7 */ CS_CMD_ACTOR_CUE_503,
+	/* 0x1F8 */ CS_CMD_ACTOR_CUE_504,
+	/* 0x1F9 */ CS_CMD_ACTOR_CUE_SOTCS,
+	/* 0x1FA */ CS_CMD_ACTOR_CUE_506,
+	/* 0x1FB */ CS_CMD_ACTOR_CUE_507,
+	/* 0x1FC */ CS_CMD_ACTOR_CUE_508,
+	/* 0x1FD */ CS_CMD_ACTOR_CUE_509,
+	/* 0x1FE */ CS_CMD_ACTOR_CUE_510,
+	/* 0x1FF */ CS_CMD_ACTOR_CUE_511,
+	/* 0x200 */ CS_CMD_ACTOR_CUE_512,
+	/* 0x201 */ CS_CMD_ACTOR_CUE_513,
+	/* 0x202 */ CS_CMD_ACTOR_CUE_514,
+	/* 0x203 */ CS_CMD_ACTOR_CUE_515,
+	/* 0x204 */ CS_CMD_ACTOR_CUE_516,
+	/* 0x205 */ CS_CMD_ACTOR_CUE_517,
+	/* 0x206 */ CS_CMD_ACTOR_CUE_518,
+	/* 0x207 */ CS_CMD_ACTOR_CUE_519,
+	/* 0x208 */ CS_CMD_ACTOR_CUE_520,
+	/* 0x209 */ CS_CMD_ACTOR_CUE_521,
+	/* 0x20A */ CS_CMD_ACTOR_CUE_522,
+	/* 0x20B */ CS_CMD_ACTOR_CUE_523,
+	/* 0x20C */ CS_CMD_ACTOR_CUE_524,
+	/* 0x20D */ CS_CMD_ACTOR_CUE_525,
+	/* 0x20E */ CS_CMD_ACTOR_CUE_526,
+	/* 0x20F */ CS_CMD_ACTOR_CUE_527,
+	/* 0x210 */ CS_CMD_ACTOR_CUE_528,
+	/* 0x211 */ CS_CMD_ACTOR_CUE_529,
+	/* 0x212 */ CS_CMD_ACTOR_CUE_530,
+	/* 0x213 */ CS_CMD_ACTOR_CUE_531,
+	/* 0x214 */ CS_CMD_ACTOR_CUE_532,
+	/* 0x215 */ CS_CMD_ACTOR_CUE_533,
+	/* 0x216 */ CS_CMD_ACTOR_CUE_534,
+	/* 0x217 */ CS_CMD_ACTOR_CUE_535,
+	/* 0x218 */ CS_CMD_ACTOR_CUE_536,
+	/* 0x219 */ CS_CMD_ACTOR_CUE_537,
+	/* 0x21A */ CS_CMD_ACTOR_CUE_538,
+	/* 0x21B */ CS_CMD_ACTOR_CUE_539,
+	/* 0x21C */ CS_CMD_ACTOR_CUE_540,
+	/* 0x21D */ CS_CMD_ACTOR_CUE_541,
+	/* 0x21E */ CS_CMD_ACTOR_CUE_542,
+	/* 0x21F */ CS_CMD_ACTOR_CUE_543,
+	/* 0x220 */ CS_CMD_ACTOR_CUE_544,
+	/* 0x221 */ CS_CMD_ACTOR_CUE_545,
+	/* 0x222 */ CS_CMD_ACTOR_CUE_546,
+	/* 0x223 */ CS_CMD_ACTOR_CUE_547,
+	/* 0x224 */ CS_CMD_ACTOR_CUE_548,
+	/* 0x225 */ CS_CMD_ACTOR_CUE_549,
+	/* 0x226 */ CS_CMD_ACTOR_CUE_550,
+	/* 0x227 */ CS_CMD_ACTOR_CUE_551,
+	/* 0x228 */ CS_CMD_ACTOR_CUE_552,
+	/* 0x229 */ CS_CMD_ACTOR_CUE_553,
+	/* 0x22A */ CS_CMD_ACTOR_CUE_554,
+	/* 0x22B */ CS_CMD_ACTOR_CUE_555,
+	/* 0x22C */ CS_CMD_ACTOR_CUE_556,
+	/* 0x22D */ CS_CMD_ACTOR_CUE_557,
+	/* 0x22E */ CS_CMD_ACTOR_CUE_558,
+	/* 0x22F */ CS_CMD_ACTOR_CUE_559,
+	/* 0x230 */ CS_CMD_ACTOR_CUE_560,
+	/* 0x231 */ CS_CMD_ACTOR_CUE_561,
+	/* 0x232 */ CS_CMD_ACTOR_CUE_562,
+	/* 0x233 */ CS_CMD_ACTOR_CUE_563,
+	/* 0x234 */ CS_CMD_ACTOR_CUE_564,
+	/* 0x235 */ CS_CMD_ACTOR_CUE_565,
+	/* 0x236 */ CS_CMD_ACTOR_CUE_566,
+	/* 0x237 */ CS_CMD_ACTOR_CUE_567,
+	/* 0x238 */ CS_CMD_ACTOR_CUE_568,
+	/* 0x239 */ CS_CMD_ACTOR_CUE_569,
+	/* 0x23A */ CS_CMD_ACTOR_CUE_570,
+	/* 0x23B */ CS_CMD_ACTOR_CUE_571,
+	/* 0x23C */ CS_CMD_ACTOR_CUE_572,
+	/* 0x23D */ CS_CMD_ACTOR_CUE_573,
+	/* 0x23E */ CS_CMD_ACTOR_CUE_574,
+	/* 0x23F */ CS_CMD_ACTOR_CUE_575,
+	/* 0x240 */ CS_CMD_ACTOR_CUE_576,
+	/* 0x241 */ CS_CMD_ACTOR_CUE_577,
+	/* 0x242 */ CS_CMD_ACTOR_CUE_578,
+	/* 0x243 */ CS_CMD_ACTOR_CUE_579,
+	/* 0x244 */ CS_CMD_ACTOR_CUE_580,
+	/* 0x245 */ CS_CMD_ACTOR_CUE_581,
+	/* 0x246 */ CS_CMD_ACTOR_CUE_582,
+	/* 0x247 */ CS_CMD_ACTOR_CUE_583,
+	/* 0x248 */ CS_CMD_ACTOR_CUE_584,
+	/* 0x249 */ CS_CMD_ACTOR_CUE_585,
+	/* 0x24A */ CS_CMD_ACTOR_CUE_586,
+	/* 0x24B */ CS_CMD_ACTOR_CUE_587,
+	/* 0x24C */ CS_CMD_ACTOR_CUE_588,
+	/* 0x24D */ CS_CMD_ACTOR_CUE_589,
+	/* 0x24E */ CS_CMD_ACTOR_CUE_590,
+	/* 0x24F */ CS_CMD_ACTOR_CUE_591,
+	/* 0x250 */ CS_CMD_ACTOR_CUE_592,
+	/* 0x251 */ CS_CMD_ACTOR_CUE_593,
+	/* 0x252 */ CS_CMD_ACTOR_CUE_594,
+	/* 0x253 */ CS_CMD_ACTOR_CUE_595,
+	/* 0x254 */ CS_CMD_ACTOR_CUE_596,
+	/* 0x255 */ CS_CMD_ACTOR_CUE_597,
+	/* 0x256 */ CS_CMD_ACTOR_CUE_598,
+	/* 0x257 */ CS_CMD_ACTOR_CUE_599
 };
 
-class CutsceneSubCommandEntry_GenericMMCmd : public CutsceneSubCommandEntry
+/**** GENERIC ****/
+
+class CutsceneMMSubCommandEntry_GenericCmd : public CutsceneSubCommandEntry
 {
 public:
-	CutsceneMMCommands commandId;
+	CutsceneMM_CommandType commandId;
 
-	CutsceneSubCommandEntry_GenericMMCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
-	                                     CutsceneMMCommands cmdId);
+	CutsceneMMSubCommandEntry_GenericCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
+	                                     CutsceneMM_CommandType cmdId);
 
 	std::string GetBodySourceCode() const override;
 };
@@ -54,11 +259,13 @@ class CutsceneMMCommand_GenericCmd : public CutsceneCommand
 {
 public:
 	CutsceneMMCommand_GenericCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
-	                             CutsceneMMCommands cmdId);
+	                             CutsceneMM_CommandType cmdId);
 
 	std::string GetCommandMacro() const override;
 };
 
+/**** CAMERA ****/
+
 // TODO: MM cutscene camera command is implemented as a placeholder until we better understand how
 // it works
 class CutsceneSubCommandEntry_Camera : public CutsceneSubCommandEntry
@@ -81,7 +288,9 @@ public:
 	std::string GetCommandMacro() const override;
 };
 
-class CutsceneSubCommandEntry_FadeScreen : public CutsceneSubCommandEntry
+/**** TRANSITION GENERAL ****/
+
+class CutsceneSubCommandEntry_TransitionGeneral : public CutsceneSubCommandEntry
 {
 public:
 	uint8_t unk_06;
@@ -91,41 +300,46 @@ public:
 	uint8_t unk_0A;
 	uint8_t unk_0B;
 
-	CutsceneSubCommandEntry_FadeScreen(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	CutsceneSubCommandEntry_TransitionGeneral(const std::vector<uint8_t>& rawData,
+	                                          offset_t rawDataIndex);
 
 	std::string GetBodySourceCode() const override;
 
 	size_t GetRawSize() const override;
 };
 
-class CutsceneMMCommand_FadeScreen : public CutsceneCommand
+class CutsceneMMCommand_TransitionGeneral : public CutsceneCommand
 {
 public:
-	CutsceneMMCommand_FadeScreen(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	CutsceneMMCommand_TransitionGeneral(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
 
 	std::string GetCommandMacro() const override;
 };
 
-class CutsceneSubCommandEntry_FadeSeq : public CutsceneSubCommandEntry
+/**** FADE OUT SEQUENCE ****/
+
+class CutsceneSubCommandEntry_FadeOutSeq : public CutsceneSubCommandEntry
 {
 public:
 	uint32_t unk_08;
 
-	CutsceneSubCommandEntry_FadeSeq(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	CutsceneSubCommandEntry_FadeOutSeq(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
 
 	std::string GetBodySourceCode() const override;
 
 	size_t GetRawSize() const override;
 };
 
-class CutsceneMMCommand_FadeSeq : public CutsceneCommand
+class CutsceneMMCommand_FadeOutSeq : public CutsceneCommand
 {
 public:
-	CutsceneMMCommand_FadeSeq(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	CutsceneMMCommand_FadeOutSeq(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
 
 	std::string GetCommandMacro() const override;
 };
 
+/**** NON IMPLEMENTED ****/
+
 class CutsceneSubCommandEntry_NonImplemented : public CutsceneSubCommandEntry
 {
 public:
@@ -138,3 +352,75 @@ class CutsceneMMCommand_NonImplemented : public CutsceneCommand
 public:
 	CutsceneMMCommand_NonImplemented(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
 };
+
+/**** RUMBLE ****/
+
+class CutsceneMMSubCommandEntry_Rumble : public CutsceneSubCommandEntry
+{
+public:
+	uint8_t intensity;
+	uint8_t decayTimer;
+	uint8_t decayStep;
+
+	CutsceneMMSubCommandEntry_Rumble(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneMMCommand_Rumble : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_Rumble(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+/**** TEXT ****/
+
+class CutsceneMMSubCommandEntry_Text : public CutsceneSubCommandEntry
+{
+public:
+	uint16_t type;
+	uint16_t textId1;
+	uint16_t textId2;
+
+	CutsceneMMSubCommandEntry_Text(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneMMCommand_Text : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_Text(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+/**** ACTOR CUE ****/
+
+class CutsceneMMSubCommandEntry_ActorCue : public CutsceneSubCommandEntry
+{
+public:
+	uint16_t rotX, rotY, rotZ;
+	int32_t startPosX, startPosY, startPosZ;
+	int32_t endPosX, endPosY, endPosZ;
+	float normalX, normalY, normalZ;
+
+	CutsceneMMSubCommandEntry_ActorCue(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneMMCommand_ActorCue : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_ActorCue(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
diff --git a/ZAPD/OtherStructs/CutsceneOoT_Commands.cpp b/ZAPD/OtherStructs/CutsceneOoT_Commands.cpp
new file mode 100644
index 0000000..367be0e
--- /dev/null
+++ b/ZAPD/OtherStructs/CutsceneOoT_Commands.cpp
@@ -0,0 +1,458 @@
+#include "CutsceneOoT_Commands.h"
+
+#include <cassert>
+#include <unordered_map>
+#include "Globals.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+
+/**** GENERIC ****/
+
+// Specific for command lists where each entry has size 0x30 bytes
+const std::unordered_map<CutsceneOoT_CommandType, CsCommandListDescriptor> csCommandsDesc = {
+	{CutsceneOoT_CommandType::CS_CMD_MISC,
+     {"CS_MISC", "(%s, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
+	{CutsceneOoT_CommandType::CS_CMD_LIGHT_SETTING,
+     {"CS_LIGHT_SETTING", "(0x%02X, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
+	{CutsceneOoT_CommandType::CS_CMD_START_SEQ,
+     {"CS_START_SEQ", "(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
+	{CutsceneOoT_CommandType::CS_CMD_STOP_SEQ,
+     {"CS_STOP_SEQ", "(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
+	{CutsceneOoT_CommandType::CS_CMD_FADE_OUT_SEQ,
+     {"CS_FADE_OUT_SEQ", "(%s, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
+};
+
+CutsceneOoTSubCommandEntry_GenericCmd::CutsceneOoTSubCommandEntry_GenericCmd(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex, CutsceneOoT_CommandType cmdId)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex), commandId(cmdId)
+{
+	word0 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x0);
+	word1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x4);
+
+	unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x8);
+	unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0xC);
+	unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x10);
+	unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x14);
+	unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x18);
+	unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x1C);
+	unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x20);
+	unused8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x24);
+	unused9 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x28);
+	unused10 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x2C);
+}
+
+std::string CutsceneOoTSubCommandEntry_GenericCmd::GetBodySourceCode() const
+{
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+	const auto& element = csCommandsDesc.find(commandId);
+
+	if (element != csCommandsDesc.end())
+	{
+		bool isIndexInMisc = cutsceneData->miscType.find(base) != cutsceneData->miscType.end();
+		bool isIndexInFade =
+			cutsceneData->fadeOutSeqPlayer.find(base) != cutsceneData->fadeOutSeqPlayer.end();
+		std::string entryFmt = element->second.cmdMacro;
+		std::string firstArg;
+		entryFmt += element->second.args;
+
+		if (commandId == CutsceneOoT_CommandType::CS_CMD_MISC && isIndexInMisc)
+			firstArg = cutsceneData->miscType[base];
+		else if (commandId == CutsceneOoT_CommandType::CS_CMD_FADE_OUT_SEQ && isIndexInFade)
+			firstArg = cutsceneData->fadeOutSeqPlayer[base];
+		else
+		{
+			bool baseOne = (commandId == CutsceneOoT_CommandType::CS_CMD_LIGHT_SETTING ||
+			                commandId == CutsceneOoT_CommandType::CS_CMD_START_SEQ ||
+			                commandId == CutsceneOoT_CommandType::CS_CMD_STOP_SEQ);
+			return StringHelper::Sprintf(entryFmt.c_str(), baseOne ? base - 1 : base, startFrame,
+			                             endFrame, pad, unused1, unused2, unused3, unused4, unused5,
+			                             unused6, unused7, unused8, unused9, unused10);
+		}
+		return StringHelper::Sprintf(entryFmt.c_str(), firstArg.c_str(), startFrame, endFrame, pad,
+		                             unused1, unused2, unused3, unused4, unused5, unused6, unused7,
+		                             unused8, unused9, unused10);
+	}
+	return StringHelper::Sprintf("CS_UNK_DATA(0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, "
+	                             "0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X)",
+	                             word0, word1, unused1, unused2, unused3, unused4, unused5, unused6,
+	                             unused7, unused8, unused9, unused10);
+}
+
+size_t CutsceneOoTSubCommandEntry_GenericCmd::GetRawSize() const
+{
+	return 0x30;
+}
+
+CutsceneOoTCommand_GenericCmd::CutsceneOoTCommand_GenericCmd(const std::vector<uint8_t>& rawData,
+                                                             offset_t rawDataIndex,
+                                                             CutsceneOoT_CommandType cmdId)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	commandID = static_cast<uint32_t>(cmdId);
+	entries.reserve(numEntries);
+
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneOoTSubCommandEntry_GenericCmd(rawData, rawDataIndex, cmdId);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneOoTCommand_GenericCmd::GetCommandMacro() const
+{
+	const auto& element = csCommandsDesc.find(static_cast<CutsceneOoT_CommandType>(commandID));
+
+	if (element != csCommandsDesc.end())
+	{
+		return StringHelper::Sprintf("%s_LIST(%i)", element->second.cmdMacro, numEntries);
+	}
+
+	return StringHelper::Sprintf("CS_UNK_DATA_LIST(0x%X, %i)", commandID, numEntries);
+}
+
+/**** CAMERA ****/
+
+CutsceneOoTCommand_CameraPoint::CutsceneOoTCommand_CameraPoint(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	continueFlag = BitConverter::ToInt8BE(rawData, rawDataIndex + 0);
+	cameraRoll = BitConverter::ToInt8BE(rawData, rawDataIndex + 1);
+	nextPointFrame = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
+	viewAngle = BitConverter::ToFloatBE(rawData, rawDataIndex + 4);
+
+	posX = BitConverter::ToInt16BE(rawData, rawDataIndex + 8);
+	posY = BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
+	posZ = BitConverter::ToInt16BE(rawData, rawDataIndex + 12);
+
+	unused = BitConverter::ToInt16BE(rawData, rawDataIndex + 14);
+}
+
+std::string CutsceneOoTCommand_CameraPoint::GetBodySourceCode() const
+{
+	std::string continueMacro = "CS_CAM_CONTINUE";
+	if (continueFlag != 0)
+		continueMacro = "CS_CAM_STOP";
+
+	return StringHelper::Sprintf("CS_CAM_POINT(%s, 0x%02X, %i, %ff, %i, %i, %i, 0x%04X)",
+	                             continueMacro.c_str(), cameraRoll, nextPointFrame, viewAngle, posX,
+	                             posY, posZ, unused);
+}
+
+size_t CutsceneOoTCommand_CameraPoint::GetRawSize() const
+{
+	return 0x10;
+}
+
+CutsceneOoTCommand_GenericCameraCmd::CutsceneOoTCommand_GenericCameraCmd(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
+	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
+	unused = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
+
+	bool shouldContinue = true;
+
+	uint32_t currentPtr = rawDataIndex + 8;
+
+	while (shouldContinue)
+	{
+		CutsceneOoTCommand_CameraPoint* camPoint =
+			new CutsceneOoTCommand_CameraPoint(rawData, currentPtr);
+		entries.push_back(camPoint);
+
+		if (camPoint->continueFlag == -1)
+			shouldContinue = false;
+
+		currentPtr += camPoint->GetRawSize();
+	}
+}
+
+std::string CutsceneOoTCommand_GenericCameraCmd::GetCommandMacro() const
+{
+	std::string result;
+	const char* listStr;
+
+	if (commandID == (uint32_t)CutsceneOoT_CommandType::CS_CMD_CAM_AT_SPLINE)
+	{
+		listStr = "CS_CAM_AT_SPLINE";
+	}
+	else if (commandID == (uint32_t)CutsceneOoT_CommandType::CS_CMD_CAM_AT_SPLINE_REL_TO_PLAYER)
+	{
+		listStr = "CS_CAM_AT_SPLINE_REL_TO_PLAYER";
+	}
+	else if (commandID == (uint32_t)CutsceneOoT_CommandType::CS_CMD_CAM_EYE_SPLINE_REL_TO_PLAYER)
+	{
+		listStr = "CS_CAM_EYE_SPLINE_REL_TO_PLAYER";
+	}
+	else
+	{
+		listStr = "CS_CAM_EYE_SPLINE";
+	}
+
+	result += StringHelper::Sprintf("%s(%i, %i)", listStr, startFrame, endFrame);
+
+	return result;
+}
+
+size_t CutsceneOoTCommand_GenericCameraCmd::GetCommandSize() const
+{
+	return 0x0C + entries.at(0)->GetRawSize() * entries.size();
+}
+
+/**** RUMBLE ****/
+
+CutsceneOoTSubCommandEntry_Rumble::CutsceneOoTSubCommandEntry_Rumble(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	sourceStrength = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x06);
+	duration = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x07);
+	decreaseRate = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x08);
+	unk_09 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x09);
+	unk_0A = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x0A);
+}
+
+std::string CutsceneOoTSubCommandEntry_Rumble::GetBodySourceCode() const
+{
+	// Note: the first argument is unused
+	return StringHelper::Sprintf("CS_RUMBLE_CONTROLLER(%i, %i, %i, %i, %i, %i, 0x%02X, 0x%02X)",
+	                             base, startFrame, endFrame, sourceStrength, duration, decreaseRate,
+	                             unk_09, unk_0A);
+}
+
+size_t CutsceneOoTSubCommandEntry_Rumble::GetRawSize() const
+{
+	return 0x0C;
+}
+
+CutsceneOoTCommand_Rumble::CutsceneOoTCommand_Rumble(const std::vector<uint8_t>& rawData,
+                                                     offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	entries.reserve(numEntries);
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneOoTSubCommandEntry_Rumble(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneOoTCommand_Rumble::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_RUMBLE_CONTROLLER_LIST(%i)", numEntries);
+}
+
+/**** TEXT ****/
+
+CutsceneOoTSubCommandEntry_Text::CutsceneOoTSubCommandEntry_Text(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	type = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x6);
+	textId1 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x8);
+	textId2 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0xA);
+}
+
+std::string CutsceneOoTSubCommandEntry_Text::GetBodySourceCode() const
+{
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (type == 0xFFFF)
+	{
+		return StringHelper::Sprintf("CS_TEXT_NONE(%i, %i)", startFrame, endFrame);
+	}
+	if (type == 2)
+	{
+		return StringHelper::Sprintf("CS_TEXT_OCARINA_ACTION(%i, %i, %i, 0x%X)", base, startFrame,
+		                             endFrame, textId1);
+	}
+
+	if (cutsceneData->textType.find(type) != cutsceneData->textType.end())
+	{
+		return StringHelper::Sprintf("CS_TEXT(0x%X, %i, %i, %s, 0x%X, 0x%X)", base, startFrame,
+		                             endFrame, cutsceneData->textType[type].c_str(), textId1,
+		                             textId2);
+	}
+
+	return StringHelper::Sprintf("CS_TEXT(0x%X, %i, %i, %i, 0x%X, 0x%X)", base, startFrame,
+	                             endFrame, type, textId1, textId2);
+}
+
+size_t CutsceneOoTSubCommandEntry_Text::GetRawSize() const
+{
+	return 0x0C;
+}
+
+CutsceneOoTCommand_Text::CutsceneOoTCommand_Text(const std::vector<uint8_t>& rawData,
+                                                 offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	entries.reserve(numEntries);
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneOoTSubCommandEntry_Text(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneOoTCommand_Text::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_TEXT_LIST(%i)", numEntries);
+}
+
+/**** ACTOR CUE ****/
+
+CutsceneOoTSubCommandEntry_ActorCue::CutsceneOoTSubCommandEntry_ActorCue(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	rotX = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x6);
+	rotY = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x8);
+	rotZ = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0xA);
+	startPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 0xC);
+	startPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x10);
+	startPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x14);
+	endPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x18);
+	endPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x1C);
+	endPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x20);
+	normalX = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x24);
+	normalY = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x28);
+	normalZ = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x2C);
+}
+
+std::string CutsceneOoTSubCommandEntry_ActorCue::GetBodySourceCode() const
+{
+	std::string result;
+
+	if (static_cast<CutsceneOoT_CommandType>(commandID) ==
+	    CutsceneOoT_CommandType::CS_CMD_PLAYER_CUE)
+	{
+		result = "CS_PLAYER_CUE";
+	}
+	else
+	{
+		result = "CS_ACTOR_CUE";
+	}
+
+	result +=
+		StringHelper::Sprintf("(%i, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, "
+	                          "%i, %i, %i, %i, %.8ef, %.8ef, %.8ef)",
+	                          base, startFrame, endFrame, rotX, rotY, rotZ, startPosX, startPosY,
+	                          startPosZ, endPosX, endPosY, endPosZ, normalX, normalY, normalZ);
+	return result;
+}
+
+size_t CutsceneOoTSubCommandEntry_ActorCue::GetRawSize() const
+{
+	return 0x30;
+}
+
+CutsceneOoTCommand_ActorCue::CutsceneOoTCommand_ActorCue(const std::vector<uint8_t>& rawData,
+                                                         offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	entries.reserve(numEntries);
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneOoTSubCommandEntry_ActorCue(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneOoTCommand_ActorCue::GetCommandMacro() const
+{
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (static_cast<CutsceneOoT_CommandType>(commandID) ==
+	    CutsceneOoT_CommandType::CS_CMD_PLAYER_CUE)
+	{
+		return StringHelper::Sprintf("CS_PLAYER_CUE_LIST(%i)", entries.size());
+	}
+
+	if (cutsceneData->cutsceneCmd.find(commandID) != cutsceneData->cutsceneCmd.end())
+	{
+		return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(%s, %i)",
+		                             cutsceneData->cutsceneCmd[commandID].c_str(), entries.size());
+	}
+
+	return StringHelper::Sprintf("CS_ACTOR_CUE_LIST(0x%04X, %i)", commandID, entries.size());
+}
+
+/**** DESTINATION ****/
+
+CutsceneOoTCommand_Destination::CutsceneOoTCommand_Destination(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
+	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
+	unknown = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);  // endFrame duplicate
+}
+
+std::string CutsceneOoTCommand_Destination::GenerateSourceCode() const
+{
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (cutsceneData->destination.find(base) != cutsceneData->destination.end())
+	{
+		return StringHelper::Sprintf("CS_DESTINATION(%s, %i, %i),\n",
+		                             cutsceneData->destination[base].c_str(), startFrame, endFrame);
+	}
+
+	return StringHelper::Sprintf("CS_DESTINATION(%i, %i, %i),\n", base, startFrame, endFrame);
+}
+
+size_t CutsceneOoTCommand_Destination::GetCommandSize() const
+{
+	return 0x10;
+}
+
+/**** TRANSITION ****/
+
+CutsceneOoTCommand_Transition::CutsceneOoTCommand_Transition(const std::vector<uint8_t>& rawData,
+                                                             offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
+	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
+}
+
+std::string CutsceneOoTCommand_Transition::GenerateSourceCode() const
+{
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (cutsceneData->transitionType.find(base) != cutsceneData->transitionType.end())
+	{
+		return StringHelper::Sprintf("CS_TRANSITION(%s, %i, %i),\n",
+		                             cutsceneData->transitionType[base].c_str(), startFrame,
+		                             endFrame);
+	}
+
+	return StringHelper::Sprintf("CS_TRANSITION(%i, %i, %i),\n", base, startFrame, endFrame);
+}
+
+size_t CutsceneOoTCommand_Transition::GetCommandSize() const
+{
+	return 0x10;
+}
diff --git a/ZAPD/OtherStructs/CutsceneOoT_Commands.h b/ZAPD/OtherStructs/CutsceneOoT_Commands.h
new file mode 100644
index 0000000..ff9b679
--- /dev/null
+++ b/ZAPD/OtherStructs/CutsceneOoT_Commands.h
@@ -0,0 +1,314 @@
+#pragma once
+
+#include "Cutscene_Common.h"
+
+// https://github.com/zeldaret/oot/blob/7235af2249843fb68740111b70089bad827a4730/include/z64cutscene.h#L35-L165
+enum class CutsceneOoT_CommandType
+{
+	CS_CMD_CAM_EYE_SPLINE = 0x01,
+	CS_CMD_CAM_AT_SPLINE,
+	CS_CMD_MISC,
+	CS_CMD_LIGHT_SETTING,
+	CS_CMD_CAM_EYE_SPLINE_REL_TO_PLAYER,
+	CS_CMD_CAM_AT_SPLINE_REL_TO_PLAYER,
+	CS_CMD_CAM_EYE,
+	CS_CMD_CAM_AT,
+	CS_CMD_RUMBLE_CONTROLLER,
+	CS_CMD_PLAYER_CUE,
+	CS_CMD_UNIMPLEMENTED_B,
+	CS_CMD_UNIMPLEMENTED_D = 0x0D,
+	CS_CMD_ACTOR_CUE_1_0,
+	CS_CMD_ACTOR_CUE_0_0,
+	CS_CMD_ACTOR_CUE_1_1,
+	CS_CMD_ACTOR_CUE_0_1,
+	CS_CMD_ACTOR_CUE_0_2,
+	CS_CMD_TEXT,
+	CS_CMD_UNIMPLEMENTED_15 = 0x15,
+	CS_CMD_UNIMPLEMENTED_16,
+	CS_CMD_ACTOR_CUE_0_3,
+	CS_CMD_ACTOR_CUE_1_2,
+	CS_CMD_ACTOR_CUE_2_0,
+	CS_CMD_UNIMPLEMENTED_1B = 0x1B,
+	CS_CMD_UNIMPLEMENTED_1C,
+	CS_CMD_ACTOR_CUE_3_0,
+	CS_CMD_ACTOR_CUE_4_0,
+	CS_CMD_ACTOR_CUE_6_0,
+	CS_CMD_UNIMPLEMENTED_20,
+	CS_CMD_UNIMPLEMENTED_21,
+	CS_CMD_ACTOR_CUE_0_4,
+	CS_CMD_ACTOR_CUE_1_3,
+	CS_CMD_ACTOR_CUE_2_1,
+	CS_CMD_ACTOR_CUE_3_1,
+	CS_CMD_ACTOR_CUE_4_1,
+	CS_CMD_ACTOR_CUE_0_5,
+	CS_CMD_ACTOR_CUE_1_4,
+	CS_CMD_ACTOR_CUE_2_2,
+	CS_CMD_ACTOR_CUE_3_2,
+	CS_CMD_ACTOR_CUE_4_2,
+	CS_CMD_ACTOR_CUE_5_0,
+	CS_CMD_TRANSITION,
+	CS_CMD_ACTOR_CUE_0_6,
+	CS_CMD_ACTOR_CUE_4_3,
+	CS_CMD_ACTOR_CUE_1_5,
+	CS_CMD_ACTOR_CUE_7_0,
+	CS_CMD_ACTOR_CUE_2_3,
+	CS_CMD_ACTOR_CUE_3_3,
+	CS_CMD_ACTOR_CUE_6_1,
+	CS_CMD_ACTOR_CUE_3_4,
+	CS_CMD_ACTOR_CUE_4_4,
+	CS_CMD_ACTOR_CUE_5_1,
+	CS_CMD_ACTOR_CUE_6_2 = 0x39,
+	CS_CMD_ACTOR_CUE_6_3,
+	CS_CMD_UNIMPLEMENTED_3B,
+	CS_CMD_ACTOR_CUE_7_1,
+	CS_CMD_UNIMPLEMENTED_3D,
+	CS_CMD_ACTOR_CUE_8_0,
+	CS_CMD_ACTOR_CUE_3_5,
+	CS_CMD_ACTOR_CUE_1_6,
+	CS_CMD_ACTOR_CUE_3_6,
+	CS_CMD_ACTOR_CUE_3_7,
+	CS_CMD_ACTOR_CUE_2_4,
+	CS_CMD_ACTOR_CUE_1_7,
+	CS_CMD_ACTOR_CUE_2_5,
+	CS_CMD_ACTOR_CUE_1_8,
+	CS_CMD_UNIMPLEMENTED_47,
+	CS_CMD_ACTOR_CUE_2_6,
+	CS_CMD_UNIMPLEMENTED_49,
+	CS_CMD_ACTOR_CUE_2_7,
+	CS_CMD_ACTOR_CUE_3_8,
+	CS_CMD_ACTOR_CUE_0_7,
+	CS_CMD_ACTOR_CUE_5_2,
+	CS_CMD_ACTOR_CUE_1_9,
+	CS_CMD_ACTOR_CUE_4_5,
+	CS_CMD_ACTOR_CUE_1_10,
+	CS_CMD_ACTOR_CUE_2_8,
+	CS_CMD_ACTOR_CUE_3_9,
+	CS_CMD_ACTOR_CUE_4_6,
+	CS_CMD_ACTOR_CUE_5_3,
+	CS_CMD_ACTOR_CUE_0_8,
+	CS_CMD_START_SEQ,
+	CS_CMD_STOP_SEQ,
+	CS_CMD_ACTOR_CUE_6_4,
+	CS_CMD_ACTOR_CUE_7_2,
+	CS_CMD_ACTOR_CUE_5_4,
+	CS_CMD_ACTOR_CUE_0_9 = 0x5D,
+	CS_CMD_ACTOR_CUE_1_11,
+	CS_CMD_ACTOR_CUE_0_10 = 0x69,
+	CS_CMD_ACTOR_CUE_2_9,
+	CS_CMD_ACTOR_CUE_0_11,
+	CS_CMD_ACTOR_CUE_3_10,
+	CS_CMD_UNIMPLEMENTED_6D,
+	CS_CMD_ACTOR_CUE_0_12,
+	CS_CMD_ACTOR_CUE_7_3,
+	CS_CMD_UNIMPLEMENTED_70,
+	CS_CMD_UNIMPLEMENTED_71,
+	CS_CMD_ACTOR_CUE_7_4,
+	CS_CMD_ACTOR_CUE_6_5,
+	CS_CMD_ACTOR_CUE_1_12,
+	CS_CMD_ACTOR_CUE_2_10,
+	CS_CMD_ACTOR_CUE_1_13,
+	CS_CMD_ACTOR_CUE_0_13,
+	CS_CMD_ACTOR_CUE_1_14,
+	CS_CMD_ACTOR_CUE_2_11,
+	CS_CMD_ACTOR_CUE_0_14 = 0x7B,
+	CS_CMD_FADE_OUT_SEQ,
+	CS_CMD_ACTOR_CUE_1_15,
+	CS_CMD_ACTOR_CUE_2_12,
+	CS_CMD_ACTOR_CUE_3_11,
+	CS_CMD_ACTOR_CUE_4_7,
+	CS_CMD_ACTOR_CUE_5_5,
+	CS_CMD_ACTOR_CUE_6_6,
+	CS_CMD_ACTOR_CUE_1_16,
+	CS_CMD_ACTOR_CUE_2_13,
+	CS_CMD_ACTOR_CUE_3_12,
+	CS_CMD_ACTOR_CUE_7_5,
+	CS_CMD_ACTOR_CUE_4_8,
+	CS_CMD_ACTOR_CUE_5_6,
+	CS_CMD_ACTOR_CUE_6_7,
+	CS_CMD_ACTOR_CUE_0_15,
+	CS_CMD_ACTOR_CUE_0_16,
+	CS_CMD_TIME,
+	CS_CMD_ACTOR_CUE_1_17,
+	CS_CMD_ACTOR_CUE_7_6,
+	CS_CMD_ACTOR_CUE_9_0,
+	CS_CMD_ACTOR_CUE_0_17,
+	CS_CMD_DESTINATION = 0x03E8,
+	CS_CMD_END = 0xFFFF
+};
+
+/**** GENERIC ****/
+
+class CutsceneOoTSubCommandEntry_GenericCmd : public CutsceneSubCommandEntry
+{
+public:
+	CutsceneOoT_CommandType commandId;
+
+	uint32_t word0 = 0;
+	uint32_t word1 = 0;
+
+	uint32_t unused1 = 0;
+	uint32_t unused2 = 0;
+	uint32_t unused3 = 0;
+	uint32_t unused4 = 0;
+	uint32_t unused5 = 0;
+	uint32_t unused6 = 0;
+	uint32_t unused7 = 0;
+	uint32_t unused8 = 0;
+	uint32_t unused9 = 0;
+	uint32_t unused10 = 0;
+
+	CutsceneOoTSubCommandEntry_GenericCmd(const std::vector<uint8_t>& rawData,
+	                                      offset_t rawDataIndex, CutsceneOoT_CommandType cmdId);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneOoTCommand_GenericCmd : public CutsceneCommand
+{
+public:
+	CutsceneOoTCommand_GenericCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
+	                              CutsceneOoT_CommandType cmdId);
+
+	std::string GetCommandMacro() const override;
+};
+
+/**** CAMERA ****/
+
+class CutsceneOoTCommand_CameraPoint : public CutsceneSubCommandEntry
+{
+public:
+	int8_t continueFlag;
+	int8_t cameraRoll;
+	int16_t nextPointFrame;
+	float viewAngle;
+	int16_t posX, posY, posZ;
+	int16_t unused;
+
+	CutsceneOoTCommand_CameraPoint(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneOoTCommand_GenericCameraCmd : public CutsceneCommand
+{
+public:
+	uint16_t base;
+	uint16_t startFrame;
+	uint16_t endFrame;
+	uint16_t unused;
+
+	CutsceneOoTCommand_GenericCameraCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+
+	size_t GetCommandSize() const override;
+};
+
+/**** TRANSITION ****/
+
+class CutsceneOoTCommand_Transition : public CutsceneCommand
+{
+public:
+	uint16_t base;
+	uint16_t startFrame;
+	uint16_t endFrame;
+
+	CutsceneOoTCommand_Transition(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GenerateSourceCode() const override;
+	size_t GetCommandSize() const override;
+};
+
+/**** RUMBLE ****/
+
+class CutsceneOoTSubCommandEntry_Rumble : public CutsceneSubCommandEntry
+{
+public:
+	uint8_t sourceStrength;
+	uint8_t duration;
+	uint8_t decreaseRate;
+	uint8_t unk_09;
+	uint8_t unk_0A;
+
+	CutsceneOoTSubCommandEntry_Rumble(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneOoTCommand_Rumble : public CutsceneCommand
+{
+public:
+	CutsceneOoTCommand_Rumble(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+/**** TEXT ****/
+
+class CutsceneOoTSubCommandEntry_Text : public CutsceneSubCommandEntry
+{
+public:
+	uint16_t type;
+	uint16_t textId1;
+	uint16_t textId2;
+
+	CutsceneOoTSubCommandEntry_Text(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneOoTCommand_Text : public CutsceneCommand
+{
+public:
+	CutsceneOoTCommand_Text(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+/**** ACTOR CUE ****/
+
+class CutsceneOoTSubCommandEntry_ActorCue : public CutsceneSubCommandEntry
+{
+public:
+	uint16_t rotX, rotY, rotZ;
+	int32_t startPosX, startPosY, startPosZ;
+	int32_t endPosX, endPosY, endPosZ;
+	float normalX, normalY, normalZ;
+
+	CutsceneOoTSubCommandEntry_ActorCue(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneOoTCommand_ActorCue : public CutsceneCommand
+{
+public:
+	CutsceneOoTCommand_ActorCue(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+/**** DESTINATION ****/
+
+class CutsceneOoTCommand_Destination : public CutsceneCommand
+{
+public:
+	uint16_t base;
+	uint16_t startFrame;
+	uint16_t endFrame;
+	uint16_t unknown;
+
+	CutsceneOoTCommand_Destination(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GenerateSourceCode() const override;
+	size_t GetCommandSize() const override;
+};
diff --git a/ZAPD/OtherStructs/Cutscene_Commands.cpp b/ZAPD/OtherStructs/Cutscene_Commands.cpp
deleted file mode 100644
index 8ae4c69..0000000
--- a/ZAPD/OtherStructs/Cutscene_Commands.cpp
+++ /dev/null
@@ -1,596 +0,0 @@
-#include "Cutscene_Commands.h"
-
-#include <cassert>
-#include <unordered_map>
-
-#include "CutsceneMM_Commands.h"
-#include "Globals.h"
-#include "Utils/BitConverter.h"
-#include "Utils/StringHelper.h"
-
-/* CutsceneSubCommandEntry */
-
-CutsceneSubCommandEntry::CutsceneSubCommandEntry(const std::vector<uint8_t>& rawData,
-                                                 offset_t rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	pad = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-}
-
-std::string CutsceneSubCommandEntry::GetBodySourceCode() const
-{
-	return StringHelper::Sprintf("CMD_HH(0x%04X, 0x%04X), CMD_HH(0x%04X, 0x%04X)", base, startFrame,
-	                             endFrame, pad);
-}
-
-size_t CutsceneSubCommandEntry::GetRawSize() const
-{
-	return 0x08;
-}
-
-/* CutsceneCommand */
-
-CutsceneCommand::CutsceneCommand(const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
-{
-	numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
-}
-
-CutsceneCommand::~CutsceneCommand()
-{
-	for (auto& entry : entries)
-	{
-		delete entry;
-	}
-}
-
-std::string CutsceneCommand::GetCommandMacro() const
-{
-	return StringHelper::Sprintf("CMD_W(0x%08X), CMD_W(0x%08X)", commandID, numEntries);
-}
-
-std::string CutsceneCommand::GenerateSourceCode() const
-{
-	std::string result;
-
-	result += GetCommandMacro();
-	result += ",\n";
-
-	for (auto& entry : entries)
-	{
-		result += "        ";
-		result += entry->GetBodySourceCode();
-		result += ",\n";
-	}
-
-	return result;
-}
-
-size_t CutsceneCommand::GetCommandSize() const
-{
-	size_t size = 0;
-	if (entries.size() > 0)
-	{
-		size = entries.at(0)->GetRawSize() * entries.size();
-	}
-	else
-	{
-		size = 0x08 * numEntries;
-	}
-	return 0x08 + size;
-}
-
-void CutsceneCommand::SetCommandID(uint32_t nCommandID)
-{
-	commandID = nCommandID;
-
-	for (auto& entry : entries)
-	{
-		entry->commandID = commandID;
-	}
-}
-
-// Specific for command lists where each entry has size 0x30 bytes
-const std::unordered_map<CutsceneCommands, CsCommandListDescriptor> csCommandsDesc = {
-	{CutsceneCommands::Misc,
-     {"CS_MISC", "(0x%04X, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
-	{CutsceneCommands::SetLighting,
-     {"CS_LIGHTING", "(0x%02X, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
-	{CutsceneCommands::PlayBGM, {"CS_PLAY_BGM", "(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
-	{CutsceneCommands::StopBGM, {"CS_STOP_BGM", "(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
-	{CutsceneCommands::FadeBGM, {"CS_FADE_BGM", "(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i)"}},
-};
-
-CutsceneSubCommandEntry_GenericCmd::CutsceneSubCommandEntry_GenericCmd(
-	const std::vector<uint8_t>& rawData, offset_t rawDataIndex, CutsceneCommands cmdId)
-	: CutsceneSubCommandEntry(rawData, rawDataIndex), commandId(cmdId)
-{
-	word0 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x0);
-	word1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x4);
-
-	unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x8);
-	unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0xC);
-	unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x10);
-	unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x14);
-	unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x18);
-	unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x1C);
-	unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x20);
-	unused8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x24);
-	unused9 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x28);
-	unused10 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0x2C);
-}
-
-std::string CutsceneSubCommandEntry_GenericCmd::GetBodySourceCode() const
-{
-	const auto& element = csCommandsDesc.find(commandId);
-
-	if (element != csCommandsDesc.end())
-	{
-		std::string entryFmt = element->second.cmdMacro;
-		entryFmt += element->second.args;
-
-		return StringHelper::Sprintf(entryFmt.c_str(), base, startFrame, endFrame, pad, unused1,
-		                             unused2, unused3, unused4, unused5, unused6, unused7, unused8,
-		                             unused9, unused10);
-	}
-
-	return StringHelper::Sprintf("CS_UNK_DATA(0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, "
-	                             "0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X)",
-	                             word0, word1, unused1, unused2, unused3, unused4, unused5, unused6,
-	                             unused7, unused8, unused9, unused10);
-}
-
-size_t CutsceneSubCommandEntry_GenericCmd::GetRawSize() const
-{
-	return 0x30;
-}
-
-CutsceneCommand_GenericCmd::CutsceneCommand_GenericCmd(const std::vector<uint8_t>& rawData,
-                                                       offset_t rawDataIndex,
-                                                       CutsceneCommands cmdId)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	rawDataIndex += 4;
-
-	commandID = static_cast<uint32_t>(cmdId);
-	entries.reserve(numEntries);
-
-	for (size_t i = 0; i < numEntries; i++)
-	{
-		auto* entry = new CutsceneSubCommandEntry_GenericCmd(rawData, rawDataIndex, cmdId);
-		entries.push_back(entry);
-		rawDataIndex += entry->GetRawSize();
-	}
-}
-
-std::string CutsceneCommand_GenericCmd::GetCommandMacro() const
-{
-	const auto& element = csCommandsDesc.find(static_cast<CutsceneCommands>(commandID));
-
-	if (element != csCommandsDesc.end())
-	{
-		return StringHelper::Sprintf("%s_LIST(%i)", element->second.cmdMacro, numEntries);
-	}
-
-	return StringHelper::Sprintf("CS_UNK_DATA_LIST(0x%X, %i)", commandID, numEntries);
-}
-
-CutsceneCameraPoint::CutsceneCameraPoint(const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
-	: CutsceneSubCommandEntry(rawData, rawDataIndex)
-{
-	continueFlag = BitConverter::ToInt8BE(rawData, rawDataIndex + 0);
-	cameraRoll = BitConverter::ToInt8BE(rawData, rawDataIndex + 1);
-	nextPointFrame = BitConverter::ToInt16BE(rawData, rawDataIndex + 2);
-	viewAngle = BitConverter::ToFloatBE(rawData, rawDataIndex + 4);
-
-	posX = BitConverter::ToInt16BE(rawData, rawDataIndex + 8);
-	posY = BitConverter::ToInt16BE(rawData, rawDataIndex + 10);
-	posZ = BitConverter::ToInt16BE(rawData, rawDataIndex + 12);
-
-	unused = BitConverter::ToInt16BE(rawData, rawDataIndex + 14);
-}
-
-std::string CutsceneCameraPoint::GetBodySourceCode() const
-{
-	std::string result = "";
-
-	if (commandID == (int32_t)CutsceneCommands::SetCameraFocus)
-	{
-		result += "CS_CAM_FOCUS_POINT";
-	}
-	else if (commandID == (int32_t)CutsceneCommands::SetCameraFocusLink)
-	{
-		result += "CS_CAM_FOCUS_POINT_PLAYER";
-	}
-	else if (commandID == (int32_t)CutsceneCommands::SetCameraPosLink)
-	{
-		result += "CS_CAM_POS_PLAYER";
-	}
-	else
-	{
-		result += "CS_CAM_POS";
-	}
-
-	std::string continueMacro = "CS_CMD_CONTINUE";
-	if (continueFlag != 0)
-		continueMacro = "CS_CMD_STOP";
-
-	result +=
-		StringHelper::Sprintf("(%s, 0x%02X, %i, %ff, %i, %i, %i, 0x%04X)", continueMacro.c_str(),
-	                          cameraRoll, nextPointFrame, viewAngle, posX, posY, posZ, unused);
-	return result;
-}
-
-size_t CutsceneCameraPoint::GetRawSize() const
-{
-	return 0x10;
-}
-
-CutsceneCommandSetCameraPos::CutsceneCommandSetCameraPos(const std::vector<uint8_t>& rawData,
-                                                         offset_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	unused = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-
-	bool shouldContinue = true;
-
-	uint32_t currentPtr = rawDataIndex + 8;
-
-	while (shouldContinue)
-	{
-		CutsceneCameraPoint* camPoint = new CutsceneCameraPoint(rawData, currentPtr);
-		entries.push_back(camPoint);
-
-		if (camPoint->continueFlag == -1)
-			shouldContinue = false;
-
-		currentPtr += camPoint->GetRawSize();
-	}
-}
-
-std::string CutsceneCommandSetCameraPos::GetCommandMacro() const
-{
-	std::string result;
-
-	std::string listStr;
-
-	if (commandID == (int32_t)CutsceneCommands::SetCameraFocus)
-	{
-		listStr = "CS_CAM_FOCUS_POINT_LIST";
-	}
-	else if (commandID == (int32_t)CutsceneCommands::SetCameraFocusLink)
-	{
-		listStr = "CS_CAM_FOCUS_POINT_PLAYER_LIST";
-	}
-	else if (commandID == (int32_t)CutsceneCommands::SetCameraPosLink)
-	{
-		listStr = "CS_CAM_POS_PLAYER_LIST";
-	}
-	else
-	{
-		listStr = "CS_CAM_POS_LIST";
-	}
-
-	result += StringHelper::Sprintf("%s(%i, %i)", listStr.c_str(), startFrame, endFrame);
-
-	return result;
-}
-
-size_t CutsceneCommandSetCameraPos::GetCommandSize() const
-{
-	return 0x0C + entries.at(0)->GetRawSize() * entries.size();
-}
-
-CutsceneSubCommandEntry_Rumble::CutsceneSubCommandEntry_Rumble(const std::vector<uint8_t>& rawData,
-                                                               offset_t rawDataIndex)
-	: CutsceneSubCommandEntry(rawData, rawDataIndex)
-{
-	unk_06 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x06);
-	unk_07 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x07);
-	unk_08 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x08);
-	unk_09 = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x09);
-	unk_0A = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x0A);
-	unk_0B = BitConverter::ToUInt8BE(rawData, rawDataIndex + 0x0B);
-}
-
-std::string CutsceneSubCommandEntry_Rumble::GetBodySourceCode() const
-{
-	if (Globals::Instance->game == ZGame::MM_RETAIL)
-	{
-		return StringHelper::Sprintf("CS_RUMBLE(%i, %i, %i, 0x%02X, 0x%02X, 0x%02X)", base,
-		                             startFrame, endFrame, unk_06, unk_07, unk_08);
-	}
-
-	return StringHelper::Sprintf("CS_CMD_09(%i, %i, %i, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X)",
-	                             base, startFrame, endFrame, unk_06, unk_07, unk_08, unk_09, unk_0A,
-	                             unk_0B);
-}
-
-size_t CutsceneSubCommandEntry_Rumble::GetRawSize() const
-{
-	return 0x0C;
-}
-
-CutsceneCommand_Rumble::CutsceneCommand_Rumble(const std::vector<uint8_t>& rawData,
-                                               offset_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	rawDataIndex += 4;
-
-	entries.reserve(numEntries);
-	for (size_t i = 0; i < numEntries; i++)
-	{
-		auto* entry = new CutsceneSubCommandEntry_Rumble(rawData, rawDataIndex);
-		entries.push_back(entry);
-		rawDataIndex += entry->GetRawSize();
-	}
-}
-
-std::string CutsceneCommand_Rumble::GetCommandMacro() const
-{
-	if (Globals::Instance->game == ZGame::MM_RETAIL)
-	{
-		return StringHelper::Sprintf("CS_RUMBLE_LIST(%i)", numEntries);
-	}
-	return StringHelper::Sprintf("CS_CMD_09_LIST(%i)", numEntries);
-}
-
-CutsceneSubCommandEntry_SetTime::CutsceneSubCommandEntry_SetTime(
-	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
-	: CutsceneSubCommandEntry(rawData, rawDataIndex)
-{
-	hour = BitConverter::ToUInt8BE(rawData, rawDataIndex + 6);
-	minute = BitConverter::ToUInt8BE(rawData, rawDataIndex + 7);
-	unk_08 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
-}
-
-std::string CutsceneSubCommandEntry_SetTime::GetBodySourceCode() const
-{
-	return StringHelper::Sprintf("CS_TIME(%i, %i, %i, %i, %i, %i)", base, startFrame, endFrame,
-	                             hour, minute, unk_08);
-}
-
-size_t CutsceneSubCommandEntry_SetTime::GetRawSize() const
-{
-	return 0x0C;
-}
-
-CutsceneCommand_SetTime::CutsceneCommand_SetTime(const std::vector<uint8_t>& rawData,
-                                                 offset_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	rawDataIndex += 4;
-
-	entries.reserve(numEntries);
-	for (size_t i = 0; i < numEntries; i++)
-	{
-		auto* entry = new CutsceneSubCommandEntry_SetTime(rawData, rawDataIndex);
-		entries.push_back(entry);
-		rawDataIndex += entry->GetRawSize();
-	}
-}
-
-std::string CutsceneCommand_SetTime::GetCommandMacro() const
-{
-	return StringHelper::Sprintf("CS_TIME_LIST(%i)", numEntries);
-}
-
-CutsceneSubCommandEntry_TextBox::CutsceneSubCommandEntry_TextBox(
-	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
-	: CutsceneSubCommandEntry(rawData, rawDataIndex)
-{
-	type = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x6);
-	textId1 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x8);
-	textId2 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0xA);
-}
-
-std::string CutsceneSubCommandEntry_TextBox::GetBodySourceCode() const
-{
-	if (type == 0xFFFF)
-	{
-		return StringHelper::Sprintf("CS_TEXT_NONE(%i, %i)", startFrame, endFrame);
-	}
-	if (type == 2)
-	{
-		return StringHelper::Sprintf("CS_TEXT_LEARN_SONG(%i, %i, %i, 0x%X)", base, startFrame,
-		                             endFrame, textId1);
-	}
-
-	if (Globals::Instance->game == ZGame::MM_RETAIL)
-	{
-		switch (type)
-		{
-		case 0:
-			return StringHelper::Sprintf("CS_TEXT_DEFAULT(0x%X, %i, %i, 0x%X, 0x%X)", base,
-			                             startFrame, endFrame, textId1, textId2);
-
-		case 1:
-			return StringHelper::Sprintf("CS_TEXT_TYPE_1(0x%X, %i, %i, 0x%X, 0x%X)", base,
-			                             startFrame, endFrame, textId1, textId2);
-
-		case 3:
-			return StringHelper::Sprintf("CS_TEXT_TYPE_3(0x%X, %i, %i, 0x%X, 0x%X)", base,
-			                             startFrame, endFrame, textId1, textId2);
-
-		case 4:
-			return StringHelper::Sprintf("CS_TEXT_BOSSES_REMAINS(0x%X, %i, %i, 0x%X)", base,
-			                             startFrame, endFrame, textId1);
-
-		case 5:
-			return StringHelper::Sprintf("CS_TEXT_ALL_NORMAL_MASKS(0x%X, %i, %i, 0x%X)", base,
-			                             startFrame, endFrame, textId1);
-		}
-	}
-
-	return StringHelper::Sprintf("CS_TEXT_DISPLAY_TEXTBOX(0x%X, %i, %i, %i, 0x%X, 0x%X)", base,
-	                             startFrame, endFrame, type, textId1, textId2);
-}
-
-size_t CutsceneSubCommandEntry_TextBox::GetRawSize() const
-{
-	return 0x0C;
-}
-
-CutsceneCommand_TextBox::CutsceneCommand_TextBox(const std::vector<uint8_t>& rawData,
-                                                 offset_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	rawDataIndex += 4;
-
-	entries.reserve(numEntries);
-	for (size_t i = 0; i < numEntries; i++)
-	{
-		auto* entry = new CutsceneSubCommandEntry_TextBox(rawData, rawDataIndex);
-		entries.push_back(entry);
-		rawDataIndex += entry->GetRawSize();
-	}
-}
-
-std::string CutsceneCommand_TextBox::GetCommandMacro() const
-{
-	return StringHelper::Sprintf("CS_TEXT_LIST(%i)", numEntries);
-}
-
-CutsceneSubCommandEntry_ActorAction::CutsceneSubCommandEntry_ActorAction(
-	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
-	: CutsceneSubCommandEntry(rawData, rawDataIndex)
-{
-	rotX = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x6);
-	rotY = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0x8);
-	rotZ = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0xA);
-	startPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 0xC);
-	startPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x10);
-	startPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x14);
-	endPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x18);
-	endPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x1C);
-	endPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 0x20);
-	normalX = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x24);
-	normalY = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x28);
-	normalZ = BitConverter::ToFloatBE(rawData, rawDataIndex + 0x2C);
-}
-
-std::string CutsceneSubCommandEntry_ActorAction::GetBodySourceCode() const
-{
-	std::string result;
-
-	if (Globals::Instance->game == ZGame::MM_RETAIL)
-	{
-		if (static_cast<CutsceneMMCommands>(commandID) ==
-		    CutsceneMMCommands::CS_CMD_SET_PLAYER_ACTION)
-		{
-			result = "CS_PLAYER_ACTION";
-		}
-		else
-		{
-			result = "CS_ACTOR_ACTION";
-		}
-	}
-	else
-	{
-		if (static_cast<CutsceneCommands>(commandID) == CutsceneCommands::SetPlayerAction)
-		{
-			result = "CS_PLAYER_ACTION";
-		}
-		else
-		{
-			result = "CS_NPC_ACTION";
-		}
-	}
-
-	result +=
-		StringHelper::Sprintf("(%i, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, "
-	                          "%i, %i, %i, %i, %.11ef, %.11ef, %.11ef)",
-	                          base, startFrame, endFrame, rotX, rotY, rotZ, startPosX, startPosY,
-	                          startPosZ, endPosX, endPosY, endPosZ, normalX, normalY, normalZ);
-	return result;
-}
-
-size_t CutsceneSubCommandEntry_ActorAction::GetRawSize() const
-{
-	return 0x30;
-}
-
-CutsceneCommand_ActorAction::CutsceneCommand_ActorAction(const std::vector<uint8_t>& rawData,
-                                                         offset_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	rawDataIndex += 4;
-
-	entries.reserve(numEntries);
-	for (size_t i = 0; i < numEntries; i++)
-	{
-		auto* entry = new CutsceneSubCommandEntry_ActorAction(rawData, rawDataIndex);
-		entries.push_back(entry);
-		rawDataIndex += entry->GetRawSize();
-	}
-}
-
-std::string CutsceneCommand_ActorAction::GetCommandMacro() const
-{
-	if (Globals::Instance->game == ZGame::MM_RETAIL)
-	{
-		if (static_cast<CutsceneMMCommands>(commandID) ==
-		    CutsceneMMCommands::CS_CMD_SET_PLAYER_ACTION)
-		{
-			return StringHelper::Sprintf("CS_PLAYER_ACTION_LIST(%i)", numEntries);
-		}
-		return StringHelper::Sprintf("CS_ACTOR_ACTION_LIST(0x%03X, %i)", commandID, numEntries);
-	}
-
-	if (static_cast<CutsceneCommands>(commandID) == CutsceneCommands::SetPlayerAction)
-	{
-		return StringHelper::Sprintf("CS_PLAYER_ACTION_LIST(%i)", entries.size());
-	}
-	return StringHelper::Sprintf("CS_NPC_ACTION_LIST(0x%03X, %i)", commandID, entries.size());
-}
-
-CutsceneCommand_Terminator::CutsceneCommand_Terminator(const std::vector<uint8_t>& rawData,
-                                                       offset_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	rawDataIndex += 4;
-
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	unknown = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);  // endFrame duplicate
-}
-
-std::string CutsceneCommand_Terminator::GenerateSourceCode() const
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_TERMINATOR(%i, %i, %i),\n", base, startFrame, endFrame);
-
-	return result;
-}
-
-size_t CutsceneCommand_Terminator::GetCommandSize() const
-{
-	return 0x10;
-}
-
-CutsceneCommandSceneTransFX::CutsceneCommandSceneTransFX(const std::vector<uint8_t>& rawData,
-                                                         offset_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	rawDataIndex += 4;
-
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-}
-
-std::string CutsceneCommandSceneTransFX::GenerateSourceCode() const
-{
-	return StringHelper::Sprintf("CS_SCENE_TRANS_FX(%i, %i, %i),\n", base, startFrame, endFrame);
-}
-
-size_t CutsceneCommandSceneTransFX::GetCommandSize() const
-{
-	return 0x10;
-}
diff --git a/ZAPD/OtherStructs/Cutscene_Commands.h b/ZAPD/OtherStructs/Cutscene_Commands.h
deleted file mode 100644
index c462735..0000000
--- a/ZAPD/OtherStructs/Cutscene_Commands.h
+++ /dev/null
@@ -1,267 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "Declaration.h"
-
-enum class CutsceneCommands
-{
-	SetCameraPos = 0x0001,
-	SetCameraFocus = 0x0002,
-	Misc = 0x0003,
-	SetLighting = 0x0004,
-	SetCameraPosLink = 0x0005,
-	SetCameraFocusLink = 0x0006,
-	Cmd07 = 0x0007,
-	Cmd08 = 0x0008,
-	Cmd09 = 0x0009,  // Rumble
-	Textbox = 0x0013,
-	SetPlayerAction = 0x000A,
-	SetActorAction1 = 0x000F,
-	SetActorAction2 = 0x000E,
-	SetActorAction3 = 0x0019,
-	SetActorAction4 = 0x001D,
-	SetActorAction5 = 0x001E,
-	SetActorAction6 = 0x002C,
-	SetActorAction7 = 0x001F,
-	SetActorAction8 = 0x0031,
-	SetActorAction9 = 0x003E,
-	SetActorAction10 = 0x008F,
-	SetSceneTransFX = 0x002D,
-	PlayBGM = 0x0056,
-	StopBGM = 0x0057,
-	FadeBGM = 0x007C,
-	SetTime = 0x008C,
-	Terminator = 0x03E8,
-};
-
-typedef struct CsCommandListDescriptor
-{
-	const char* cmdMacro;
-	const char* args;
-} CsCommandListDescriptor;
-
-class CutsceneSubCommandEntry
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t pad;
-
-	uint32_t commandID;
-
-	CutsceneSubCommandEntry(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-	virtual ~CutsceneSubCommandEntry() = default;
-
-	virtual std::string GetBodySourceCode() const;
-
-	virtual size_t GetRawSize() const;
-};
-
-class CutsceneCommand
-{
-public:
-	uint32_t commandID;
-	uint32_t commandIndex;
-
-	uint32_t numEntries;
-	std::vector<CutsceneSubCommandEntry*> entries;
-
-	CutsceneCommand(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-	virtual ~CutsceneCommand();
-
-	virtual std::string GetCommandMacro() const;
-	virtual std::string GenerateSourceCode() const;
-	virtual size_t GetCommandSize() const;
-
-	virtual void SetCommandID(uint32_t nCommandID);
-};
-
-class CutsceneSubCommandEntry_GenericCmd : public CutsceneSubCommandEntry
-{
-public:
-	CutsceneCommands commandId;
-
-	uint32_t word0 = 0;
-	uint32_t word1 = 0;
-
-	uint32_t unused1 = 0;
-	uint32_t unused2 = 0;
-	uint32_t unused3 = 0;
-	uint32_t unused4 = 0;
-	uint32_t unused5 = 0;
-	uint32_t unused6 = 0;
-	uint32_t unused7 = 0;
-	uint32_t unused8 = 0;
-	uint32_t unused9 = 0;
-	uint32_t unused10 = 0;
-
-	CutsceneSubCommandEntry_GenericCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
-	                                   CutsceneCommands cmdId);
-
-	std::string GetBodySourceCode() const override;
-
-	size_t GetRawSize() const override;
-};
-
-class CutsceneCommand_GenericCmd : public CutsceneCommand
-{
-public:
-	CutsceneCommand_GenericCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
-	                           CutsceneCommands cmdId);
-
-	std::string GetCommandMacro() const override;
-};
-
-class CutsceneCameraPoint : public CutsceneSubCommandEntry
-{
-public:
-	int8_t continueFlag;
-	int8_t cameraRoll;
-	int16_t nextPointFrame;
-	float viewAngle;
-	int16_t posX, posY, posZ;
-	int16_t unused;
-
-	CutsceneCameraPoint(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetBodySourceCode() const override;
-
-	size_t GetRawSize() const override;
-};
-
-class CutsceneCommandSetCameraPos : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unused;
-
-	CutsceneCommandSetCameraPos(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetCommandMacro() const override;
-
-	size_t GetCommandSize() const override;
-};
-
-class CutsceneCommandSceneTransFX : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-
-	CutsceneCommandSceneTransFX(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GenerateSourceCode() const override;
-	size_t GetCommandSize() const override;
-};
-
-class CutsceneSubCommandEntry_Rumble : public CutsceneSubCommandEntry
-{
-public:
-	uint8_t unk_06;
-	uint8_t unk_07;
-	uint8_t unk_08;
-	uint8_t unk_09;
-	uint8_t unk_0A;
-	uint8_t unk_0B;
-
-	CutsceneSubCommandEntry_Rumble(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetBodySourceCode() const override;
-
-	size_t GetRawSize() const override;
-};
-
-class CutsceneCommand_Rumble : public CutsceneCommand
-{
-public:
-	CutsceneCommand_Rumble(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetCommandMacro() const override;
-};
-
-class CutsceneSubCommandEntry_SetTime : public CutsceneSubCommandEntry
-{
-public:
-	uint8_t hour;
-	uint8_t minute;
-	uint32_t unk_08;
-
-	CutsceneSubCommandEntry_SetTime(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetBodySourceCode() const override;
-
-	size_t GetRawSize() const override;
-};
-
-class CutsceneCommand_SetTime : public CutsceneCommand
-{
-public:
-	CutsceneCommand_SetTime(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetCommandMacro() const override;
-};
-
-class CutsceneSubCommandEntry_TextBox : public CutsceneSubCommandEntry
-{
-public:
-	uint16_t type;
-	uint16_t textId1;
-	uint16_t textId2;
-
-	CutsceneSubCommandEntry_TextBox(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetBodySourceCode() const override;
-
-	size_t GetRawSize() const override;
-};
-
-class CutsceneCommand_TextBox : public CutsceneCommand
-{
-public:
-	CutsceneCommand_TextBox(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetCommandMacro() const override;
-};
-
-class CutsceneSubCommandEntry_ActorAction : public CutsceneSubCommandEntry
-{
-public:
-	uint16_t rotX, rotY, rotZ;
-	int32_t startPosX, startPosY, startPosZ;
-	int32_t endPosX, endPosY, endPosZ;
-	float normalX, normalY, normalZ;
-
-	CutsceneSubCommandEntry_ActorAction(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-	std::string GetBodySourceCode() const override;
-
-	size_t GetRawSize() const override;
-};
-
-class CutsceneCommand_ActorAction : public CutsceneCommand
-{
-public:
-	CutsceneCommand_ActorAction(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GetCommandMacro() const override;
-};
-
-class CutsceneCommand_Terminator : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unknown;
-
-	CutsceneCommand_Terminator(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
-
-	std::string GenerateSourceCode() const override;
-	size_t GetCommandSize() const override;
-};
diff --git a/ZAPD/OtherStructs/Cutscene_Common.cpp b/ZAPD/OtherStructs/Cutscene_Common.cpp
new file mode 100644
index 0000000..a5ea609
--- /dev/null
+++ b/ZAPD/OtherStructs/Cutscene_Common.cpp
@@ -0,0 +1,128 @@
+#include "Cutscene_Common.h"
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+
+/* CutsceneSubCommandEntry */
+
+CutsceneSubCommandEntry::CutsceneSubCommandEntry(const std::vector<uint8_t>& rawData,
+                                                 offset_t rawDataIndex)
+{
+	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
+	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
+	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
+	pad = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
+}
+
+std::string CutsceneSubCommandEntry::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("CMD_HH(0x%04X, 0x%04X), CMD_HH(0x%04X, 0x%04X)", base, startFrame,
+	                             endFrame, pad);
+}
+
+size_t CutsceneSubCommandEntry::GetRawSize() const
+{
+	return 0x08;
+}
+
+/* CutsceneCommand */
+
+CutsceneCommand::CutsceneCommand(const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+{
+	numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
+}
+
+CutsceneCommand::~CutsceneCommand()
+{
+	for (auto entry : entries)
+	{
+		delete entry;
+	}
+}
+
+std::string CutsceneCommand::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CMD_W(0x%08X), CMD_W(0x%08X)", commandID, numEntries);
+}
+
+std::string CutsceneCommand::GenerateSourceCode() const
+{
+	std::string result;
+
+	result += GetCommandMacro();
+	result += ",\n";
+
+	for (auto& entry : entries)
+	{
+		result += "        ";
+		result += entry->GetBodySourceCode();
+		result += ",\n";
+	}
+
+	return result;
+}
+
+size_t CutsceneCommand::GetCommandSize() const
+{
+	size_t size = 0;
+	if (entries.size() > 0)
+	{
+		size = entries.at(0)->GetRawSize() * entries.size();
+	}
+	else
+	{
+		size = 0x08 * numEntries;
+	}
+	return 0x08 + size;
+}
+
+void CutsceneCommand::SetCommandID(uint32_t nCommandID)
+{
+	commandID = nCommandID;
+
+	for (auto& entry : entries)
+	{
+		entry->commandID = commandID;
+	}
+}
+
+/*** TIME ****/
+
+CutsceneSubCommandEntry_SetTime::CutsceneSubCommandEntry_SetTime(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+	hour = BitConverter::ToUInt8BE(rawData, rawDataIndex + 6);
+	minute = BitConverter::ToUInt8BE(rawData, rawDataIndex + 7);
+}
+
+std::string CutsceneSubCommandEntry_SetTime::GetBodySourceCode() const
+{
+	// Note: Both OoT and MM have the first argument unused
+	return StringHelper::Sprintf("CS_TIME(%i, %i, %i, %i, %i)", base, startFrame, endFrame, hour,
+	                             minute);
+}
+
+size_t CutsceneSubCommandEntry_SetTime::GetRawSize() const
+{
+	return 0x0C;
+}
+
+CutsceneCommand_Time::CutsceneCommand_Time(const std::vector<uint8_t>& rawData,
+                                           offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	entries.reserve(numEntries);
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneSubCommandEntry_SetTime(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneCommand_Time::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_TIME_LIST(%i)", numEntries);
+}
diff --git a/ZAPD/OtherStructs/Cutscene_Common.h b/ZAPD/OtherStructs/Cutscene_Common.h
new file mode 100644
index 0000000..9d8dcf6
--- /dev/null
+++ b/ZAPD/OtherStructs/Cutscene_Common.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "Declaration.h"
+
+typedef struct CsCommandListDescriptor
+{
+	const char* cmdMacro;
+	const char* args;
+} CsCommandListDescriptor;
+
+class CutsceneSubCommandEntry
+{
+public:
+	uint16_t base;
+	uint16_t startFrame;
+	uint16_t endFrame;
+	uint16_t pad;
+
+	uint32_t commandID;
+
+	CutsceneSubCommandEntry(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	virtual ~CutsceneSubCommandEntry() = default;
+
+	virtual std::string GetBodySourceCode() const;
+
+	virtual size_t GetRawSize() const;
+};
+
+class CutsceneCommand
+{
+public:
+	uint32_t commandID;
+	uint32_t commandIndex;
+
+	uint32_t numEntries;
+	std::vector<CutsceneSubCommandEntry*> entries;
+
+	CutsceneCommand(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+	virtual ~CutsceneCommand();
+
+	virtual std::string GetCommandMacro() const;
+	virtual std::string GenerateSourceCode() const;
+	virtual size_t GetCommandSize() const;
+
+	virtual void SetCommandID(uint32_t nCommandID);
+};
+
+/**** TIME ****/
+
+class CutsceneSubCommandEntry_SetTime : public CutsceneSubCommandEntry
+{
+public:
+	uint8_t hour;
+	uint8_t minute;
+
+	CutsceneSubCommandEntry_SetTime(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneCommand_Time : public CutsceneCommand
+{
+public:
+	CutsceneCommand_Time(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
diff --git a/ZAPD/ZCutscene.cpp b/ZAPD/ZCutscene.cpp
index c2e6c2b..ea723b2 100644
--- a/ZAPD/ZCutscene.cpp
+++ b/ZAPD/ZCutscene.cpp
@@ -3,7 +3,6 @@
 #include <cassert>
 
 #include "Globals.h"
-#include "OtherStructs/CutsceneMM_Commands.h"
 #include "Utils/BitConverter.h"
 #include "Utils/StringHelper.h"
 #include "WarningHandler.h"
@@ -129,174 +128,147 @@ void ZCutscene::ParseRawData()
 
 CutsceneCommand* ZCutscene::GetCommandOoT(uint32_t id, offset_t currentPtr) const
 {
-	CutsceneCommands cmdID = static_cast<CutsceneCommands>(id);
+	CutsceneOoT_CommandType cmdID = static_cast<CutsceneOoT_CommandType>(id);
 
 	const auto& rawData = parent->GetRawData();
 
-	switch (id)
-	{
-	case 10:  // CutsceneCommands::SetPlayerAction
-	case 15:  // CutsceneCommands::SetActorAction1
-	case 17:
-	case 18:
-	case 23:
-	case 34:
-	case 39:
-	case 46:
-	case 76:
-	case 85:
-	case 93:
-	case 105:
-	case 107:
-	case 110:
-	case 119:
-	case 123:
-	case 138:
-	case 139:
-	case 144:
-	case 14:  // CutsceneCommands::SetActorAction2
-	case 16:
-	case 24:
-	case 35:
-	case 40:
-	case 48:
-	case 64:
-	case 68:
-	case 70:
-	case 78:
-	case 80:
-	case 94:
-	case 116:
-	case 118:
-	case 120:
-	case 125:
-	case 131:
-	case 141:
-	case 25:  // CutsceneCommands::SetActorAction3
-	case 36:
-	case 41:
-	case 50:
-	case 67:
-	case 69:
-	case 72:
-	case 81:
-	case 106:
-	case 117:
-	case 121:
-	case 126:
-	case 132:
-	case 29:  // CutsceneCommands::SetActorAction4
-	case 37:
-	case 42:
-	case 51:
-	case 53:
-	case 63:
-	case 65:
-	case 66:
-	case 75:
-	case 82:
-	case 108:
-	case 127:
-	case 133:
-	case 30:  // CutsceneCommands::SetActorAction5
-	case 38:
-	case 43:
-	case 47:
-	case 54:
-	case 79:
-	case 83:
-	case 128:
-	case 135:
-	case 44:  // CutsceneCommands::SetActorAction6
-	case 55:
-	case 77:
-	case 84:
-	case 90:
-	case 129:
-	case 136:
-	case 31:  // CutsceneCommands::SetActorAction7
-	case 52:
-	case 57:
-	case 58:
-	case 88:
-	case 115:
-	case 130:
-	case 137:
-	case 49:  // CutsceneCommands::SetActorAction8
-	case 60:
-	case 89:
-	case 111:
-	case 114:
-	case 134:
-	case 142:
-	case 62:   // CutsceneCommands::SetActorAction9
-	case 143:  // CutsceneCommands::SetActorAction10
-	case 74:
-		return new CutsceneCommand_ActorAction(rawData, currentPtr);
-
-	case 0x0B:
-	case 0x0D:
-	case 0x1A:
-	case 0x1B:
-	case 0x1C:
-	case 0x20:
-	case 0x21:
-	case 0x3B:
-	case 0x3D:
-	case 0x47:
-	case 0x49:
-	case 0x6D:
-	case 0x15:
-	case 0x16:
-	case 0x70:
-	case 0x71:
-		return new CutsceneCommand_GenericCmd(rawData, currentPtr, cmdID);
-	}
-
 	switch (cmdID)
 	{
-	case CutsceneCommands::Misc:
-	case CutsceneCommands::SetLighting:
-	case CutsceneCommands::PlayBGM:
-	case CutsceneCommands::StopBGM:
-	case CutsceneCommands::FadeBGM:
-		return new CutsceneCommand_GenericCmd(rawData, currentPtr, cmdID);
-
-	case CutsceneCommands::SetCameraPos:
-	case CutsceneCommands::SetCameraFocus:
-	case CutsceneCommands::SetCameraPosLink:
-	case CutsceneCommands::SetCameraFocusLink:
-		return new CutsceneCommandSetCameraPos(rawData, currentPtr);
-
-	case CutsceneCommands::Cmd07:
-		break;
-	case CutsceneCommands::Cmd08:
+	case CutsceneOoT_CommandType::CS_CMD_PLAYER_CUE:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_5_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_7_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_5_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_7_1:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_8_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_7:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_7:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_8:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_7:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_8:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_7:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_5_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_9:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_10:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_8:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_9:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_5_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_8:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_7_2:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_5_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_9:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_11:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_10:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_9:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_11:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_10:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_12:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_7_3:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_7_4:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_12:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_10:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_13:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_13:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_14:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_11:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_14:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_15:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_12:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_11:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_7:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_5_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_16:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_2_13:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_3_12:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_7_5:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_4_8:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_5_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_6_7:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_15:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_16:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_1_17:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_7_6:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_9_0:
+	case CutsceneOoT_CommandType::CS_CMD_ACTOR_CUE_0_17:
+		return new CutsceneOoTCommand_ActorCue(rawData, currentPtr);
+
+	case CutsceneOoT_CommandType::CS_CMD_MISC:
+	case CutsceneOoT_CommandType::CS_CMD_LIGHT_SETTING:
+	case CutsceneOoT_CommandType::CS_CMD_START_SEQ:
+	case CutsceneOoT_CommandType::CS_CMD_STOP_SEQ:
+	case CutsceneOoT_CommandType::CS_CMD_FADE_OUT_SEQ:
+		return new CutsceneOoTCommand_GenericCmd(rawData, currentPtr, cmdID);
+
+	case CutsceneOoT_CommandType::CS_CMD_CAM_EYE_SPLINE:
+	case CutsceneOoT_CommandType::CS_CMD_CAM_AT_SPLINE:
+	case CutsceneOoT_CommandType::CS_CMD_CAM_EYE_SPLINE_REL_TO_PLAYER:
+	case CutsceneOoT_CommandType::CS_CMD_CAM_AT_SPLINE_REL_TO_PLAYER:
+		return new CutsceneOoTCommand_GenericCameraCmd(rawData, currentPtr);
+
+	case CutsceneOoT_CommandType::CS_CMD_RUMBLE_CONTROLLER:
+		return new CutsceneOoTCommand_Rumble(rawData, currentPtr);
+
+	case CutsceneOoT_CommandType::CS_CMD_TEXT:
+		return new CutsceneOoTCommand_Text(rawData, currentPtr);
+
+	case CutsceneOoT_CommandType::CS_CMD_TRANSITION:
+		return new CutsceneOoTCommand_Transition(rawData, currentPtr);
+
+	case CutsceneOoT_CommandType::CS_CMD_TIME:
+		return new CutsceneCommand_Time(rawData, currentPtr);
+
+	case CutsceneOoT_CommandType::CS_CMD_DESTINATION:
+		return new CutsceneOoTCommand_Destination(rawData, currentPtr);
+
+	case CutsceneOoT_CommandType::CS_CMD_CAM_EYE:
+	case CutsceneOoT_CommandType::CS_CMD_CAM_AT:
 		break;
-	case CutsceneCommands::Cmd09:
-		return new CutsceneCommand_Rumble(rawData, currentPtr);
-	case CutsceneCommands::Textbox:
-		return new CutsceneCommand_TextBox(rawData, currentPtr);
-
-	case CutsceneCommands::SetPlayerAction:
-	case CutsceneCommands::SetActorAction1:
-	case CutsceneCommands::SetActorAction2:
-	case CutsceneCommands::SetActorAction3:
-	case CutsceneCommands::SetActorAction4:
-	case CutsceneCommands::SetActorAction5:
-	case CutsceneCommands::SetActorAction6:
-	case CutsceneCommands::SetActorAction7:
-	case CutsceneCommands::SetActorAction8:
-	case CutsceneCommands::SetActorAction9:
-	case CutsceneCommands::SetActorAction10:
-		break;
-
-	case CutsceneCommands::SetSceneTransFX:
-		return new CutsceneCommandSceneTransFX(rawData, currentPtr);
 
-	case CutsceneCommands::SetTime:
-		return new CutsceneCommand_SetTime(rawData, currentPtr);
-	case CutsceneCommands::Terminator:
-		return new CutsceneCommand_Terminator(rawData, currentPtr);
+	default:
+		std::string errorHeader =
+			StringHelper::Sprintf("Warning: Invalid cutscene command ID: '0x%04X'", cmdID);
+		return new CutsceneOoTCommand_GenericCmd(rawData, currentPtr, cmdID);
 	}
 
 	return nullptr;
@@ -304,60 +276,74 @@ CutsceneCommand* ZCutscene::GetCommandOoT(uint32_t id, offset_t currentPtr) cons
 
 CutsceneCommand* ZCutscene::GetCommandMM(uint32_t id, offset_t currentPtr) const
 {
-	CutsceneMMCommands cmdID = static_cast<CutsceneMMCommands>(id);
+	CutsceneMM_CommandType cmdID = static_cast<CutsceneMM_CommandType>(id);
 
 	const auto& rawData = parent->GetRawData();
 
-	if (((id >= 100) && (id < 150)) || (id == 201) || ((id >= 450) && (id < 600)))
+	if (((id >= (uint32_t)CutsceneMM_CommandType::CS_CMD_ACTOR_CUE_100) &&
+	     (id <= (uint32_t)CutsceneMM_CommandType::CS_CMD_ACTOR_CUE_149)) ||
+	    (id == (uint32_t)CutsceneMM_CommandType::CS_CMD_ACTOR_CUE_201) ||
+	    ((id >= (uint32_t)CutsceneMM_CommandType::CS_CMD_ACTOR_CUE_450) &&
+	     (id <= (uint32_t)CutsceneMM_CommandType::CS_CMD_ACTOR_CUE_599)))
 	{
-		return new CutsceneCommand_ActorAction(rawData, currentPtr);
+		return new CutsceneMMCommand_ActorCue(rawData, currentPtr);
 	}
 
 	switch (cmdID)
 	{
-	case CutsceneMMCommands::CS_CMD_MISC:
-	case CutsceneMMCommands::CS_CMD_SET_LIGHTING:
-	case CutsceneMMCommands::CS_CMD_SCENE_TRANS_FX:
-	case CutsceneMMCommands::CS_CMD_MOTIONBLUR:
-	case CutsceneMMCommands::CS_CMD_GIVETATL:
-	case CutsceneMMCommands::CS_CMD_PLAYSEQ:
-	case CutsceneMMCommands::CS_CMD_130:
-	case CutsceneMMCommands::CS_CMD_131:
-	case CutsceneMMCommands::CS_CMD_132:
-	case CutsceneMMCommands::CS_CMD_STOPSEQ:
-	case CutsceneMMCommands::CS_CMD_PLAYAMBIENCE:
-	case CutsceneMMCommands::CS_CMD_FADEAMBIENCE:
-	case CutsceneMMCommands::CS_CMD_TERMINATOR:
-	case CutsceneMMCommands::CS_CMD_CHOOSE_CREDITS_SCENES:
-
-	case CutsceneMMCommands::CS_CMD_UNK_FA:
-	case CutsceneMMCommands::CS_CMD_UNK_FE:
-	case CutsceneMMCommands::CS_CMD_UNK_FF:
-	case CutsceneMMCommands::CS_CMD_UNK_100:
-	case CutsceneMMCommands::CS_CMD_UNK_101:
-	case CutsceneMMCommands::CS_CMD_UNK_102:
-	case CutsceneMMCommands::CS_CMD_UNK_103:
-	case CutsceneMMCommands::CS_CMD_UNK_104:
-	case CutsceneMMCommands::CS_CMD_UNK_105:
-	case CutsceneMMCommands::CS_CMD_UNK_108:
-	case CutsceneMMCommands::CS_CMD_UNK_109:
-	case CutsceneMMCommands::CS_CMD_UNK_12D:
+	case CutsceneMM_CommandType::CS_CMD_MISC:
+	case CutsceneMM_CommandType::CS_CMD_LIGHT_SETTING:
+	case CutsceneMM_CommandType::CS_CMD_TRANSITION:
+	case CutsceneMM_CommandType::CS_CMD_MOTION_BLUR:
+	case CutsceneMM_CommandType::CS_CMD_GIVE_TATL:
+	case CutsceneMM_CommandType::CS_CMD_START_SEQ:
+	case CutsceneMM_CommandType::CS_CMD_SFX_REVERB_INDEX_2:
+	case CutsceneMM_CommandType::CS_CMD_SFX_REVERB_INDEX_1:
+	case CutsceneMM_CommandType::CS_CMD_MODIFY_SEQ:
+	case CutsceneMM_CommandType::CS_CMD_STOP_SEQ:
+	case CutsceneMM_CommandType::CS_CMD_START_AMBIENCE:
+	case CutsceneMM_CommandType::CS_CMD_FADE_OUT_AMBIENCE:
+	case CutsceneMM_CommandType::CS_CMD_DESTINATION:
+	case CutsceneMM_CommandType::CS_CMD_CHOOSE_CREDITS_SCENES:
+
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_FA:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_FE:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_FF:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_100:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_101:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_102:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_103:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_104:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_105:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_108:
+	case CutsceneMM_CommandType::CS_CMD_UNK_DATA_109:
 		return new CutsceneMMCommand_GenericCmd(rawData, currentPtr, cmdID);
 
-	case CutsceneMMCommands::CS_CMD_TEXTBOX:
-		return new CutsceneCommand_TextBox(rawData, currentPtr);
-	case CutsceneMMCommands::CS_CMD_CAMERA:
+	case CutsceneMM_CommandType::CS_CMD_TEXT:
+		return new CutsceneMMCommand_Text(rawData, currentPtr);
+
+	case CutsceneMM_CommandType::CS_CMD_CAMERA_SPLINE:
 		return new CutsceneMMCommand_Camera(rawData, currentPtr);
-	case CutsceneMMCommands::CS_CMD_FADESCREEN:
-		return new CutsceneMMCommand_FadeScreen(rawData, currentPtr);
-	case CutsceneMMCommands::CS_CMD_FADESEQ:
-		return new CutsceneMMCommand_FadeSeq(rawData, currentPtr);
-	case CutsceneMMCommands::CS_CMD_SETTIME:
-		return new CutsceneCommand_SetTime(rawData, currentPtr);
-	case CutsceneMMCommands::CS_CMD_SET_PLAYER_ACTION:
-		return new CutsceneCommand_ActorAction(rawData, currentPtr);
-	case CutsceneMMCommands::CS_CMD_RUMBLE:
-		return new CutsceneCommand_Rumble(rawData, currentPtr);
+
+	case CutsceneMM_CommandType::CS_CMD_TRANSITION_GENERAL:
+		return new CutsceneMMCommand_TransitionGeneral(rawData, currentPtr);
+
+	case CutsceneMM_CommandType::CS_CMD_FADE_OUT_SEQ:
+		return new CutsceneMMCommand_FadeOutSeq(rawData, currentPtr);
+
+	case CutsceneMM_CommandType::CS_CMD_TIME:
+		return new CutsceneCommand_Time(rawData, currentPtr);
+
+	case CutsceneMM_CommandType::CS_CMD_PLAYER_CUE:
+		return new CutsceneMMCommand_ActorCue(rawData, currentPtr);
+
+	case CutsceneMM_CommandType::CS_CMD_RUMBLE:
+		return new CutsceneMMCommand_Rumble(rawData, currentPtr);
+
+	default:
+		std::string errorHeader =
+			StringHelper::Sprintf("Warning: Invalid cutscene command ID: '0x%04X'", cmdID);
+		return new CutsceneMMCommand_GenericCmd(rawData, currentPtr, cmdID);
 	}
 
 	return nullptr;
diff --git a/ZAPD/ZCutscene.h b/ZAPD/ZCutscene.h
index 098f3ad..5b54426 100644
--- a/ZAPD/ZCutscene.h
+++ b/ZAPD/ZCutscene.h
@@ -5,7 +5,8 @@
 #include <vector>
 #include "tinyxml2.h"
 
-#include "OtherStructs/Cutscene_Commands.h"
+#include "OtherStructs/CutsceneOoT_Commands.h"
+#include "OtherStructs/CutsceneMM_Commands.h"
 #include "ZFile.h"
 #include "ZResource.h"
 
diff --git a/ZAPD/ZRoom/Commands/SetActorCutsceneList.cpp b/ZAPD/ZRoom/Commands/SetCutsceneEntryList.cpp
index 15f2c6b..e747d91 100644
--- a/ZAPD/ZRoom/Commands/SetActorCutsceneList.cpp
+++ b/ZAPD/ZRoom/Commands/SetCutsceneEntryList.cpp
@@ -1,4 +1,4 @@
-#include "SetActorCutsceneList.h"
+#include "SetCutsceneEntryList.h"
 
 #include "Globals.h"
 #include "Utils/BitConverter.h"
@@ -19,7 +19,7 @@ void SetActorCutsceneList::ParseRawData()
 	cutscenes.reserve(numCutscenes);
 	for (int32_t i = 0; i < numCutscenes; i++)
 	{
-		ActorCutsceneEntry entry(parent->GetRawData(), currentPtr);
+		CutsceneEntry entry(parent->GetRawData(), currentPtr);
 		cutscenes.push_back(entry);
 
 		currentPtr += 16;
@@ -55,7 +55,7 @@ void SetActorCutsceneList::DeclareReferences(const std::string& prefix)
 std::string SetActorCutsceneList::GetBodySourceCode() const
 {
 	std::string listName;
-	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "ActorCutscene", listName);
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneEntry", listName);
 	return StringHelper::Sprintf("SCENE_CMD_ACTOR_CUTSCENE_LIST(%i, %s)", cutscenes.size(),
 	                             listName.c_str());
 }
@@ -70,25 +70,34 @@ RoomCommand SetActorCutsceneList::GetRoomCommand() const
 	return RoomCommand::SetActorCutsceneList;
 }
 
-ActorCutsceneEntry::ActorCutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+CutsceneEntry::CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
 	: priority(BitConverter::ToInt16BE(rawData, rawDataIndex + 0)),
 	  length(BitConverter::ToInt16BE(rawData, rawDataIndex + 2)),
-	  unk4(BitConverter::ToInt16BE(rawData, rawDataIndex + 4)),
-	  unk6(BitConverter::ToInt16BE(rawData, rawDataIndex + 6)),
-	  additionalCutscene(BitConverter::ToInt16BE(rawData, rawDataIndex + 8)),
-	  sound(rawData[rawDataIndex + 0xA]), unkB(rawData[rawDataIndex + 0xB]),
-	  unkC(BitConverter::ToInt16BE(rawData, rawDataIndex + 0xC)), unkE(rawData[rawDataIndex + 0xE]),
-	  letterboxSize(rawData[rawDataIndex + 0xF])
+	  csCamId(BitConverter::ToInt16BE(rawData, rawDataIndex + 4)),
+	  scriptIndex(BitConverter::ToInt16BE(rawData, rawDataIndex + 6)),
+	  additionalCsId(BitConverter::ToInt16BE(rawData, rawDataIndex + 8)),
+	  endSfx(rawData[rawDataIndex + 0xA]), customValue(rawData[rawDataIndex + 0xB]),
+	  hudVisibility(BitConverter::ToInt16BE(rawData, rawDataIndex + 0xC)),
+	  endCam(rawData[rawDataIndex + 0xE]), letterboxSize(rawData[rawDataIndex + 0xF])
 {
 }
 
-std::string ActorCutsceneEntry::GetBodySourceCode() const
+std::string CutsceneEntry::GetBodySourceCode() const
 {
-	return StringHelper::Sprintf("%i, %i, %i, %i, %i, %i, %i, %i, %i, %i", priority, length, unk4,
-	                             unk6, additionalCutscene, sound, unkB, unkC, unkE, letterboxSize);
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
+
+	if (cutsceneData->endSfx.find(endSfx) != cutsceneData->endSfx.end())
+		return StringHelper::Sprintf("%i, %i, %i, %i, %i, %s, %i, %i, %i, %i", priority, length,
+		                             csCamId, scriptIndex, additionalCsId,
+		                             cutsceneData->endSfx[endSfx].c_str(), customValue,
+		                             hudVisibility, endCam, letterboxSize);
+	else
+		return StringHelper::Sprintf("%i, %i, %i, %i, %i, %i, %i, %i, %i, %i", priority, length,
+		                             csCamId, scriptIndex, additionalCsId, endSfx, customValue,
+		                             hudVisibility, endCam, letterboxSize);
 }
 
-std::string ActorCutsceneEntry::GetSourceTypeName() const
+std::string CutsceneEntry::GetSourceTypeName() const
 {
-	return "ActorCutscene";
+	return "CutsceneEntry";
 }
diff --git a/ZAPD/ZRoom/Commands/SetActorCutsceneList.h b/ZAPD/ZRoom/Commands/SetCutsceneEntryList.h
index 8fd48e4..6ba6c23 100644
--- a/ZAPD/ZRoom/Commands/SetActorCutsceneList.h
+++ b/ZAPD/ZRoom/Commands/SetCutsceneEntryList.h
@@ -2,22 +2,22 @@
 
 #include "ZRoom/ZRoomCommand.h"
 
-class ActorCutsceneEntry
+class CutsceneEntry
 {
 protected:
 	int16_t priority;
 	int16_t length;
-	int16_t unk4;
-	int16_t unk6;
-	int16_t additionalCutscene;
-	uint8_t sound;
-	uint8_t unkB;
-	int16_t unkC;
-	uint8_t unkE;
+	int16_t csCamId;
+	int16_t scriptIndex;
+	int16_t additionalCsId;
+	uint8_t endSfx;
+	uint8_t customValue;
+	int16_t hudVisibility;
+	uint8_t endCam;
 	uint8_t letterboxSize;
 
 public:
-	ActorCutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+	CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
 
 	std::string GetBodySourceCode() const;
 	std::string GetSourceTypeName() const;
@@ -26,7 +26,7 @@ public:
 class SetActorCutsceneList : public ZRoomCommand
 {
 public:
-	std::vector<ActorCutsceneEntry> cutscenes;
+	std::vector<CutsceneEntry> cutscenes;
 
 	SetActorCutsceneList(ZFile* nParent);
 
diff --git a/ZAPD/ZRoom/Commands/SetCutscenes.cpp b/ZAPD/ZRoom/Commands/SetCutscenes.cpp
index 51df68c..b3bde73 100644
--- a/ZAPD/ZRoom/Commands/SetCutscenes.cpp
+++ b/ZAPD/ZRoom/Commands/SetCutscenes.cpp
@@ -23,7 +23,7 @@ void SetCutscenes::ParseRawData()
 		cutsceneEntries.reserve(numCutscenes);
 		for (uint8_t i = 0; i < numCutscenes; i++)
 		{
-			CutsceneEntry entry(parent->GetRawData(), currentPtr);
+			CutsceneScriptEntry entry(parent->GetRawData(), currentPtr);
 			cutsceneEntries.push_back(entry);
 			currentPtr += 8;
 		}
@@ -32,6 +32,7 @@ void SetCutscenes::ParseRawData()
 
 void SetCutscenes::DeclareReferences(const std::string& prefix)
 {
+	CutsceneEnumData* cutsceneData = &Globals::Instance->cfg.cutsceneData;
 	std::string varPrefix = name;
 	if (varPrefix == "")
 		varPrefix = prefix;
@@ -62,10 +63,14 @@ void SetCutscenes::DeclareReferences(const std::string& prefix)
 			Globals::Instance->GetSegmentedPtrName(entry.segmentPtr, parent, "CutsceneData",
 			                                       csName);
 
-			declaration +=
-				StringHelper::Sprintf("    { %s, 0x%04X, 0x%02X, 0x%02X },", csName.c_str(),
-			                          entry.exit, entry.entrance, entry.flag);
-
+			if (cutsceneData->spawnFlag.find(entry.flag) != cutsceneData->spawnFlag.end())
+				declaration += StringHelper::Sprintf("    { %s, 0x%04X, 0x%02X, %s },",
+				                                     csName.c_str(), entry.exit, entry.entrance,
+				                                     cutsceneData->spawnFlag[entry.flag].c_str());
+			else
+				declaration +=
+					StringHelper::Sprintf("    { %s, 0x%04X, 0x%02X, 0x%02X },", csName.c_str(),
+				                          entry.exit, entry.entrance, entry.flag);
 			if (i + 1 < numCutscenes)
 				declaration += "\n";
 
@@ -73,8 +78,8 @@ void SetCutscenes::DeclareReferences(const std::string& prefix)
 		}
 
 		parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::Align4,
-		                            cutsceneEntries.size() * 8, "CutsceneEntry",
-		                            StringHelper::Sprintf("%sCutsceneEntryList_%06X",
+		                            cutsceneEntries.size() * 8, "CutsceneScriptEntry",
+		                            StringHelper::Sprintf("%sCutsceneScriptEntryList_%06X",
 		                                                  zRoom->GetName().c_str(), segmentOffset),
 		                            cutsceneEntries.size(), declaration);
 	}
@@ -102,7 +107,7 @@ std::string SetCutscenes::GetBodySourceCode() const
 
 	if (Globals::Instance->game == ZGame::MM_RETAIL)
 	{
-		Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneEntry", listName);
+		Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneScriptEntry", listName);
 		return StringHelper::Sprintf("SCENE_CMD_CUTSCENE_LIST(%i, %s)", numCutscenes,
 		                             listName.c_str());
 	}
@@ -121,7 +126,7 @@ RoomCommand SetCutscenes::GetRoomCommand() const
 	return RoomCommand::SetCutscenes;
 }
 
-CutsceneEntry::CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
+CutsceneScriptEntry::CutsceneScriptEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
 	: segmentPtr(BitConverter::ToInt32BE(rawData, rawDataIndex + 0)),
 	  exit(BitConverter::ToInt16BE(rawData, rawDataIndex + 4)), entrance(rawData[rawDataIndex + 6]),
 	  flag(rawData[rawDataIndex + 7])
diff --git a/ZAPD/ZRoom/Commands/SetCutscenes.h b/ZAPD/ZRoom/Commands/SetCutscenes.h
index 81a622c..e6d979d 100644
--- a/ZAPD/ZRoom/Commands/SetCutscenes.h
+++ b/ZAPD/ZRoom/Commands/SetCutscenes.h
@@ -3,10 +3,10 @@
 #include "ZCutscene.h"
 #include "ZRoom/ZRoomCommand.h"
 
-class CutsceneEntry
+class CutsceneScriptEntry
 {
 public:
-	CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
+	CutsceneScriptEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
 
 	segptr_t segmentPtr;
 	uint16_t exit;
@@ -17,8 +17,8 @@ public:
 class SetCutscenes : public ZRoomCommand
 {
 public:
-	std::vector<CutsceneEntry> cutsceneEntries;  // (MM Only)
-	uint8_t numCutscenes;                        // (MM Only)
+	std::vector<CutsceneScriptEntry> cutsceneEntries;  // (MM Only)
+	uint8_t numCutscenes;                              // (MM Only)
 
 	SetCutscenes(ZFile* nParent);
 
diff --git a/ZAPD/ZRoom/ZRoom.cpp b/ZAPD/ZRoom/ZRoom.cpp
index a28ea7b..f38c4d4 100644
--- a/ZAPD/ZRoom/ZRoom.cpp
+++ b/ZAPD/ZRoom/ZRoom.cpp
@@ -6,7 +6,7 @@
 #include <string_view>
 
 #include "Commands/EndMarker.h"
-#include "Commands/SetActorCutsceneList.h"
+#include "Commands/SetCutsceneEntryList.h"
 #include "Commands/SetActorList.h"
 #include "Commands/SetAlternateHeaders.h"
 #include "Commands/SetAnimatedMaterialList.h"
diff --git a/ZAPDUtils/Utils/Directory.h b/ZAPDUtils/Utils/Directory.h
index 2e78262..d150f17 100644
--- a/ZAPDUtils/Utils/Directory.h
+++ b/ZAPDUtils/Utils/Directory.h
@@ -21,12 +21,21 @@ class Directory
 {
 public:
 #ifdef USE_BOOST_FS
-	static std::string GetCurrentDirectory() { return fs::current_path().string(); }
+	static std::string GetCurrentDirectory()
+	{
+		return fs::current_path().string();
+	}
 #else
-	static std::string GetCurrentDirectory() { return fs::current_path().u8string(); }
+	static std::string GetCurrentDirectory()
+	{
+		return fs::current_path().u8string();
+	}
 #endif
 
-	static bool Exists(const fs::path& path) { return fs::exists(path); }
+	static bool Exists(const fs::path& path)
+	{
+		return fs::exists(path);
+	}
 
 	static void CreateDirectory(const std::string& path)
 	{