diff --git a/CMakeLists.txt b/CMakeLists.txt
index 30efbd67..d4d9ccb2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -83,6 +83,7 @@ add_library(lego1 SHARED
   LEGO1/legopartpresenter.cpp
   LEGO1/legopathactor.cpp
   LEGO1/legopathcontroller.cpp
+  LEGO1/legopathcontrollerlist.cpp
   LEGO1/legopathpresenter.cpp
   LEGO1/legophonemepresenter.cpp
   LEGO1/legoplantmanager.cpp
diff --git a/LEGO1/helicopter.cpp b/LEGO1/helicopter.cpp
index 005d9b56..6e159a26 100644
--- a/LEGO1/helicopter.cpp
+++ b/LEGO1/helicopter.cpp
@@ -24,9 +24,9 @@ Helicopter::~Helicopter()
 }
 
 // OFFSET: LEGO1 0x100032c0
-MxResult Helicopter::InitFromMxDSObject(MxDSObject& p_dsObject)
+MxResult Helicopter::Create(MxDSObject& p_dsObject)
 {
-	MxResult result = IslePathActor::InitFromMxDSObject(p_dsObject);
+	MxResult result = IslePathActor::Create(p_dsObject);
 	LegoWorld* world = GetCurrentWorld();
 	SetWorld(world);
 	if (world->IsA("Act3")) {
diff --git a/LEGO1/helicopter.h b/LEGO1/helicopter.h
index 7ed0a30f..0701c437 100644
--- a/LEGO1/helicopter.h
+++ b/LEGO1/helicopter.h
@@ -24,7 +24,7 @@ class Helicopter : public IslePathActor {
 		return !strcmp(name, Helicopter::ClassName()) || IslePathActor::IsA(name);
 	}
 
-	virtual MxResult InitFromMxDSObject(MxDSObject& p_dsObject) override; // vtable+0x18
+	virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
 	virtual void VTable0xe4() override;
 
 	// OFFSET: LEGO1 0x10003210 TEMPLATE
diff --git a/LEGO1/islepathactor.cpp b/LEGO1/islepathactor.cpp
index 9aca029b..21fca59a 100644
--- a/LEGO1/islepathactor.cpp
+++ b/LEGO1/islepathactor.cpp
@@ -44,9 +44,9 @@ IslePathActor::IslePathActor()
 }
 
 // OFFSET: LEGO1 0x1001a280
-MxResult IslePathActor::InitFromMxDSObject(MxDSObject& p_dsObject)
+MxResult IslePathActor::Create(MxDSObject& p_dsObject)
 {
-	return MxEntity::InitFromMxDSObject(p_dsObject);
+	return MxEntity::Create(p_dsObject);
 }
 
 // OFFSET: LEGO1 0x1001a350 STUB
diff --git a/LEGO1/islepathactor.h b/LEGO1/islepathactor.h
index c0222047..7885fbb2 100644
--- a/LEGO1/islepathactor.h
+++ b/LEGO1/islepathactor.h
@@ -28,16 +28,16 @@ class IslePathActor : public LegoPathActor {
 	// IslePathActor::`scalar deleting destructor'
 	inline virtual ~IslePathActor() override { IslePathActor::Destroy(TRUE); }
 
-	virtual MxResult InitFromMxDSObject(MxDSObject& p_dsObject) override; // vtable+0x18
-	virtual void VTable0xcc();                                            // vtable+0xcc
-	virtual void VTable0xd0();                                            // vtable+0xd0
-	virtual void VTable0xd4();                                            // vtable+0xd4
-	virtual void VTable0xd8();                                            // vtable+0xd8
-	virtual void VTable0xdc();                                            // vtable+0xdc
-	virtual void VTable0xe0();                                            // vtable+0xe0
-	virtual void VTable0xe4();                                            // vtable+0xe4
-	virtual void VTable0xe8(MxU32 p_1, MxBool p_2, MxU8 p_3);             // vtable+0xe8
-	virtual void VTable0xec();                                            // vtable+0xec
+	virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+0x18
+	virtual void VTable0xcc();                                // vtable+0xcc
+	virtual void VTable0xd0();                                // vtable+0xd0
+	virtual void VTable0xd4();                                // vtable+0xd4
+	virtual void VTable0xd8();                                // vtable+0xd8
+	virtual void VTable0xdc();                                // vtable+0xdc
+	virtual void VTable0xe0();                                // vtable+0xe0
+	virtual void VTable0xe4();                                // vtable+0xe4
+	virtual void VTable0xe8(MxU32 p_1, MxBool p_2, MxU8 p_3); // vtable+0xe8
+	virtual void VTable0xec();                                // vtable+0xec
 
 	inline void SetWorld(LegoWorld* p_world) { m_pLegoWorld = p_world; }
 	inline LegoWorld* GetWorld() { return m_pLegoWorld; }
diff --git a/LEGO1/legoentity.cpp b/LEGO1/legoentity.cpp
index f7601ee5..f5c6477c 100644
--- a/LEGO1/legoentity.cpp
+++ b/LEGO1/legoentity.cpp
@@ -42,7 +42,7 @@ void LegoEntity::SetWorldTransform(Vector3Impl& p_loc, Vector3Impl& p_dir, Vecto
 }
 
 // OFFSET: LEGO1 0x100107e0
-MxResult LegoEntity::InitFromMxDSObject(MxDSObject& p_dsObject)
+MxResult LegoEntity::Create(MxDSObject& p_dsObject)
 {
 	m_mxEntityId = p_dsObject.GetObjectId();
 	m_atom = p_dsObject.GetAtomId();
diff --git a/LEGO1/legoentity.h b/LEGO1/legoentity.h
index d42d85c6..0c559fb7 100644
--- a/LEGO1/legoentity.h
+++ b/LEGO1/legoentity.h
@@ -32,7 +32,7 @@ class LegoEntity : public MxEntity {
 		return !strcmp(name, LegoEntity::ClassName()) || MxEntity::IsA(name);
 	}
 
-	virtual MxResult InitFromMxDSObject(MxDSObject& p_dsObject);                               // vtable+0x18
+	virtual MxResult Create(MxDSObject& p_dsObject);                                           // vtable+0x18
 	virtual void Destroy(MxBool p_fromDestructor);                                             // vtable+0x1c
 	virtual void ParseAction(char*);                                                           // vtable+0x20
 	virtual void SetROI(LegoROI* p_roi, MxBool p_bool1, MxBool p_bool2);                       // vtable+0x24
diff --git a/LEGO1/legoinputmanager.cpp b/LEGO1/legoinputmanager.cpp
index e9a82cc6..fb0fc079 100644
--- a/LEGO1/legoinputmanager.cpp
+++ b/LEGO1/legoinputmanager.cpp
@@ -5,6 +5,7 @@
 #include "mxautolocker.h"
 
 DECOMP_SIZE_ASSERT(LegoInputManager, 0x338);
+DECOMP_SIZE_ASSERT(LegoEventQueue, 0x18);
 
 // OFFSET: LEGO1 0x1005b790
 LegoInputManager::LegoInputManager()
@@ -55,6 +56,27 @@ MxResult LegoInputManager::Create(HWND p_hwnd)
 	return SUCCESS;
 }
 
+// OFFSET: LEGO1 0x1005bb80 TEMPLATE
+// MxCollection<LegoEventNotificationParam>::Compare
+
+// OFFSET: LEGO1 0x1005bc30 TEMPLATE
+// MxCollection<LegoEventNotificationParam>::Destroy
+
+// OFFSET: LEGO1 0x1005bc80 TEMPLATE
+// MxList<LegoEventNotificationParam>::~MxList<LegoEventNotificationParam>
+
+// OFFSET: LEGO1 0x1005bd50 TEMPLATE
+// MxCollection<LegoEventNotificationParam>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x1005bdc0 TEMPLATE
+// MxList<LegoEventNotificationParam>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x1005beb0 TEMPLATE
+// LegoEventQueue::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x1005bf70 TEMPLATE
+// MxQueue<LegoEventNotificationParam>::`scalar deleting destructor'
+
 // OFFSET: LEGO1 0x1005bfe0
 void LegoInputManager::Destroy()
 {
@@ -270,3 +292,6 @@ void LegoInputManager::KillTimer()
 		::KillTimer(omni->GetWindowHandle(), m_timer);
 	}
 }
+
+// OFFSET: LEGO1 0x1005d010 TEMPLATE
+// MxListEntry<LegoEventNotificationParam>::GetValue
diff --git a/LEGO1/legoinputmanager.h b/LEGO1/legoinputmanager.h
index c583a64a..542bd02d 100644
--- a/LEGO1/legoinputmanager.h
+++ b/LEGO1/legoinputmanager.h
@@ -12,7 +12,17 @@
 
 class LegoControlManager;
 
+// VTABLE 0x100d87b8 TEMPLATE
+// class MxCollection<LegoEventNotificationParam>
+
+// VTABLE 0x100d87d0 TEMPLATE
+// class MxList<LegoEventNotificationParam>
+
+// VTABLE 0x100d87e8 TEMPLATE
+// class MxQueue<LegoEventNotificationParam>
+
 // VTABLE 0x100d8800
+// SIZE 0x18
 class LegoEventQueue : public MxQueue<LegoEventNotificationParam> {};
 
 // VTABLE 0x100d8760
@@ -80,37 +90,4 @@ class LegoInputManager : public MxPresenter {
 	MxBool m_unk0x336;
 };
 
-// OFFSET: LEGO1 0x1005bb80 TEMPLATE
-// MxListParent<LegoEventNotificationParam>::Compare
-
-// OFFSET: LEGO1 0x1005bc30 TEMPLATE
-// MxListParent<LegoEventNotificationParam>::Destroy
-
-// OFFSET: LEGO1 0x1005bc80 TEMPLATE
-// MxList<LegoEventNotificationParam>::~MxList<LegoEventNotificationParam>
-
-// OFFSET: LEGO1 0x1005bd50 TEMPLATE
-// MxListParent<LegoEventNotificationParam>::`scalar deleting destructor'
-
-// OFFSET: LEGO1 0x1005bdc0 TEMPLATE
-// MxList<LegoEventNotificationParam>::`scalar deleting destructor'
-
-// OFFSET: LEGO1 0x1005beb0 TEMPLATE
-// LegoEventQueue::`scalar deleting destructor'
-
-// OFFSET: LEGO1 0x1005bf70 TEMPLATE
-// MxQueue<LegoEventNotificationParam>::`scalar deleting destructor'
-
-// OFFSET: LEGO1 0x1005d010 TEMPLATE
-// MxListEntry<LegoEventNotificationParam>::GetValue
-
-// VTABLE 0x100d87e8 TEMPLATE
-// class MxQueue<LegoEventNotificationParam>
-
-// VTABLE 0x100d87d0 TEMPLATE
-// class MxList<LegoEventNotificationParam>
-
-// VTABLE 0x100d87b8 TEMPLATE
-// class MxListParent<LegoEventNotificationParam>
-
 #endif // LEGOINPUTMANAGER_H
diff --git a/LEGO1/legopalettepresenter.cpp b/LEGO1/legopalettepresenter.cpp
index 86b99b0a..6b3981a7 100644
--- a/LEGO1/legopalettepresenter.cpp
+++ b/LEGO1/legopalettepresenter.cpp
@@ -8,14 +8,34 @@ LegoPalettePresenter::LegoPalettePresenter()
 	Init();
 }
 
-// OFFSET: LEGO1 0x1007a070 STUB
+// OFFSET: LEGO1 0x1007a070
 LegoPalettePresenter::~LegoPalettePresenter()
 {
-	// TODO
+	Destroy(TRUE);
 }
 
 // OFFSET: LEGO1 0x1007a0d0
 void LegoPalettePresenter::Init()
 {
-	this->m_unk64 = 0;
+	m_palette = NULL;
+}
+
+// OFFSET: LEGO1 0x1007a0e0
+void LegoPalettePresenter::Destroy(MxBool p_fromDestructor)
+{
+	m_criticalSection.Enter();
+	if (m_palette) {
+		delete m_palette;
+	}
+	Init();
+	m_criticalSection.Leave();
+	if (!p_fromDestructor) {
+		MxVideoPresenter::Destroy(FALSE);
+	}
+}
+
+// OFFSET: LEGO1 0x1007a120
+void LegoPalettePresenter::Destroy()
+{
+	Destroy(FALSE);
 }
diff --git a/LEGO1/legopalettepresenter.h b/LEGO1/legopalettepresenter.h
index 7688d0af..9d500e08 100644
--- a/LEGO1/legopalettepresenter.h
+++ b/LEGO1/legopalettepresenter.h
@@ -2,6 +2,7 @@
 #define LEGOPALETTEPRESENTER_H
 
 #include "decomp.h"
+#include "mxpalette.h"
 #include "mxvideopresenter.h"
 
 // VTABLE 0x100d9aa0
@@ -9,7 +10,7 @@
 class LegoPalettePresenter : public MxVideoPresenter {
 public:
 	LegoPalettePresenter();
-	virtual ~LegoPalettePresenter(); // vtable+0x0
+	virtual ~LegoPalettePresenter() override; // vtable+0x0
 
 	// OFFSET: LEGO1 0x10079f30
 	inline const char* ClassName() const override // vtable+0xc
@@ -24,10 +25,12 @@ class LegoPalettePresenter : public MxVideoPresenter {
 		return !strcmp(name, ClassName()) || MxVideoPresenter::IsA(name);
 	}
 
+	virtual void Destroy() override; // vtable+0x38
 private:
 	void Init();
+	void Destroy(MxBool p_fromDestructor);
 
-	undefined4 m_unk64;
+	MxPalette* m_palette;
 };
 
 #endif // LEGOPALETTEPRESENTER_H
diff --git a/LEGO1/legopathcontrollerlist.cpp b/LEGO1/legopathcontrollerlist.cpp
new file mode 100644
index 00000000..762217c0
--- /dev/null
+++ b/LEGO1/legopathcontrollerlist.cpp
@@ -0,0 +1,42 @@
+#include "legopathcontrollerlist.h"
+
+#include "decomp.h"
+#include "legopathcontroller.h"
+
+DECOMP_SIZE_ASSERT(LegoPathControllerList, 0x18);
+
+// OFFSET: LEGO1 0x1001d210
+MxS8 LegoPathControllerList::Compare(LegoPathController* p_a, LegoPathController* p_b)
+{
+	return p_a == p_b ? 0 : p_a < p_b ? -1 : 1;
+}
+
+// OFFSET: LEGO1 0x1001d230 TEMPLATE
+// MxCollection<LegoPathController *>::Compare
+
+// OFFSET: LEGO1 0x1001d240 TEMPLATE
+// MxList<LegoPathController *>::MxList<LegoPathController *>
+
+// OFFSET: LEGO1 0x1001d2d0 TEMPLATE
+// MxCollection<LegoPathController *>::~MxCollection<LegoPathController *>
+
+// OFFSET: LEGO1 0x1001d320 TEMPLATE
+// MxCollection<LegoPathController *>::Destroy
+
+// OFFSET: LEGO1 0x1001d330 TEMPLATE
+// MxList<LegoPathController *>::~MxList<LegoPathController *>
+
+// OFFSET: LEGO1 0x1001d3c0
+void LegoPathControllerList::Destroy(LegoPathController* p_controller)
+{
+	delete p_controller;
+}
+
+// OFFSET: LEGO1 0x1001d490 TEMPLATE
+// MxCollection<LegoPathController *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x1001d500 TEMPLATE
+// MxList<LegoPathController *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x1001d5b0 TEMPLATE
+// MxPtrList<LegoPathController>::`scalar deleting destructor'
diff --git a/LEGO1/legopathcontrollerlist.h b/LEGO1/legopathcontrollerlist.h
new file mode 100644
index 00000000..f69472d6
--- /dev/null
+++ b/LEGO1/legopathcontrollerlist.h
@@ -0,0 +1,26 @@
+#ifndef LEGOPATHCONTROLLERLIST_H
+#define LEGOPATHCONTROLLERLIST_H
+
+#include "legopathcontroller.h"
+#include "mxlist.h"
+#include "mxtypes.h"
+
+// VTABLE 0x100d6320 TEMPLATE
+// class MxPtrList<LegoPathController>
+
+// VTABLE 0x100d6338
+// SIZE 0x18
+class LegoPathControllerList : public MxPtrList<LegoPathController> {
+public:
+	LegoPathControllerList() : MxPtrList<LegoPathController>(Destroy) {}
+	virtual MxS8 Compare(LegoPathController*, LegoPathController*) override; // vtable+0x14
+	static void Destroy(LegoPathController*);
+};
+
+// VTABLE 0x100d6380 TEMPLATE
+// class MxCollection<LegoPathController *>
+
+// VTABLE 0x100d6398 TEMPLATE
+// class MxList<LegoPathController *>
+
+#endif // LEGOPATHCONTROLLERLIST_H
diff --git a/LEGO1/legoworld.h b/LEGO1/legoworld.h
index b2ad8793..7f46ff58 100644
--- a/LEGO1/legoworld.h
+++ b/LEGO1/legoworld.h
@@ -3,7 +3,9 @@
 
 #include "legocameracontroller.h"
 #include "legoentity.h"
+#include "legopathcontrollerlist.h"
 #include "mxpresenter.h"
+#include "mxpresenterlist.h"
 
 // VTABLE 0x100d6280
 // SIZE 0xf8
@@ -39,9 +41,12 @@ class LegoWorld : public LegoEntity {
 	void EndAction(MxPresenter* p_presenter);
 
 protected:
-	undefined m_unk68[0x30];
-	LegoCameraController* m_camera;
-	undefined m_unk9c[0x5a];
+	LegoPathControllerList m_list0x68; // 0x68
+	MxPresenterList m_list0x80;        // 0x80
+	LegoCameraController* m_camera;    // 0x98
+	undefined m_unk9c[0x1c];
+	MxPresenterList m_list0xb8; // 0xb8
+	undefined m_unkd0[0x26];
 	undefined m_unkf6;
 	undefined m_unkf7;
 };
diff --git a/LEGO1/mxcollection.h b/LEGO1/mxcollection.h
index 0f32a064..903ba8bd 100644
--- a/LEGO1/mxcollection.h
+++ b/LEGO1/mxcollection.h
@@ -18,8 +18,8 @@ class MxCollection : public MxCore {
 	virtual MxS8 Compare(T, T) { return 0; }
 
 protected:
-	MxU32 m_count;                 // +0x8
-	void (*m_customDestructor)(T); // +0xc
+	MxU32 m_count;                 // 0x8
+	void (*m_customDestructor)(T); // 0xc
 };
 
 #endif // MXCOLLECTION_H
diff --git a/LEGO1/mxdsactionlist.cpp b/LEGO1/mxdsactionlist.cpp
index 2959ffcd..123a38eb 100644
--- a/LEGO1/mxdsactionlist.cpp
+++ b/LEGO1/mxdsactionlist.cpp
@@ -17,3 +17,18 @@ void MxDSActionList::Destroy(MxDSAction* p_action)
 	if (p_action)
 		delete p_action;
 }
+
+// OFFSET: LEGO1 0x100c9cc0 TEMPLATE
+// MxCollection<MxDSAction *>::Compare
+
+// OFFSET: LEGO1 0x100c9d20 TEMPLATE
+// MxCollection<MxDSAction *>::Destroy
+
+// OFFSET: LEGO1 0x100c9d30 TEMPLATE
+// MxList<MxDSAction *>::~MxList<MxDSAction *>
+
+// OFFSET: LEGO1 0x100c9e30 TEMPLATE
+// MxCollection<MxDSAction *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100c9ea0 TEMPLATE
+// MxList<MxDSAction *>::`scalar deleting destructor'
diff --git a/LEGO1/mxdsactionlist.h b/LEGO1/mxdsactionlist.h
index d3bafbbb..b6ca0c11 100644
--- a/LEGO1/mxdsactionlist.h
+++ b/LEGO1/mxdsactionlist.h
@@ -6,13 +6,19 @@
 
 class MxDSAction;
 
+// VTABLE 0x100dcea8 TEMPLATE
+// class MxCollection<MxDSAction *>
+
+// VTABLE 0x100dcec0 TEMPLATE
+// class MxList<MxDSAction *>
+
 // VTABLE 0x100dced8
 // SIZE 0x1c
 class MxDSActionList : public MxList<MxDSAction*> {
 public:
 	MxDSActionList() { this->m_unk18 = 0; }
 
-	virtual MxS8 Compare(MxDSAction*, MxDSAction*) override; // +0x14
+	virtual MxS8 Compare(MxDSAction*, MxDSAction*) override; // vtable+0x14
 
 	static void Destroy(MxDSAction* p_action);
 
@@ -22,13 +28,4 @@ class MxDSActionList : public MxList<MxDSAction*> {
 
 typedef MxListCursorChild<MxDSAction*> MxDSActionListCursor;
 
-// OFFSET: LEGO1 0x100c9cc0 TEMPLATE
-// MxListParent<MxDSAction *>::Compare
-
-// OFFSET: LEGO1 0x100c9d20 TEMPLATE
-// MxListParent<MxDSAction *>::Destroy
-
-// OFFSET: LEGO1 0x100c9d30 TEMPLATE
-// MxList<MxDSAction *>::~MxList<MxDSAction *>
-
 #endif // MXDSACTIONLIST_H
diff --git a/LEGO1/mxentity.cpp b/LEGO1/mxentity.cpp
index 27067e37..524bb293 100644
--- a/LEGO1/mxentity.cpp
+++ b/LEGO1/mxentity.cpp
@@ -14,7 +14,7 @@ MxEntity::~MxEntity()
 }
 
 // OFFSET: LEGO1 0x10001070
-MxResult MxEntity::SetEntityId(MxS32 p_id, const MxAtomId& p_atom)
+MxResult MxEntity::Create(MxS32 p_id, const MxAtomId& p_atom)
 {
 	this->m_mxEntityId = p_id;
 	this->m_atom = p_atom;
diff --git a/LEGO1/mxentity.h b/LEGO1/mxentity.h
index 4ec82f1c..aa8df045 100644
--- a/LEGO1/mxentity.h
+++ b/LEGO1/mxentity.h
@@ -27,8 +27,8 @@ class MxEntity : public MxCore {
 		return !strcmp(name, MxEntity::ClassName()) || MxCore::IsA(name);
 	}
 
-	virtual MxResult SetEntityId(MxS32 p_id, const MxAtomId& p_atom); // vtable+0x14
-	inline MxResult InitFromMxDSObject(MxDSObject& p_dsObject)
+	virtual MxResult Create(MxS32 p_id, const MxAtomId& p_atom); // vtable+0x14
+	inline MxResult Create(MxDSObject& p_dsObject)
 	{
 		m_mxEntityId = p_dsObject.GetObjectId();
 		m_atom = p_dsObject.GetAtomId();
diff --git a/LEGO1/mxflcpresenter.cpp b/LEGO1/mxflcpresenter.cpp
index 5c8c23a5..991e0bbe 100644
--- a/LEGO1/mxflcpresenter.cpp
+++ b/LEGO1/mxflcpresenter.cpp
@@ -1,6 +1,10 @@
 #include "mxflcpresenter.h"
 
 #include "decomp.h"
+#include "mxbitmap.h"
+#include "mxomni.h"
+#include "mxpalette.h"
+#include "mxvideomanager.h"
 
 DECOMP_SIZE_ASSERT(MxFlcPresenter, 0x68);
 
@@ -19,3 +23,13 @@ MxFlcPresenter::~MxFlcPresenter()
 		delete this->m_unk64;
 	}
 }
+
+// OFFSET: LEGO1 0x100b3620
+void MxFlcPresenter::VTable0x70()
+{
+	MxPalette* pal = m_bitmap->CreatePalette();
+	MVideoManager()->RealizePalette(pal);
+
+	if (pal)
+		delete pal;
+}
diff --git a/LEGO1/mxflcpresenter.h b/LEGO1/mxflcpresenter.h
index 99035172..6fcf8973 100644
--- a/LEGO1/mxflcpresenter.h
+++ b/LEGO1/mxflcpresenter.h
@@ -24,6 +24,8 @@ class MxFlcPresenter : public MxVideoPresenter {
 		return !strcmp(name, MxFlcPresenter::ClassName()) || MxVideoPresenter::IsA(name);
 	}
 
+	virtual void VTable0x70() override; // vtable+0x70
+
 	undefined4* m_unk64;
 };
 
diff --git a/LEGO1/mxhashtable.h b/LEGO1/mxhashtable.h
index a276cfd8..b09bf28c 100644
--- a/LEGO1/mxhashtable.h
+++ b/LEGO1/mxhashtable.h
@@ -59,16 +59,16 @@ class MxHashTable : protected MxCollection<T> {
 protected:
 	void _NodeInsert(MxHashTableNode<T>*);
 
-	MxHashTableNode<T>** m_slots; // +0x10
-	MxU32 m_numSlots;             // +0x14
-	MxU32 m_autoResizeRatio;      // +0x18
-	HashTableOpt m_resizeOption;  // +0x1c
+	MxHashTableNode<T>** m_slots; // 0x10
+	MxU32 m_numSlots;             // 0x14
+	MxU32 m_autoResizeRatio;      // 0x18
+	HashTableOpt m_resizeOption;  // 0x1c
 	// FIXME: or FIXME? This qword is used as an integer or double depending
 	// on the value of m_resizeOption. Hard to say whether this is how the devs
 	// did it, but a simple cast in either direction doesn't match.
 	union {
-		MxU32 m_increaseAmount;  // +0x20
-		double m_increaseFactor; // +0x20
+		MxU32 m_increaseAmount;  // 0x20
+		double m_increaseFactor; // 0x20
 	};
 };
 
@@ -156,13 +156,13 @@ void MxHashTable<T>::DeleteAll()
 
 		while (t) {
 			MxHashTableNode<T>* next = t->m_next;
-			m_customDestructor(t->m_obj);
+			this->m_customDestructor(t->m_obj);
 			delete t;
 			t = next;
 		}
 	}
 
-	m_count = 0;
+	this->m_count = 0;
 	memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
 
 	delete[] m_slots;
@@ -188,7 +188,7 @@ inline void MxHashTable<T>::Resize()
 	MxHashTableNode<T>** new_table = new MxHashTableNode<T>*[m_numSlots];
 	m_slots = new_table;
 	memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
-	m_count = 0;
+	this->m_count = 0;
 
 	for (MxS32 i = 0; i != old_size; i++) {
 		MxHashTableNode<T>* t = old_table[i];
@@ -214,13 +214,13 @@ inline void MxHashTable<T>::_NodeInsert(MxHashTableNode<T>* p_node)
 		m_slots[bucket]->m_prev = p_node;
 
 	m_slots[bucket] = p_node;
-	m_count++;
+	this->m_count++;
 }
 
 template <class T>
 inline void MxHashTable<T>::Add(T p_newobj)
 {
-	if (m_resizeOption && ((m_count + 1) / m_numSlots) > m_autoResizeRatio)
+	if (m_resizeOption && ((this->m_count + 1) / m_numSlots) > m_autoResizeRatio)
 		MxHashTable<T>::Resize();
 
 	MxU32 hash = Hash(p_newobj);
diff --git a/LEGO1/mxlist.h b/LEGO1/mxlist.h
index 11f0e8ba..d44d6c8f 100644
--- a/LEGO1/mxlist.h
+++ b/LEGO1/mxlist.h
@@ -1,6 +1,7 @@
 #ifndef MXLIST_H
 #define MXLIST_H
 
+#include "mxcollection.h"
 #include "mxcore.h"
 #include "mxtypes.h"
 
@@ -9,6 +10,12 @@ class MxList;
 template <class T>
 class MxListCursor;
 
+template <class T>
+class MxPtrList : public MxList<T*> {
+public:
+	MxPtrList(void (*p_destroy)(T*) = Destroy) { m_customDestructor = p_destroy; }
+};
+
 template <class T>
 class MxListEntry {
 public:
@@ -40,29 +47,9 @@ class MxListEntry {
 	MxListEntry* m_next;
 };
 
-// SIZE 0x10
-template <class T>
-class MxListParent : public MxCore {
-public:
-	MxListParent()
-	{
-		m_count = 0;
-		m_customDestructor = Destroy;
-	}
-
-	virtual ~MxListParent() {}
-	virtual MxS8 Compare(T, T) { return 0; };
-
-	static void Destroy(T){};
-
-protected:
-	MxU32 m_count;                 // +0x8
-	void (*m_customDestructor)(T); // +0xc
-};
-
 // SIZE 0x18
 template <class T>
-class MxList : protected MxListParent<T> {
+class MxList : protected MxCollection<T> {
 public:
 	MxList()
 	{
@@ -80,8 +67,8 @@ class MxList : protected MxListParent<T> {
 	friend class MxListCursor<T>;
 
 protected:
-	MxListEntry<T>* m_first; // +0x10
-	MxListEntry<T>* m_last;  // +0x14
+	MxListEntry<T>* m_first; // 0x10
+	MxListEntry<T>* m_last;  // 0x14
 
 	void _DeleteEntry(MxListEntry<T>* match);
 	MxListEntry<T>* _InsertEntry(T, MxListEntry<T>*, MxListEntry<T>*);
diff --git a/LEGO1/mxpresenterlist.cpp b/LEGO1/mxpresenterlist.cpp
index f6ed6594..da625f24 100644
--- a/LEGO1/mxpresenterlist.cpp
+++ b/LEGO1/mxpresenterlist.cpp
@@ -10,3 +10,27 @@ MxS8 MxPresenterList::Compare(MxPresenter* p_a, MxPresenter* p_b)
 {
 	return p_a == p_b ? 0 : p_a < p_b ? -1 : 1;
 }
+
+// OFFSET: LEGO1 0x1001cd20 TEMPLATE
+// MxCollection<MxPresenter *>::Compare
+
+// OFFSET: LEGO1 0x1001cd30 TEMPLATE
+// MxCollection<MxPresenter *>::Destroy
+
+// OFFSET: LEGO1 0x1001cd40 TEMPLATE
+// MxList<MxPresenter *>::MxList<MxPresenter *>
+
+// OFFSET: LEGO1 0x1001cdd0 TEMPLATE
+// MxCollection<MxPresenter *>::~MxCollection<MxPresenter *>
+
+// OFFSET: LEGO1 0x1001ce20 TEMPLATE
+// MxList<MxPresenter *>::~MxList<MxPresenter *>
+
+// OFFSET: LEGO1 0x1001cf70 TEMPLATE
+// MxCollection<MxPresenter *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x1001cfe0 TEMPLATE
+// MxList<MxPresenter *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x1001d090 TEMPLATE
+// MxPtrList<MxPresenter>::`scalar deleting destructor'
diff --git a/LEGO1/mxpresenterlist.h b/LEGO1/mxpresenterlist.h
index 350d6c17..b8c95950 100644
--- a/LEGO1/mxpresenterlist.h
+++ b/LEGO1/mxpresenterlist.h
@@ -5,30 +5,22 @@
 
 class MxPresenter;
 
-// Unclear what the purpose of this class is
-// VTABLE 0x100d62f0
-// SIZE 0x18
-class MxPresenterListParent : public MxList<MxPresenter*> {
-public:
-	MxPresenterListParent() { m_customDestructor = Destroy; }
-};
+// VTABLE 0x100d62f0 TEMPLATE
+// class MxPtrList<MxPresenter>
 
 // VTABLE 0x100d6308
 // SIZE 0x18
-class MxPresenterList : public MxPresenterListParent {
+class MxPresenterList : public MxPtrList<MxPresenter> {
 public:
-	virtual MxS8 Compare(MxPresenter*, MxPresenter*) override; // +0x14
+	virtual MxS8 Compare(MxPresenter*, MxPresenter*) override; // vtable+0x14
 };
 
 typedef MxListCursorChildChild<MxPresenter*> MxPresenterListCursor;
 
-// OFFSET: LEGO1 0x1001cd20 TEMPLATE
-// MxListParent<MxPresenter *>::Compare
+// VTABLE 0x100d6350 TEMPLATE
+// class MxCollection<MxPresenter *>
 
-// OFFSET: LEGO1 0x1001cd30 TEMPLATE
-// MxListParent<MxPresenter *>::Destroy
-
-// OFFSET: LEGO1 0x1001ce20 TEMPLATE
-// MxList<MxPresenter *>::~MxList<MxPresenter *>
+// VTABLE 0x100d6368 TEMPLATE
+// class MxList<MxPresenter *>
 
 #endif // MXPRESENTERLIST_H
diff --git a/LEGO1/mxregion.h b/LEGO1/mxregion.h
index ac6acd5e..a0fa7475 100644
--- a/LEGO1/mxregion.h
+++ b/LEGO1/mxregion.h
@@ -21,7 +21,7 @@ struct MxRegionTopBottom {
 	inline void SetTop(MxS32 p_top) { m_top = p_top; }
 	inline void SetBottom(MxS32 p_bottom) { m_bottom = p_bottom; }
 
-	friend class MxRegionListParent;
+	friend class MxRegionList;
 
 private:
 	MxS32 m_top;
diff --git a/LEGO1/mxregionlist.cpp b/LEGO1/mxregionlist.cpp
index a33d78b7..74e5739a 100644
--- a/LEGO1/mxregionlist.cpp
+++ b/LEGO1/mxregionlist.cpp
@@ -3,7 +3,7 @@
 #include "mxregion.h"
 
 // OFFSET: LEGO1 0x100c33e0
-void MxRegionListParent::Destroy(MxRegionTopBottom* p_topBottom)
+void MxRegionList::Destroy(MxRegionTopBottom* p_topBottom)
 {
 	if (p_topBottom) {
 		if (p_topBottom->m_leftRightList)
@@ -13,7 +13,52 @@ void MxRegionListParent::Destroy(MxRegionTopBottom* p_topBottom)
 }
 
 // OFFSET: LEGO1 0x100c4e80
-void MxRegionLeftRightListParent::Destroy(MxRegionLeftRight* p_leftRight)
+void MxRegionLeftRightList::Destroy(MxRegionLeftRight* p_leftRight)
 {
 	delete p_leftRight;
 }
+
+// OFFSET: LEGO1 0x100c32e0 TEMPLATE
+// MxCollection<MxRegionTopBottom *>::Compare
+
+// OFFSET: LEGO1 0x100c3340 TEMPLATE
+// MxCollection<MxRegionTopBottom *>::Destroy
+
+// OFFSET: LEGO1 0x100c34d0 TEMPLATE
+// MxCollection<MxRegionTopBottom *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100c3540 TEMPLATE
+// MxList<MxRegionTopBottom *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100c35f0 TEMPLATE
+// MxPtrList<MxRegionTopBottom>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100c4d80 TEMPLATE
+// MxCollection<MxRegionLeftRight *>::Compare
+
+// OFFSET: LEGO1 0x100c4de0 TEMPLATE
+// MxCollection<MxRegionLeftRight *>::Destroy
+
+// OFFSET: LEGO1 0x100c4f50 TEMPLATE
+// MxCollection<MxRegionLeftRight *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100c4fc0 TEMPLATE
+// MxList<MxRegionLeftRight *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100c5070 TEMPLATE
+// MxPtrList<MxRegionLeftRight>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100c54f0 TEMPLATE
+// MxListCursor<MxRegionLeftRight *>::MxListCursor<MxRegionLeftRight *>
+
+// OFFSET: LEGO1 0x100c58c0 TEMPLATE
+// MxList<MxRegionLeftRight *>::_InsertEntry
+
+// OFFSET: LEGO1 0x100c5970 TEMPLATE
+// MxList<MxRegionTopBottom *>::_InsertEntry
+
+// OFFSET: LEGO1 0x100c5a20 TEMPLATE
+// MxListEntry<MxRegionTopBottom *>::MxListEntry<MxRegionTopBottom *>
+
+// OFFSET: LEGO1 0x100c5a40 TEMPLATE
+// MxList<MxRegionLeftRight *>::_DeleteEntry
diff --git a/LEGO1/mxregionlist.h b/LEGO1/mxregionlist.h
index 52336d38..c3a5d2ef 100644
--- a/LEGO1/mxregionlist.h
+++ b/LEGO1/mxregionlist.h
@@ -6,51 +6,44 @@
 struct MxRegionTopBottom;
 struct MxRegionLeftRight;
 
-// VTABLE 0x100dcb40
-// SIZE 0x18
-class MxRegionListParent : public MxList<MxRegionTopBottom*> {
-public:
-	static void Destroy(MxRegionTopBottom* p_topBottom);
+// VTABLE 0x100dcb10 TEMPLATE
+// class MxCollection<MxRegionTopBottom *>
 
-	MxRegionListParent() { m_customDestructor = Destroy; }
-};
+// VTABLE 0x100dcb28 TEMPLATE
+// class MxList<MxRegionTopBottom *>
+
+// VTABLE 0x100dcb40 TEMPLATE
+// class MxPtrList<MxRegionTopBottom>
 
 // VTABLE 0x100dcb58
 // SIZE 0x18
-class MxRegionList : public MxRegionListParent {};
+class MxRegionList : public MxPtrList<MxRegionTopBottom> {
+public:
+	MxRegionList() : MxPtrList<MxRegionTopBottom>(Destroy) {}
+	static void Destroy(MxRegionTopBottom*);
+};
 
 // VTABLE 0x100dcb88
 typedef MxListCursorChildChild<MxRegionTopBottom*> MxRegionListCursor;
 
-// OFFSET: LEGO1 0x100c5970 TEMPLATE
-// MxList<MxRegionTopBottom *>::_InsertEntry
-
-// OFFSET: LEGO1 0x100c5a20 TEMPLATE
-// MxListEntry<MxRegionTopBottom *>::MxListEntry<MxRegionTopBottom *>
-
-// VTABLE 0x100dcc70
-// SIZE 0x18
-class MxRegionLeftRightListParent : public MxList<MxRegionLeftRight*> {
-public:
-	static void Destroy(MxRegionLeftRight* p_leftRight);
-
-	MxRegionLeftRightListParent() { m_customDestructor = Destroy; }
-};
-
-// VTABLE 0x100dcc88
-// SIZE 0x18
-class MxRegionLeftRightList : public MxRegionLeftRightListParent {};
-
 // VTABLE 0x100dcc10
 typedef MxListCursorChildChild<MxRegionLeftRight*> MxRegionLeftRightListCursor;
 
-// OFFSET: LEGO1 0x100c54f0 TEMPLATE
-// MxListCursor<MxRegionLeftRight *>::MxListCursor<MxRegionLeftRight *>
+// VTABLE 0x100dcc40 TEMPLATE
+// class MxCollection<MxRegionLeftRight *>
 
-// OFFSET: LEGO1 0x100c58c0 TEMPLATE
-// MxList<MxRegionLeftRight *>::_InsertEntry
+// VTABLE 0x100dcc58 TEMPLATE
+// class MxList<MxRegionLeftRight *>
 
-// OFFSET: LEGO1 0x100c5a40 TEMPLATE
-// MxList<MxRegionLeftRight *>::_DeleteEntry
+// VTABLE 0x100dcc70 TEMPLATE
+// class MxPtrList<MxRegionLeftRight>
+
+// VTABLE 0x100dcc88
+// SIZE 0x18
+class MxRegionLeftRightList : public MxPtrList<MxRegionLeftRight> {
+public:
+	MxRegionLeftRightList() : MxPtrList<MxRegionLeftRight>(Destroy) {}
+	static void Destroy(MxRegionLeftRight*);
+};
 
 #endif // MXREGIONLIST_H
diff --git a/LEGO1/mxstreamchunklist.cpp b/LEGO1/mxstreamchunklist.cpp
index 8c76452e..46a610ad 100644
--- a/LEGO1/mxstreamchunklist.cpp
+++ b/LEGO1/mxstreamchunklist.cpp
@@ -17,3 +17,18 @@ void MxStreamChunkList::Destroy(MxStreamChunk* p_chunk)
 	if (p_chunk)
 		delete p_chunk;
 }
+
+// OFFSET: LEGO1 0x100b5930 TEMPLATE
+// MxCollection<MxStreamChunk *>::Compare
+
+// OFFSET: LEGO1 0x100b5990 TEMPLATE
+// MxCollection<MxStreamChunk *>::Destroy
+
+// OFFSET: LEGO1 0x100b59a0 TEMPLATE
+// MxList<MxStreamChunk *>::~MxList<MxStreamChunk *>
+
+// OFFSET: LEGO1 0x100b5aa0 TEMPLATE
+// MxCollection<MxStreamChunk *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100b5b10 TEMPLATE
+// MxList<MxStreamChunk *>::`scalar deleting destructor'
diff --git a/LEGO1/mxstreamchunklist.h b/LEGO1/mxstreamchunklist.h
index 3a19950b..9a84e572 100644
--- a/LEGO1/mxstreamchunklist.h
+++ b/LEGO1/mxstreamchunklist.h
@@ -6,29 +6,23 @@
 
 class MxStreamChunk;
 
+// VTABLE 0x100dc5d0 TEMPLATE
+// class MxCollection<MxStreamChunk *>
+
+// VTABLE 0x100dc5e8 TEMPLATE
+// class MxList<MxStreamChunk *>
+
 // VTABLE 0x100dc600
 // SIZE 0x18
 class MxStreamChunkList : public MxList<MxStreamChunk*> {
 public:
 	MxStreamChunkList() { m_customDestructor = Destroy; }
 
-	virtual MxS8 Compare(MxStreamChunk*, MxStreamChunk*) override; // +0x14
+	virtual MxS8 Compare(MxStreamChunk*, MxStreamChunk*) override; // vtable+0x14
 
 	static void Destroy(MxStreamChunk* p_chunk);
 };
 
 typedef MxListCursorChild<MxStreamChunk*> MxStreamChunkListCursor;
 
-// OFFSET: LEGO1 0x100b5930 TEMPLATE
-// MxListParent<MxStreamChunk *>::Compare
-
-// OFFSET: LEGO1 0x100b5990 TEMPLATE
-// MxListParent<MxStreamChunk *>::Destroy
-
-// OFFSET: LEGO1 0x100b59a0 TEMPLATE
-// MxList<MxStreamChunk *>::~MxList<MxStreamChunk *>
-
-// OFFSET: LEGO1 0x100b5b10 TEMPLATE
-// MxList<MxStreamChunk *>::`scalar deleting destructor'
-
 #endif // MXSTREAMCHUNKLIST_H
diff --git a/LEGO1/mxstringlist.cpp b/LEGO1/mxstringlist.cpp
index 8a0a2ddc..9279e8cf 100644
--- a/LEGO1/mxstringlist.cpp
+++ b/LEGO1/mxstringlist.cpp
@@ -3,3 +3,24 @@
 #include "decomp.h"
 
 DECOMP_SIZE_ASSERT(MxListEntry<MxString>, 0x18)
+
+// OFFSET: LEGO1 0x100cb3c0 TEMPLATE
+// MxCollection<MxString>::Compare
+
+// OFFSET: LEGO1 0x100cb470 TEMPLATE
+// MxCollection<MxString>::Destroy
+
+// OFFSET: LEGO1 0x100cb4c0 TEMPLATE
+// MxList<MxString>::~MxList<MxString>
+
+// OFFSET: LEGO1 0x100cbb40 TEMPLATE
+// MxList<MxString>::Append
+
+// OFFSET: LEGO1 0x100cc2d0 TEMPLATE
+// MxList<MxString>::_InsertEntry
+
+// OFFSET: LEGO1 0x100cc3c0 TEMPLATE
+// MxListEntry<MxString>::MxListEntry<MxString>
+
+// OFFSET: LEGO1 0x100cc450 TEMPLATE
+// MxListEntry<MxString>::GetValue
diff --git a/LEGO1/mxstringlist.h b/LEGO1/mxstringlist.h
index d80c4777..f397fbf7 100644
--- a/LEGO1/mxstringlist.h
+++ b/LEGO1/mxstringlist.h
@@ -11,25 +11,4 @@ class MxStringList : public MxList<MxString> {};
 // VTABLE 0x100dd058
 typedef MxListCursorChild<MxString> MxStringListCursor;
 
-// OFFSET: LEGO1 0x100cb3c0 TEMPLATE
-// MxListParent<MxString>::Compare
-
-// OFFSET: LEGO1 0x100cb470 TEMPLATE
-// MxListParent<MxString>::Destroy
-
-// OFFSET: LEGO1 0x100cb4c0 TEMPLATE
-// MxList<MxString>::~MxList<MxString>
-
-// OFFSET: LEGO1 0x100cbb40 TEMPLATE
-// MxList<MxString>::Append
-
-// OFFSET: LEGO1 0x100cc2d0 TEMPLATE
-// MxList<MxString>::_InsertEntry
-
-// OFFSET: LEGO1 0x100cc3c0 TEMPLATE
-// MxListEntry<MxString>::MxListEntry<MxString>
-
-// OFFSET: LEGO1 0x100cc450 TEMPLATE
-// MxListEntry<MxString>::GetValue
-
 #endif // MXSTRINGLIST_H
diff --git a/LEGO1/mxvariabletable.h b/LEGO1/mxvariabletable.h
index 872aa49f..1df02204 100644
--- a/LEGO1/mxvariabletable.h
+++ b/LEGO1/mxvariabletable.h
@@ -17,8 +17,8 @@ class MxVariableTable : public MxHashTable<MxVariable*> {
 	// OFFSET: LEGO1 0x100afdb0
 	static void Destroy(MxVariable* p_obj) { p_obj->Destroy(); }
 
-	virtual MxS8 Compare(MxVariable*, MxVariable*) override; // +0x14
-	virtual MxU32 Hash(MxVariable*) override;                // +0x18
+	virtual MxS8 Compare(MxVariable*, MxVariable*) override; // vtable+0x14
+	virtual MxU32 Hash(MxVariable*) override;                // vtable+0x18
 };
 
 // OFFSET: LEGO1 0x100afcd0 TEMPLATE
diff --git a/LEGO1/score.cpp b/LEGO1/score.cpp
index 1c122482..2b7f2d95 100644
--- a/LEGO1/score.cpp
+++ b/LEGO1/score.cpp
@@ -74,7 +74,7 @@ MxBool Score::VTable0x5c()
 }
 
 // OFFSET: LEGO1 0x100012a0
-MxResult Score::InitFromMxDSObject(MxDSObject& p_dsObject)
+MxResult Score::Create(MxDSObject& p_dsObject)
 {
 	MxResult result = SetAsCurrentWorld(p_dsObject);
 
diff --git a/LEGO1/score.h b/LEGO1/score.h
index 612bba4c..756ba089 100644
--- a/LEGO1/score.h
+++ b/LEGO1/score.h
@@ -29,13 +29,13 @@ class Score : public LegoWorld {
 	}
 
 	// OFFSET: LEGO1 0x100011e0 TEMPLATE
-	// Helicopter::`scalar deleting destructor'
+	// Score::`scalar deleting destructor'
 
-	virtual MxResult InitFromMxDSObject(MxDSObject& p_dsObject) override; // vtable+18
-	virtual void Stop() override;                                         // vtable+50
-	virtual MxBool VTable0x5c() override;                                 // vtable+5c
-	virtual MxBool VTable0x64() override;                                 // vtable+64
-	virtual void VTable0x68(MxBool p_add) override;                       // vtable+68
+	virtual MxResult Create(MxDSObject& p_dsObject) override; // vtable+18
+	virtual void Stop() override;                             // vtable+50
+	virtual MxBool VTable0x5c() override;                     // vtable+5c
+	virtual MxBool VTable0x64() override;                     // vtable+64
+	virtual void VTable0x68(MxBool p_add) override;           // vtable+68
 
 	void Paint();
 	MxLong FUN_10001510(MxEndActionNotificationParam& p);