diff --git a/LEGO1/legobuildingmanager.cpp b/LEGO1/legobuildingmanager.cpp
index 3c6b26b1..b4450e2e 100644
--- a/LEGO1/legobuildingmanager.cpp
+++ b/LEGO1/legobuildingmanager.cpp
@@ -3,10 +3,10 @@
 // 0x100f37cc
 int g_buildingManagerConfig = 1;
 
-// OFFSET: LEGO1 0x1002f8c0 STUB
+// OFFSET: LEGO1 0x1002f8c0
 LegoBuildingManager::LegoBuildingManager()
 {
-	// TODO
+	Init();
 }
 
 // OFFSET: LEGO1 0x1002f960 STUB
diff --git a/LEGO1/legoomni.cpp b/LEGO1/legoomni.cpp
index fb5e187c..12cc7f9f 100644
--- a/LEGO1/legoomni.cpp
+++ b/LEGO1/legoomni.cpp
@@ -532,7 +532,7 @@ MxBool LegoOmni::DoesEntityExist(MxDSAction& ds)
 }
 
 // OFFSET: LEGO1 0x1005b2f0
-MxEntity* LegoOmni::FindWorld(const char* p_id, MxS32 p_entityId, MxCore* p_presenter)
+MxEntity* LegoOmni::FindWorld(const char* p_id, MxS32 p_entityId, MxPresenter* p_presenter)
 {
 	LegoWorld* foundEntity = NULL;
 	if (strcmpi(p_id, g_current)) {
diff --git a/LEGO1/legoomni.h b/LEGO1/legoomni.h
index 52ea2d85..3406bd6c 100644
--- a/LEGO1/legoomni.h
+++ b/LEGO1/legoomni.h
@@ -83,16 +83,16 @@ class LegoOmni : public MxOmni {
 		return !strcmp(name, LegoOmni::ClassName()) || MxOmni::IsA(name);
 	}
 
-	virtual void Init() override;                                                                  // vtable+14
-	virtual MxResult Create(MxOmniCreateParam& p) override;                                        // vtable+18
-	virtual void Destroy() override;                                                               // vtable+1c
-	virtual MxResult Start(MxDSAction* action) override;                                           // vtable+20
-	virtual MxResult DeleteObject(MxDSAction& ds) override;                                        // vtable+24
-	virtual MxBool DoesEntityExist(MxDSAction& ds) override;                                       // vtable+28
-	virtual MxEntity* FindWorld(const char* p_id, MxS32 p_entityId, MxCore* p_presenter) override; // vtable+30
-	virtual void NotifyCurrentEntity(MxNotificationParam* p_param) override;                       // vtable+34
-	virtual void StartTimer() override;                                                            // vtable+38
-	virtual void StopTimer() override;                                                             // vtable+3c
+	virtual void Init() override;                                                                       // vtable+14
+	virtual MxResult Create(MxOmniCreateParam& p) override;                                             // vtable+18
+	virtual void Destroy() override;                                                                    // vtable+1c
+	virtual MxResult Start(MxDSAction* action) override;                                                // vtable+20
+	virtual MxResult DeleteObject(MxDSAction& ds) override;                                             // vtable+24
+	virtual MxBool DoesEntityExist(MxDSAction& ds) override;                                            // vtable+28
+	virtual MxEntity* FindWorld(const char* p_id, MxS32 p_entityId, MxPresenter* p_presenter) override; // vtable+30
+	virtual void NotifyCurrentEntity(MxNotificationParam* p_param) override;                            // vtable+34
+	virtual void StartTimer() override;                                                                 // vtable+38
+	virtual void StopTimer() override;                                                                  // vtable+3c
 
 	LegoEntity* FindByEntityIdOrAtomId(const MxAtomId& p_atom, MxS32 p_entityid);
 
diff --git a/LEGO1/legotexturepresenter.cpp b/LEGO1/legotexturepresenter.cpp
index 56925d97..2e9dba68 100644
--- a/LEGO1/legotexturepresenter.cpp
+++ b/LEGO1/legotexturepresenter.cpp
@@ -1,7 +1,17 @@
 #include "legotexturepresenter.h"
 
-// OFFSET: LEGO1 0x1004eb40 STUB
+#include "legoomni.h"
+#include "legovideomanager.h"
+
+// OFFSET: LEGO1 0x1004eb40
 LegoTexturePresenter::~LegoTexturePresenter()
 {
-	// TODO
+	VideoManager()->RemovePresenter(*this);
+}
+
+// OFFSET: LEGO1 0x1004ebb0
+MxResult LegoTexturePresenter::AddToManager()
+{
+	VideoManager()->AddPresenter(*this);
+	return SUCCESS;
 }
diff --git a/LEGO1/legotexturepresenter.h b/LEGO1/legotexturepresenter.h
index 50d6f86c..e39e4758 100644
--- a/LEGO1/legotexturepresenter.h
+++ b/LEGO1/legotexturepresenter.h
@@ -21,6 +21,8 @@ class LegoTexturePresenter : public MxMediaPresenter {
 	{
 		return !strcmp(name, LegoTexturePresenter::ClassName()) || MxMediaPresenter::IsA(name);
 	}
+
+	virtual MxResult AddToManager() override; // vtable+0x34
 };
 
 #endif // LEGOTEXTUREPRESENTER_H
diff --git a/LEGO1/mxcollection.h b/LEGO1/mxcollection.h
new file mode 100644
index 00000000..0f32a064
--- /dev/null
+++ b/LEGO1/mxcollection.h
@@ -0,0 +1,25 @@
+#ifndef MXCOLLECTION_H
+#define MXCOLLECTION_H
+
+#include "mxcore.h"
+
+template <class T>
+class MxCollection : public MxCore {
+public:
+	MxCollection()
+	{
+		m_count = 0;
+		m_customDestructor = Destroy;
+	}
+
+	virtual ~MxCollection() {}
+
+	static void Destroy(T){};
+	virtual MxS8 Compare(T, T) { return 0; }
+
+protected:
+	MxU32 m_count;                 // +0x8
+	void (*m_customDestructor)(T); // +0xc
+};
+
+#endif // MXCOLLECTION_H
diff --git a/LEGO1/mxcompositepresenter.cpp b/LEGO1/mxcompositepresenter.cpp
index 25a290a4..b702acda 100644
--- a/LEGO1/mxcompositepresenter.cpp
+++ b/LEGO1/mxcompositepresenter.cpp
@@ -35,8 +35,10 @@ void MxCompositePresenter::VTable0x60(undefined4 p_unknown)
 	// TODO
 }
 
-// OFFSET: LEGO1 0x1000caf0 STUB
-void MxCompositePresenter::VTable0x64()
+// OFFSET: LEGO1 0x1000caf0
+MxBool MxCompositePresenter::VTable0x64(undefined4 p_unknown)
 {
-	// TODO
+	if (m_compositePresenter)
+		return m_compositePresenter->VTable0x64(p_unknown);
+	return TRUE;
 }
diff --git a/LEGO1/mxcompositepresenter.h b/LEGO1/mxcompositepresenter.h
index 7def4ded..c8eedfaf 100644
--- a/LEGO1/mxcompositepresenter.h
+++ b/LEGO1/mxcompositepresenter.h
@@ -27,7 +27,7 @@ class MxCompositePresenter : public MxPresenter {
 	virtual void VTable0x58();
 	virtual void VTable0x5c();
 	virtual void VTable0x60(undefined4 p_unknown);
-	virtual void VTable0x64();
+	virtual MxBool VTable0x64(undefined4 p_unknown);
 
 private:
 	MxUnkList m_list;
diff --git a/LEGO1/mxdsaction.h b/LEGO1/mxdsaction.h
index 1126481d..01e4af51 100644
--- a/LEGO1/mxdsaction.h
+++ b/LEGO1/mxdsaction.h
@@ -18,7 +18,7 @@ class MxDSAction : public MxDSObject {
 		Flag_Bit5 = 0x10,
 		Flag_Enabled = 0x20,
 		Flag_Bit7 = 0x40,
-		Flag_Parsed = 0x80,
+		Flag_World = 0x80,
 		Flag_Bit9 = 0x200,
 		Flag_Bit10 = 0x400,
 	};
@@ -64,6 +64,7 @@ class MxDSAction : public MxDSObject {
 	inline void SetLoopCount(MxS32 p_loopCount) { m_loopCount = p_loopCount; }
 	inline const MxVector3Data& GetLocation() const { return m_location; }
 	inline void SetUnknown84(MxCore* p_unk84) { m_unk84 = p_unk84; }
+	inline MxCore* GetUnknown8c() { return m_unk8c; }
 	inline void SetUnknown8c(MxCore* p_unk8c) { m_unk8c = p_unk8c; }
 
 	inline MxBool IsLooping() const { return m_flags & Flag_Looping; }
diff --git a/LEGO1/mxhashtable.h b/LEGO1/mxhashtable.h
index 54ca16bd..a276cfd8 100644
--- a/LEGO1/mxhashtable.h
+++ b/LEGO1/mxhashtable.h
@@ -1,13 +1,11 @@
 #ifndef MXHASHTABLE_H
 #define MXHASHTABLE_H
 
+#include "mxcollection.h"
 #include "mxcore.h"
 #include "mxtypes.h"
 
 #define HASH_TABLE_INIT_SIZE 128
-#define HASH_TABLE_OPT_NO_EXPAND 0
-#define HASH_TABLE_OPT_EXPAND_ADD 1
-#define HASH_TABLE_OPT_EXPAND_MULTIPLY 2
 
 template <class T>
 class MxHashTableCursor;
@@ -15,8 +13,7 @@ class MxHashTableCursor;
 template <class T>
 class MxHashTableNode {
 public:
-	MxHashTableNode<T>() {}
-	MxHashTableNode<T>(T* p_obj, MxU32 p_hash)
+	MxHashTableNode<T>(T p_obj, MxU32 p_hash)
 	{
 		m_obj = p_obj;
 		m_hash = p_hash;
@@ -24,54 +21,39 @@ class MxHashTableNode {
 		m_next = NULL;
 	}
 
-	// private:
-	T* m_obj;
+	// DECOMP: Should use getter and setter methods here per the style guide.
+	// However, LEGO1D (with no functions inlined) does not use them.
+	T m_obj;
 	MxU32 m_hash;
 	MxHashTableNode* m_prev;
 	MxHashTableNode* m_next;
 };
 
-// See MxOmni::Create
-// VTABLE 0x100dc1b0
 template <class T>
-class HashTableParent : public MxCore {
+class MxHashTable : protected MxCollection<T> {
 public:
-	HashTableParent()
-	{
-		m_numKeys = 0;
-		m_customDestructor = Destroy;
-	}
+	enum HashTableOpt {
+		HashTableOpt_NoExpand = 0,
+		HashTableOpt_ExpandAdd = 1,
+		HashTableOpt_ExpandMultiply = 2,
+	};
 
-	static void Destroy(T*){};
-
-	virtual MxS8 Compare(T*, T*) = 0;
-
-protected:
-	MxU32 m_numKeys;                // +0x8
-	void (*m_customDestructor)(T*); // +0xc
-};
-
-// VTABLE 0x100dc1e8
-template <class T>
-class MxHashTable : protected HashTableParent<T> {
-public:
 	MxHashTable()
 	{
 		m_numSlots = HASH_TABLE_INIT_SIZE;
 		m_slots = new MxHashTableNode<T>*[HASH_TABLE_INIT_SIZE];
 		memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
-		m_resizeOption = HASH_TABLE_OPT_NO_EXPAND;
+		m_resizeOption = HashTableOpt_NoExpand;
 	}
 
 	virtual ~MxHashTable() override;
 
 	void Resize();
-	void Add(T*);
+	void Add(T);
+	void DeleteAll();
 
-	virtual MxS8 Compare(T*, T*) override = 0;
-	virtual MxU32 Hash(T*) = 0;
+	virtual MxU32 Hash(T) { return 0; }
 
-	// FIXME: use of friend here?
 	friend class MxHashTableCursor<T>;
 
 protected:
@@ -79,91 +61,108 @@ class MxHashTable : protected HashTableParent<T> {
 
 	MxHashTableNode<T>** m_slots; // +0x10
 	MxU32 m_numSlots;             // +0x14
-	MxU32 m_autoResizeRatio;
-	int m_resizeOption; // +0x1c
+	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;
-		double m_increaseFactor;
+		MxU32 m_increaseAmount;  // +0x20
+		double m_increaseFactor; // +0x20
 	};
 };
 
 template <class T>
 class MxHashTableCursor : public MxCore {
 public:
-	MxHashTableCursor(MxHashTable<T>* p_hashTable)
+	MxHashTableCursor(MxHashTable<T>* p_table)
 	{
-		m_table = p_hashTable;
+		m_table = p_table;
 		m_match = NULL;
 	}
 
-	MxBool Find(T* p_obj)
-	{
-		MxU32 hash = m_table->Hash(p_obj);
-		int bucket = hash % m_table->m_numSlots;
-
-		MxHashTableNode<T>* t = m_table->m_slots[bucket];
-
-		while (t) {
-			if (t->m_hash == hash && !m_table->Compare(t->m_obj, p_obj))
-				m_match = t;
-			t = t->m_next;
-		}
-
-		return m_match != NULL;
-	}
-
-	void GetMatch(T*& p_obj)
-	{
-		if (m_match) {
-			p_obj = m_match->m_obj;
-		}
-	}
-
-	void DeleteMatch()
-	{
-		// Cut the matching node out of the linked list
-		// by updating pointer references.
-
-		if (m_match->m_prev) {
-			m_match->m_prev->m_next = m_match->m_next;
-		}
-		else {
-			// No "prev" node, so move "next" to the head of the list.
-			int bucket = m_match->m_hash % m_table->m_numSlots;
-			m_table->m_slots[bucket] = m_match->m_next;
-		}
-
-		if (m_match->m_next)
-			m_match->m_next->m_prev = m_match->m_prev;
-
-		m_table->m_customDestructor(m_match->m_obj);
-		delete m_match;
-		m_table->m_numKeys--;
-	}
+	MxBool Find(T p_obj);
+	MxBool Current(T& p_obj);
+	void DeleteMatch();
 
 private:
 	MxHashTable<T>* m_table;
 	MxHashTableNode<T>* m_match;
 };
 
+template <class T>
+MxBool MxHashTableCursor<T>::Find(T p_obj)
+{
+	MxU32 hash = m_table->Hash(p_obj);
+	MxS32 bucket = hash % m_table->m_numSlots;
+
+	MxHashTableNode<T>* t = m_table->m_slots[bucket];
+
+	while (t) {
+		if (t->m_hash == hash && !m_table->Compare(t->m_obj, p_obj))
+			m_match = t;
+		t = t->m_next;
+	}
+
+	return m_match != NULL;
+}
+
+template <class T>
+MxBool MxHashTableCursor<T>::Current(T& p_obj)
+{
+	if (m_match) {
+		p_obj = m_match->m_obj;
+	}
+
+	return m_match != NULL;
+}
+
+template <class T>
+void MxHashTableCursor<T>::DeleteMatch()
+{
+	// Cut the matching node out of the linked list
+	// by updating pointer references.
+	if (m_match == NULL)
+		return;
+
+	if (m_match->m_prev) {
+		m_match->m_prev->m_next = m_match->m_next;
+	}
+	else {
+		// No "prev" node, so move "next" to the head of the list.
+		MxS32 bucket = m_match->m_hash % m_table->m_numSlots;
+		m_table->m_slots[bucket] = m_match->m_next;
+	}
+
+	if (m_match->m_next)
+		m_match->m_next->m_prev = m_match->m_prev;
+
+	m_table->m_customDestructor(m_match->m_obj);
+	delete m_match;
+	m_table->m_count--;
+}
+
 template <class T>
 MxHashTable<T>::~MxHashTable()
 {
-	for (int i = 0; i < m_numSlots; i++) {
+	DeleteAll();
+}
+
+template <class T>
+void MxHashTable<T>::DeleteAll()
+{
+	for (MxS32 i = 0; i < m_numSlots; i++) {
 		MxHashTableNode<T>* t = m_slots[i];
 
 		while (t) {
 			MxHashTableNode<T>* next = t->m_next;
-			this->m_customDestructor(t->m_obj);
+			m_customDestructor(t->m_obj);
 			delete t;
 			t = next;
 		}
 	}
 
-	this->m_numKeys = 0;
+	m_count = 0;
 	memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
 
 	delete[] m_slots;
@@ -178,21 +177,20 @@ inline void MxHashTable<T>::Resize()
 	MxHashTableNode<T>** old_table = m_slots;
 
 	switch (m_resizeOption) {
-	case HASH_TABLE_OPT_EXPAND_ADD:
+	case HashTableOpt_ExpandAdd:
 		m_numSlots += m_increaseAmount;
 		break;
-	case HASH_TABLE_OPT_EXPAND_MULTIPLY:
+	case HashTableOpt_ExpandMultiply:
 		m_numSlots *= m_increaseFactor;
 		break;
 	}
 
 	MxHashTableNode<T>** new_table = new MxHashTableNode<T>*[m_numSlots];
-	// FIXME: order? m_numKeys set after `rep stosd`
 	m_slots = new_table;
 	memset(m_slots, 0, sizeof(MxHashTableNode<T>*) * m_numSlots);
-	this->m_numKeys = 0;
+	m_count = 0;
 
-	for (int i = 0; i != old_size; i++) {
+	for (MxS32 i = 0; i != old_size; i++) {
 		MxHashTableNode<T>* t = old_table[i];
 
 		while (t) {
@@ -208,7 +206,7 @@ inline void MxHashTable<T>::Resize()
 template <class T>
 inline void MxHashTable<T>::_NodeInsert(MxHashTableNode<T>* p_node)
 {
-	int bucket = p_node->m_hash % m_numSlots;
+	MxS32 bucket = p_node->m_hash % m_numSlots;
 
 	p_node->m_next = m_slots[bucket];
 
@@ -216,13 +214,13 @@ inline void MxHashTable<T>::_NodeInsert(MxHashTableNode<T>* p_node)
 		m_slots[bucket]->m_prev = p_node;
 
 	m_slots[bucket] = p_node;
-	this->m_numKeys++;
+	m_count++;
 }
 
 template <class T>
-inline void MxHashTable<T>::Add(T* p_newobj)
+inline void MxHashTable<T>::Add(T p_newobj)
 {
-	if (m_resizeOption && ((this->m_numKeys + 1) / m_numSlots) > m_autoResizeRatio)
+	if (m_resizeOption && ((m_count + 1) / m_numSlots) > m_autoResizeRatio)
 		MxHashTable<T>::Resize();
 
 	MxU32 hash = Hash(p_newobj);
@@ -231,4 +229,6 @@ inline void MxHashTable<T>::Add(T* p_newobj)
 	MxHashTable<T>::_NodeInsert(node);
 }
 
+#undef HASH_TABLE_INIT_SIZE
+
 #endif // MXHASHTABLE_H
diff --git a/LEGO1/mxmediapresenter.cpp b/LEGO1/mxmediapresenter.cpp
index 0422d2aa..1b9e4f06 100644
--- a/LEGO1/mxmediapresenter.cpp
+++ b/LEGO1/mxmediapresenter.cpp
@@ -1,6 +1,9 @@
 #include "mxmediapresenter.h"
 
+#include "mxactionnotificationparam.h"
 #include "mxautolocker.h"
+#include "mxcompositepresenter.h"
+#include "mxnotificationmanager.h"
 #include "mxstreamchunk.h"
 #include "mxtimer.h"
 
@@ -217,10 +220,37 @@ MxResult MxMediaPresenter::StartAction(MxStreamController* p_controller, MxDSAct
 	return result;
 }
 
-// OFFSET: LEGO1 0x100b5bc0 STUB
+// OFFSET: LEGO1 0x100b5bc0
 void MxMediaPresenter::EndAction()
 {
-	// TODO
+	MxAutoLocker lock(&m_criticalSection);
+
+	if (!m_action)
+		return;
+
+	m_currentChunk = NULL;
+
+	if (m_action->GetFlags() & MxDSAction::Flag_World &&
+		(!m_compositePresenter || !m_compositePresenter->VTable0x64(2))) {
+		MxPresenter::Enable(FALSE);
+		SetTickleState(TickleState::TickleState_Idle);
+	}
+	else {
+		MxDSAction* action = m_action;
+		MxPresenter::EndAction();
+
+		if (m_subscriber) {
+			delete m_subscriber;
+			m_subscriber = NULL;
+		}
+
+		if (action && action->GetUnknown8c()) {
+			NotificationManager()->Send(
+				action->GetUnknown8c(),
+				&MxEndActionNotificationParam(c_notificationEndAction, this, action, FALSE)
+			);
+		}
+	}
 }
 
 // OFFSET: LEGO1 0x100b5f10
diff --git a/LEGO1/mxomni.cpp b/LEGO1/mxomni.cpp
index b4b430a3..469e058a 100644
--- a/LEGO1/mxomni.cpp
+++ b/LEGO1/mxomni.cpp
@@ -92,7 +92,7 @@ void MxOmni::Vtable0x2c()
 }
 
 // OFFSET: LEGO1 0x100aefb0
-MxEntity* MxOmni::FindWorld(const char*, MxS32, MxCore*)
+MxEntity* MxOmni::FindWorld(const char*, MxS32, MxPresenter*)
 {
 	return NULL;
 }
diff --git a/LEGO1/mxomni.h b/LEGO1/mxomni.h
index 562de18a..bdafe9c1 100644
--- a/LEGO1/mxomni.h
+++ b/LEGO1/mxomni.h
@@ -14,6 +14,7 @@ class MxNotificationManager;
 class MxNotificationParam;
 class MxObjectFactory;
 class MxOmniCreateParam;
+class MxPresenter;
 class MxSoundManager;
 class MxStreamer;
 class MxTickleManager;
@@ -46,7 +47,7 @@ class MxOmni : public MxCore {
 	virtual MxResult DeleteObject(MxDSAction& p_dsAction);          // vtable+24
 	virtual MxBool DoesEntityExist(MxDSAction& p_dsAction);         // vtable+28
 	virtual void Vtable0x2c();                                      // vtable+2c
-	virtual MxEntity* FindWorld(const char*, MxS32, MxCore*);       // vtable+30
+	virtual MxEntity* FindWorld(const char*, MxS32, MxPresenter*);  // vtable+30
 	virtual void NotifyCurrentEntity(MxNotificationParam* p_param); // vtable+34
 	virtual void StartTimer();                                      // vtable+38
 	virtual void StopTimer();                                       // vtable+3c
diff --git a/LEGO1/mxpresenter.cpp b/LEGO1/mxpresenter.cpp
index 1ff02c7a..8843bef5 100644
--- a/LEGO1/mxpresenter.cpp
+++ b/LEGO1/mxpresenter.cpp
@@ -5,6 +5,7 @@
 #include "legoomni.h"
 #include "mxactionnotificationparam.h"
 #include "mxautolocker.h"
+#include "mxcompositepresenter.h"
 #include "mxdsanim.h"
 #include "mxdssound.h"
 #include "mxnotificationmanager.h"
@@ -22,7 +23,7 @@ void MxPresenter::Init()
 	m_action = NULL;
 	m_location = MxPoint32(0, 0);
 	m_displayZ = 0;
-	m_unkPresenter = NULL;
+	m_compositePresenter = NULL;
 	m_previousTickleStates = 0;
 }
 
@@ -49,24 +50,24 @@ void MxPresenter::ParseExtra()
 			MxS32 val = token ? atoi(token) : 0;
 			MxEntity* result = MxOmni::GetInstance()->FindWorld(t_token, val, this);
 
-			m_action->SetFlags(m_action->GetFlags() | MxDSAction::Flag_Parsed);
+			m_action->SetFlags(m_action->GetFlags() | MxDSAction::Flag_World);
 
 			if (result)
-				SendTo_unkPresenter(MxOmni::GetInstance());
+				SendToCompositePresenter(MxOmni::GetInstance());
 		}
 	}
 }
 
 // OFFSET: LEGO1 0x100b5120
-void MxPresenter::SendTo_unkPresenter(MxOmni* p_omni)
+void MxPresenter::SendToCompositePresenter(MxOmni* p_omni)
 {
-	if (m_unkPresenter) {
+	if (m_compositePresenter) {
 		MxAutoLocker lock(&m_criticalSection);
 
-		NotificationManager()->Send(m_unkPresenter, &MxNotificationParam(MXPRESENTER_NOTIFICATION, this));
+		NotificationManager()->Send(m_compositePresenter, &MxNotificationParam(MXPRESENTER_NOTIFICATION, this));
 
 		m_action->SetUnknown8c(p_omni ? p_omni : MxOmni::GetInstance());
-		m_unkPresenter = NULL;
+		m_compositePresenter = NULL;
 	}
 }
 
@@ -138,8 +139,10 @@ void MxPresenter::EndAction()
 {
 	if (this->m_action == FALSE)
 		return;
+
 	MxAutoLocker lock(&this->m_criticalSection);
-	if (!this->m_unkPresenter) {
+
+	if (!this->m_compositePresenter) {
 		MxOmni::GetInstance()->NotifyCurrentEntity(
 			&MxEndActionNotificationParam(c_notificationEndAction, NULL, this->m_action, TRUE)
 		);
diff --git a/LEGO1/mxpresenter.h b/LEGO1/mxpresenter.h
index a126a370..ea552845 100644
--- a/LEGO1/mxpresenter.h
+++ b/LEGO1/mxpresenter.h
@@ -8,6 +8,7 @@
 #include "mxomni.h"
 #include "mxpoint32.h"
 
+class MxCompositePresenter;
 class MxStreamController;
 
 // VTABLE 0x100d4d38
@@ -75,14 +76,15 @@ class MxPresenter : public MxCore {
 
 protected:
 	__declspec(dllexport) void Init();
-	void SendTo_unkPresenter(MxOmni*);
-	TickleState m_currentTickleState;    // 0x8
-	MxU32 m_previousTickleStates;        // 0x0c
-	MxPoint32 m_location;                // 0x10
-	MxS32 m_displayZ;                    // 0x18
-	MxDSAction* m_action;                // 0x1c
-	MxCriticalSection m_criticalSection; // 0x20
-	MxPresenter* m_unkPresenter;         // 0x3c
+	void SendToCompositePresenter(MxOmni*);
+
+	TickleState m_currentTickleState;           // 0x8
+	MxU32 m_previousTickleStates;               // 0x0c
+	MxPoint32 m_location;                       // 0x10
+	MxS32 m_displayZ;                           // 0x18
+	MxDSAction* m_action;                       // 0x1c
+	MxCriticalSection m_criticalSection;        // 0x20
+	MxCompositePresenter* m_compositePresenter; // 0x3c
 };
 
 const char* PresenterNameDispatch(const MxDSAction&);
diff --git a/LEGO1/mxstring.h b/LEGO1/mxstring.h
index df5863b7..3984f428 100644
--- a/LEGO1/mxstring.h
+++ b/LEGO1/mxstring.h
@@ -18,6 +18,7 @@ class MxString : public MxCore {
 	MxString operator+(const char*);
 	MxString& operator+=(const char*);
 
+	inline MxS8 Compare(const MxString& p_str) const { return strcmp(m_data, p_str.m_data); }
 	inline const char* GetData() const { return m_data; }
 
 private:
diff --git a/LEGO1/mxtransitionmanager.cpp b/LEGO1/mxtransitionmanager.cpp
index 0e60855e..0df51929 100644
--- a/LEGO1/mxtransitionmanager.cpp
+++ b/LEGO1/mxtransitionmanager.cpp
@@ -468,7 +468,7 @@ void MxTransitionManager::SetWaitIndicator(MxVideoPresenter* p_waitIndicator)
 {
 	// End current wait indicator
 	if (m_waitIndicator != NULL) {
-		m_waitIndicator->GetAction()->SetFlags(m_waitIndicator->GetAction()->GetFlags() & ~MxDSAction::Flag_Parsed);
+		m_waitIndicator->GetAction()->SetFlags(m_waitIndicator->GetAction()->GetFlags() & ~MxDSAction::Flag_World);
 		m_waitIndicator->EndAction();
 		m_waitIndicator = NULL;
 	}
diff --git a/LEGO1/mxvariabletable.cpp b/LEGO1/mxvariabletable.cpp
index 96500167..0faa2b7b 100644
--- a/LEGO1/mxvariabletable.cpp
+++ b/LEGO1/mxvariabletable.cpp
@@ -3,7 +3,7 @@
 // OFFSET: LEGO1 0x100b7330
 MxS8 MxVariableTable::Compare(MxVariable* p_var0, MxVariable* p_var1)
 {
-	return strcmp(p_var0->GetKey()->GetData(), p_var1->GetKey()->GetData());
+	return p_var0->GetKey()->Compare(*p_var1->GetKey());
 }
 
 // OFFSET: LEGO1 0x100b7370
@@ -22,43 +22,43 @@ MxU32 MxVariableTable::Hash(MxVariable* p_var)
 // OFFSET: LEGO1 0x100b73a0
 void MxVariableTable::SetVariable(const char* p_key, const char* p_value)
 {
-	MxHashTableCursor<MxVariable> cursor(this);
+	MxHashTableCursor<MxVariable*> cursor(this);
 	MxVariable* var = new MxVariable(p_key, p_value);
 
 	if (cursor.Find(var)) {
 		delete var;
-		cursor.GetMatch(var);
+		cursor.Current(var);
 		var->SetValue(p_value);
 	}
 	else {
-		MxHashTable<MxVariable>::Add(var);
+		MxHashTable<MxVariable*>::Add(var);
 	}
 }
 
 // OFFSET: LEGO1 0x100b7740
-void MxVariableTable::SetVariable(MxVariable* var)
+void MxVariableTable::SetVariable(MxVariable* p_var)
 {
-	MxHashTableCursor<MxVariable> cursor(this);
-	MxBool found = cursor.Find(var);
+	MxHashTableCursor<MxVariable*> cursor(this);
+	MxBool found = cursor.Find(p_var);
 
 	if (found)
 		cursor.DeleteMatch();
 
-	MxHashTable<MxVariable>::Add(var);
+	MxHashTable<MxVariable*>::Add(p_var);
 }
 
 // OFFSET: LEGO1 0x100b78f0
 const char* MxVariableTable::GetVariable(const char* p_key)
 {
 	const char* value = "";
-	MxHashTableCursor<MxVariable> cursor(this);
+	MxHashTableCursor<MxVariable*> cursor(this);
 	MxVariable* var = new MxVariable(p_key);
 
 	MxBool found = cursor.Find(var);
 	delete var;
 
 	if (found) {
-		cursor.GetMatch(var);
+		cursor.Current(var);
 		value = var->GetValue()->GetData();
 	}
 
diff --git a/LEGO1/mxvariabletable.h b/LEGO1/mxvariabletable.h
index df34eb15..872aa49f 100644
--- a/LEGO1/mxvariabletable.h
+++ b/LEGO1/mxvariabletable.h
@@ -7,12 +7,12 @@
 
 // VTABLE 0x100dc1c8
 // SIZE 0x28
-class MxVariableTable : public MxHashTable<MxVariable> {
+class MxVariableTable : public MxHashTable<MxVariable*> {
 public:
 	MxVariableTable() { m_customDestructor = Destroy; }
-	__declspec(dllexport) void SetVariable(const char* key, const char* value);
-	__declspec(dllexport) void SetVariable(MxVariable* var);
-	__declspec(dllexport) const char* GetVariable(const char* key);
+	__declspec(dllexport) void SetVariable(const char* p_key, const char* p_value);
+	__declspec(dllexport) void SetVariable(MxVariable* p_var);
+	__declspec(dllexport) const char* GetVariable(const char* p_key);
 
 	// OFFSET: LEGO1 0x100afdb0
 	static void Destroy(MxVariable* p_obj) { p_obj->Destroy(); }
@@ -21,13 +21,37 @@ class MxVariableTable : public MxHashTable<MxVariable> {
 	virtual MxU32 Hash(MxVariable*) override;                // +0x18
 };
 
+// OFFSET: LEGO1 0x100afcd0 TEMPLATE
+// MxCollection<MxVariable *>::Compare
+
+// OFFSET: LEGO1 0x100afce0 TEMPLATE
+// MxCollection<MxVariable *>::~MxCollection<MxVariable *>
+
+// OFFSET: LEGO1 0x100afd30 TEMPLATE
+// MxCollection<MxVariable *>::Destroy
+
+// OFFSET: LEGO1 0x100afd40 TEMPLATE
+// MxCollection<MxVariable *>::`scalar deleting destructor'
+
+// OFFSET: LEGO1 0x100afdc0 TEMPLATE
+// MxHashTable<MxVariable *>::Hash
+
 // OFFSET: LEGO1 0x100b0bd0 TEMPLATE
-// MxHashTable<MxVariable>::~MxHashTable<MxVariable>
+// MxHashTable<MxVariable *>::~MxHashTable<MxVariable *>
+
+// OFFSET: LEGO1 0x100b0ca0 TEMPLATE
+// MxHashTable<MxVariable *>::`scalar deleting destructor'
 
 // OFFSET: LEGO1 0x100b7ab0 TEMPLATE
-// MxHashTable<MxVariable>::Resize
+// MxHashTable<MxVariable *>::Resize
 
 // OFFSET: LEGO1 0x100b7b80 TEMPLATE
-// MxHashTable<MxVariable>::_NodeInsert
+// MxHashTable<MxVariable *>::_NodeInsert
+
+// VTABLE 0x100dc1b0 TEMPLATE
+// class MxCollection<MxVariable *>
+
+// VTABLE 0x100dc1e8 TEMPLATE
+// class MxHashTable<MxVariable *>
 
 #endif // MXVARIABLETABLE_H