Implement/match Isle::Enable (#681)

* Implement/match Isle::Enable

* Fix order

LEGO1/lego/legoomni/include/act1state.h

@@ -15,37 +15,6 @@ class Act1State : public LegoState {
 		e_unk955 = 955,
 	};
 
-	Act1State();
-
-	// FUNCTION: LEGO1 0x100338a0
-	inline const char* ClassName() const override // vtable+0x0c
-	{
-		// STRING: LEGO1 0x100f0154
-		return "Act1State";
-	}
-
-	// FUNCTION: LEGO1 0x100338b0
-	inline MxBool IsA(const char* p_name) const override // vtable+0x10
-	{
-		return !strcmp(p_name, Act1State::ClassName()) || LegoState::IsA(p_name);
-	}
-
-	MxBool SetFlag() override;                          // vtable+0x18
-	MxResult VTable0x1c(LegoFile* p_legoFile) override; // vtable+0x1c
-
-	inline void SetUnknown18(MxU32 p_unk0x18) { m_unk0x018 = p_unk0x18; }
-	inline MxU32 GetUnknown18() { return m_unk0x018; }
-	inline MxU32 GetUnknown1c() { return m_unk0x01c; }
-	inline MxS16 GetUnknown21() { return m_unk0x021; }
-
-	inline void SetUnknown1c(MxU32 p_unk0x1c) { m_unk0x01c = p_unk0x1c; }
-	inline void SetUnknown21(MxS16 p_unk0x21) { m_unk0x021 = p_unk0x21; }
-
-	void FUN_10034d00();
-
-	// SYNTHETIC: LEGO1 0x10033960
-	// Act1State::`scalar deleting destructor'
-
 	// SIZE 0x4c
 	class NamedPlane {
 	public:
@@ -81,9 +50,42 @@ class Act1State : public LegoState {
 		Mx3DPointFloat m_point3; // 0x38
 	};
 
+	Act1State();
+
+	// FUNCTION: LEGO1 0x100338a0
+	inline const char* ClassName() const override // vtable+0x0c
+	{
+		// STRING: LEGO1 0x100f0154
+		return "Act1State";
+	}
+
+	// FUNCTION: LEGO1 0x100338b0
+	inline MxBool IsA(const char* p_name) const override // vtable+0x10
+	{
+		return !strcmp(p_name, Act1State::ClassName()) || LegoState::IsA(p_name);
+	}
+
+	MxBool SetFlag() override;                          // vtable+0x18
+	MxResult VTable0x1c(LegoFile* p_legoFile) override; // vtable+0x1c
+
+	void FUN_10034b60();
+	void FUN_10034d00();
+
+	inline MxU32 GetUnknown18() { return m_unk0x018; }
+	inline MxU32 GetUnknown1c() { return m_unk0x01c; }
+	inline MxS16 GetUnknown21() { return m_unk0x021; }
+
+	inline void SetUnknown18(MxU32 p_unk0x18) { m_unk0x018 = p_unk0x18; }
+	inline void SetUnknown1c(MxU32 p_unk0x1c) { m_unk0x01c = p_unk0x1c; }
+	inline void SetUnknown21(MxS16 p_unk0x21) { m_unk0x021 = p_unk0x21; }
+
+	// SYNTHETIC: LEGO1 0x10033960
+	// Act1State::`scalar deleting destructor'
+
+	friend class Isle;
+
 protected:
-	MxS32* m_unk0x008; // 0x008
-	// FIXME: count for m_unk0x008
+	MxS32* m_unk0x008;            // 0x008 FIXME: count for m_unk0x008
 	MxS16 m_unk0x00c;             // 0x00c
 	undefined2 m_unk0x00e;        // 0x00e
 	undefined2 m_unk0x010;        // 0x010

LEGO1/lego/legoomni/include/ambulance.h

@@ -33,6 +33,8 @@ class Ambulance : public IslePathActor {
 	MxU32 VTable0xdc(MxType19NotificationParam&) override;       // vtable+0xdc
 	void VTable0xe4() override;                                  // vtable+0xe4
 
+	void FUN_10036e60();
+
 	// SYNTHETIC: LEGO1 0x10036130
 	// Ambulance::`scalar deleting destructor'
 

LEGO1/lego/legoomni/include/isle.h

@@ -1,6 +1,7 @@
 #ifndef ISLE_H
 #define ISLE_H
 
+#include "legogamestate.h"
 #include "legoworld.h"
 #include "radio.h"
 
@@ -22,6 +23,11 @@ class Act1State;
 // SIZE 0x140
 class Isle : public LegoWorld {
 public:
+	// For g_unk0x100f1198
+	enum {
+		c_bit7 = 0x40
+	};
+
 	Isle();
 	~Isle() override;
 
@@ -59,28 +65,29 @@ class Isle : public LegoWorld {
 	MxLong HandleType19Notification(MxParam& p_param);
 	MxLong HandleTransitionEnd();
 	void FUN_10032620();
+	void FUN_100330e0();
 
-	inline void SetUnknown13c(MxU32 p_unk0x13c) { m_unk0x13c = p_unk0x13c; }
+	inline void SetUnknown13c(LegoGameState::Area p_unk0x13c) { m_unk0x13c = p_unk0x13c; }
 
 	// SYNTHETIC: LEGO1 0x10030a30
 	// Isle::`scalar deleting destructor'
 
 protected:
-	Act1State* m_act1state;   // 0xf8
-	Pizza* m_pizza;           // 0xfc
-	Pizzeria* m_pizzeria;     // 0x100
-	TowTrack* m_towtrack;     // 0x104
-	Ambulance* m_ambulance;   // 0x108
-	JukeBoxEntity* m_jukebox; // 0x10c
-	Helicopter* m_helicopter; // 0x110
-	Bike* m_bike;             // 0x114
-	DuneBuggy* m_dunebuggy;   // 0x118
-	Motocycle* m_motocycle;   // 0x11c
-	SkateBoard* m_skateboard; // 0x120
-	RaceCar* m_racecar;       // 0x124
-	Jetski* m_jetski;         // 0x128
-	Radio m_radio;            // 0x12c
-	MxU32 m_unk0x13c;         // 0x13c
+	Act1State* m_act1state;         // 0xf8
+	Pizza* m_pizza;                 // 0xfc
+	Pizzeria* m_pizzeria;           // 0x100
+	TowTrack* m_towtrack;           // 0x104
+	Ambulance* m_ambulance;         // 0x108
+	JukeBoxEntity* m_jukebox;       // 0x10c
+	Helicopter* m_helicopter;       // 0x110
+	Bike* m_bike;                   // 0x114
+	DuneBuggy* m_dunebuggy;         // 0x118
+	Motocycle* m_motocycle;         // 0x11c
+	SkateBoard* m_skateboard;       // 0x120
+	RaceCar* m_racecar;             // 0x124
+	Jetski* m_jetski;               // 0x128
+	Radio m_radio;                  // 0x12c
+	LegoGameState::Area m_unk0x13c; // 0x13c
 };
 
 #endif // ISLE_H

LEGO1/lego/legoomni/include/islepathactor.h

@@ -15,7 +15,7 @@ class IslePathActor : public LegoPathActor {
 	IslePathActor();
 
 	// FUNCTION: LEGO1 0x10002e10
-	inline ~IslePathActor() override { IslePathActor::Destroy(TRUE); } // vtable+0x00
+	inline ~IslePathActor() override { IslePathActor::Destroy(TRUE); }
 
 	MxLong Notify(MxParam& p_param) override; // vtable+0x04
 
@@ -34,20 +34,26 @@ class IslePathActor : public LegoPathActor {
 
 	MxResult Create(MxDSAction& p_dsAction) override; // vtable+0x18
 	void Destroy(MxBool p_fromDestructor) override;   // vtable+0x1c
+
 	// FUNCTION: LEGO1 0x10002e70
 	virtual MxU32 VTable0xcc() { return 0; } // vtable+0xcc
+
 	// FUNCTION: LEGO1 0x10002df0
 	virtual MxU32 VTable0xd0() { return 0; } // vtable+0xd0
+
 	// FUNCTION: LEGO1 0x10002e80
 	virtual MxU32 VTable0xd4(LegoControlManagerEvent&) { return 0; } // vtable+0xd4
+
 	// FUNCTION: LEGO1 0x10002e90
 	virtual MxU32 VTable0xd8(MxType18NotificationParam&) { return 0; } // vtable+0xd8
+
 	// FUNCTION: LEGO1 0x10002e00
 	virtual MxU32 VTable0xdc(MxType19NotificationParam&) { return 0; } // vtable+0xdc
-	virtual void VTable0xe0();                                         // vtable+0xe0
-	virtual void VTable0xe4();                                         // vtable+0xe4
-	virtual void VTable0xe8(MxU32, MxBool, MxU8);                      // vtable+0xe8
-	virtual void VTable0xec();                                         // vtable+0xec
+
+	virtual void VTable0xe0();                    // vtable+0xe0
+	virtual void VTable0xe4();                    // vtable+0xe4
+	virtual void VTable0xe8(MxU32, MxBool, MxU8); // vtable+0xe8
+	virtual void VTable0xec();                    // vtable+0xec
 
 	// SYNTHETIC: LEGO1 0x10002ff0
 	// IslePathActor::`scalar deleting destructor'

LEGO1/lego/legoomni/include/legoanimationmanager.h

@@ -40,15 +40,29 @@ class LegoAnimationManager : public MxCore {
 	void FUN_1005ef10();
 	void FUN_1005f0b0();
 	void FUN_1005f6d0(MxBool);
+	void FUN_1005f700(MxBool);
 	MxResult LoadScriptInfo(MxS32 p_scriptIndex);
 	MxBool FUN_10060140(char* p_name, MxU32& p_index);
 	MxResult ReadAnimInfo(LegoFile* p_file, AnimInfo* p_info);
 	MxResult ReadModelInfo(LegoFile* p_file, ModelInfo* p_info);
 	void FUN_100603c0();
+	undefined4 FUN_10060dc0(
+		undefined4,
+		undefined4,
+		undefined,
+		undefined,
+		undefined4,
+		undefined,
+		undefined,
+		undefined,
+		undefined
+	);
 	void FUN_10061010(undefined4);
 	void FUN_100617c0(MxS32, MxU16&, MxU32&);
 	MxS8 FUN_10062360(char*);
+	void FUN_100629b0(MxU32, MxBool);
 	void FUN_10064670(MxBool);
+	void FUN_10064740(MxBool);
 
 	static void configureLegoAnimationManager(MxS32 p_legoAnimationManagerConfig);
 

LEGO1/lego/legoomni/include/legogamestate.h

@@ -198,9 +198,13 @@ class LegoGameState {
 	undefined2 m_unk0x41a; // 0x41a
 	undefined4 m_unk0x41c; // 0x41c
 	MxBool m_isDirty;      // 0x420
-	Area m_currentArea;    // 0x424
-	Area m_previousArea;   // 0x428
-	Area m_unk0x42c;       // 0x42c
+
+public:
+	Area m_currentArea;  // 0x424
+	Area m_previousArea; // 0x428
+
+private:
+	Area m_unk0x42c; // 0x42c
 };
 
 MxBool ROIHandlerFunction(const char* p_input, char* p_output, MxU32 p_copyLen);

LEGO1/lego/legoomni/include/legopathactor.h

@@ -30,38 +30,54 @@ class LegoPathActor : public LegoActor {
 	virtual void VTable0x6c();                     // vtable+0x6c
 	virtual void VTable0x70(float p_float);        // vtable+0x70
 	virtual void VTable0x74(Matrix4& p_transform); // vtable+0x74
+
 	// FUNCTION: LEGO1 0x10002d20
 	virtual void VTable0x78(MxU8 p_unk0xea) { m_unk0xea = p_unk0xea; } // vtable+0x78
+
 	// FUNCTION: LEGO1 0x10002d30
 	virtual MxU8 VTable0x7c() { return m_unk0xea; } // vtable+0x7c
-	virtual void VTable0x80();                      // vtable+0x80
-	virtual void VTable0x84();                      // vtable+0x84
-	virtual void VTable0x88();                      // vtable+0x88
-	virtual void VTable0x8c();                      // vtable+0x8c
+
+	virtual void VTable0x80(); // vtable+0x80
+	virtual void VTable0x84(); // vtable+0x84
+	virtual void VTable0x88(); // vtable+0x88
+	virtual void VTable0x8c(); // vtable+0x8c
+
 	// FUNCTION: LEGO1 0x10002d40
 	virtual MxS32 VTable0x90() { return 0; } // vtable+0x90
+
 	// FUNCTION: LEGO1 0x10002d50
 	virtual MxS32 VTable0x94() { return 0; } // vtable+0x94
-	virtual void VTable0x98();               // vtable+0x98
-	virtual void VTable0x9c();               // vtable+0x9c
+
+	virtual void VTable0x98(); // vtable+0x98
+	virtual void VTable0x9c(); // vtable+0x9c
+
 	// FUNCTION: LEGO1 0x10002d60
 	virtual MxS32 VTable0xa0() { return 0; } // vtable+0xa0
-	virtual void VTable0xa4();               // vtable+0xa4
-	virtual void VTable0xa8();               // vtable+0xa8
+
+	virtual void VTable0xa4(); // vtable+0xa4
+	virtual void VTable0xa8(); // vtable+0xa8
+
 	// FUNCTION: LEGO1 0x10002d70
 	virtual void VTable0xac(MxFloat p_unk0x13c) { m_unk0x13c = p_unk0x13c; } // vtable+0xac
+
 	// FUNCTION: LEGO1 0x10002d80
 	virtual MxFloat VTable0xb0() { return m_unk0x13c; } // vtable+0xb0
+
 	// FUNCTION: LEGO1 0x10002d90
 	virtual MxFloat VTable0xb4() { return m_unk0x140; } // vtable+0xb4
+
 	// FUNCTION: LEGO1 0x10002da0
 	virtual MxFloat VTable0xb8() { return m_unk0x144; } // vtable+0xb8
+
 	// FUNCTION: LEGO1 0x10002db0
 	virtual void VTable0xbc(MxFloat p_unk0x140) { m_unk0x140 = p_unk0x140; } // vtable+0xbc
+
 	// FUNCTION: LEGO1 0x10002dc0
 	virtual void VTable0xc0(MxFloat p_unk0x144) { m_unk0x144 = p_unk0x144; } // vtable+0xc0
+
 	// FUNCTION: LEGO1 0x10002dd0
 	virtual void VTable0xc4() {} // vtable+0xc4
+
 	// FUNCTION: LEGO1 0x10002de0
 	virtual void VTable0xc8(MxU8 p_unk0x148) { m_unk0x148 = p_unk0x148; } // vtable+0xc8
 

LEGO1/lego/legoomni/include/legoutils.h

@@ -17,7 +17,7 @@ class LegoNamedTexture;
 
 void FUN_1003e050(LegoAnimPresenter* p_presenter);
 Extra::ActionType MatchActionString(const char*);
-void InvokeAction(Extra::ActionType p_actionId, MxAtomId& p_pAtom, int p_targetEntityId, LegoEntity* p_sender);
+void InvokeAction(Extra::ActionType p_actionId, MxAtomId& p_pAtom, MxS32 p_targetEntityId, LegoEntity* p_sender);
 void SetCameraControllerFromIsle();
 void ConvertHSVToRGB(float p_h, float p_s, float p_v, float* p_rOut, float* p_bOut, float* p_gOut);
 MxBool FUN_1003ee00(MxAtomId& p_atomId, MxS32 p_id);

LEGO1/lego/legoomni/include/legovideomanager.h

@@ -37,6 +37,7 @@ class LegoVideoManager : public MxVideoManager {
 
 	void SetSkyColor(float p_red, float p_green, float p_blue);
 	void OverrideSkyColor(MxBool p_shouldOverride);
+	MxResult ResetPalette(MxBool p_ignoreSkyColor);
 	void FUN_1007c520();
 
 	inline Tgl::Renderer* GetRenderer() { return this->m_renderer; }

LEGO1/lego/legoomni/include/legoworld.h

@@ -64,18 +64,19 @@ class LegoWorld : public LegoEntity {
 	virtual MxBool VTable0x64();          // vtable+0x64
 	virtual void Enable(MxBool p_enable); // vtable+0x68
 
-	inline LegoCameraController* GetCamera() { return m_cameraController; }
-	inline MxS32 GetScriptIndex() { return m_scriptIndex; }
-	inline MxCoreSet& GetUnknown0xd0() { return m_set0xd0; }
-	inline list<LegoROI*>& GetROIList() { return m_roiList; }
-
 	MxBool PresentersPending();
 	void Remove(MxCore* p_object);
+	undefined4 FUN_1001fa70(IslePathActor* p_actor);
 	void FUN_1001fc80(IslePathActor* p_actor);
 	MxResult GetCurrPathInfo(LegoPathBoundary** p_path, MxS32& p_value);
 	MxCore* Find(const char* p_class, const char* p_name);
 	MxCore* Find(const MxAtomId& p_atom, MxS32 p_entityId);
 
+	inline LegoCameraController* GetCamera() { return m_cameraController; }
+	inline MxS32 GetScriptIndex() { return m_scriptIndex; }
+	inline MxCoreSet& GetUnknown0xd0() { return m_set0xd0; }
+	inline list<LegoROI*>& GetROIList() { return m_roiList; }
+
 	inline void SetScriptIndex(MxS32 p_scriptIndex) { m_scriptIndex = p_scriptIndex; }
 
 	// SYNTHETIC: LEGO1 0x1001dee0

LEGO1/lego/legoomni/include/racestate.h

@@ -3,12 +3,15 @@
 
 #include "legostate.h"
 
+// SIZE 0x06
 struct RaceStateEntry {
 public:
-	MxU8 m_id;
-	undefined m_unk0x01[1];
-	MxU16 m_unk0x02;
-	MxU16 m_color;
+	inline MxS16 GetUnknown0x02() { return m_unk0x02; }
+
+	// TODO: Possibly private
+	MxU8 m_id;       // 0x00
+	MxS16 m_unk0x02; // 0x02
+	MxU16 m_color;   // 0x04
 };
 
 // VTABLE: LEGO1 0x100d5e30
@@ -32,7 +35,10 @@ class RaceState : public LegoState {
 
 	MxResult VTable0x1c(LegoFile* p_legoFile) override; // vtable+0x1c
 
+	RaceStateEntry* GetState(MxU8 p_id);
+
 	inline MxU16 GetColor(MxU8 p_id) { return GetState(p_id)->m_color; }
+	inline undefined4 GetUnknown0x28() { return m_unk0x28; }
 
 	// SYNTHETIC: LEGO1 0x1000f6f0
 	// RaceState::~RaceState
@@ -40,12 +46,8 @@ class RaceState : public LegoState {
 	// SYNTHETIC: LEGO1 0x100160d0
 	// RaceState::`scalar deleting destructor'
 
-private:
-	RaceStateEntry* GetState(MxU8 p_id);
-
 protected:
 	RaceStateEntry m_state[5]; // 0x08
-	undefined2 m_unk0x26[2];   // 0x26
 	undefined4 m_unk0x28;      // 0x28
 };
 

LEGO1/lego/legoomni/include/towtrack.h

@@ -32,6 +32,8 @@ class TowTrack : public IslePathActor {
 	MxU32 VTable0xdc(MxType19NotificationParam& p_param) override; // vtable+0xdc
 	void VTable0xe4() override;                                    // vtable+0xe4
 
+	void FUN_1004dab0();
+
 	// SYNTHETIC: LEGO1 0x1004c950
 	// TowTrack::`scalar deleting destructor'
 

LEGO1/lego/legoomni/src/act1/act1state.cpp

@@ -267,6 +267,12 @@ MxBool Act1State::SetFlag()
 	return TRUE;
 }
 
+// STUB: LEGO1 0x10034b60
+void Act1State::FUN_10034b60()
+{
+	// TODO
+}
+
 // STUB: LEGO1 0x10034d00
 void Act1State::FUN_10034d00()
 {

LEGO1/lego/legoomni/src/actors/ambulance.cpp

@@ -60,6 +60,12 @@ MxU32 Ambulance::VTable0xcc()
 	return 0;
 }
 
+// STUB: LEGO1 0x10036e60
+void Ambulance::FUN_10036e60()
+{
+	// TODO
+}
+
 // STUB: LEGO1 0x10036e90
 void Ambulance::VTable0xe4()
 {

LEGO1/lego/legoomni/src/actors/helicopter.cpp

@@ -114,7 +114,7 @@ MxU32 Helicopter::VTable0xcc()
 		m_script = *g_isleScript;
 		AnimationManager()->FUN_10064670(FALSE);
 		VTable0xe8(0x29, TRUE, 7);
-		((Isle*) CurrentWorld())->SetUnknown13c(0x3c);
+		((Isle*) CurrentWorld())->SetUnknown13c(LegoGameState::e_unk60);
 		FUN_10015820(TRUE, 0);
 		TransitionManager()->StartTransition(MxTransitionManager::e_mosaic, 50, FALSE, TRUE);
 		SetUnknownDC(4);
@@ -229,7 +229,7 @@ MxU32 Helicopter::VTable0xd4(LegoControlManagerEvent& p_param)
 			break;
 		case 0x1c:
 			if (GameState()->GetCurrentAct() == LegoGameState::e_act1) {
-				((Isle*) CurrentWorld())->SetUnknown13c(2);
+				((Isle*) CurrentWorld())->SetUnknown13c(LegoGameState::e_infomain);
 				TransitionManager()->StartTransition(MxTransitionManager::e_mosaic, 50, FALSE, FALSE);
 				VTable0xe4();
 			}

LEGO1/lego/legoomni/src/actors/jukeboxentity.cpp

@@ -36,7 +36,7 @@ MxLong JukeBoxEntity::Notify(MxParam& p_param)
 			CurrentActor()->VTable0xe4();
 		}
 
-		((Isle*) FindWorld(*g_isleScript, 0))->SetUnknown13c(0x35);
+		((Isle*) FindWorld(*g_isleScript, 0))->SetUnknown13c(LegoGameState::e_jukeboxw);
 		TransitionManager()->StartTransition(MxTransitionManager::e_mosaic, 50, FALSE, FALSE);
 		return 1;
 	}

LEGO1/lego/legoomni/src/actors/towtrack.cpp

@@ -69,3 +69,9 @@ MxU32 TowTrack::VTable0xd4(LegoControlManagerEvent& p_param)
 	// TODO
 	return 0;
 }
+
+// STUB: LEGO1 0x1004dab0
+void TowTrack::FUN_1004dab0()
+{
+	// TODO
+}

LEGO1/lego/legoomni/src/common/legoanimationmanager.cpp

@@ -63,6 +63,12 @@ void LegoAnimationManager::FUN_1005f6d0(MxBool)
 	// TODO
 }
 
+// STUB: LEGO1 0x1005f700
+void LegoAnimationManager::FUN_1005f700(MxBool)
+{
+	// TODO
+}
+
 // FUNCTION: LEGO1 0x1005f720
 MxResult LegoAnimationManager::LoadScriptInfo(MxS32 p_scriptIndex)
 {
@@ -338,6 +344,14 @@ void LegoAnimationManager::FUN_100603c0()
 	// TODO
 }
 
+// STUB: LEGO1 0x10060dc0
+undefined4 LegoAnimationManager::
+	FUN_10060dc0(undefined4, undefined4, undefined, undefined, undefined4, undefined, undefined, undefined, undefined)
+{
+	// TODO
+	return 0;
+}
+
 // STUB: LEGO1 0x10061010
 void LegoAnimationManager::FUN_10061010(undefined4)
 {
@@ -371,8 +385,20 @@ MxS8 LegoAnimationManager::FUN_10062360(char*)
 	return 0;
 }
 
+// STUB: LEGO1 0x100629b0
+void LegoAnimationManager::FUN_100629b0(MxU32, MxBool)
+{
+	// TODO
+}
+
 // STUB: LEGO1 0x10064670
 void LegoAnimationManager::FUN_10064670(MxBool)
 {
 	// TODO
 }
+
+// STUB: LEGO1 0x10064740
+void LegoAnimationManager::FUN_10064740(MxBool)
+{
+	// TODO
+}

LEGO1/lego/legoomni/src/common/legoutils.cpp

@@ -64,7 +64,7 @@ MxBool CheckIfEntityExists(MxBool p_enable, const char* p_filename, MxS32 p_enti
 void NotifyEntity(const char* p_filename, MxS32 p_entityId, LegoEntity* p_sender);
 
 // FUNCTION: LEGO1 0x1003e430
-void InvokeAction(Extra::ActionType p_actionId, MxAtomId& p_pAtom, int p_targetEntityId, LegoEntity* p_sender)
+void InvokeAction(Extra::ActionType p_actionId, MxAtomId& p_pAtom, MxS32 p_targetEntityId, LegoEntity* p_sender)
 {
 	MxDSAction action;
 	action.SetAtomId(p_pAtom);

LEGO1/lego/legoomni/src/entity/legocameracontroller.cpp

@@ -90,7 +90,7 @@ Mx3DPointFloat LegoCameraController::GetWorldUp()
 {
 	if (m_lego3DView && m_lego3DView->GetPointOfView()) {
 		Mx3DPointFloat vec;
-		vec = m_lego3DView->GetPointOfView()->GetWorldUp();
+		vec = Vector3(m_lego3DView->GetPointOfView()->GetWorldUp());
 		return Mx3DPointFloat(vec[0], vec[1], vec[2]);
 	}
 	else {
@@ -103,7 +103,7 @@ Mx3DPointFloat LegoCameraController::GetWorldLocation()
 {
 	if (m_lego3DView && m_lego3DView->GetPointOfView()) {
 		Mx3DPointFloat vec;
-		vec = m_lego3DView->GetPointOfView()->GetWorldPosition();
+		vec = Vector3(m_lego3DView->GetPointOfView()->GetWorldPosition());
 		return Mx3DPointFloat(vec[0], vec[1] - m_entityOffsetUp, vec[2]);
 	}
 	else {
@@ -116,7 +116,7 @@ Mx3DPointFloat LegoCameraController::GetWorldDirection()
 {
 	if (m_lego3DView && m_lego3DView->GetPointOfView()) {
 		Mx3DPointFloat vec;
-		vec = m_lego3DView->GetPointOfView()->GetWorldDirection();
+		vec = Vector3(m_lego3DView->GetPointOfView()->GetWorldDirection());
 		return Mx3DPointFloat(vec[0], vec[1], vec[2]);
 	}
 	else {

LEGO1/lego/legoomni/src/entity/legoworld.cpp

@@ -266,6 +266,13 @@ LegoCameraController* LegoWorld::VTable0x54()
 	return m_cameraController;
 }
 
+// STUB: LEGO1 0x1001fa70
+undefined4 LegoWorld::FUN_1001fa70(IslePathActor* p_actor)
+{
+	// TODO
+	return 0;
+}
+
 // FUNCTION: LEGO1 0x1001fc80
 void LegoWorld::FUN_1001fc80(IslePathActor* p_actor)
 {

LEGO1/lego/legoomni/src/video/legovideomanager.cpp

@@ -383,6 +383,20 @@ MxResult LegoVideoManager::RealizePalette(MxPalette* p_pallete)
 	return SUCCESS;
 }
 
+// FUNCTION: LEGO1 0x1007c2d0
+MxResult LegoVideoManager::ResetPalette(MxBool p_ignoreSkyColor)
+{
+	MxResult result = FAILURE;
+
+	if (m_videoParam.GetPalette() != NULL) {
+		m_videoParam.GetPalette()->Reset(p_ignoreSkyColor);
+		m_displaySurface->SetPalette(m_videoParam.GetPalette());
+		result = SUCCESS;
+	}
+
+	return result;
+}
+
 // FUNCTION: LEGO1 0x1007c300
 void LegoVideoManager::EnableFullScreenMovie(MxBool p_enable)
 {

LEGO1/lego/legoomni/src/worlds/isle.cpp

@@ -2,21 +2,36 @@
 
 #include "act1state.h"
 #include "ambulance.h"
+#include "bike.h"
+#include "carracestate.h"
+#include "dunebuggy.h"
+#include "helicopter.h"
 #include "islepathactor.h"
+#include "jetski.h"
+#include "jetskiracestate.h"
+#include "jukeboxentity.h"
+#include "legoanimationmanager.h"
 #include "legocontrolmanager.h"
-#include "legogamestate.h"
 #include "legoinputmanager.h"
 #include "legoomni.h"
 #include "legoutils.h"
+#include "legovideomanager.h"
 #include "misc.h"
+#include "motocycle.h"
 #include "mxmisc.h"
 #include "mxnotificationmanager.h"
 #include "mxtransitionmanager.h"
 #include "pizza.h"
+#include "skateboard.h"
 #include "towtrack.h"
 
+#include <vec.h>
+
 DECOMP_SIZE_ASSERT(Isle, 0x140);
 
+// GLOBAL: LEGO1 0x100f1198
+undefined4 g_unk0x100f1198 = 0x7f;
+
 // FUNCTION: LEGO1 0x10030820
 Isle::Isle()
 {
@@ -33,7 +48,7 @@ Isle::Isle()
 	m_racecar = NULL;
 	m_jetski = NULL;
 	m_act1state = 0;
-	m_unk0x13c = 0;
+	m_unk0x13c = LegoGameState::e_undefined;
 
 	NotificationManager()->Register(this);
 }
@@ -74,7 +89,7 @@ MxResult Isle::Create(MxDSAction& p_dsAction)
 			GameState()->StopArea(LegoGameState::e_act2main); // Looks like a bug
 			break;
 		case LegoGameState::e_actNotFound:
-			m_unk0x13c = 2;
+			m_unk0x13c = LegoGameState::e_infomain;
 		}
 
 		if (GameState()->GetCurrentArea() == LegoGameState::e_isle) {
@@ -184,7 +199,7 @@ MxLong Isle::HandleType19Notification(MxParam& p_param)
 	return 0;
 }
 
-// STUB: LEGO1 0x10031820
+// FUNCTION: LEGO1 0x10031820
 void Isle::Enable(MxBool p_enable)
 {
 	if (m_set0xd0.empty() == p_enable) {
@@ -195,12 +210,329 @@ void Isle::Enable(MxBool p_enable)
 	m_radio.Initialize(p_enable);
 
 	if (p_enable) {
-		// TODO
+		FUN_100330e0();
+
+		VideoManager()->ResetPalette(FALSE);
+		m_act1state->FUN_10034d00();
+
+		if (CurrentActor() != NULL && CurrentActor()->GetActorId() != 0) {
+			// TODO: Match, most likely an inline function
+			MxS32 targetEntityId = (CurrentActor()->GetActorId() == 1) + 250;
+
+			if (targetEntityId != -1) {
+				InvokeAction(Extra::e_start, *g_isleScript, targetEntityId, NULL);
+			}
+		}
+
+		InputManager()->SetWorld(this);
+		GameState()->StopArea(LegoGameState::e_previousArea);
+		GameState()->m_previousArea = GameState()->m_currentArea;
+
+		FUN_1003ef00(TRUE);
+
+		if (m_act1state->m_unk0x018 == 0) {
+			MxU32 und[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+			for (MxU32 i = 0; i < 5; i++) {
+				MxS32 und2 = rand() % 5;
+
+				for (MxU32 j = 0; j < _countof(und); j++) {
+					if (und[j] != 0 && und2-- == 0) {
+						AnimationManager()->FUN_100629b0(und[j], TRUE);
+						und[j] = 0;
+						break;
+					}
+				}
+			}
+		}
+
+		if (CurrentActor() != NULL && CurrentActor()->IsA("Jetski")) {
+			IslePathActor* actor = CurrentActor();
+			actor->VTable0xe8(0x2d, FALSE, 7);
+			actor->SetUnknownDC(0);
+		}
+		else {
+			FUN_10032620();
+		}
+
+		switch (GameState()->m_currentArea) {
+		case LegoGameState::e_elevride:
+			m_unk0x13c = LegoGameState::e_elevride;
+
+#ifdef COMPAT_MODE
+			{
+				MxNotificationParam param(c_notificationTransitioned, NULL);
+				NotificationManager()->Send(this, &param);
+			}
+#else
+			NotificationManager()->Send(this, &MxNotificationParam(c_notificationTransitioned, NULL));
+#endif
+
+			SetIsWorldActive(FALSE);
+			break;
+		case LegoGameState::e_jetrace2:
+			if (((JetskiRaceState*) GameState()->GetState("JetskiRaceState"))->GetUnknown0x28() == 2) {
+				m_act1state->m_unk0x018 = 5;
+			}
+
+			FUN_1001fa70(CurrentActor());
+			SetIsWorldActive(TRUE);
+
+#ifdef COMPAT_MODE
+			{
+				LegoEventNotificationParam param(c_notificationType11, NULL, 0, 0, 0, 0);
+				m_jetski->Notify(param);
+			}
+#else
+			m_jetski->Notify(LegoEventNotificationParam(c_notificationType11, NULL, 0, 0, 0, 0));
+#endif
+			break;
+		case LegoGameState::e_garadoor:
+			m_unk0x13c = LegoGameState::e_garadoor;
+
+#ifdef COMPAT_MODE
+			{
+				MxNotificationParam param(c_notificationTransitioned, NULL);
+				NotificationManager()->Send(this, &param);
+			}
+#else
+			NotificationManager()->Send(this, &MxNotificationParam(c_notificationTransitioned, NULL));
+#endif
+
+			SetIsWorldActive(FALSE);
+			break;
+		case LegoGameState::e_polidoor:
+			m_unk0x13c = LegoGameState::e_polidoor;
+
+#ifdef COMPAT_MODE
+			{
+				MxNotificationParam param(c_notificationTransitioned, NULL);
+				NotificationManager()->Send(this, &param);
+			}
+#else
+			NotificationManager()->Send(this, &MxNotificationParam(c_notificationTransitioned, NULL));
+#endif
+
+			SetIsWorldActive(FALSE);
+			break;
+		case LegoGameState::e_unk57:
+			FUN_1001fa70(CurrentActor());
+			SetIsWorldActive(TRUE);
+
+#ifdef COMPAT_MODE
+			{
+				LegoEventNotificationParam param(c_notificationType11, NULL, 0, 0, 0, 0);
+				m_bike->Notify(param);
+			}
+#else
+			m_bike->Notify(LegoEventNotificationParam(c_notificationType11, NULL, 0, 0, 0, 0));
+#endif
+			break;
+		case LegoGameState::e_unk58:
+			FUN_1001fa70(CurrentActor());
+			SetIsWorldActive(TRUE);
+
+#ifdef COMPAT_MODE
+			{
+				LegoEventNotificationParam param(c_notificationType11, NULL, 0, 0, 0, 0);
+				m_dunebuggy->Notify(param);
+			}
+#else
+			m_dunebuggy->Notify(LegoEventNotificationParam(c_notificationType11, NULL, 0, 0, 0, 0));
+#endif
+			break;
+		case LegoGameState::e_unk59:
+			FUN_1001fa70(CurrentActor());
+			SetIsWorldActive(TRUE);
+
+#ifdef COMPAT_MODE
+			{
+				LegoEventNotificationParam param(c_notificationType11, NULL, 0, 0, 0, 0);
+				m_motocycle->Notify(param);
+			}
+#else
+			m_motocycle->Notify(LegoEventNotificationParam(c_notificationType11, NULL, 0, 0, 0, 0));
+#endif
+			break;
+		case LegoGameState::e_unk60:
+			FUN_1001fa70(CurrentActor());
+			SetIsWorldActive(TRUE);
+
+#ifdef COMPAT_MODE
+			{
+				LegoEventNotificationParam param(c_notificationType11, NULL, 0, 0, 0, 0);
+				m_helicopter->Notify(param);
+			}
+#else
+			m_helicopter->Notify(LegoEventNotificationParam(c_notificationType11, NULL, 0, 0, 0, 0));
+#endif
+			break;
+		case LegoGameState::e_unk61:
+			FUN_1001fa70(CurrentActor());
+			SetIsWorldActive(TRUE);
+
+#ifdef COMPAT_MODE
+			{
+				LegoEventNotificationParam param(c_notificationType11, NULL, 0, 0, 0, 0);
+				m_skateboard->Notify(param);
+			}
+#else
+			m_skateboard->Notify(LegoEventNotificationParam(c_notificationType11, NULL, 0, 0, 0, 0));
+#endif
+			break;
+		case LegoGameState::e_unk64:
+			FUN_1001fa70(CurrentActor());
+			SetIsWorldActive(TRUE);
+
+#ifdef COMPAT_MODE
+			{
+				LegoEventNotificationParam param(c_notificationType11, NULL, 0, 0, 0, 0);
+				m_jetski->Notify(param);
+			}
+#else
+			m_jetski->Notify(LegoEventNotificationParam(c_notificationType11, NULL, 0, 0, 0, 0));
+#endif
+			break;
+		default:
+			InputManager()->SetCamera(m_cameraController);
+			SetIsWorldActive(TRUE);
+			break;
+		}
+
+		switch (m_act1state->m_unk0x018) {
+		case 0:
+		case 1:
+			m_act1state->m_unk0x018 = 0;
+
+			if (GameState()->m_currentArea == LegoGameState::e_pizzeriaExterior) {
+				AnimationManager()->FUN_10064740(FALSE);
+			}
+			else if (GameState()->m_currentArea == LegoGameState::e_unk66) {
+				Mx3DPointFloat position(CurrentActor()->GetROI()->GetWorldPosition());
+
+				Mx3DPointFloat sub(-21.375f, 0.0f, -41.75f);
+				sub.Sub(&position);
+				if (NORMSQRD3(sub) < 1024.0f) {
+					AnimationManager()->FUN_10064740(FALSE);
+				}
+
+				Mx3DPointFloat sub2(98.874992f, 0.0f, -46.156292f);
+				sub2.Sub(&position);
+				if (NORMSQRD3(sub2) < 1024.0f) {
+					AnimationManager()->FUN_10064670(FALSE);
+				}
+			}
+			break;
+		case 5: {
+			CurrentActor()->VTable0xe8(0xf, FALSE, 7);
+			JetskiRaceState* raceState = (JetskiRaceState*) GameState()->GetState("JetskiRaceState");
+
+			if (raceState->GetUnknown0x28() == 2) {
+				undefined4 und = -1;
+
+				switch (raceState->GetState(GameState()->GetActorId())->GetUnknown0x02()) {
+				case 1:
+					und = 0x35e;
+					break;
+				case 2:
+					und = 0x35d;
+					break;
+				case 3:
+					und = 0x35c;
+					break;
+				}
+
+				AnimationManager()->FUN_10060dc0(und, 0, 1, 1, 0, 0, 0, 1, 0);
+			}
+
+			m_act1state->m_unk0x018 = 0;
+			FUN_1003ef00(FALSE);
+			AnimationManager()->FUN_10064670(FALSE);
+			break;
+		}
+		case 6: {
+			GameState()->m_currentArea = LegoGameState::e_carraceExterior;
+			CurrentActor()->VTable0xe8(0x15, FALSE, 7);
+
+			CarRaceState* raceState = (CarRaceState*) GameState()->GetState("CarRaceState");
+
+			if (raceState->GetUnknown0x28() == 2) {
+				undefined4 und = -1;
+
+				switch (raceState->GetState(GameState()->GetActorId())->GetUnknown0x02()) {
+				case 1:
+					und = 0x362;
+					break;
+				case 2:
+					und = 0x361;
+					break;
+				case 3:
+					und = 0x360;
+					break;
+				}
+
+				AnimationManager()->FUN_10060dc0(und, 0, 1, 1, 0, 0, 0, 1, 0);
+			}
+
+			m_act1state->m_unk0x018 = 0;
+			FUN_1003ef00(TRUE);
+			break;
+		}
+		case 7:
+			m_act1state->m_unk0x018 = 8;
+
+			AnimationManager()->FUN_1005f6d0(FALSE);
+			AnimationManager()->FUN_1005f700(FALSE);
+
+			g_unk0x100f1198 &= ~c_bit7;
+			m_towtrack->FUN_1004dab0();
+			break;
+		case 9:
+			m_act1state->m_unk0x018 = 10;
+
+			AnimationManager()->FUN_1005f6d0(FALSE);
+			AnimationManager()->FUN_1005f700(FALSE);
+
+			g_unk0x100f1198 &= ~c_bit7;
+			m_ambulance->FUN_10036e60();
+			break;
+		case 11:
+			m_act1state->m_unk0x018 = 0;
+			CurrentActor()->VTable0xe8(0x36, TRUE, 7);
+			GameState()->m_currentArea = LegoGameState::e_unk66;
+			FUN_1003ef00(TRUE);
+			m_jukebox->StartAction();
+			break;
+		}
+
+		SetAppCursor(0);
+
+		if (m_act1state->m_unk0x018 != 8 &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_elevride) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_polidoor) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_garadoor) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_unk57) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_unk58) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_unk59) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_unk60) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_unk64) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_unk61) &&
+			(m_act1state->m_unk0x018 != 0 || GameState()->m_currentArea != LegoGameState::e_jetrace2)) {
+			FUN_10015820(FALSE, LegoOmni::c_disableInput | LegoOmni::c_disable3d | LegoOmni::c_clearScreen);
+		}
+
+		SetROIUnknown0x0c("stretch", 0);
+		SetROIUnknown0x0c("bird", 0);
+		SetROIUnknown0x0c("rcred", 0);
+		SetROIUnknown0x0c("towtk", 0);
+		SetROIUnknown0x0c("pizpie", 0);
 	}
 	else {
 		if (InputManager()->GetWorld() == this) {
 			InputManager()->ClearWorld();
 		}
+
+		m_act1state->FUN_10034b60();
 	}
 }
 
@@ -278,6 +610,12 @@ void Isle::VTable0x6c(IslePathActor* p_actor)
 	}
 }
 
+// STUB: LEGO1 0x100330e0
+void Isle::FUN_100330e0()
+{
+	// TODO
+}
+
 // STUB: LEGO1 0x10033180
 MxBool Isle::VTable0x64()
 {

LEGO1/mxgeometry/mxgeometry3d.h

@@ -20,6 +20,8 @@ class Mx3DPointFloat : public Vector3 {
 	// FUNCTION: LEGO1 0x100343a0
 	inline Mx3DPointFloat(const Mx3DPointFloat& p_other) : Vector3(m_elements) { EqualsImpl(p_other.m_data); }
 
+	inline Mx3DPointFloat(const float* p_other) : Vector3(m_elements) { EqualsImpl((float*) p_other); }
+
 	// SYNTHETIC: LEGO1 0x1001d170
 	// Mx3DPointFloat::Mx3DPointFloat