Class layout for LEGO1 classes (#43)

* Stubbed a bunch of classes and annotated them for later use. Heavily wip and more of pseudocode right now.

* Converted pseudocode into real code!

* Created a bunch more classes and added more information to exisiting ones
Did not error check, this was pushed just for reference

* More classes and implementation details. Still not checked for any errors

* Fixed code and decided on a way to handle virtual table stubs

* Some additional fixes

* More smaller fixes

* Added classes to project and made it compile

* Fixed function adresses that caused the python script to fail

* More classes and virtual function resolves. Builds and compares fine.

* Again more classes and virtual function resolves. Builds and compares fine.

* No clue, I guess forced update for line endings

* Finished up some work, compiles fine. All functions are STUB annotated to not pollute reccmp.py output.

* line ending change

* rename GetClassName/IsClass

Mirroring recent changes from master

* further conform to current master

* update project

* cleanup

* project only updates when you close msdev

---------

Co-authored-by: Cydra <cydra95@gmail.com>
Co-authored-by: itsmattkc <34096995+itsmattkc@users.noreply.github.com>

ISLE/isleapp.cpp

@@ -1,4 +1,4 @@
-#include "isle.h"
+#include "isleapp.h"
 #include "define.h"
 
 #include <dsound.h>

ISLE/isleapp.h

@@ -1,9 +1,9 @@
-#ifndef ISLE_H
+#ifndef ISLEAPP_H
-#define ISLE_H
+#define ISLEAPP_H
 
 #include <windows.h>
 
-#include "mxresult.h"
+#include "mxtypes.h"
 #include "mxvideoparam.h"
 
 class IsleApp
@@ -73,4 +73,4 @@ class IsleApp
   HCURSOR m_cursorCurrent;
 };
 
-#endif // ISLE_H
+#endif // ISLEAPP_H

LEGO1/act1state.cpp

@@ -0,0 +1,8 @@
+#include "act1state.h"
+
+// OFFSET: LEGO1 0x100334b0 STUB
+Act1State::Act1State()
+{
+  // TODO
+}
+

LEGO1/act1state.h

@@ -0,0 +1,27 @@
+#ifndef ACT1STATE_H
+#define ACT1STATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d7028
+// SIZE 0x26c
+class Act1State : public LegoState
+{
+public:
+  Act1State();
+
+  // OFFSET: LEGO1 0x100338a0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0154
+    return "Act1State";
+  };
+
+  // OFFSET: LEGO1 0x100338b0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Act1State::ClassName()) || LegoState::IsA(name);
+  };
+};
+
+#endif // ACT1STATE_H

LEGO1/act2brick.cpp

@@ -0,0 +1,29 @@
+#include "act2brick.h"
+
+// OFFSET: LEGO1 0x1007a2b0 STUB
+Act2Brick::Act2Brick()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x1007a470 STUB
+Act2Brick::~Act2Brick()
+{
+  // TODO
+}
+
+// STUB OFFSET: LEGO1 0x1007a8c0 STUB
+long Act2Brick::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}
+
+// OFFSET: LEGO1 0x1007a7f0 STUB
+long Act2Brick::Tickle()
+{
+  // TODO
+
+  return 0;
+}

LEGO1/act2brick.h

@@ -0,0 +1,32 @@
+#ifndef ACT2BRICK_H
+#define ACT2BRICK_H
+
+#include "legopathactor.h"
+
+// VTABLE 0x100d9b60
+// SIZE 0x194
+class Act2Brick : public LegoPathActor
+{
+public:
+  Act2Brick();	
+  virtual ~Act2Brick() override; // vtable+0x0
+
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+  virtual long Tickle() override; // vtable+0x08
+
+  // OFFSET: LEGO1 0x1007a360
+  inline virtual const char *ClassName() override // vtable+0x0c
+  {
+    // 0x100f0438
+    return "Act2Brick";
+  }
+
+  // OFFSET: LEGO1 0x1007a370
+  inline virtual MxBool IsA(const char *name) override // vtable+0x10
+  {
+    return !strcmp(Act2Brick::ClassName(), name) || LegoEntity::IsA(name);
+  }
+
+};
+
+#endif // ACT2BRICK_H

LEGO1/act2policestation.cpp

@@ -0,0 +1,9 @@
+#include "act2policestation.h"
+
+// OFFSET: LEGO1 0x1004e0e0 STUB
+long Act2PoliceStation::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}

LEGO1/act2policestation.h

@@ -0,0 +1,27 @@
+#ifndef ACT2POLICESTATION_H
+#define ACT2POLICESTATION_H
+
+#include "legoentity.h"
+
+// VTABLE 0x100d53a8
+// SIZE 0x68
+class Act2PoliceStation : public LegoEntity
+{
+public:
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+
+  // OFFSET: LEGO1 0x1000e200
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f03fc
+    return "Act2PoliceStation";
+  }
+
+  // OFFSET: LEGO1 0x1000e210
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Act2PoliceStation::ClassName()) || LegoEntity::IsA(name);
+  }
+};
+
+#endif // ACT2POLICESTATION_H

LEGO1/act3.cpp

@@ -0,0 +1,13 @@
+#include "act3.h"
+
+// OFFSET: LEGO1 0x10072270 STUB
+Act3::Act3()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100726a0 STUB
+Act3::~Act3()
+{
+  // TODO
+}

LEGO1/act3.h

@@ -0,0 +1,31 @@
+#ifndef ACT3_H
+#define ACT3_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d9628
+// SIZE 0x4274
+class Act3 : public LegoWorld
+{
+public:
+  Act3();
+
+  virtual ~Act3() override; // vtable+00
+
+  // OFFSET: LEGO1 0x10072510
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f013c
+    return "Act3";
+  }
+
+  // OFFSET: LEGO1 0x10072520
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Act3::ClassName()) || LegoWorld::IsA(name);
+  }
+
+};
+
+
+#endif // ACT3_H

LEGO1/act3actor.h

@@ -0,0 +1,18 @@
+#ifndef ACT3ACTOR_H
+#define ACT3ACTOR_H
+
+// FIXME: Uncertain location. There are three vtables which eventually call this
+//        class' ClassName() function, but none of them call it directly.
+class Act3Actor
+{
+public:
+  // OFFSET: LEGO1 0x100431b0
+  inline virtual const char *ClassName() override
+  {
+    // 0x100f03ac
+    return "Act3Actor";
+  }
+
+};
+
+#endif // ACT3ACTOR_H

LEGO1/act3shark.cpp

@@ -0,0 +1 @@
+#include "act3shark.h"

LEGO1/act3shark.h

@@ -0,0 +1,18 @@
+#ifndef ACT3SHARK_H
+#define ACT3SHARK_H
+
+#include "legoanimactor.h"
+
+// VTABLE 0x100d7920
+class Act3Shark : public LegoAnimActor
+{
+public:
+  // OFFSET: LEGO1 0x100430c0
+  inline virtual const char *ClassName() const override
+  {
+    // 0x100f03a0
+    return "Act3Shark";
+  }
+};
+
+#endif // ACT3SHARK_H

LEGO1/act3state.cpp

@@ -0,0 +1,7 @@
+#include "act3state.h"
+
+// OFFSET: LEGO1 0x1000e2f0
+MxBool Act3State::VTable0x14()
+{
+  return FALSE;
+}

LEGO1/act3state.h

@@ -0,0 +1,37 @@
+#ifndef ACT3STATE_H
+#define ACT3STATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d4fc8
+// SIZE 0xc
+class Act3State : public LegoState
+{
+public:
+  inline Act3State()
+  {
+    m_unk08 = 0;
+  }
+
+  // OFFSET: LEGO1 0x1000e300
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f03f0
+    return "Act3State";
+  }
+
+  // OFFSET: LEGO1 0x1000e310
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Act3State::ClassName()) || LegoState::IsA(name);
+  }
+
+  virtual MxBool VTable0x14() override;
+
+private:
+  // FIXME: May be part of LegoState? Uncertain...
+  MxU32 m_unk08;
+
+};
+
+#endif // ACT3STATE_H

LEGO1/ambulance.cpp

@@ -0,0 +1,7 @@
+#include "ambulance.h"
+
+// OFFSET: LEGO1 0x10035ee0 STUB
+Ambulance::Ambulance()
+{
+  // TODO
+}

LEGO1/ambulance.h

@@ -0,0 +1,28 @@
+#ifndef AMBULANCE_H
+#define AMBULANCE_H
+
+#include "islepathactor.h"
+
+// VTABLE 0x100d71a8
+// SIZE 0x184
+class Ambulance : public IslePathActor
+{
+public:
+  Ambulance();
+
+  // OFFSET: LEGO1 0x10035fa0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f03c4
+    return "Ambulance";
+  }
+
+  // OFFSET: LEGO1 0x10035fb0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Ambulance::ClassName()) || IslePathActor::IsA(name);
+  }
+
+};
+
+#endif // AMBULANCE_H

LEGO1/ambulancemissionstate.cpp

@@ -0,0 +1,7 @@
+#include "ambulancemissionstate.h"
+
+// OFFSET: LEGO1 0x100373a0 STUB
+AmbulanceMissionState::AmbulanceMissionState()
+{
+  // TODO
+}

LEGO1/ambulancemissionstate.h

@@ -0,0 +1,29 @@
+#ifndef AMBULANCEMISSIONSTATE_H
+#define AMBULANCEMISSIONSTATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d72a0
+// SIZE 0x24
+class AmbulanceMissionState : public LegoState
+{
+public:
+  AmbulanceMissionState();
+
+  // OFFSET: LEGO1 0x10037600
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f00e8
+    return "AmbulanceMissionState";
+  }
+
+  // OFFSET: LEGO1 0x10037610
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, AmbulanceMissionState::ClassName()) || LegoState::IsA(name);
+  }
+
+};
+
+
+#endif // AMBULANCEMISSIONSTATE_H

LEGO1/animstate.cpp

@@ -0,0 +1,13 @@
+#include "animstate.h"
+
+// OFFSET: LEGO1 0x10064ff0 STUB
+AnimState::AnimState()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10065150 STUB
+AnimState::~AnimState()
+{
+  // TODO
+}

LEGO1/animstate.h

@@ -0,0 +1,29 @@
+#ifndef ANIMSTATE_H
+#define ANIMSTATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d8d80
+// SIZE 0x1c
+class AnimState : public LegoState
+{
+public:
+  AnimState();
+  virtual ~AnimState() override; // vtable+0x0
+
+  // OFFSET: LEGO1 0x10065070
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f0460
+    return "AnimState";
+  }
+
+  // OFFSET: LEGO1 0x10065080
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, AnimState::ClassName()) || LegoState::IsA(name);
+  }
+
+};
+
+#endif // ANIMSTATE_H

LEGO1/beachhouseentity.cpp

@@ -0,0 +1,9 @@
+#include "beachhouseentity.h"
+
+// OFFSET: LEGO1 0x100150a0 STUB
+long BeachHouseEntity::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}

LEGO1/beachhouseentity.h

@@ -0,0 +1,27 @@
+#ifndef BEACHHOUSEENTITY_H
+#define BEACHHOUSEENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE 0x100d4a18
+// SIZE 0x68
+class BeachHouseEntity : public BuildingEntity
+{
+public:
+  virtual long Notify(MxParam &p) override; // vtable+04
+
+  // OFFSET: LEGO1 0x1000ee80
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0314
+    return "BeachHouseEntity";
+  }
+
+  // OFFSET: LEGO1 0x1000ee90
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, BeachHouseEntity::ClassName()) || BuildingEntity::IsA(name);
+  }
+};
+
+#endif // BEACHHOUSEENTITY_H

LEGO1/bike.cpp

@@ -0,0 +1,8 @@
+#include "bike.h"
+
+// OFFSET: LEGO1 0x10076670 STUB
+Bike::Bike()
+{
+  // TODO
+}
+

LEGO1/bike.h

@@ -0,0 +1,29 @@
+#ifndef BIKE_H
+#define BIKE_H
+
+#include "islepathactor.h"
+
+// VTABLE 0x100d9808
+// SIZE 0x164
+class Bike : public IslePathActor
+{
+public:
+  Bike();
+
+  // OFFSET: LEGO1 0x100766f0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f03d0
+    return "Bike";
+  }
+
+  // OFFSET: LEGO1 0x10076700
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Bike::ClassName()) || IslePathActor::IsA(name);
+  }
+
+};
+
+
+#endif // BIKE_H

LEGO1/buildingentity.cpp

@@ -0,0 +1,13 @@
+#include "buildingentity.h"
+
+// OFFSET: LEGO1 0x10014e20 STUB
+BuildingEntity::BuildingEntity()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10015030 STUB
+BuildingEntity::~BuildingEntity()
+{
+  // TODO
+}

LEGO1/buildingentity.h

@@ -0,0 +1,28 @@
+#ifndef BUILDINGENTITY_H
+#define BUILDINGENTITY_H
+
+#include "legoentity.h"
+
+// VTABLE 0x100d5c88
+// SIZE <= 0x68, hard to tell because it's always constructed as a derivative
+class BuildingEntity : public LegoEntity
+{
+public:
+  BuildingEntity();
+  virtual ~BuildingEntity() override; // vtable+0x0
+
+  // OFFSET: LEGO1 0x10014f20
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f07e8
+    return "BuildingEntity";
+  }
+
+  // OFFSET: LEGO1 0x10014f30
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, BuildingEntity::ClassName()) || LegoEntity::IsA(name);
+  }
+};
+
+#endif // BUILDINGENTITY_H

LEGO1/bumpbouy.cpp

@@ -0,0 +1 @@
+#include "bumpbouy.h"

LEGO1/bumpbouy.h

@@ -0,0 +1,25 @@
+#ifndef BUMPBOUY_H
+#define BUMPBOUY_H
+
+#include "legoanimactor.h"
+#include "mxtypes.h"
+
+// VTABLE 0x100d6790
+class BumpBouy : public LegoAnimActor
+{
+public:
+  // OFFSET: LEGO1 0x100274e0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0394
+    return "BumpBouy";
+  }
+
+  // OFFSET: LEGO1 0x10027500
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, BumpBouy::ClassName()) || LegoAnimActor::IsA(name);
+  }
+};
+
+#endif // BUMPBOUY_H

LEGO1/carrace.cpp

@@ -0,0 +1,7 @@
+#include "carrace.h"
+
+// OFFSET: LEGO1 0x10016a90 STUB
+CarRace::CarRace()
+{
+  // TODO
+}

LEGO1/carrace.h

@@ -0,0 +1,27 @@
+#ifndef CARRACE_H
+#define CARRACE_H
+
+#include "legorace.h"
+
+// VTABLE 0x100d5e50
+// SIZE 0x154
+class CarRace : public LegoRace
+{
+public:
+  CarRace();
+
+  // OFFSET: LEGO1 0x10016b20
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0528
+    return "CarRace";
+  }
+
+  // OFFSET: LEGO1 0x10016b30
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, CarRace::ClassName()) || LegoRace::IsA(name);
+  }
+};
+
+#endif // CARRACE_H

LEGO1/carracestate.h

@@ -0,0 +1,25 @@
+#ifndef CARRACESTATE_H
+#define CARRACESTATE_H
+
+#include "racestate.h"
+
+// VTABLE 0x100d4b70
+// SIZE 0x2c
+class CarRaceState : public RaceState
+{
+public:
+  // OFFSET: LEGO1 0x1000dd30
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f009c
+    return "CarRaceState";
+  }
+
+  // OFFSET: LEGO1 0x1000dd40
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, CarRaceState::ClassName()) || RaceState::IsA(name);
+  }
+};
+
+#endif // CARRACESTATE_H

LEGO1/doors.h

@@ -0,0 +1,26 @@
+#ifndef DOORS_H
+#define DOORS_H
+
+#include "legopathactor.h"
+
+// VTABLE 0x100d4788
+// SIZE 0x1f8
+class Doors : public LegoPathActor
+{
+public:
+  // OFFSET: LEGO1 0x1000e430
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f03e8
+    return "Doors";
+  }
+
+  // OFFSET: LEGO1 0x1000e440
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Doors::ClassName()) || LegoPathActor::IsA(name);
+  }
+};
+
+
+#endif // DOORS_H

LEGO1/dunebuggy.cpp

@@ -0,0 +1,7 @@
+#include "dunebuggy.h"
+
+// OFFSET: LEGO1 0x10067bb0 STUB
+DuneBuggy::DuneBuggy()
+{
+  // TODO
+}

LEGO1/dunebuggy.h

@@ -0,0 +1,28 @@
+#ifndef DUNEBUGGY_H
+#define DUNEBUGGY_H
+
+#include "islepathactor.h"
+
+// VTABLE 0x100d8f98
+// SIZE 0x16c
+class DuneBuggy : public IslePathActor
+{
+public:
+  DuneBuggy();
+
+  // OFFSET: LEGO1 0x10067c30
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0410
+    return "DuneBuggy";
+  }
+
+  // OFFSET: LEGO1 0x10067c40
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, DuneBuggy::ClassName()) || IslePathActor::IsA(name);
+  }
+  
+};
+
+#endif // DUNEBUGGY_H

LEGO1/elevatorbottom.cpp

@@ -0,0 +1,21 @@
+#include "elevatorbottom.h"
+
+// OFFSET: LEGO1 0x10017e90 STUB
+ElevatorBottom::ElevatorBottom()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10018060 STUB
+ElevatorBottom::~ElevatorBottom()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10018150 STUB
+long ElevatorBottom::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}

LEGO1/elevatorbottom.h

@@ -0,0 +1,30 @@
+#ifndef ELEVATORBOTTOM_H
+#define ELEVATORBOTTOM_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d5f20
+class ElevatorBottom : public LegoWorld
+{
+public:
+  ElevatorBottom();
+  virtual ~ElevatorBottom() override; // vtable+0x0
+
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+
+  // OFFSET: LEGO1 0x10017f20
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f04ac
+    return "ElevatorBottom";
+  }
+
+  // OFFSET: LEGO1 0x10017f30
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, ElevatorBottom::ClassName()) || LegoWorld::IsA(name);
+  }
+
+};
+
+#endif // ELEVATORBOTTOM_H

LEGO1/gasstation.cpp

@@ -0,0 +1,29 @@
+#include "gasstation.h"
+
+// OFFSET: LEGO1 0x100046a0 STUB
+GasStation::GasStation()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100048c0 STUB
+GasStation::~GasStation()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10004a60 STUB
+long GasStation::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}
+
+// OFFSET: LEGO1 0x10005c90 STUB
+long GasStation::Tickle()
+{
+  // TODO
+
+  return 0;
+}

LEGO1/gasstation.h

@@ -0,0 +1,33 @@
+#ifndef GASSTATION_H
+#define GASSTATION_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d4650
+// SIZE 0x128
+// Radio variable at 0x46, in constructor
+class GasStation : public LegoWorld
+{
+public:
+  GasStation();
+  virtual ~GasStation() override; // vtable+0x0
+  
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+  virtual long Tickle() override; // vtable+0x8
+
+  // OFFSET: LEGO1 0x10004780
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0168
+    return "GasStation";
+  }
+
+  // OFFSET: LEGO1 0x10004790
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, GasStation::ClassName()) || LegoWorld::IsA(name);
+  }
+
+};
+
+#endif // GASSTATION_H

LEGO1/gasstationentity.cpp

@@ -0,0 +1 @@
+#include "gasstationentity.h"

LEGO1/gasstationentity.h

@@ -0,0 +1,25 @@
+#ifndef GASSTATIONENTITY_H
+#define GASSTATIONENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE 0x100d5258
+// SIZE 0x68
+class GasStationEntity : public BuildingEntity
+{
+public:
+  // OFFSET: LEGO1 0x1000eb20
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0348
+    return "GasStationEntity";
+  }
+
+  // OFFSET: LEGO1 0x1000eb30
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, GasStationEntity::ClassName()) || BuildingEntity::IsA(name);
+  }
+};
+
+#endif // GASSTATIONENTITY_H

LEGO1/gasstationstate.cpp

@@ -0,0 +1,7 @@
+#include "gasstationstate.h"
+
+// OFFSET: LEGO1 0x10005eb0 STUB
+GasStationState::GasStationState()
+{
+  // TODO
+}

LEGO1/gasstationstate.h

@@ -0,0 +1,28 @@
+#ifndef GASSTATIONSTATE_H
+#define GASSTATIONSTATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d46e0
+// SIZE 0x24
+class GasStationState : public LegoState
+{
+public:
+  GasStationState();
+
+  // OFFSET: LEGO1 0x100061d0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f0174
+    return "GasStationState";
+  }
+
+  // OFFSET: LEGO1 0x100061e0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, GasStationState::ClassName()) || LegoState::IsA(name);
+  }
+
+};
+
+#endif // GASSTATIONSTATE_H

LEGO1/helicopter.cpp

@@ -0,0 +1,13 @@
+#include "helicopter.h"
+
+// OFFSET: LEGO1 0x10001e60 STUB
+Helicopter::Helicopter()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10003230 STUB
+Helicopter::~Helicopter()
+{
+  // TODO
+}

LEGO1/helicopter.h

@@ -0,0 +1,29 @@
+#ifndef HELICOPTER_H
+#define HELICOPTER_H
+
+#include "islepathactor.h"
+
+// VTABLE 0x100d40f8
+// SIZE 0x230
+class Helicopter : public IslePathActor
+{
+public:
+  Helicopter();
+  virtual ~Helicopter(); // vtable+0x0
+
+  // OFFSET: LEGO1 0x10003070
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0130
+    return "Helicopter";
+  }
+
+  // OFFSET: LEGO1 0x10003080
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Helicopter::ClassName()) || IslePathActor::IsA(name);
+  }
+
+};
+
+#endif // HELICOPTER_H

LEGO1/helicopterstate.cpp

@@ -0,0 +1 @@
+#include "helicopterstate.h"

LEGO1/helicopterstate.h

@@ -0,0 +1,25 @@
+#ifndef HELICOPTERSTATE_H
+#define HELICOPTERSTATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d5418
+// SIZE 0xc
+class HelicopterState : public LegoState
+{
+public:
+  // OFFSET: LEGO1 0x1000e0d0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f0144
+    return "HelicopterState";
+  }
+
+  // OFFSET: LEGO1 0x1000e0e0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, HelicopterState::ClassName()) || LegoState::IsA(name);
+  }
+};
+
+#endif // HELICOPTERSTATE_H

LEGO1/historybook.cpp

@@ -0,0 +1,21 @@
+#include "historybook.h"
+
+// OFFSET: LEGO1 0x100822f0 STUB
+HistoryBook::HistoryBook()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100824d0 STUB
+HistoryBook::~HistoryBook()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10082680 STUB
+long HistoryBook::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}

LEGO1/historybook.h

@@ -0,0 +1,30 @@
+#ifndef HISTORYBOOK_H
+#define HISTORYBOOK_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100da328
+// SIZE 0x3e4
+class HistoryBook : public LegoWorld
+{
+public:
+  HistoryBook();
+  virtual ~HistoryBook() override; // vtable+0x0
+
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+
+  // OFFSET: LEGO1 0x10082390
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f04bc
+    return "HistoryBook";
+  }
+
+  // OFFSET: LEGO1 0x100823a0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, HistoryBook::ClassName()) || LegoWorld::IsA(name);
+  }
+};
+
+#endif // HISTORYBOOK_H

LEGO1/hospital.cpp

@@ -0,0 +1,21 @@
+#include "hospital.h"
+
+// OFFSET: LEGO1 0x100745e0 STUB
+Hospital::Hospital()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100747f0 STUB
+Hospital::~Hospital()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10074990 STUB
+long Hospital::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}

LEGO1/hospital.h

@@ -0,0 +1,31 @@
+#ifndef HOSPITAL_H
+#define HOSPITAL_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d9730
+// SIZE 0x12c
+class Hospital : public LegoWorld
+{
+public:
+  Hospital();
+  virtual ~Hospital() override; // vtable+0x0
+  
+  virtual long Notify(MxParam &p) override; // vtable+0x04
+
+  // OFFSET: LEGO1 0x100746b0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0490
+    return "Hospital";
+  }
+
+  // OFFSET: LEGO1 0x100746c0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Hospital::ClassName()) || LegoWorld::IsA(name);
+  }
+
+};
+
+#endif // HOSPITAL_H

LEGO1/hospitalentity.cpp

@@ -0,0 +1 @@
+#include "hospitalentity.h"

LEGO1/hospitalentity.h

@@ -0,0 +1,26 @@
+#ifndef HOSPITALENTITY_H
+#define HOSPITALENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE 0x100d5068
+// SIZE 0x68
+class HospitalEntity : public BuildingEntity
+{
+public:
+  // OFFSET: LEGO1 0x1000ec40
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0338
+    return "HospitalEntity";
+  }
+
+  // OFFSET: LEGO1 0x1000ec50
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, HospitalEntity::ClassName()) || BuildingEntity::IsA(name);
+  }
+
+};
+
+#endif // HOSPITALENTITY_H

LEGO1/hospitalstate.cpp

@@ -0,0 +1,7 @@
+#include "hospitalstate.h"
+
+// OFFSET: LEGO1 0x10076370 STUB
+HospitalState::HospitalState()
+{
+  // TODO
+}

LEGO1/hospitalstate.h

@@ -0,0 +1,28 @@
+#ifndef HOSPITALSTATE_H
+#define HOSPITALSTATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d97a0
+// SIZE 0x18
+class HospitalState : public LegoState
+{
+public:
+  HospitalState();
+
+  // OFFSET: LEGO1 0x10076400
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f0480
+    return "HospitalState";
+  }
+
+  // OFFSET: LEGO1 0x10076410
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, HospitalState::ClassName()) || LegoState::IsA(name);
+  }
+
+};
+
+#endif // HOSPITALSTATE_H

LEGO1/infocenter.cpp

@@ -0,0 +1,29 @@
+#include "infocenter.h"
+
+// OFFSET: LEGO1 0x1006ea20 STUB
+Infocenter::Infocenter()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x1006ec90 STUB
+Infocenter::~Infocenter()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x1006ef10 STUB
+long Infocenter::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}
+
+// OFFSET: LEGO1 0x10070af0 STUB
+long Infocenter::Tickle()
+{
+  // TODO
+
+  return 0;
+}

LEGO1/infocenter.h

@@ -0,0 +1,32 @@
+#ifndef INFOCENTER_H
+#define INFOCENTER_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d9338
+// SIZE 0x1d8
+class Infocenter : public LegoWorld
+{
+public:
+  Infocenter();
+  virtual ~Infocenter() override;
+
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+  virtual long Tickle() override; // vtable+0x8
+
+  // OFFSET: LEGO1 0x1006eb40
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f04ec
+    return "Infocenter";
+  }
+
+  // OFFSET: LEGO1 0x1006eb50
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Infocenter::ClassName()) || LegoWorld::IsA(name);
+  }
+
+};
+
+#endif // INFOCENTER_H

LEGO1/infocenterdoor.cpp

@@ -0,0 +1,21 @@
+#include "infocenterdoor.h"
+
+// OFFSET: LEGO1 0x10037730 STUB
+InfocenterDoor::InfocenterDoor()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100378f0 STUB
+InfocenterDoor::~InfocenterDoor()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100379e0 STUB
+long InfocenterDoor::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}

LEGO1/infocenterdoor.h

@@ -0,0 +1,31 @@
+#ifndef INFOCENTERDOOR_H
+#define INFOCENTERDOOR_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d72d8
+// SIZE 0xfc
+class InfocenterDoor : public LegoWorld
+{
+public:
+  InfocenterDoor();
+  virtual ~InfocenterDoor(); // vtable+0x0
+  
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+
+  // OFFSET: LEGO1 0x100377b0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f049c
+    return "InfocenterDoor";
+  }
+
+  // OFFSET: LEGO1 0x100377c0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, InfocenterDoor::ClassName()) || LegoWorld::IsA(name);
+  }
+
+};
+
+#endif // INFOCENTERDOOR_H

LEGO1/infocenterentity.cpp

@@ -0,0 +1 @@
+#include "infocenterentity.h"

LEGO1/infocenterentity.h

@@ -0,0 +1,26 @@
+#ifndef INFOCENTERENTITY_H
+#define INFOCENTERENTITY_H
+
+#include "buildingentity.h"
+
+// VTABLE 0x100d4b90
+// SIZE 0x68
+class InfoCenterEntity : public BuildingEntity
+{
+public:
+  // OFFSET: LEGO1 0x1000ea00
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f035c
+    return "InfoCenterEntity";
+  }
+
+  // OFFSET: LEGO1 0x1000ea10
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, InfoCenterEntity::ClassName()) || BuildingEntity::IsA(name);
+  }
+
+};
+
+#endif // INFOCENTERENTITY_H

LEGO1/infocenterstate.cpp

@@ -0,0 +1,14 @@
+#include "infocenterstate.h"
+
+// OFFSET: LEGO1 0x10071600 STUB
+InfocenterState::InfocenterState()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10071920 STUB
+InfocenterState::~InfocenterState()
+{
+  // TODO
+}
+

LEGO1/infocenterstate.h

@@ -0,0 +1,28 @@
+#ifndef INFOCENTERSTATE_H
+#define INFOCENTERSTATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d93a8
+// SIZE 0x94
+class InfocenterState : public LegoState
+{
+public:
+  InfocenterState();
+  virtual ~InfocenterState();
+
+  // OFFSET: LEGO1 0x10071840
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f04dc
+    return "InfocenterState";
+  }
+
+  // OFFSET: LEGO1 0x10071850
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, InfocenterState::ClassName()) || LegoState::IsA(name);
+  }
+};
+
+#endif // INFOCENTERSTATE_H

LEGO1/isle.cpp

@@ -0,0 +1,7 @@
+#include "isle.h"
+
+// OFFSET: LEGO1 0x10030820 STUB
+Isle::Isle()
+{
+  // TODO
+}

LEGO1/isle.h

@@ -0,0 +1,28 @@
+#ifndef ISLE_H
+#define ISLE_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d6fb8
+// SIZE 0x140
+// Radio at 0x12c
+class Isle : public LegoWorld
+{
+public:
+  Isle();
+
+  // OFFSET: LEGO1 0x10030910
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0458
+    return "Isle";
+  }
+
+  // OFFSET: LEGO1 0x10030920
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Isle::ClassName()) || LegoWorld::IsA(name);
+  }
+};
+
+#endif // ISLE_H

LEGO1/isleactor.cpp

@@ -0,0 +1 @@
+#include "isleactor.h"

LEGO1/isleactor.h

@@ -0,0 +1,24 @@
+#ifndef ISLEACTOR_H
+#define ISLEACTOR_H
+
+#include "legoactor.h"
+
+// VTABLE 0x100d5178
+class IsleActor : public LegoActor
+{
+public:
+  // OFFSET: LEGO1 0x1000e660
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f07dc
+    return "IsleActor";
+  }
+
+  // OFFSET: LEGO1 0x1000e670
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, IsleActor::ClassName()) || LegoActor::IsA(name);
+  }
+};
+
+#endif // ISLEACTOR_H

LEGO1/islepathactor.cpp

@@ -0,0 +1 @@
+#include "islepathactor.h"

LEGO1/islepathactor.h

@@ -0,0 +1,25 @@
+#ifndef ISLEPATHACTOR_H
+#define ISLEPATHACTOR_H
+
+#include "legopathactor.h"
+
+// VTABLE 0x100d4398
+// SIZE >= 0x230
+class IslePathActor : public LegoPathActor
+{
+public:
+  // OFFSET: LEGO1 0x10002ea0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0104
+    return "IslePathActor";
+  }
+
+  // OFFSET: LEGO1 0x10002eb0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, IslePathActor::ClassName()) || LegoPathActor::IsA(name);
+  }
+};
+
+#endif // ISLEPATHACTOR_H

LEGO1/jetski.cpp

@@ -0,0 +1,7 @@
+#include "jetski.h"
+
+// OFFSET: LEGO1 0x1007e3b0 STUB
+Jetski::Jetski()
+{
+  // TODO
+}

LEGO1/jetski.h

@@ -0,0 +1,29 @@
+#ifndef JETSKI_H
+#define JETSKI_H
+
+#include "islepathactor.h"
+
+// VTABLE 0x100d9ec8
+// SIZE 0x164
+class Jetski : public IslePathActor
+{
+public:
+  Jetski();
+
+  // OFFSET: LEGO1 0x1007e430
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f03d8
+    return "Jetski";
+  }
+
+  // OFFSET: LEGO1 0x1007e440
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Jetski::ClassName()) || IslePathActor::IsA(name);
+  }
+
+};
+
+
+#endif // JETSKI_H

LEGO1/jetskirace.cpp

@@ -0,0 +1 @@
+#include "jetskirace.h"

LEGO1/jetskirace.h

@@ -0,0 +1,26 @@
+#ifndef JETSKIRACE_H
+#define JETSKIRACE_H
+
+#include "legorace.h"
+
+// VTABLE 0x100d4fe8
+// SIZE 0x144
+class JetskiRace : public LegoRace
+{
+public:
+
+  // OFFSET: LEGO1 0x1000daf0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0530
+    return "JetskiRace";
+  }
+
+  // OFFSET: LEGO1 0x1000db00
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, JetskiRace::ClassName()) || LegoRace::IsA(name);
+  }
+};
+
+#endif // JETSKIRACE_H

LEGO1/jetskiracestate.h

@@ -0,0 +1,26 @@
+#ifndef JETSKIRACESTATE_H
+#define JETSKIRACESTATE_H
+
+#include "racestate.h"
+
+// VTABLE 0x100d4fa8
+// SIZE 0x2c
+class JetskiRaceState : public RaceState
+{
+public:
+  // OFFSET: LEGO1 0x1000dc40
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f00ac
+    return "JetskiRaceState";
+  }
+
+  // OFFSET: LEGO1 0x1000dc50
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, JetskiRaceState::ClassName()) || RaceState::IsA(name);
+  }
+
+};
+
+#endif // JETSKIRACESTATE_H

LEGO1/jukebox.cpp

@@ -0,0 +1,7 @@
+#include "jukebox.h"
+
+// OFFSET: LEGO1 0x1005d660 STUB
+JukeBox::JukeBox()
+{
+  // TODO
+}

LEGO1/jukebox.h

@@ -0,0 +1,28 @@
+#ifndef JUKEBOX_H
+#define JUKEBOX_H
+
+#include "legoworld.h"
+
+// VTABLE 0x100d8958
+// SIZE 0x104
+class JukeBox : public LegoWorld
+{
+public:
+  JukeBox();
+
+  // OFFSET: LEGO1 0x1005d6f0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f02cc
+    return "JukeBox";
+  }
+
+  // OFFSET: LEGO1 0x1005d700
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, JukeBox::ClassName()) || LegoWorld::IsA(name);
+  }
+  
+};
+
+#endif // JUKEBOX_H

LEGO1/jukeboxentity.cpp

@@ -0,0 +1,13 @@
+#include "jukeboxentity.h"
+
+// OFFSET: LEGO1 0x10085bc0 STUB
+JukeBoxEntity::JukeBoxEntity()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10085dd0 STUB
+JukeBoxEntity::~JukeBoxEntity()
+{
+  // TODO
+}

LEGO1/jukeboxentity.h

@@ -0,0 +1,29 @@
+#ifndef JUKEBOXENTITY_H
+#define JUKEBOXENTITY_H
+
+#include "legoentity.h"
+
+// VTABLE 0x100da8a0
+// SIZE 0x6c
+class JukeBoxEntity : public LegoEntity
+{
+public:
+  JukeBoxEntity();
+  virtual ~JukeBoxEntity() override; // vtable+0x0
+
+  // OFFSET: LEGO1 0x10085cc0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f02f0
+    return "JukeBoxEntity";
+  }
+
+  // OFFSET: LEGO1 0x10085cd0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, JukeBoxEntity::ClassName()) || LegoEntity::IsA(name);
+  }
+
+};
+
+#endif // JUKEBOXENTITY_H

LEGO1/jukeboxstate.cpp

@@ -0,0 +1 @@
+#include "jukeboxstate.h"

LEGO1/jukeboxstate.h

@@ -0,0 +1,26 @@
+#ifndef JUKEBOXSTATE_H
+#define JUKEBOXSTATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d4a90
+// SIZE 0x10
+class JukeBoxState : public LegoState
+{
+public:
+  // OFFSET: LEGO1 0x1000f310
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f02bc
+    return "JukeBoxState";
+  }
+
+  // OFFSET: LEGO1 0x1000f320
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, JukeBoxState::ClassName()) || LegoState::IsA(name);
+  }
+
+};
+
+#endif // JUKEBOXSTATE_H

LEGO1/lego3dwavepresenter.h

@@ -0,0 +1,25 @@
+#ifndef LEGO3DWAVEPRESENTER_H
+#define LEGO3DWAVEPRESENTER_H
+
+#include "legowavepresenter.h"
+
+// VTABLE 0x100d52b0
+// SIZE 0xa0
+class Lego3DWavePresenter : public LegoWavePresenter
+{
+public:
+  // OFFSET: LEGO1 0x1000d890
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f058c
+    return "Lego3DWavePresenter";
+  }
+
+  // OFFSET: LEGO1 0x1000d8a0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, Lego3DWavePresenter::ClassName()) || MxWavePresenter::IsA(name);
+  }
+};
+
+#endif // LEGO3DWAVEPRESENTER_H

LEGO1/legoact2state.cpp

@@ -0,0 +1 @@
+#include "legoact2state.h"

LEGO1/legoact2state.h

@@ -0,0 +1,26 @@
+#ifndef LEGOACT2STATE_H
+#define LEGOACT2STATE_H
+
+#include "legostate.h"
+
+// VTABLE 0x100d4a70
+// SIZE 0x10
+class LegoAct2State : public LegoState
+{
+public:
+  // OFFSET: LEGO1 0x1000df80
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  { 
+    // 0x100f0428
+    return "LegoAct2State";
+  }
+
+  // OFFSET: LEGO1 0x1000df90
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoAct2State::ClassName()) || LegoState::IsA(name);
+  }
+
+};
+
+#endif // LEGOACT2STATE_H

LEGO1/legoactioncontrolpresenter.cpp

@@ -0,0 +1 @@
+#include "legoactioncontrolpresenter.h"

LEGO1/legoactioncontrolpresenter.h

@@ -0,0 +1,25 @@
+#ifndef LEGOACTIONCONTROLPRESENTER_H
+#define LEGOACTIONCONTROLPRESENTER_H
+
+#include "mxmediapresenter.h"
+
+// VTABLE 0x100d5118
+// SIZE 0x68
+class LegoActionControlPresenter : public MxMediaPresenter
+{
+public:
+  // OFFSET: LEGO1 0x1000d0e0
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f05bc
+    return "LegoActionControlPresenter";
+  }
+
+  // OFFSET: LEGO1 0x1000d0f0
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoActionControlPresenter::ClassName()) || MxMediaPresenter::IsA(name);
+  }
+};
+
+#endif // LEGOACTIONCONTROLPRESENTER_H

LEGO1/legoactor.h

@@ -0,0 +1,25 @@
+#ifndef LEGOACTOR_H
+#define LEGOACTOR_H
+
+#include "legoentity.h"
+
+// VTABLE 0x100d6d68
+// SIZE 0x78
+class LegoActor : public LegoEntity
+{
+public:
+  // OFFSET: LEGO1 0x1002d210
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f0124
+    return "LegoActor";
+  }
+
+  // OFFSET: LEGO1 0x1002d220
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoActor::ClassName()) || LegoEntity::IsA(name);
+  }
+};
+
+#endif // LEGOACTOR_H

LEGO1/legoactorpresenter.h

@@ -0,0 +1,25 @@
+#ifndef LEGOACTORPRESENTER_H
+#define LEGOACTORPRESENTER_H
+
+#include "legoentitypresenter.h"
+
+// VTABLE 0x100d5320
+// SIZE 0x50
+class LegoActorPresenter : public LegoEntityPresenter
+{
+public:
+  // OFFSET: LEGO1 0x1000cb10
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f06a4
+    return "LegoActorPresenter";
+  }
+
+  // OFFSET: LEGO1 0x1000cb20
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoActorPresenter::ClassName()) || LegoEntityPresenter::IsA(name);
+  }
+};
+
+#endif // LEGOACTORPRESENTER_H

LEGO1/legoanimactor.cpp

@@ -0,0 +1 @@
+#include "legoanimactor.h"

LEGO1/legoanimactor.h

@@ -0,0 +1,11 @@
+#ifndef LEGOANIMACTOR_H
+#define LEGOANIMACTOR_H
+
+#include "legopathactor.h"
+
+class LegoAnimActor : public LegoPathActor
+{
+public:
+};
+
+#endif // LEGOANIMACTOR_H

LEGO1/legoanimationmanager.cpp

@@ -0,0 +1,34 @@
+#include "legoanimationmanager.h"
+
+// OFFSET: LEGO1 0x1005eb60 STUB
+LegoAnimationManager::LegoAnimationManager()
+{
+}
+
+// OFFSET: LEGO1 0x1005ed30 STUB
+LegoAnimationManager::~LegoAnimationManager()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100619f0 STUB
+long LegoAnimationManager::Notify(MxParam &p)
+{
+  // TODO
+
+  return 0;
+}
+
+// OFFSET: LEGO1 0x10061cc0 STUB
+long LegoAnimationManager::Tickle()
+{
+  // TODO
+
+  return 0;
+}
+
+// OFFSET: LEGO1 0x1005f130 STUB
+void LegoAnimationManager::Init()
+{
+  // TODO
+}

LEGO1/legoanimationmanager.h

@@ -1,10 +1,37 @@
 #ifndef LEGOANIMATIONMANAGER_H
 #define LEGOANIMATIONMANAGER_H
 
-class LegoAnimationManager
+#include "mxcore.h"
+
+// VTABLE 0x100d8c18
+// SIZE 0x500
+class LegoAnimationManager : public MxCore
 {
 public:
+  LegoAnimationManager();
+  virtual ~LegoAnimationManager() override; // vtable+0x0
+
+  virtual long Notify(MxParam &p) override; // vtable+0x4
+  virtual long Tickle() override; // vtable+0x8
+
+  // OFFSET: LEGO1 0x1005ec80
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f7508
+    return "LegoAnimationManager";
+  }
+
+  // OFFSET: LEGO1 0x1005ec90
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoAnimationManager::ClassName()) || MxCore::IsA(name);
+  }
+
   __declspec(dllexport) static void configureLegoAnimationManager(int param_1);
+  
+private:
+  void Init();
+
 };
 
 #endif // LEGOANIMATIONMANAGER_H

LEGO1/legoanimmmpresenter.cpp

@@ -0,0 +1,7 @@
+#include "legoanimmmpresenter.h"
+
+// OFFSET: LEGO1 0x1004a8d0 STUB
+LegoAnimMMPresenter::LegoAnimMMPresenter()
+{
+  // TODO
+}

LEGO1/legoanimmmpresenter.h

@@ -0,0 +1,28 @@
+#ifndef LEGOANIMMMPRESENTER_H
+#define LEGOANIMMMPRESENTER_H
+
+#include "mxcompositepresenter.h"
+
+// VTABLE 0x100d7de8
+// SIZE 0x74
+class LegoAnimMMPresenter : public MxCompositePresenter
+{
+public:
+  LegoAnimMMPresenter();
+
+  // OFFSET: LEGO1 0x1004a950
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f046c
+    return "LegoAnimMMPresenter";
+  }
+
+  // OFFSET: LEGO1 0x1004a960
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoAnimMMPresenter::ClassName()) || MxCompositePresenter::IsA(name);
+  }
+
+};
+
+#endif // LEGOANIMMMPRESENTER_H

LEGO1/legoanimpresenter.cpp

@@ -0,0 +1,13 @@
+#include "legoanimpresenter.h"
+
+// OFFSET: LEGO1 0x10068420 STUB
+LegoAnimPresenter::LegoAnimPresenter()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100686f0 STUB
+void LegoAnimPresenter::Init()
+{
+  // TODO
+}

LEGO1/legoanimpresenter.h

@@ -0,0 +1,30 @@
+#ifndef LEGOANIMPRESENTER_H
+#define LEGOANIMPRESENTER_H
+
+#include "mxvideopresenter.h"
+
+// VTABLE 0x100d90c8
+class LegoAnimPresenter : public MxVideoPresenter
+{
+public:
+  LegoAnimPresenter();
+
+  // OFFSET: LEGO1 0x10068530
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f071c
+    return "LegoAnimPresenter";
+  }
+
+  // OFFSET: LEGO1 0x10068540
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoAnimPresenter::ClassName()) || MxVideoPresenter::IsA(name);
+  }
+  
+private:
+  void Init();
+
+};
+
+#endif // LEGOANIMPRESENTER_H

LEGO1/legobuildingmanager.cpp

@@ -0,0 +1,17 @@
+#include "legobuildingmanager.h"
+
+// OFFSET: LEGO1 0x1002f8c0 STUB
+LegoBuildingManager::LegoBuildingManager()
+{
+}
+
+// OFFSET: LEGO1 0x1002f960 STUB
+LegoBuildingManager::~LegoBuildingManager()
+{
+}
+
+// OFFSET: LEGO1 0x1002f9d0 STUB
+void LegoBuildingManager::Init()
+{
+  // TODO
+}

LEGO1/legobuildingmanager.h

@@ -1,10 +1,28 @@
 #ifndef LEGOBUILDINGMANAGER_H
 #define LEGOBUILDINGMANAGER_H
 
-class LegoBuildingManager
+#include "mxcore.h"
+
+// VTABLE 0x100d6f50
+// SIZE 0x30
+class LegoBuildingManager : public MxCore
 {
 public:
+  LegoBuildingManager();
+  virtual ~LegoBuildingManager() override;
+
+  // OFFSET: LEGO1 0x1002f930
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f37d0
+    return "LegoBuildingManager";
+  }
+
   __declspec(dllexport) static void configureLegoBuildingManager(int param_1);
+
+private:
+  void Init();
+
 };
 
 #endif // LEGOBUILDINGMANAGER_H

LEGO1/legocachesound.cpp

@@ -0,0 +1,19 @@
+#include "legocachesound.h"
+
+// OFFSET: LEGO1 0x100064d0
+LegoCacheSound::LegoCacheSound()
+{
+  Init();
+}
+
+// OFFSET: LEGO1 0x10006630 STUB
+LegoCacheSound::~LegoCacheSound()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x100066d0 STUB
+void LegoCacheSound::Init()
+{
+  // TODO
+}

LEGO1/legocachesound.h

@@ -0,0 +1,31 @@
+#ifndef LEGOCACHESOUND_H
+#define LEGOCACHESOUND_H
+
+#include "mxcore.h"
+
+// VTABLE 0x100d4718
+// SIZE 0x88
+class LegoCacheSound : public MxCore
+{
+public:
+  LegoCacheSound();
+  virtual ~LegoCacheSound() override; // vtable+0x0
+
+  // OFFSET: LEGO1 0x10006580
+  inline virtual const char *ClassName() const override // vtable+0x0c
+  {
+    // 0x100f01c4
+    return "LegoCacheSound";
+  }
+
+  // OFFSET: LEGO1 0x10006590
+  inline virtual MxBool IsA(const char *name) const override // vtable+0x10
+  {
+    return !strcmp(name, LegoCacheSound::ClassName()) || MxCore::IsA(name);
+  }
+
+private:
+  void Init();
+};
+
+#endif // LEGOCACHESOUND_H

LEGO1/legocameracontroller.cpp

@@ -0,0 +1,13 @@
+#include "legocameracontroller.h"
+
+// OFFSET: LEGO1 0x10011d50 STUB
+LegoCameraController::LegoCameraController()
+{
+  // TODO
+}
+
+// OFFSET: LEGO1 0x10011f70 STUB
+LegoCameraController::~LegoCameraController()
+{
+  // TODO
+}