ZAPD update: Cutscene extraction (#770)

* git subrepo pull --force tools/ZAPD

subrepo:
  subdir:   "tools/ZAPD"
  merged:   "89a0b2628"
upstream:
  origin:   "https://github.com/zeldaret/ZAPD.git"
  branch:   "master"
  commit:   "89a0b2628"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"

* git subrepo pull --force tools/ZAPD

subrepo:
  subdir:   "tools/ZAPD"
  merged:   "efae567d3"
upstream:
  origin:   "https://github.com/zeldaret/ZAPD.git"
  branch:   "master"
  commit:   "efae567d3"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo.git"
  commit:   "2f68596"

16 files changed, 1463 insertions, 1600 deletions

diff --git a/tools/ZAPD/.gitrepo b/tools/ZAPD/.gitrepo
index 475415d99..5d67a3762 100644
--- a/tools/ZAPD/.gitrepo
+++ b/tools/ZAPD/.gitrepo
@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/zeldaret/ZAPD.git
 	branch = master
-	commit = 119a6883e6f795815744b9afd6a79084c619ddb6
-	parent = 66a66f61b6368af0ed711803c54a963494329217
+	commit = efae567d3917afa341bd843ba185b3bd66d57429
+	parent = 22c6551083172f5c506aecf8c31ad761afbbd658
 	method = merge
 	cmdver = 0.4.3
diff --git a/tools/ZAPD/ZAPD/OtherStructs/CutsceneMM_Commands.cpp b/tools/ZAPD/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
new file mode 100644
index 000000000..b69f47321
--- /dev/null
+++ b/tools/ZAPD/ZAPD/OtherStructs/CutsceneMM_Commands.cpp
@@ -0,0 +1,208 @@
+#include "CutsceneMM_Commands.h"
+
+#include <cassert>
+#include <unordered_map>
+
+#include "Utils/BitConverter.h"
+#include "Utils/StringHelper.h"
+
+// 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)"}},
+};
+
+CutsceneSubCommandEntry_GenericMMCmd::CutsceneSubCommandEntry_GenericMMCmd(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex, CutsceneMMCommands cmdId)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex), commandId(cmdId)
+{
+}
+
+std::string CutsceneSubCommandEntry_GenericMMCmd::GetBodySourceCode() const
+{
+	const auto& element = csCommandsDescMM.find(commandId);
+	std::string entryFmt = "CS_UNK_DATA(0x%02X, %i, %i, %i)";
+
+	if (element != csCommandsDescMM.end())
+	{
+		entryFmt = element->second.cmdMacro;
+		entryFmt += element->second.args;
+	}
+
+	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)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	commandID = static_cast<uint32_t>(cmdId);
+
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneSubCommandEntry_GenericMMCmd(rawData, rawDataIndex, cmdId);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneMMCommand_GenericCmd::GetCommandMacro() const
+{
+	const auto& element = csCommandsDescMM.find(static_cast<CutsceneMMCommands>(commandID));
+
+	if (element != csCommandsDescMM.end())
+	{
+		return StringHelper::Sprintf("%s_LIST(%i)", element->second.cmdMacro, numEntries);
+	}
+
+	return StringHelper::Sprintf("CS_UNK_DATA_LIST(0x%X, %i)", commandID, numEntries);
+}
+
+CutsceneSubCommandEntry_Camera::CutsceneSubCommandEntry_Camera(const std::vector<uint8_t>& rawData,
+                                                               offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+}
+
+std::string CutsceneSubCommandEntry_Camera::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("CMD_HH(0x%04X, 0x%04X)", base, startFrame);
+}
+
+size_t CutsceneSubCommandEntry_Camera::GetRawSize() const
+{
+	return 0x04;
+}
+
+CutsceneMMCommand_Camera::CutsceneMMCommand_Camera(const std::vector<uint8_t>& rawData,
+                                                   offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	for (size_t i = 0; i < numEntries / 4; i++)
+	{
+		auto* entry = new CutsceneSubCommandEntry_Camera(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneMMCommand_Camera::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_CAMERA_LIST(%i)", numEntries);
+}
+
+CutsceneSubCommandEntry_FadeScreen::CutsceneSubCommandEntry_FadeScreen(
+	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_FadeScreen::GetBodySourceCode() const
+{
+	return StringHelper::Sprintf("CS_FADESCREEN(0x%02X, %i, %i, %i, %i, %i)", base, startFrame,
+	                             endFrame, unk_06, unk_07, unk_08);
+}
+
+size_t CutsceneSubCommandEntry_FadeScreen::GetRawSize() const
+{
+	return 0x0C;
+}
+
+CutsceneMMCommand_FadeScreen::CutsceneMMCommand_FadeScreen(const std::vector<uint8_t>& rawData,
+                                                           offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneSubCommandEntry_FadeScreen(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneMMCommand_FadeScreen::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_FADESCREEN_LIST(%i)", numEntries);
+}
+
+CutsceneSubCommandEntry_FadeSeq::CutsceneSubCommandEntry_FadeSeq(
+	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
+{
+	return StringHelper::Sprintf("CS_FADESEQ(%i, %i, %i)", base, startFrame, endFrame);
+}
+
+size_t CutsceneSubCommandEntry_FadeSeq::GetRawSize() const
+{
+	return 0x0C;
+}
+
+CutsceneMMCommand_FadeSeq::CutsceneMMCommand_FadeSeq(const std::vector<uint8_t>& rawData,
+                                                     offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneSubCommandEntry_FadeSeq(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
+
+std::string CutsceneMMCommand_FadeSeq::GetCommandMacro() const
+{
+	return StringHelper::Sprintf("CS_FADESEQ_LIST(%i)", numEntries);
+}
+
+CutsceneSubCommandEntry_NonImplemented::CutsceneSubCommandEntry_NonImplemented(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneSubCommandEntry(rawData, rawDataIndex)
+{
+}
+
+CutsceneMMCommand_NonImplemented::CutsceneMMCommand_NonImplemented(
+	const std::vector<uint8_t>& rawData, offset_t rawDataIndex)
+	: CutsceneCommand(rawData, rawDataIndex)
+{
+	rawDataIndex += 4;
+
+	for (size_t i = 0; i < numEntries; i++)
+	{
+		auto* entry = new CutsceneSubCommandEntry_NonImplemented(rawData, rawDataIndex);
+		entries.push_back(entry);
+		rawDataIndex += entry->GetRawSize();
+	}
+}
diff --git a/tools/ZAPD/ZAPD/OtherStructs/CutsceneMM_Commands.h b/tools/ZAPD/ZAPD/OtherStructs/CutsceneMM_Commands.h
new file mode 100644
index 000000000..c8ae4eb60
--- /dev/null
+++ b/tools/ZAPD/ZAPD/OtherStructs/CutsceneMM_Commands.h
@@ -0,0 +1,140 @@
+#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,
+	/* 0x15F */ CS_CMD_CHOOSE_CREDITS_SCENES,
+	/* 0x190 */ CS_CMD_RUMBLE = 0x190,
+};
+
+class CutsceneSubCommandEntry_GenericMMCmd : public CutsceneSubCommandEntry
+{
+public:
+	CutsceneMMCommands commandId;
+
+	CutsceneSubCommandEntry_GenericMMCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
+	                                     CutsceneMMCommands cmdId);
+
+	std::string GetBodySourceCode() const override;
+};
+
+class CutsceneMMCommand_GenericCmd : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_GenericCmd(const std::vector<uint8_t>& rawData, offset_t rawDataIndex,
+	                             CutsceneMMCommands cmdId);
+
+	std::string GetCommandMacro() const override;
+};
+
+// TODO: MM cutscene camera command is implemented as a placeholder until we better understand how
+// it works
+class CutsceneSubCommandEntry_Camera : public CutsceneSubCommandEntry
+{
+public:
+	uint32_t unk_08;
+
+	CutsceneSubCommandEntry_Camera(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneMMCommand_Camera : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_Camera(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+class CutsceneSubCommandEntry_FadeScreen : 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_FadeScreen(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneMMCommand_FadeScreen : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_FadeScreen(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+class CutsceneSubCommandEntry_FadeSeq : public CutsceneSubCommandEntry
+{
+public:
+	uint32_t unk_08;
+
+	CutsceneSubCommandEntry_FadeSeq(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetBodySourceCode() const override;
+
+	size_t GetRawSize() const override;
+};
+
+class CutsceneMMCommand_FadeSeq : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_FadeSeq(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+
+	std::string GetCommandMacro() const override;
+};
+
+class CutsceneSubCommandEntry_NonImplemented : public CutsceneSubCommandEntry
+{
+public:
+	CutsceneSubCommandEntry_NonImplemented(const std::vector<uint8_t>& rawData,
+	                                       offset_t rawDataIndex);
+};
+
+class CutsceneMMCommand_NonImplemented : public CutsceneCommand
+{
+public:
+	CutsceneMMCommand_NonImplemented(const std::vector<uint8_t>& rawData, offset_t rawDataIndex);
+};
diff --git a/tools/ZAPD/ZAPD/OtherStructs/Cutscene_Commands.cpp b/tools/ZAPD/ZAPD/OtherStructs/Cutscene_Commands.cpp
new file mode 100644
index 000000000..a716176b9
--- /dev/null
+++ b/tools/ZAPD/ZAPD/OtherStructs/Cutscene_Commands.cpp
@@ -0,0 +1,591 @@
+#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);
+
+	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;
+
+	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;
+
+	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;
+
+	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;
+
+	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/tools/ZAPD/ZAPD/OtherStructs/Cutscene_Commands.h b/tools/ZAPD/ZAPD/OtherStructs/Cutscene_Commands.h
new file mode 100644
index 000000000..c46273587
--- /dev/null
+++ b/tools/ZAPD/ZAPD/OtherStructs/Cutscene_Commands.h
@@ -0,0 +1,267 @@
+#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/tools/ZAPD/ZAPD/ZCutscene.cpp b/tools/ZAPD/ZAPD/ZCutscene.cpp
index 71bb690c7..62f814b13 100644
--- a/tools/ZAPD/ZAPD/ZCutscene.cpp
+++ b/tools/ZAPD/ZAPD/ZCutscene.cpp
@@ -1,5 +1,9 @@
 #include "ZCutscene.h"
 
+#include <cassert>
+
+#include "Globals.h"
+#include "OtherStructs/CutsceneMM_Commands.h"
 #include "Utils/BitConverter.h"
 #include "Utils/StringHelper.h"
 #include "WarningHandler.h"
@@ -7,7 +11,7 @@
 
 REGISTER_ZFILENODE(Cutscene, ZCutscene);
 
-ZCutscene::ZCutscene(ZFile* nParent) : ZCutsceneBase(nParent)
+ZCutscene::ZCutscene(ZFile* nParent) : ZResource(nParent)
 {
 }
 
@@ -16,91 +20,20 @@ ZCutscene::~ZCutscene()
 	for (CutsceneCommand* cmd : commands)
 		delete cmd;
 }
-CutsceneCommandSetCameraPos::~CutsceneCommandSetCameraPos()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandSpecialAction::~CutsceneCommandSpecialAction()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandFadeBGM::~CutsceneCommandFadeBGM()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandPlayBGM::~CutsceneCommandPlayBGM()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandStopBGM::~CutsceneCommandStopBGM()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandEnvLighting::~CutsceneCommandEnvLighting()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandUnknown9::~CutsceneCommandUnknown9()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandUnknown::~CutsceneCommandUnknown()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandDayTime::~CutsceneCommandDayTime()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandTextbox::~CutsceneCommandTextbox()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandActorAction::~CutsceneCommandActorAction()
-{
-	for (auto e : entries)
-		delete e;
-}
-
-CutsceneCommandSceneTransFX::~CutsceneCommandSceneTransFX()
-{
-}
 
 std::string ZCutscene::GetBodySourceCode() const
 {
 	std::string output = "";
-	uint32_t curPtr = 0;
 
 	output += StringHelper::Sprintf("    CS_BEGIN_CUTSCENE(%i, %i),\n", commands.size(), endFrame);
 
 	for (size_t i = 0; i < commands.size(); i++)
 	{
 		CutsceneCommand* cmd = commands[i];
-		output += "    " + cmd->GenerateSourceCode(curPtr);
-		curPtr += cmd->GetCommandSize();
+		output += "    " + cmd->GenerateSourceCode();
 	}
 
-	output += StringHelper::Sprintf("    CS_END(),\n", commands.size(), endFrame);
+	output += StringHelper::Sprintf("    CS_END(),", commands.size(), endFrame);
 
 	return output;
 }
@@ -115,12 +48,19 @@ size_t ZCutscene::GetRawDataSize() const
 	for (size_t i = 0; i < commands.size(); i++)
 	{
 		CutsceneCommand* cmd = commands[i];
+
 		size += cmd->GetCommandSize();
-		size += 4;
 	}
 
 	// End
-	size += 8;
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		size += 4;
+	}
+	else
+	{
+		size += 8;
+	}
 
 	return size;
 }
@@ -135,153 +75,68 @@ void ZCutscene::ParseRawData()
 	commands = std::vector<CutsceneCommand*>();
 
 	endFrame = BitConverter::ToInt32BE(rawData, rawDataIndex + 4);
-	uint32_t currentPtr = rawDataIndex + 8;
+	offset_t currentPtr = rawDataIndex + 8;
 
 	for (int32_t i = 0; i < numCommands; i++)
 	{
-		int32_t id = BitConverter::ToInt32BE(rawData, currentPtr);
+		uint32_t id = BitConverter::ToUInt32BE(rawData, currentPtr);
 
-		if (id == -1)
+		if (id == 0xFFFFFFFF)
 			break;
 
-		CutsceneCommands cmdID = (CutsceneCommands)GetCommandFromID(id);
+		if (Globals::Instance->verbosity >= VerbosityLevel::VERBOSITY_DEBUG)
+		{
+			printf("Cutscene Command: 0x%X (%i)\n", id, id);
+		}
+
 		currentPtr += 4;
 
-		int32_t numEntries = 1;
+		CutsceneCommand* cmd = nullptr;
 
-		for (int32_t j = 0; j < numEntries; j++)
+		if (Globals::Instance->game == ZGame::MM_RETAIL)
+		{
+			cmd = GetCommandMM(id, currentPtr);
+		}
+		else
 		{
-			CutsceneCommand* cmd = nullptr;
+			cmd = GetCommandOoT(id, currentPtr);
+		}
 
-			switch (cmdID)
-			{
-			case CutsceneCommands::Cmd00:
-				break;
-			case CutsceneCommands::SetCameraPos:
-				cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SetCameraFocus:
-				cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SpecialAction:
-				cmd = new CutsceneCommandSpecialAction(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SetLighting:
-				cmd = new CutsceneCommandEnvLighting(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SetCameraPosLink:
-				cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SetCameraFocusLink:
-				cmd = new CutsceneCommandSetCameraPos(rawData, currentPtr);
-				break;
-			case CutsceneCommands::Cmd07:
-				break;
-			case CutsceneCommands::Cmd08:
-				break;
-			case CutsceneCommands::Cmd09:
-				cmd = new CutsceneCommandUnknown9(rawData, currentPtr);
-				break;
-			case CutsceneCommands::Textbox:
-				cmd = new CutsceneCommandTextbox(rawData, currentPtr);
-				break;
-			case CutsceneCommands::Unknown:
-				cmd = new CutsceneCommandUnknown(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SetActorAction0:
-			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:
-				cmd = new CutsceneCommandActorAction(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SetSceneTransFX:
-				cmd = new CutsceneCommandSceneTransFX(rawData, currentPtr);
-				break;
-			case CutsceneCommands::Nop:
-				cmd = new CutsceneCommandNop(rawData, currentPtr);
-				break;
-			case CutsceneCommands::PlayBGM:
-				cmd = new CutsceneCommandPlayBGM(rawData, currentPtr);
-				break;
-			case CutsceneCommands::StopBGM:
-				cmd = new CutsceneCommandStopBGM(rawData, currentPtr);
-				break;
-			case CutsceneCommands::FadeBGM:
-				cmd = new CutsceneCommandFadeBGM(rawData, currentPtr);
-				break;
-			case CutsceneCommands::SetTime:
-				cmd = new CutsceneCommandDayTime(rawData, currentPtr);
-				break;
-			case CutsceneCommands::Terminator:
-				cmd = new CutsceneCommandTerminator(rawData, currentPtr);
-				break;
-			case CutsceneCommands::End:
-				cmd = new CutsceneCommandEnd(rawData, currentPtr);
-				break;
-			case CutsceneCommands::Error:
-				HANDLE_WARNING_RESOURCE(WarningType::NotImplemented, parent, this, rawDataIndex,
-				                        StringHelper::Sprintf("cutscene command error %d", cmdID),
-				                        "");
-				break;
-			}
+		if (cmd == nullptr)
+		{
+			HANDLE_WARNING_RESOURCE(
+				WarningType::NotImplemented, parent, this, rawDataIndex,
+				StringHelper::Sprintf("Cutscene command not implemented"),
+				StringHelper::Sprintf("Command ID: 0x%X\nIndex: %d\ncurrentPtr-rawDataIndex: 0x%X",
+			                          id, i, currentPtr - rawDataIndex));
+			cmd = new CutsceneMMCommand_NonImplemented(rawData, currentPtr);
+		}
 
-			cmd->commandIndex = i;
-			cmd->commandID = (uint32_t)id;
-			currentPtr += (uint32_t)cmd->GetCommandSize();
+		assert(cmd != nullptr);
 
-			commands.push_back(cmd);
+		cmd->commandIndex = i;
+		cmd->SetCommandID(id);
+		size_t commmandSize = cmd->GetCommandSize();
+		if (Globals::Instance->verbosity >= VerbosityLevel::VERBOSITY_DEBUG)
+		{
+			printf("\t Command size: 0x%zX (%zu)\n", commmandSize, commmandSize);
 		}
+		currentPtr += commmandSize - 4;
+
+		commands.push_back(cmd);
 	}
 }
 
-CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
+CutsceneCommand* ZCutscene::GetCommandOoT(uint32_t id, offset_t currentPtr) const
 {
+	CutsceneCommands cmdID = static_cast<CutsceneCommands>(id);
+
+	const auto& rawData = parent->GetRawData();
+
 	switch (id)
 	{
-	case 0x0003:
-		return CutsceneCommands::SpecialAction;
-	case 0x0004:
-		return CutsceneCommands::SetLighting;
-	case 0x0056:
-		return CutsceneCommands::PlayBGM;
-	case 0x0057:
-		return CutsceneCommands::StopBGM;
-	case 0x007C:
-		return CutsceneCommands::FadeBGM;
-	case 0x0009:
-		return CutsceneCommands::Cmd09;
-	case 0x0013:
-		return CutsceneCommands::Textbox;
-	case 0x008C:
-		return CutsceneCommands::SetTime;
-	case 0x0001:
-		return CutsceneCommands::SetCameraPos;
-	case 0x0002:
-		return CutsceneCommands::SetCameraFocus;
-	case 0x0005:
-		return CutsceneCommands::SetCameraPosLink;
-	case 0x0006:
-		return CutsceneCommands::SetCameraFocusLink;
-	case 0x0007:
-		return CutsceneCommands::Cmd07;
-	case 0x0008:
-		return CutsceneCommands::Cmd08;
-	case 0x03E8:
-		return CutsceneCommands::Terminator;
-	case 0xFFFF:
-		return CutsceneCommands::End;
-	case 0x002D:
-		return CutsceneCommands::SetSceneTransFX;
-	case 10:
-		return CutsceneCommands::SetActorAction0;
-	case 15:
+	case 10:  // CutsceneCommands::SetPlayerAction
+	case 15:  // CutsceneCommands::SetActorAction1
 	case 17:
 	case 18:
 	case 23:
@@ -299,8 +154,7 @@ CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
 	case 138:
 	case 139:
 	case 144:
-		return CutsceneCommands::SetActorAction1;
-	case 14:
+	case 14:  // CutsceneCommands::SetActorAction2
 	case 16:
 	case 24:
 	case 35:
@@ -318,8 +172,7 @@ CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
 	case 125:
 	case 131:
 	case 141:
-		return CutsceneCommands::SetActorAction2;
-	case 25:
+	case 25:  // CutsceneCommands::SetActorAction3
 	case 36:
 	case 41:
 	case 50:
@@ -332,8 +185,7 @@ CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
 	case 121:
 	case 126:
 	case 132:
-		return CutsceneCommands::SetActorAction3;
-	case 29:
+	case 29:  // CutsceneCommands::SetActorAction4
 	case 37:
 	case 42:
 	case 51:
@@ -346,8 +198,7 @@ CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
 	case 108:
 	case 127:
 	case 133:
-		return CutsceneCommands::SetActorAction4;
-	case 30:
+	case 30:  // CutsceneCommands::SetActorAction5
 	case 38:
 	case 43:
 	case 47:
@@ -356,16 +207,14 @@ CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
 	case 83:
 	case 128:
 	case 135:
-		return CutsceneCommands::SetActorAction5;
-	case 44:
+	case 44:  // CutsceneCommands::SetActorAction6
 	case 55:
 	case 77:
 	case 84:
 	case 90:
 	case 129:
 	case 136:
-		return CutsceneCommands::SetActorAction6;
-	case 31:
+	case 31:  // CutsceneCommands::SetActorAction7
 	case 52:
 	case 57:
 	case 58:
@@ -373,19 +222,17 @@ CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
 	case 115:
 	case 130:
 	case 137:
-		return CutsceneCommands::SetActorAction7;
-	case 49:
+	case 49:  // CutsceneCommands::SetActorAction8
 	case 60:
 	case 89:
 	case 111:
 	case 114:
 	case 134:
 	case 142:
-		return CutsceneCommands::SetActorAction8;
-	case 62:
-		return CutsceneCommands::SetActorAction9;
-	case 143:
-		return CutsceneCommands::SetActorAction10;
+	case 62:   // CutsceneCommands::SetActorAction9
+	case 143:  // CutsceneCommands::SetActorAction10
+		return new CutsceneCommand_ActorAction(rawData, currentPtr);
+
 	case 0x0B:
 	case 0x0D:
 	case 0x1A:
@@ -403,835 +250,120 @@ CutsceneCommands ZCutscene::GetCommandFromID(int32_t id)
 	case 0x70:
 	case 0x71:
 	case 0x4A:
-		return CutsceneCommands::Unknown;
-	}
-
-	HANDLE_WARNING_RESOURCE(
-		WarningType::NotImplemented, parent, this, rawDataIndex,
-		StringHelper::Sprintf("could not identify cutscene command. ID 0x%04X", id), "");
-
-	return CutsceneCommands::Error;
-}
-
-ZResourceType ZCutscene::GetResourceType() const
-{
-	return ZResourceType::Cutscene;
-}
-
-CutsceneCommand::CutsceneCommand([[maybe_unused]] const std::vector<uint8_t>& rawData,
-                                 [[maybe_unused]] uint32_t rawDataIndex)
-{
-}
-
-CutsceneCommand::~CutsceneCommand()
-{
-}
-
-std::string CutsceneCommand::GetCName()
-{
-	return "SCmdCutsceneData";
-}
-
-std::string CutsceneCommand::GenerateSourceCode(uint32_t baseAddress)
-{
-	return StringHelper::Sprintf("%s CutsceneData%04XCmd%02X = { 0x%02X,", GetCName().c_str(),
-	                             baseAddress, commandIndex, commandID);
-}
-
-size_t CutsceneCommand::GetCommandSize()
-{
-	return 4;
-}
-
-CutsceneCameraPoint::CutsceneCameraPoint(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	continueFlag = rawData.at(rawDataIndex + 0);
-	cameraRoll = rawData.at(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);
-}
-
-CutsceneCommandSetCameraPos::CutsceneCommandSetCameraPos(const std::vector<uint8_t>& rawData,
-                                                         uint32_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);
-
-	entries = std::vector<CutsceneCameraPoint*>();
-
-	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 += 16;
-	}
-}
-
-// TODO
-std::string CutsceneCommandSetCameraPos::GetCName()
-{
-	return "";
-}
-
-std::string CutsceneCommandSetCameraPos::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	std::string listStr;
-	std::string posStr;
-
-	if (commandID == (int32_t)CutsceneCommands::SetCameraFocus)
-	{
-		listStr = "CS_CAM_FOCUS_POINT_LIST";
-		posStr = "CS_CAM_FOCUS_POINT";
-	}
-	else if (commandID == (int32_t)CutsceneCommands::SetCameraFocusLink)
-	{
-		listStr = "CS_CAM_FOCUS_POINT_PLAYER_LIST";
-		posStr = "CS_CAM_FOCUS_POINT_PLAYER";
-	}
-	else if (commandID == (int32_t)CutsceneCommands::SetCameraPosLink)
-	{
-		listStr = "CS_CAM_POS_PLAYER_LIST";
-		posStr = "CS_CAM_POS_PLAYER";
-	}
-	else
-	{
-		listStr = "CS_CAM_POS_LIST";
-		posStr = "CS_CAM_POS";
-	}
-
-	result += StringHelper::Sprintf("%s(%i, %i),\n", listStr.c_str(), startFrame, endFrame);
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		std::string continueMacro = "CS_CMD_CONTINUE";
-		if (entries[i]->continueFlag != 0)
-			continueMacro = "CS_CMD_STOP";
-		result += StringHelper::Sprintf("        %s(%s, 0x%02X, %i, %ff, %i, %i, %i, 0x%04X),\n",
-		                                posStr.c_str(), continueMacro.c_str(),
-		                                entries[i]->cameraRoll, entries[i]->nextPointFrame,
-		                                entries[i]->viewAngle, entries[i]->posX, entries[i]->posY,
-		                                entries[i]->posZ, entries[i]->unused);
-	}
-
-	return result;
-}
-
-size_t CutsceneCommandSetCameraPos::GetCommandSize()
-{
-	return 8 + (entries.size() * 16);
-}
-
-MusicFadeEntry::MusicFadeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	unknown0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-	unknown1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
-	unknown2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
-	unknown3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
-	unknown4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
-	unknown5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
-	unknown6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
-	unknown7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
-	unknown8 = BitConverter::ToUInt32BE(rawData,
-	                                    rawDataIndex + 36);  // Macro hardcodes it as zero
-	unknown9 = BitConverter::ToUInt32BE(rawData,
-	                                    rawDataIndex + 40);  // Macro hardcodes it as zero
-	unknown10 = BitConverter::ToUInt32BE(rawData,
-	                                     rawDataIndex + 44);  // Macro hardcodes it as zero
-}
-
-CutsceneCommandFadeBGM::CutsceneCommandFadeBGM(const std::vector<uint8_t>& rawData,
-                                               uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	uint32_t numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
-
-	rawDataIndex += 4;
-
-	for (uint32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new MusicFadeEntry(rawData, rawDataIndex));
-		rawDataIndex += 0x30;
-	}
-}
-
-std::string CutsceneCommandFadeBGM::GetCName()
-{
-	return "CsCmdMusicFade";
-}
-
-std::string CutsceneCommandFadeBGM::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_FADE_BGM_LIST(%i),\n", entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"        CS_FADE_BGM(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n", entries[i]->base,
-			entries[i]->startFrame, entries[i]->endFrame, entries[i]->unknown0,
-			entries[i]->unknown1, entries[i]->unknown2, entries[i]->unknown3, entries[i]->unknown4,
-			entries[i]->unknown5, entries[i]->unknown6, entries[i]->unknown7);
-	}
-
-	return result;
-}
-
-size_t CutsceneCommandFadeBGM::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + 0x30 * entries.size();
-}
-
-MusicChangeEntry::MusicChangeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	sequence = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	unknown0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-	unknown1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
-	unknown2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
-	unknown3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
-	unknown4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
-	unknown5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
-	unknown6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
-	unknown7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
-}
-
-CutsceneCommandPlayBGM::CutsceneCommandPlayBGM(const std::vector<uint8_t>& rawData,
-                                               uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	uint32_t numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
-
-	rawDataIndex += 4;
-
-	for (uint32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new MusicChangeEntry(rawData, rawDataIndex));
-		rawDataIndex += 0x30;
-	}
-}
-
-std::string CutsceneCommandPlayBGM::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_PLAY_BGM_LIST(%i),\n", entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"        CS_PLAY_BGM(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n",
-			entries[i]->sequence, entries[i]->startFrame, entries[i]->endFrame,
-			entries[i]->unknown0, entries[i]->unknown1, entries[i]->unknown2, entries[i]->unknown3,
-			entries[i]->unknown4, entries[i]->unknown5, entries[i]->unknown6, entries[i]->unknown7);
-	}
-
-	return result;
-}
-
-std::string CutsceneCommandPlayBGM::GetCName()
-{
-	return "CsCmdMusicChange";
-}
-
-size_t CutsceneCommandPlayBGM::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + 0x30;
-}
-
-CutsceneCommandStopBGM::CutsceneCommandStopBGM(const std::vector<uint8_t>& rawData,
-                                               uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	uint32_t numEntries = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
-
-	rawDataIndex += 4;
-
-	for (uint32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new MusicChangeEntry(rawData, rawDataIndex));
-		rawDataIndex += 0x30;
-	}
-}
-
-std::string CutsceneCommandStopBGM::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_STOP_BGM_LIST(%i),\n", entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"\t\tCS_STOP_BGM(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n", entries[i]->sequence,
-			entries[i]->startFrame, entries[i]->endFrame, entries[i]->unknown0,
-			entries[i]->unknown1, entries[i]->unknown2, entries[i]->unknown3, entries[i]->unknown4,
-			entries[i]->unknown5, entries[i]->unknown6, entries[i]->unknown7);
-	}
-
-	return result;
-}
-
-std::string CutsceneCommandStopBGM::GetCName()
-{
-	return "CsCmdMusicChange";
-}
-
-size_t CutsceneCommandStopBGM::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + 0x30;
-}
-
-EnvLightingEntry::EnvLightingEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	setting = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	unused0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-	unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
-	unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
-	unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
-	unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
-	unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
-	unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
-	unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
-}
-
-CutsceneCommandEnvLighting::CutsceneCommandEnvLighting(const std::vector<uint8_t>& rawData,
-                                                       uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
-
-	rawDataIndex += 4;
-
-	for (int32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new EnvLightingEntry(rawData, rawDataIndex));
-		rawDataIndex += 0x30;
-	}
-}
-
-std::string CutsceneCommandEnvLighting::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_LIGHTING_LIST(%i),\n", entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"\t\tCS_LIGHTING(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n", entries[i]->setting,
-			entries[i]->startFrame, entries[i]->endFrame, entries[i]->unused0, entries[i]->unused1,
-			entries[i]->unused2, entries[i]->unused3, entries[i]->unused4, entries[i]->unused5,
-			entries[i]->unused6, entries[i]->unused7);
+		return new CutsceneCommand_GenericCmd(rawData, currentPtr, cmdID);
 	}
 
-	return result;
-}
-
-std::string CutsceneCommandEnvLighting::GetCName()
-{
-	return "CsCmdEnvLighting";
-}
-
-size_t CutsceneCommandEnvLighting::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + (0x30 * entries.size());
-}
-
-Unknown9Entry::Unknown9Entry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	unk2 = rawData[rawDataIndex + 6];
-	unk3 = rawData[rawDataIndex + 7];
-	unk4 = rawData[rawDataIndex + 8];
-	unused0 = rawData[rawDataIndex + 10];
-	unused1 = rawData[rawDataIndex + 11];
-	;
-}
-
-CutsceneCommandUnknown9::CutsceneCommandUnknown9(const std::vector<uint8_t>& rawData,
-                                                 uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
-
-	rawDataIndex += 4;
-
-	for (int32_t i = 0; i < numEntries; i++)
+	switch (cmdID)
 	{
-		entries.push_back(new Unknown9Entry(rawData, rawDataIndex));
-		rawDataIndex += 0x0C;
-	}
-}
+	case CutsceneCommands::Misc:
+	case CutsceneCommands::SetLighting:
+	case CutsceneCommands::PlayBGM:
+	case CutsceneCommands::StopBGM:
+	case CutsceneCommands::FadeBGM:
+		return new CutsceneCommand_GenericCmd(rawData, currentPtr, cmdID);
 
-std::string CutsceneCommandUnknown9::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
+	case CutsceneCommands::SetCameraPos:
+	case CutsceneCommands::SetCameraFocus:
+	case CutsceneCommands::SetCameraPosLink:
+	case CutsceneCommands::SetCameraFocusLink:
+		return new CutsceneCommandSetCameraPos(rawData, currentPtr);
 
-	result += StringHelper::Sprintf("CS_CMD_09_LIST(%i),\n", entries.size());
+	case CutsceneCommands::Cmd07:
+		break;
+	case CutsceneCommands::Cmd08:
+		break;
+	case CutsceneCommands::Cmd09:
+		return new CutsceneCommand_Rumble(rawData, currentPtr);
+	case CutsceneCommands::Textbox:
+		return new CutsceneCommand_TextBox(rawData, currentPtr);
 
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf("\t\tCS_CMD_09(%i, %i, %i, %i, %i, %i, %i, %i),\n",
-		                                entries[i]->base, entries[i]->startFrame,
-		                                entries[i]->endFrame, entries[i]->unk2, entries[i]->unk3,
-		                                entries[i]->unk4, entries[i]->unused0, entries[i]->unused1);
-	}
+	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;
 
-	return result;
-}
+	case CutsceneCommands::SetSceneTransFX:
+		return new CutsceneCommandSceneTransFX(rawData, currentPtr);
 
-std::string CutsceneCommandUnknown9::GetCName()
-{
-	return "CsCmdUnknown9";
-}
-
-size_t CutsceneCommandUnknown9::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
-}
-
-UnkEntry::UnkEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	unused0 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 0);
-	unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 4);
-	unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
-	unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
-	unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
-	unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
-	unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
-	unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
-	unused8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
-	unused9 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 36);
-	unused10 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 40);
-	unused11 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 44);
-}
-
-CutsceneCommandUnknown::CutsceneCommandUnknown(const std::vector<uint8_t>& rawData,
-                                               uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
-
-	rawDataIndex += 4;
-
-	for (int32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new UnkEntry(rawData, rawDataIndex));
-		rawDataIndex += 0x30;
-	}
-}
-
-std::string CutsceneCommandUnknown::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_UNK_DATA_LIST(0x%02X, %i),\n", commandID, entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"    CS_UNK_DATA(%i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i, %i),\n",
-			entries[i]->unused0, entries[i]->unused1, entries[i]->unused2, entries[i]->unused3,
-			entries[i]->unused4, entries[i]->unused5, entries[i]->unused6, entries[i]->unused7,
-			entries[i]->unused8, entries[i]->unused9, entries[i]->unused10, entries[i]->unused11);
+	case CutsceneCommands::SetTime:
+		return new CutsceneCommand_SetTime(rawData, currentPtr);
+	case CutsceneCommands::Terminator:
+		return new CutsceneCommand_Terminator(rawData, currentPtr);
 	}
 
-	return result;
+	return nullptr;
 }
 
-std::string CutsceneCommandUnknown::GetCName()
+CutsceneCommand* ZCutscene::GetCommandMM(uint32_t id, offset_t currentPtr) const
 {
-	return "CsCmdUnknown1A";
-}
-
-size_t CutsceneCommandUnknown::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + (entries.size() * 0x30);
-}
-
-DayTimeEntry::DayTimeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	hour = rawData[rawDataIndex + 6];
-	minute = rawData[rawDataIndex + 7];
-	unused = rawData[rawDataIndex + 8];
-}
+	CutsceneMMCommands cmdID = static_cast<CutsceneMMCommands>(id);
 
-CutsceneCommandDayTime::CutsceneCommandDayTime(const std::vector<uint8_t>& rawData,
-                                               uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
-
-	rawDataIndex += 4;
-
-	for (int32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new DayTimeEntry(rawData, rawDataIndex));
-		rawDataIndex += 12;
-	}
-}
-
-std::string CutsceneCommandDayTime::GetCName()
-{
-	return "CsCmdDayTime";
-}
-
-std::string CutsceneCommandDayTime::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_TIME_LIST(%i),\n", entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"        CS_TIME(%i, %i, %i, %i, %i, %i),\n", entries[i]->base, entries[i]->startFrame,
-			entries[i]->endFrame, entries[i]->hour, entries[i]->minute, entries[i]->unused);
-	}
-
-	return result;
-}
-
-size_t CutsceneCommandDayTime::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
-}
-
-TextboxEntry::TextboxEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	type = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-	textID1 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 8);
-	textID2 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 10);
-}
-
-CutsceneCommandTextbox::CutsceneCommandTextbox(const std::vector<uint8_t>& rawData,
-                                               uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
-
-	rawDataIndex += 4;
-
-	for (int32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new TextboxEntry(rawData, rawDataIndex));
-		rawDataIndex += 12;
-	}
-}
-
-std::string CutsceneCommandTextbox::GetCName()
-{
-	return "CsCmdTextbox";
-}
-
-std::string CutsceneCommandTextbox::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_TEXT_LIST(%i),\n", entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		if (entries[i]->base == 0xFFFF)
-		{
-			result += StringHelper::Sprintf("        CS_TEXT_NONE(%i, %i),\n",
-			                                entries[i]->startFrame, entries[i]->endFrame);
-		}
-		else
-		{
-			result += StringHelper::Sprintf(
-				"        CS_TEXT_DISPLAY_TEXTBOX(%i, %i, %i, %i, %i, %i),\n", entries[i]->base,
-				entries[i]->startFrame, entries[i]->endFrame, entries[i]->type, entries[i]->textID1,
-				entries[i]->textID2);
-		}
-	}
-
-	return result;
-}
-
-size_t CutsceneCommandTextbox::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + (entries.size() * 12);
-}
-
-ActorAction::ActorAction(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	action = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	rotX = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-	rotY = BitConverter::ToUInt16BE(rawData, rawDataIndex + 8);
-	rotZ = BitConverter::ToUInt16BE(rawData, rawDataIndex + 10);
-	startPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 12);
-	startPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 16);
-	startPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 20);
-	endPosX = BitConverter::ToInt32BE(rawData, rawDataIndex + 24);
-	endPosY = BitConverter::ToInt32BE(rawData, rawDataIndex + 28);
-	endPosZ = BitConverter::ToInt32BE(rawData, rawDataIndex + 32);
-	normalX = BitConverter::ToFloatBE(rawData, rawDataIndex + 36);
-	normalY = BitConverter::ToFloatBE(rawData, rawDataIndex + 40);
-	normalZ = BitConverter::ToFloatBE(rawData, rawDataIndex + 44);
-}
-
-CutsceneCommandActorAction::CutsceneCommandActorAction(const std::vector<uint8_t>& rawData,
-                                                       uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex);
-
-	rawDataIndex += 4;
-
-	for (int32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new ActorAction(rawData, rawDataIndex));
-		rawDataIndex += 0x30;
-	}
-}
-
-std::string CutsceneCommandActorAction::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-	std::string subCommand;
-
-	if (commandID == 10)
-	{
-		result += StringHelper::Sprintf("CS_PLAYER_ACTION_LIST(%i),\n", entries.size());
-		subCommand = "CS_PLAYER_ACTION";
-	}
-	else
-	{
-		result += StringHelper::Sprintf("CS_NPC_ACTION_LIST(%i, %i),\n", commandID, entries.size());
-		subCommand = "CS_NPC_ACTION";
-	}
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"\t\t%s(0x%04X, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, %i, %i, %i, %i, %.11ef, "
-			"%.11ef, %.11ef),\n",
-			subCommand.c_str(), entries[i]->action, entries[i]->startFrame, entries[i]->endFrame,
-			entries[i]->rotX, entries[i]->rotY, entries[i]->rotZ, entries[i]->startPosX,
-			entries[i]->startPosY, entries[i]->startPosZ, entries[i]->endPosX, entries[i]->endPosY,
-			entries[i]->endPosZ, entries[i]->normalX, entries[i]->normalY, entries[i]->normalZ);
-	}
-
-	return result;
-}
-
-std::string CutsceneCommandActorAction::GetCName()
-{
-	return "CsCmdBase";
-}
-
-size_t CutsceneCommandActorAction::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + (entries.size() * 0x30);
-}
-
-CutsceneCommandTerminator::CutsceneCommandTerminator(const std::vector<uint8_t>& rawData,
-                                                     uint32_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 CutsceneCommandTerminator::GetCName()
-{
-	return "CsCmdBase";
-}
-
-std::string CutsceneCommandTerminator::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_TERMINATOR(0x%04X, %i, %i),\n", base, startFrame, endFrame);
-
-	return result;
-}
-
-size_t CutsceneCommandTerminator::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + 8;
-}
-
-CutsceneCommandEnd::CutsceneCommandEnd(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-}
-
-std::string CutsceneCommandEnd::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_END(),\n");
-
-	return result;
-}
-
-std::string CutsceneCommandEnd::GetCName()
-{
-	return "CsCmdBase";
-}
-
-size_t CutsceneCommandEnd::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + 6;
-}
-
-SpecialActionEntry::SpecialActionEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-	unused0 = BitConverter::ToUInt16BE(rawData, rawDataIndex + 6);
-	unused1 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 8);
-	unused2 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 12);
-	unused3 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 16);
-	unused4 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 20);
-	unused5 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 24);
-	unused6 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 28);
-	unused7 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 32);
-	unused8 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 36);
-	unused9 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 40);
-	unused10 = BitConverter::ToUInt32BE(rawData, rawDataIndex + 44);
-}
-
-CutsceneCommandSpecialAction::CutsceneCommandSpecialAction(const std::vector<uint8_t>& rawData,
-                                                           uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	int32_t numEntries = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
-
-	rawDataIndex += 4;
-
-	for (int32_t i = 0; i < numEntries; i++)
-	{
-		entries.push_back(new SpecialActionEntry(rawData, rawDataIndex));
-		rawDataIndex += 0x30;
-	}
-}
-
-std::string CutsceneCommandSpecialAction::GenerateSourceCode([[maybe_unused]] uint32_t baseAddress)
-{
-	std::string result;
-
-	result += StringHelper::Sprintf("CS_MISC_LIST(%i),\n", entries.size());
-
-	for (size_t i = 0; i < entries.size(); i++)
-	{
-		result += StringHelper::Sprintf(
-			"\t\tCS_MISC(0x%04X, %i, %i, 0x%04X, 0x%04X, 0x%04X, %i, %i, %i, %i, %i, %i, %i, "
-			"%i),\n",
-			entries[i]->base, entries[i]->startFrame, entries[i]->endFrame, entries[i]->unused0,
-			entries[i]->unused1, entries[i]->unused2, entries[i]->unused3, entries[i]->unused4,
-			entries[i]->unused5, entries[i]->unused6, entries[i]->unused7, entries[i]->unused8,
-			entries[i]->unused9, entries[i]->unused10);
-	}
-
-	return result;
-}
-
-std::string CutsceneCommandSpecialAction::GetCName()
-{
-	return "CsCmdBase";
-}
-
-size_t CutsceneCommandSpecialAction::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + (0x30 * entries.size());
-}
-
-CutsceneCommandNop::CutsceneCommandNop(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-	: CutsceneCommand(rawData, rawDataIndex)
-{
-	base = BitConverter::ToUInt16BE(rawData, rawDataIndex + 0);
-	startFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 2);
-	endFrame = BitConverter::ToUInt16BE(rawData, rawDataIndex + 4);
-}
-
-std::string CutsceneCommandNop::GetCName()
-{
-	return "CsCmdBase";
-}
-
-size_t CutsceneCommandNop::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + 6;
-}
-
-CutsceneCommandSceneTransFX::CutsceneCommandSceneTransFX(const std::vector<uint8_t>& rawData,
-                                                         uint32_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([[maybe_unused]] uint32_t baseAddress)
-{
-	return StringHelper::Sprintf("CS_SCENE_TRANS_FX(%i, %i, %i),\n", base, startFrame, endFrame);
-}
-
-std::string CutsceneCommandSceneTransFX::GetCName()
-{
-	return "CsCmdBase";
-}
-
-size_t CutsceneCommandSceneTransFX::GetCommandSize()
-{
-	return CutsceneCommand::GetCommandSize() + 8;
-}
-
-ZCutsceneBase::ZCutsceneBase(ZFile* nParent) : ZResource(nParent)
-{
-}
+	const auto& rawData = parent->GetRawData();
 
-Declaration* ZCutsceneBase::DeclareVar(const std::string& prefix, const std::string& bodyStr)
+	if (((id >= 100) && (id < 150)) || (id == 201) || ((id >= 450) && (id < 600)))
+	{
+		return new CutsceneCommand_ActorAction(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:
+		return new CutsceneMMCommand_GenericCmd(rawData, currentPtr, cmdID);
+
+	case CutsceneMMCommands::CS_CMD_TEXTBOX:
+		return new CutsceneCommand_TextBox(rawData, currentPtr);
+	case CutsceneMMCommands::CS_CMD_CAMERA:
+		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);
+	}
+
+	return nullptr;
+}
+
+Declaration* ZCutscene::DeclareVar(const std::string& prefix, const std::string& bodyStr)
 {
 	std::string auxName = name;
 
@@ -1245,7 +377,12 @@ Declaration* ZCutsceneBase::DeclareVar(const std::string& prefix, const std::str
 	return decl;
 }
 
-std::string ZCutsceneBase::GetSourceTypeName() const
+std::string ZCutscene::GetSourceTypeName() const
 {
 	return "CutsceneData";
 }
+
+ZResourceType ZCutscene::GetResourceType() const
+{
+	return ZResourceType::Cutscene;
+}
diff --git a/tools/ZAPD/ZAPD/ZCutscene.h b/tools/ZAPD/ZAPD/ZCutscene.h
index 8e901e307..098f3ad86 100644
--- a/tools/ZAPD/ZAPD/ZCutscene.h
+++ b/tools/ZAPD/ZAPD/ZCutscene.h
@@ -3,422 +3,13 @@
 #include <cstdint>
 #include <string>
 #include <vector>
-#include "ZFile.h"
-#include "ZResource.h"
 #include "tinyxml2.h"
 
-enum class CutsceneCommands
-{
-	Cmd00 = 0x0000,
-	SetCameraPos = 0x0001,
-	SetCameraFocus = 0x0002,
-	SpecialAction = 0x0003,
-	SetLighting = 0x0004,
-	SetCameraPosLink = 0x0005,
-	SetCameraFocusLink = 0x0006,
-	Cmd07 = 0x0007,
-	Cmd08 = 0x0008,
-	Cmd09 = 0x0009,
-	Unknown = 0x001A,
-	Textbox = 0x0013,
-	SetActorAction0 = 0x000A,
-	SetActorAction1 = 0x000F,
-	SetActorAction2 = 0x000E,
-	SetActorAction3 = 0x0019,
-	SetActorAction4 = 0x001D,
-	SetActorAction5 = 0x001E,
-	SetActorAction6 = 0x002C,
-	SetActorAction7 = 0x001F,
-	SetActorAction8 = 0x0031,
-	SetActorAction9 = 0x003E,
-	SetActorAction10 = 0x008F,
-	SetSceneTransFX = 0x002D,
-	Nop = 0x000B,
-	PlayBGM = 0x0056,
-	StopBGM = 0x0057,
-	FadeBGM = 0x007C,
-	SetTime = 0x008C,
-	Terminator = 0x03E8,
-	End = 0xFFFF,
-	Error = 0xFEAF,
-};
-
-class CutsceneCameraPoint
-{
-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, uint32_t rawDataIndex);
-};
-
-class CutsceneCommand
-{
-public:
-	uint32_t commandID;
-	uint32_t commandIndex;
-	virtual ~CutsceneCommand();
-	CutsceneCommand(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	virtual std::string GetCName();
-	virtual std::string GenerateSourceCode(uint32_t baseAddress);
-	virtual size_t GetCommandSize();
-};
-
-class CutsceneCommandSetCameraPos : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unused;
-
-	std::vector<CutsceneCameraPoint*> entries;
-	~CutsceneCommandSetCameraPos();
-	CutsceneCommandSetCameraPos(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class SpecialActionEntry
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unused0;
-	uint32_t unused1;
-	uint32_t unused2;
-	uint32_t unused3;
-	uint32_t unused4;
-	uint32_t unused5;
-	uint32_t unused6;
-	uint32_t unused7;
-	uint32_t unused8;
-	uint32_t unused9;
-	uint32_t unused10;
-
-	SpecialActionEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandSpecialAction : public CutsceneCommand
-{
-public:
-	std::vector<SpecialActionEntry*> entries;
-
-	CutsceneCommandSpecialAction(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandSpecialAction();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class MusicFadeEntry
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unknown0;
-	uint32_t unknown1;
-	uint32_t unknown2;
-	uint32_t unknown3;
-	uint32_t unknown4;
-	uint32_t unknown5;
-	uint32_t unknown6;
-	uint32_t unknown7;
-	uint32_t unknown8;
-	uint32_t unknown9;
-	uint32_t unknown10;
-
-	MusicFadeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandFadeBGM : public CutsceneCommand
-{
-public:
-	std::vector<MusicFadeEntry*> entries;
-
-	CutsceneCommandFadeBGM(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandFadeBGM();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class MusicChangeEntry
-{
-public:
-	uint16_t sequence;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unknown0;
-	uint32_t unknown1;
-	uint32_t unknown2;
-	uint32_t unknown3;
-	uint32_t unknown4;
-	uint32_t unknown5;
-	uint32_t unknown6;
-	uint32_t unknown7;
-
-	MusicChangeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandPlayBGM : public CutsceneCommand
-{
-public:
-	std::vector<MusicChangeEntry*> entries;
-
-	CutsceneCommandPlayBGM(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandPlayBGM();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class CutsceneCommandStopBGM : public CutsceneCommand
-{
-public:
-	std::vector<MusicChangeEntry*> entries;
-
-	CutsceneCommandStopBGM(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandStopBGM();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class EnvLightingEntry
-{
-public:
-	uint16_t setting;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unused0;
-	uint32_t unused1;
-	uint32_t unused2;
-	uint32_t unused3;
-	uint32_t unused4;
-	uint32_t unused5;
-	uint32_t unused6;
-	uint32_t unused7;
-
-	EnvLightingEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandEnvLighting : public CutsceneCommand
-{
-public:
-	std::vector<EnvLightingEntry*> entries;
-
-	CutsceneCommandEnvLighting(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandEnvLighting();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class CutsceneCommandSceneTransFX : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	~CutsceneCommandSceneTransFX();
-	CutsceneCommandSceneTransFX(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class Unknown9Entry
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unk2;
-	uint16_t unk3;
-	uint16_t unk4;
-	uint8_t unused0;
-	uint8_t unused1;
-
-	Unknown9Entry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandUnknown9 : public CutsceneCommand
-{
-public:
-	std::vector<Unknown9Entry*> entries;
-
-	CutsceneCommandUnknown9(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandUnknown9();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class UnkEntry
-{
-public:
-	uint32_t unused0;
-	uint32_t unused1;
-	uint32_t unused2;
-	uint32_t unused3;
-	uint32_t unused4;
-	uint32_t unused5;
-	uint32_t unused6;
-	uint32_t unused7;
-	uint32_t unused8;
-	uint32_t unused9;
-	uint32_t unused10;
-	uint32_t unused11;
-
-	UnkEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandUnknown : public CutsceneCommand
-{
-public:
-	std::vector<UnkEntry*> entries;
-
-	CutsceneCommandUnknown(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandUnknown();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class DayTimeEntry
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint8_t hour;
-	uint8_t minute;
-	uint8_t unused;
-
-	DayTimeEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandDayTime : public CutsceneCommand
-{
-public:
-	std::vector<DayTimeEntry*> entries;
-
-	CutsceneCommandDayTime(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandDayTime();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class TextboxEntry
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t type;
-	uint16_t textID1;
-	uint16_t textID2;
-
-	TextboxEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandTextbox : public CutsceneCommand
-{
-public:
-	std::vector<TextboxEntry*> entries;
-
-	CutsceneCommandTextbox(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandTextbox();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class ActorAction
-{
-public:
-	uint16_t action;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	int16_t rotX, rotY, rotZ;
-	int32_t startPosX, startPosY, startPosZ;
-	int32_t endPosX, endPosY, endPosZ;
-	float normalX, normalY, normalZ;
-
-	ActorAction(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-};
-
-class CutsceneCommandActorAction : public CutsceneCommand
-{
-public:
-	std::vector<ActorAction*> entries;
-
-	CutsceneCommandActorAction(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	~CutsceneCommandActorAction();
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class CutsceneCommandTerminator : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-	uint16_t unknown;
-
-	CutsceneCommandTerminator(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class CutsceneCommandEnd : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-
-	CutsceneCommandEnd(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	std::string GetCName();
-	std::string GenerateSourceCode(uint32_t baseAddress);
-	size_t GetCommandSize();
-};
-
-class CutsceneCommandNop : public CutsceneCommand
-{
-public:
-	uint16_t base;
-	uint16_t startFrame;
-	uint16_t endFrame;
-
-	CutsceneCommandNop(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
-	std::string GetCName();
-	size_t GetCommandSize();
-};
-
-class ZCutsceneBase : public ZResource
-{
-public:
-	ZCutsceneBase(ZFile* nParent);
-
-	Declaration* DeclareVar(const std::string& prefix, const std::string& bodyStr) override;
-
-	std::string GetSourceTypeName() const override;
-};
+#include "OtherStructs/Cutscene_Commands.h"
+#include "ZFile.h"
+#include "ZResource.h"
 
-class ZCutscene : public ZCutsceneBase
+class ZCutscene : public ZResource
 {
 public:
 	ZCutscene(ZFile* nParent);
@@ -426,15 +17,20 @@ public:
 
 	void ParseRawData() override;
 
+	Declaration* DeclareVar(const std::string& prefix, const std::string& bodyStr) override;
+
 	std::string GetBodySourceCode() const override;
 
 	size_t GetRawDataSize() const override;
 
+	std::string GetSourceTypeName() const override;
 	ZResourceType GetResourceType() const override;
 
-	CutsceneCommands GetCommandFromID(int32_t id);
-
 	int32_t numCommands;
 	int32_t endFrame;
 	std::vector<CutsceneCommand*> commands;
+
+protected:
+	CutsceneCommand* GetCommandOoT(uint32_t id, offset_t currentPtr) const;
+	CutsceneCommand* GetCommandMM(uint32_t id, offset_t currentPtr) const;
 };
diff --git a/tools/ZAPD/ZAPD/ZCutsceneMM.cpp b/tools/ZAPD/ZAPD/ZCutsceneMM.cpp
deleted file mode 100644
index d0208bc07..000000000
--- a/tools/ZAPD/ZAPD/ZCutsceneMM.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "ZCutsceneMM.h"
-
-#include "Utils/BitConverter.h"
-#include "Utils/StringHelper.h"
-
-ZCutsceneMM::ZCutsceneMM(ZFile* nParent) : ZCutsceneBase(nParent)
-{
-}
-
-ZCutsceneMM::~ZCutsceneMM()
-{
-	for (CutsceneCommand* cmd : commands)
-		delete cmd;
-}
-
-std::string ZCutsceneMM::GetBodySourceCode() const
-{
-	std::string output;
-
-	output += StringHelper::Sprintf("    CS_BEGIN_CUTSCENE(%i, %i),", numCommands, endFrame);
-
-	for (size_t i = 0; i < data.size(); i++)
-	{
-		if ((i % 4) == 0)
-			output += "\n    ";
-		output += StringHelper::Sprintf("0x%08X, ", data[i]);
-	}
-
-	return output;
-}
-
-size_t ZCutsceneMM::GetRawDataSize() const
-{
-	return 8 + data.size() * 4;
-}
-
-void ZCutsceneMM::ParseRawData()
-{
-	const auto& rawData = parent->GetRawData();
-
-	numCommands = BitConverter::ToInt32BE(rawData, rawDataIndex + 0);
-	commands = std::vector<CutsceneCommand*>();
-
-	endFrame = BitConverter::ToInt32BE(rawData, rawDataIndex + 4);
-	uint32_t currentPtr = rawDataIndex + 8;
-	uint32_t lastData = 0;
-
-	// TODO currently cutscenes aren't being parsed, so just consume words until we see an end
-	// marker.
-	do
-	{
-		lastData = BitConverter::ToInt32BE(rawData, currentPtr);
-		data.push_back(lastData);
-		currentPtr += 4;
-	} while (lastData != 0xFFFFFFFF);
-}
-
-ZResourceType ZCutsceneMM::GetResourceType() const
-{
-	return ZResourceType::Cutscene;
-}
diff --git a/tools/ZAPD/ZAPD/ZCutsceneMM.h b/tools/ZAPD/ZAPD/ZCutsceneMM.h
deleted file mode 100644
index 44b108d6c..000000000
--- a/tools/ZAPD/ZAPD/ZCutsceneMM.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <vector>
-#include "ZCutscene.h"
-#include "ZFile.h"
-#include "tinyxml2.h"
-
-class ZCutsceneMM : public ZCutsceneBase
-{
-public:
-	ZCutsceneMM(ZFile* nParent);
-	virtual ~ZCutsceneMM();
-
-	std::string GetBodySourceCode() const override;
-
-	size_t GetRawDataSize() const override;
-
-	void ParseRawData() override;
-	ZResourceType GetResourceType() const override;
-
-protected:
-	int32_t numCommands;
-	int32_t endFrame;
-	std::vector<CutsceneCommand*> commands;
-
-	std::vector<uint32_t> data;
-};
diff --git a/tools/ZAPD/ZAPD/ZFile.cpp b/tools/ZAPD/ZAPD/ZFile.cpp
index d9733f326..b81399e2a 100644
--- a/tools/ZAPD/ZAPD/ZFile.cpp
+++ b/tools/ZAPD/ZAPD/ZFile.cpp
@@ -695,7 +695,7 @@ bool ZFile::GetDeclarationArrayIndexedName(segptr_t segAddress, size_t elementSi
 	return true;
 }
 
-Declaration* ZFile::GetDeclaration(uint32_t address) const
+Declaration* ZFile::GetDeclaration(offset_t address) const
 {
 	if (declarations.find(address) != declarations.end())
 		return declarations.at(address);
@@ -703,7 +703,7 @@ Declaration* ZFile::GetDeclaration(uint32_t address) const
 	return nullptr;
 }
 
-Declaration* ZFile::GetDeclarationRanged(uint32_t address) const
+Declaration* ZFile::GetDeclarationRanged(offset_t address) const
 {
 	for (const auto decl : declarations)
 	{
@@ -714,7 +714,7 @@ Declaration* ZFile::GetDeclarationRanged(uint32_t address) const
 	return nullptr;
 }
 
-bool ZFile::HasDeclaration(uint32_t address)
+bool ZFile::HasDeclaration(offset_t address)
 {
 	assert(GETSEGNUM(address) == 0);
 	return declarations.find(address) != declarations.end();
diff --git a/tools/ZAPD/ZAPD/ZFile.h b/tools/ZAPD/ZAPD/ZFile.h
index 365c7bbbb..275e27f1b 100644
--- a/tools/ZAPD/ZAPD/ZFile.h
+++ b/tools/ZAPD/ZAPD/ZFile.h
@@ -81,9 +81,9 @@ public:
 	                                    const std::string& expectedType,
 	                                    std::string& declName) const;
 
-	Declaration* GetDeclaration(uint32_t address) const;
-	Declaration* GetDeclarationRanged(uint32_t address) const;
-	bool HasDeclaration(uint32_t address);
+	Declaration* GetDeclaration(offset_t address) const;
+	Declaration* GetDeclarationRanged(offset_t address) const;
+	bool HasDeclaration(offset_t address);
 
 	std::string GetHeaderInclude() const;
 	std::string GetZRoomHeaderInclude() const;
diff --git a/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.cpp b/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.cpp
index e51e550b0..3820203ef 100644
--- a/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.cpp
+++ b/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.cpp
@@ -10,53 +10,65 @@ SetCutscenes::SetCutscenes(ZFile* nParent) : ZRoomCommand(nParent)
 {
 }
 
-SetCutscenes::~SetCutscenes()
-{
-	for (ZCutsceneBase* cutscene : cutscenes)
-		delete cutscene;
-}
-
 void SetCutscenes::ParseRawData()
 {
 	ZRoomCommand::ParseRawData();
-	std::string output;
 
 	numCutscenes = cmdArg1;
-	if (Globals::Instance->game == ZGame::OOT_RETAIL || Globals::Instance->game == ZGame::OOT_SW97)
-	{
-		ZCutscene* cutscene = new ZCutscene(parent);
-		cutscene->ExtractFromFile(segmentOffset);
 
-		auto decl = parent->GetDeclaration(segmentOffset);
-		if (decl == nullptr)
-		{
-			cutscene->DeclareVar(zRoom->GetName().c_str(), "");
-		}
-
-		cutscenes.push_back(cutscene);
-	}
-	else
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
 	{
 		int32_t currentPtr = segmentOffset;
-		std::string declaration;
 
 		for (uint8_t i = 0; i < numCutscenes; i++)
 		{
 			CutsceneEntry entry(parent->GetRawData(), currentPtr);
 			cutsceneEntries.push_back(entry);
 			currentPtr += 8;
+		}
+	}
+}
+
+void SetCutscenes::DeclareReferences(const std::string& prefix)
+{
+	std::string varPrefix = name;
+	if (varPrefix == "")
+		varPrefix = prefix;
+
+	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		std::string declaration;
+		size_t i = 0;
 
-			// TODO: don't hardcode %sCutsceneData_%06X, look up for the declared name instead
-			declaration += StringHelper::Sprintf(
-				"    { %sCutsceneData_%06X, 0x%04X, 0x%02X, 0x%02X },", zRoom->GetName().c_str(),
-				entry.segmentOffset, entry.exit, entry.entrance, entry.flag);
+		for (const auto& entry : cutsceneEntries)
+		{
+			if (entry.segmentPtr != SEGMENTED_NULL &&
+			    GETSEGNUM(entry.segmentPtr) == parent->segment)
+			{
+				offset_t csOffset = Seg2Filespace(entry.segmentPtr, parent->baseAddress);
+				if (!parent->HasDeclaration(csOffset))
+				{
+					auto* cutscene = new ZCutscene(parent);
+					cutscene->ExtractFromFile(csOffset);
+					cutscene->SetName(cutscene->GetDefaultName(varPrefix));
+					cutscene->DeclareVar(varPrefix, "");
+					cutscene->DeclareReferences(varPrefix);
+					parent->AddResource(cutscene);
+				}
+			}
+
+			std::string csName;
+			Globals::Instance->GetSegmentedPtrName(entry.segmentPtr, parent, "CutsceneData",
+			                                       csName);
 
-			if (i < numCutscenes - 1)
+			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";
 
-			ZCutsceneMM* cutscene = new ZCutsceneMM(parent);
-			cutscene->ExtractFromFile(entry.segmentOffset);
-			cutscenes.push_back(cutscene);
+			i++;
 		}
 
 		parent->AddDeclarationArray(segmentOffset, DeclarationAlignment::Align4,
@@ -65,19 +77,19 @@ void SetCutscenes::ParseRawData()
 		                                                  zRoom->GetName().c_str(), segmentOffset),
 		                            cutsceneEntries.size(), declaration);
 	}
-
-	for (ZCutsceneBase* cutscene : cutscenes)
+	else
 	{
-		if (cutscene->GetRawDataIndex() != 0)
+		if (cmdArg2 != SEGMENTED_NULL && GETSEGNUM(cmdArg2) == parent->segment)
 		{
-			Declaration* decl = parent->GetDeclaration(cutscene->GetRawDataIndex());
-			if (decl == nullptr)
-			{
-				cutscene->GetSourceOutputCode(zRoom->GetName());
-			}
-			else if (decl->text == "")
+			offset_t csOffset = Seg2Filespace(cmdArg2, parent->baseAddress);
+			if (!parent->HasDeclaration(csOffset))
 			{
-				decl->text = cutscene->GetBodySourceCode();
+				auto* cutscene = new ZCutscene(parent);
+				cutscene->ExtractFromFile(csOffset);
+				cutscene->SetName(cutscene->GetDefaultName(varPrefix));
+				cutscene->DeclareVar(varPrefix, "");
+				cutscene->DeclareReferences(varPrefix);
+				parent->AddResource(cutscene);
 			}
 		}
 	}
@@ -86,11 +98,15 @@ void SetCutscenes::ParseRawData()
 std::string SetCutscenes::GetBodySourceCode() const
 {
 	std::string listName;
-	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneData", listName);
 
 	if (Globals::Instance->game == ZGame::MM_RETAIL)
+	{
+		Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneEntry", listName);
 		return StringHelper::Sprintf("SCENE_CMD_CUTSCENE_LIST(%i, %s)", numCutscenes,
 		                             listName.c_str());
+	}
+
+	Globals::Instance->GetSegmentedPtrName(cmdArg2, parent, "CutsceneData", listName);
 	return StringHelper::Sprintf("SCENE_CMD_CUTSCENE_DATA(%s)", listName.c_str());
 }
 
@@ -105,7 +121,7 @@ RoomCommand SetCutscenes::GetRoomCommand() const
 }
 
 CutsceneEntry::CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex)
-	: segmentOffset(GETSEGOFFSET(BitConverter::ToInt32BE(rawData, rawDataIndex + 0))),
+	: segmentPtr(BitConverter::ToInt32BE(rawData, rawDataIndex + 0)),
 	  exit(BitConverter::ToInt16BE(rawData, rawDataIndex + 4)), entrance(rawData[rawDataIndex + 6]),
 	  flag(rawData[rawDataIndex + 7])
 {
diff --git a/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.h b/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.h
index ad032bbe6..81a622c5b 100644
--- a/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.h
+++ b/tools/ZAPD/ZAPD/ZRoom/Commands/SetCutscenes.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "ZCutscene.h"
-#include "ZCutsceneMM.h"
 #include "ZRoom/ZRoomCommand.h"
 
 class CutsceneEntry
@@ -9,7 +8,7 @@ class CutsceneEntry
 public:
 	CutsceneEntry(const std::vector<uint8_t>& rawData, uint32_t rawDataIndex);
 
-	uint32_t segmentOffset;
+	segptr_t segmentPtr;
 	uint16_t exit;
 	uint8_t entrance;
 	uint8_t flag;
@@ -18,14 +17,13 @@ public:
 class SetCutscenes : public ZRoomCommand
 {
 public:
-	std::vector<ZCutsceneBase*> cutscenes;
 	std::vector<CutsceneEntry> cutsceneEntries;  // (MM Only)
 	uint8_t numCutscenes;                        // (MM Only)
 
 	SetCutscenes(ZFile* nParent);
-	~SetCutscenes();
 
 	void ParseRawData() override;
+	void DeclareReferences(const std::string& prefix) override;
 
 	std::string GetBodySourceCode() const override;
 
diff --git a/tools/ZAPD/ZAPD/ZRoom/Commands/SetRoomList.cpp b/tools/ZAPD/ZAPD/ZRoom/Commands/SetRoomList.cpp
index 7027fa1f9..20138dd4d 100644
--- a/tools/ZAPD/ZAPD/ZRoom/Commands/SetRoomList.cpp
+++ b/tools/ZAPD/ZAPD/ZRoom/Commands/SetRoomList.cpp
@@ -104,9 +104,8 @@ std::string RomFile::GetBodySourceCode() const
 				if (!isFirst)
 					declaration += "\n";
 
-				declaration +=
-					StringHelper::Sprintf("\t{ (u32)_%sSegmentRomStart, (u32)_%sSegmentRomEnd },",
-				                          roomName.c_str(), roomName.c_str());
+				declaration += StringHelper::Sprintf("\t{ _%sSegmentRomStart, _%sSegmentRomEnd },",
+				                                     roomName.c_str(), roomName.c_str());
 				isFirst = false;
 			}
 		}
diff --git a/tools/ZAPD/ZAPD/ZSkeleton.cpp b/tools/ZAPD/ZAPD/ZSkeleton.cpp
index ff4333129..b3f7ce8c0 100644
--- a/tools/ZAPD/ZAPD/ZSkeleton.cpp
+++ b/tools/ZAPD/ZAPD/ZSkeleton.cpp
@@ -159,8 +159,8 @@ std::string ZSkeleton::GetBodySourceCode() const
 		return StringHelper::Sprintf("\n\t%s, %s\n", limbArrayName.c_str(), countStr.c_str());
 
 	case ZSkeletonType::Flex:
-		return StringHelper::Sprintf("\n\t{ %s, %s }, %i\n", limbArrayName.c_str(), countStr.c_str(),
-		                             dListCount);
+		return StringHelper::Sprintf("\n\t{ %s, %s }, %i\n", limbArrayName.c_str(),
+		                             countStr.c_str(), dListCount);
 	}
 
 	// TODO: Throw exception?
diff --git a/tools/ZAPD/ZAPDUtils/Utils/BitConverter.h b/tools/ZAPD/ZAPDUtils/Utils/BitConverter.h
index 98c46bc79..ac82c24ca 100644
--- a/tools/ZAPD/ZAPDUtils/Utils/BitConverter.h
+++ b/tools/ZAPD/ZAPDUtils/Utils/BitConverter.h
@@ -3,6 +3,7 @@
 #include <cinttypes>
 #include <cstdint>
 #include <cstdio>
+#include <cstring>
 #include <limits>
 #include <vector>