From 717f5cd9dacf30fe6bf1561db9297e75fd27fdef Mon Sep 17 00:00:00 2001
From: fusion32 <marcopuzziello@gmail.com>
Date: Fri, 16 May 2025 18:46:18 -0300
Subject: initial commit - getting at TSkill structs

---
 reference/types.hh | 1712 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1712 insertions(+)
 create mode 100644 reference/types.hh

(limited to 'reference/types.hh')

diff --git a/reference/types.hh b/reference/types.hh
new file mode 100644
index 0000000..5b493d2
--- /dev/null
+++ b/reference/types.hh
@@ -0,0 +1,1712 @@
+struct Object {
+    uint32 ObjectID;
+};
+
+struct TSkill {
+    int (**_vptr.TSkill)(...); // VTABLE?
+    int DAct;
+    int MDAct;
+    uint16 SkNr;
+    TCreature *Master;
+    int Act;
+    int Max;
+    int Min;
+    int FactorPercent;
+    int LastLevel;
+    int NextLevel;
+    int Delta;
+    int Exp;
+    int Cycle;
+    int MaxCycle;
+    int Count;
+    int MaxCount;
+    int AddLevel;
+};
+
+struct TSkillAdd {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillHitpoints {
+    TSkillAdd super_TSkillAdd; // INHERITANCE?
+};
+
+struct TSkillSoulpoints {
+    TSkillAdd super_TSkillAdd; // INHERITANCE?
+};
+
+struct TSkillProbe {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillMana {
+    TSkillAdd super_TSkillAdd; // INHERITANCE?
+};
+
+struct TSkillGoStrength {
+    TSkillAdd super_TSkillAdd; // INHERITANCE?
+};
+
+struct TSkillLight {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillEnergy {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillCarryStrength {
+    TSkillAdd super_TSkillAdd; // INHERITANCE?
+};
+
+struct TSkillPoison {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillBurning {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillFed {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillIllusion {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillLevel {
+    TSkill super_TSkill; // INHERITANCE?
+};
+
+struct TSkillBase {
+    TSkill *Skills[25];
+    TSkill *TimerList[25];
+    uint16 FirstFreeTimer;
+};
+
+struct TImpact {
+    int (**_vptr.TImpact)(...); // VTABLE?
+};
+
+struct TSummonImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    int Race;
+    int Maximum;
+};
+
+struct TSpeedImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    int Percent;
+    int Duration;
+};
+
+struct THealingImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    int Power;
+};
+
+struct TOutfitImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    TOutfit Outfit;
+    int Duration;
+};
+
+struct TFieldImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    int FieldType;
+};
+
+struct TDrunkenImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    int Power;
+    int Duration;
+};
+
+struct TStrengthImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    int Skills;
+    int Percent;
+    int Duration;
+};
+
+struct TDamageImpact {
+    TImpact super_TImpact; // INHERITANCE?
+    TCreature *Actor;
+    int DamageType;
+    int Power;
+    bool AllowDefense;
+};
+
+struct TCombatEntry {
+    uint32 ID;
+    uint32 Damage;
+    int TimeStamp;
+};
+
+struct TCombat {
+    TCreature *Master;
+    uint32 EarliestAttackTime;
+    uint32 EarliestDefendTime;
+    uint32 LastDefendTime;
+    uint32 LatestAttackTime;
+    uint32 AttackMode;
+    uint32 ChaseMode;
+    uint32 SecureMode;
+    uint32 AttackDest;
+    bool Following;
+    Object Shield;
+    Object Close;
+    Object Missile;
+    Object Throw;
+    Object Wand;
+    Object Ammo;
+    bool Fist;
+    uint32 CombatDamage;
+    int ActCombatEntry;
+    TCombatEntry CombatList[20];
+    int LearningPoints;
+};
+
+struct TOutfit {
+    int OutfitID;
+	union{
+		uint16 ObjectType;
+		uint8 Colors[4];
+	};
+};
+
+struct TCreature {
+    int (**_vptr.TCreature)(...); // CREATURE VTABLE?
+    TSkillBase super_TSkillBase; // INHERITANCE?
+    TCombat Combat;
+    uint32 ID;
+    TCreature *NextHashEntry;
+    uint32 NextChainCreature;
+    char Name[31];
+    char Murderer[31];
+    TOutfit OrgOutfit;
+    TOutfit Outfit;
+    int startx;
+    int starty;
+    int startz;
+    int posx;
+    int posy;
+    int posz;
+    int Sex;
+    int Race;
+    int Direction;
+    int Radius;
+    CreatureType Type;
+    bool IsDead;
+    int LoseInventory;
+    bool LoggingOut;
+    bool LogoutAllowed;
+    uint32 EarliestLogoutRound;
+    uint32 EarliestProtectionZoneRound;
+    uint32 EarliestYellRound;
+    uint32 EarliestTradeChannelRound;
+    uint32 EarliestSpellTime;
+    uint32 EarliestMultiuseTime;
+    uint32 EarliestWalkTime;
+    uint32 LifeEndRound;
+    TKnownCreature *FirstKnowingConnection;
+    int SummonedCreatures;
+    uint32 FireDamageOrigin;
+    uint32 PoisonDamageOrigin;
+    uint32 EnergyDamageOrigin;
+    Object CrObject;
+    vector<TToDoEntry> ToDoList;
+    int ActToDo;
+    int NrToDo;
+    uint32 NextWakeup;
+    bool Stop;
+    bool LockToDo;
+    uint8 Profession;
+    TConnection *Connection;
+};
+
+
+struct TKnownCreature {
+    KNOWNCREATURESTATE State;
+    uint32 CreatureID;
+    TKnownCreature *Next;
+    TConnection *Connection;
+};
+
+struct TConnection {
+    uint8 InData[2048];
+    int InDataSize;
+    bool SigIOPending;
+    bool WaitingForACK;
+    uint8 OutData[16384];
+    uint8 field5_0x4806;
+    uint8 field6_0x4807;
+    int NextToSend;
+    int NextToCommit;
+    int NextToWrite;
+    bool Overflow;
+    bool WillingToSend;
+    uint8 field12_0x4816;
+    uint8 field13_0x4817;
+    TConnection *NextSendingConnection;
+    uint32 RandomSeed;
+	CONNECTIONSTATE State;
+    pid_t PID;
+    int Socket;
+    char IPAddress[16];
+    TXTEASymmetricKey SymmetricKey;
+    bool ConnectionIsOk;
+    bool ClosingIsDelayed;
+    uint8 field23_0x4852;
+    uint8 field24_0x4853;
+    uint32 TimeStamp;
+    uint32 TimeStampAction;
+    int TerminalType;
+    int TerminalVersion;
+    int TerminalOffsetX;
+    int TerminalOffsetY;
+    int TerminalWidth;
+    int TerminalHeight;
+    uint32 CharacterID;
+    char Name[31];
+    uint8 field35_0x4897;
+    TKnownCreature KnownCreatureTable[150];
+};
+
+struct TCircle {
+    int x[32];
+    int y[32];
+    int Count;
+};
+
+struct TSpellList {
+    uint8 Syllable[10];
+    uint8 RuneGr;
+    uint8 RuneNr;
+    char *Comment;
+    uint16 Level;
+    uint16 RuneLevel;
+    uint16 Flags;
+    int Mana;
+    int SoulPoints;
+    int Amount;
+};
+
+struct TToDoEntry {
+    ToDoType Code;
+    union{
+        struct{
+            uint32 Time;
+        } Wait;
+
+        struct{
+            int x;
+            int y;
+            int z;
+        } Go;
+
+        struct{
+            int Direction;
+        } Rotate;
+
+        struct{
+            uint32 Obj;
+            int x;
+            int y;
+            int z;
+            int Count;
+        } Move;
+
+        struct{
+            uint32 Obj;
+            uint32 Partner;
+        } Trade;
+
+        struct{
+            uint32 Obj1;
+            uint32 Obj2;
+            int Dummy;
+        } Use;
+
+        struct{
+            uint32 Obj;
+        } Turn;
+
+        struct{
+            uint32 Text; // POINTER?
+            int Mode;
+            uint32 Addressee;
+            bool CheckSpamming;
+        } Talk;
+
+        struct{
+            int NewState;
+        } ChangeState;
+    };
+};
+
+// TODO(fusion): The storage per creature of TToDoEntry's?
+struct vector<TToDoEntry> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    TToDoEntry init;
+    TToDoEntry *entry;
+};
+
+struct TXTEASymmetricKey {
+    int (**_vptr.TXTEASymmetricKey)(...); // VTABLE?
+    uint8 m_SymmetricKey[16];
+};
+
+
+// NOTE(fusion): Some minimal processing up until here. Then I realized the file would be huge.
+//==================================================================================================
+//==================================================================================================
+//==================================================================================================
+
+struct TDatabasePoolConnection {
+    TDatabaseConnectionPool *DatabaseConnectionPool;
+    TDatabaseConnection *DatabaseConnection;
+    bool TransactionRunning;
+};
+
+struct TDatabaseSettings {
+    char Product[30];
+    char Database[30];
+    char Login[30];
+    char Password[30];
+    char Host[30];
+    char Port[6];
+};
+
+struct Semaphore {
+    int value;
+    struct pthread_mutex_t mutex;
+    struct pthread_cond_t condition;
+};
+
+struct TDatabaseConnectionPool {
+    int NumberOfConnections;
+    struct TDatabaseSettings DatabaseSettings;
+    struct TDatabaseConnection **DatabaseConnection;
+    bool *DatabaseConnectionFree;
+    struct Semaphore FreeDatabaseConnections;
+    struct Semaphore DatabaseConnectionMutex;
+};
+
+// TODO(fusion): Opaque struct?
+struct TDatabaseConnection {};
+
+struct TPreparedQuery {
+    int Number;
+    char *Query;
+    char *DBTypes;
+    char *CTypes;
+    char *Name;
+};
+
+struct TSharedMemory {
+    int Command;
+    char CommandBuffer[256];
+    ulong RoundNr;
+    ulong ObjectCounter;
+    ulong Errors;
+    int PlayersOnline;
+    int NewbiesOnline;
+    int PrintBufferPosition;
+    char PrintBuffer[200][128];
+    enum GAMESTATE GameState;
+    pid_t GameThreadPID;
+};
+
+struct TPlayerIndexNode {
+    bool InternalNode;
+};
+
+struct TPlayerIndexInternalNode {
+    struct TPlayerIndexNode super_TPlayerIndexNode;
+    struct TPlayerIndexNode *Child[27];
+};
+
+union storeitem<TPlayerIndexInternalNode> {
+    union storeitem<TPlayerIndexInternalNode> *next;
+    struct TPlayerIndexInternalNode data;
+};
+
+struct storeunit<TPlayerIndexInternalNode,100> {
+    union storeitem<TPlayerIndexInternalNode> item[100];
+};
+
+struct listnode<storeunit<TPlayerIndexInternalNode,_100>_> { // Original name: listnode<storeunit<TPlayerIndexInternalNode, 100> >
+    struct listnode<storeunit<TPlayerIndexInternalNode,_100>_> *next;
+    struct listnode<storeunit<TPlayerIndexInternalNode,_100>_> *prev;
+    struct storeunit<TPlayerIndexInternalNode,100> data;
+};
+
+struct TPlayerIndexEntry {
+    char Name[30];
+    ulong CharacterID;
+};
+
+struct TPlayerIndexLeafNode {
+    struct TPlayerIndexNode super_TPlayerIndexNode;
+    int Count;
+    struct TPlayerIndexEntry Entry[10];
+};
+
+union storeitem<TPlayerIndexLeafNode> {
+    union storeitem<TPlayerIndexLeafNode> *next;
+    struct TPlayerIndexLeafNode data;
+};
+
+struct storeunit<TPlayerIndexLeafNode,100> {
+    union storeitem<TPlayerIndexLeafNode> item[100];
+};
+
+struct TNode {
+    int Type;
+    int Data;
+    struct TNode *Left;
+    struct TNode *Right;
+};
+
+union storeitem<TNode> {
+    union storeitem<TNode> *next;
+    struct TNode data;
+};
+
+struct store<TPlayerIndexInternalNode,100> {
+    struct list<storeunit<TPlayerIndexInternalNode,_100>_> *Units;
+    union storeitem<TPlayerIndexInternalNode> *firstFreeItem;
+};
+
+struct list<storeunit<TPlayerIndexInternalNode,_100>_> { // Original name: list<storeunit<TPlayerIndexInternalNode, 100> >
+    struct listnode<storeunit<TPlayerIndexInternalNode,_100>_> *firstNode;
+    struct listnode<storeunit<TPlayerIndexInternalNode,_100>_> *lastNode;
+};
+
+struct priority_queue_entry<long_unsigned_int,long_unsigned_int> { // Original name: priority_queue_entry<long unsigned int,long unsigned int>
+    ulong Key;
+    ulong Data;
+};
+
+struct THouseGuest {
+    char Name[60];
+};
+
+struct vector<THouseGuest> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct THouseGuest init;
+    struct THouseGuest *entry;
+};
+
+struct THouse {
+    ushort ID;
+    char Name[50];
+    char Description[500];
+    int Size;
+    ulong Rent;
+    int DepotNr;
+    bool NoAuction;
+    bool GuildHouse;
+    int ExitX;
+    int ExitY;
+    int ExitZ;
+    int CenterX;
+    int CenterY;
+    int CenterZ;
+    ulong OwnerID;
+    char OwnerName[30];
+    int LastTransition;
+    int PaidUntil;
+    struct vector<THouseGuest> Subowner;
+    int Subowners;
+    struct vector<THouseGuest> Guest;
+    int Guests;
+    int Help;
+};
+
+struct vector<THouse> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct THouse init;
+    struct THouse *entry;
+};
+
+struct matrix<long_unsigned_int> { // Original name: matrix<long unsigned int>
+    int xmin;
+    int ymin;
+    int dx;
+    int dy;
+    ulong *entry;
+};
+
+struct TWaitinglistEntry {
+    struct TWaitinglistEntry *Next;
+    char Name[30];
+    ulong NextTry;
+    bool FreeAccount;
+    bool Newbie;
+    bool Sleeping;
+};
+
+union storeitem<TWaitinglistEntry> {
+    union storeitem<TWaitinglistEntry> *next;
+    struct TWaitinglistEntry data;
+};
+
+struct storeunit<TWaitinglistEntry,100> {
+    union storeitem<TWaitinglistEntry> item[100];
+};
+
+struct listnode<storeunit<TWaitinglistEntry,_100>_> { // Original name: listnode<storeunit<TWaitinglistEntry, 100> >
+    struct listnode<storeunit<TWaitinglistEntry,_100>_> *next;
+    struct listnode<storeunit<TWaitinglistEntry,_100>_> *prev;
+    struct storeunit<TWaitinglistEntry,100> data;
+};
+
+struct vector<TCreature*> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TCreature *init;
+    struct TCreature **entry;
+};
+
+struct ObjectType {
+    int TypeID;
+};
+
+struct priority_queue_entry<long_unsigned_int,TAttackWave*> { // Original name: priority_queue_entry<long unsigned int,TAttackWave*>
+    ulong Key;
+    struct TAttackWave *Data;
+};
+
+struct TItemData {
+    struct ObjectType Type;
+    int Maximum;
+    int Probability;
+};
+
+struct vector<TItemData> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TItemData init;
+    struct TItemData *entry;
+};
+
+struct TAttackWave {
+    int x;
+    int y;
+    int z;
+    int Spread;
+    int Race;
+    int MinCount;
+    int MaxCount;
+    int Radius;
+    int Lifetime;
+    ulong Message;
+    int ExtraItems;
+    struct vector<TItemData> ExtraItem;
+};
+
+struct TSkillData {
+    int Nr;
+    int Actual;
+    int Minimum;
+    int Maximum;
+    int NextLevel;
+    int FactorPercent;
+    int AddLevel;
+};
+
+struct vector<TSkillData> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TSkillData init;
+    struct TSkillData *entry;
+};
+
+struct store<TWaitinglistEntry,100> {
+    struct list<storeunit<TWaitinglistEntry,_100>_> *Units;
+    union storeitem<TWaitinglistEntry> *firstFreeItem;
+};
+
+struct list<storeunit<TWaitinglistEntry,_100>_> { // Original name: list<storeunit<TWaitinglistEntry, 100> >
+    struct listnode<storeunit<TWaitinglistEntry,_100>_> *firstNode;
+    struct listnode<storeunit<TWaitinglistEntry,_100>_> *lastNode;
+};
+
+struct TDynamicStringTableBlock {
+    int FreeEntries;
+    int TotalTextLength;
+    bool Dirty;
+    uchar EntryType[256];
+    ushort StringOffset[256];
+    char Text[32768];
+};
+
+struct listnode<TDynamicStringTableBlock> {
+    struct listnode<TDynamicStringTableBlock> *next;
+    struct listnode<TDynamicStringTableBlock> *prev;
+    struct TDynamicStringTableBlock data;
+};
+
+struct listIterator<TDynamicStringTableBlock> {
+    struct listnode<TDynamicStringTableBlock> *actNode;
+};
+
+
+struct vector<TNonplayer*> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TNonplayer *init;
+    struct TNonplayer **entry;
+};
+
+struct TNonplayer {
+    struct TCreature super_TCreature; // INHERITANCE?
+    enum STATE State;
+};
+
+struct TReportedStatement {
+    ulong StatementID;
+    ulong TimeStamp;
+    ulong CharacterID;
+    int Mode;
+    int Channel;
+    char Text[256];
+};
+
+struct vector<TReportedStatement> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TReportedStatement init;
+    struct TReportedStatement *entry;
+};
+
+
+struct TListener {
+    ulong StatementID;
+    ulong CharacterID;
+};
+
+struct fifo<TListener> {
+    struct TListener *Entry;
+    int Size;
+    int Head;
+    int Tail;
+};
+
+struct TDelayedMail {
+    ulong CharacterID;
+    int DepotNumber;
+    uchar *Packet;
+    int PacketSize;
+};
+
+struct vector<TDelayedMail> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TDelayedMail init;
+    struct TDelayedMail *entry;
+};
+
+struct list<storeunit<TPlayerIndexLeafNode,_100>_> { // Original name: list<storeunit<TPlayerIndexLeafNode, 100> >
+    struct listnode<storeunit<TPlayerIndexLeafNode,_100>_> *firstNode;
+    struct listnode<storeunit<TPlayerIndexLeafNode,_100>_> *lastNode;
+};
+
+struct listnode<storeunit<TPlayerIndexLeafNode,_100>_> { // Original name: listnode<storeunit<TPlayerIndexLeafNode, 100> >
+    struct listnode<storeunit<TPlayerIndexLeafNode,_100>_> *next;
+    struct listnode<storeunit<TPlayerIndexLeafNode,_100>_> *prev;
+    struct storeunit<TPlayerIndexLeafNode,100> data;
+};
+
+struct store<TPlayerIndexLeafNode,100> {
+    struct list<storeunit<TPlayerIndexLeafNode,_100>_> *Units;
+    union storeitem<TPlayerIndexLeafNode> *firstFreeItem;
+};
+
+struct listIterator<storeunit<TWaitinglistEntry,_100>_> { // Original name: listIterator<storeunit<TWaitinglistEntry, 100> >
+    struct listnode<storeunit<TWaitinglistEntry,_100>_> *actNode;
+};
+
+struct vector<priority_queue_entry<long_unsigned_int,_long_unsigned_int>_> { // Original name: vector<priority_queue_entry<long unsigned int, long unsigned int> >
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct priority_queue_entry<long_unsigned_int,long_unsigned_int> init;
+    struct priority_queue_entry<long_unsigned_int,long_unsigned_int> *entry;
+};
+
+struct TSpellData {
+    enum SpellShapeType Shape;
+    int ShapeParam1;
+    int ShapeParam2;
+    int ShapeParam3;
+    int ShapeParam4;
+    enum SpellImpactType Impact;
+    int ImpactParam1;
+    int ImpactParam2;
+    int ImpactParam3;
+    int ImpactParam4;
+    int Delay;
+};
+
+struct vector<TSpellData> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TSpellData init;
+    struct TSpellData *entry;
+};
+
+struct storeunit<TNode,256> {
+    union storeitem<TNode> item[256];
+};
+
+struct listnode<storeunit<TNode,_256>_> { // Original name: listnode<storeunit<TNode, 256> >
+    struct listnode<storeunit<TNode,_256>_> *next;
+    struct listnode<storeunit<TNode,_256>_> *prev;
+    struct storeunit<TNode,256> data;
+};
+
+struct TShortwayPoint {
+    int x;
+    int y;
+    int Waypoints;
+    int Waylength;
+    int Heuristic;
+    struct TShortwayPoint *Predecessor;
+    struct TShortwayPoint *NextToExpand;
+};
+
+struct matrix<TShortwayPoint> {
+    int xmin;
+    int ymin;
+    int dx;
+    int dy;
+    struct TShortwayPoint *entry;
+};
+
+struct TCronEntry {
+    struct Object Obj;
+    ulong RoundNr;
+    int Previous;
+    int Next;
+};
+
+struct vector<TCronEntry> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TCronEntry init;
+    struct TCronEntry *entry;
+};
+
+struct TMonsterhome {
+    int Race;
+    int x;
+    int y;
+    int z;
+    int Radius;
+    int MaxMonsters;
+    int ActMonsters;
+    int RegenerationTime;
+    int Timer;
+};
+
+struct vector<TMonsterhome> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TMonsterhome init;
+    struct TMonsterhome *entry;
+};
+
+struct TStaticStringTableBlock {
+    int TotalTextLength;
+    char Text[65536];
+};
+
+struct listnode<TStaticStringTableBlock> {
+    struct listnode<TStaticStringTableBlock> *next;
+    struct listnode<TStaticStringTableBlock> *prev;
+    struct TStaticStringTableBlock data;
+};
+
+struct list<TStaticStringTableBlock> {
+    struct listnode<TStaticStringTableBlock> *firstNode;
+    struct listnode<TStaticStringTableBlock> *lastNode;
+};
+
+struct vector<priority_queue_entry<long_unsigned_int,_TAttackWave*>_> { // Original name: vector<priority_queue_entry<long unsigned int, TAttackWave*> >
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct priority_queue_entry<long_unsigned_int,TAttackWave*> init;
+    struct priority_queue_entry<long_unsigned_int,TAttackWave*> *entry;
+};
+
+struct listIterator<TStaticStringTableBlock> {
+    struct listnode<TStaticStringTableBlock> *actNode;
+};
+
+struct list<storeunit<TNode,_256>_> { // Original name: list<storeunit<TNode, 256> >
+    struct listnode<storeunit<TNode,_256>_> *firstNode;
+    struct listnode<storeunit<TNode,_256>_> *lastNode;
+};
+
+struct TObjectType {
+    char *Name;
+    char *Description;
+    uchar Flags[9];
+    ulong Attributes[62];
+    int AttributeOffsets[18];
+};
+
+struct vector<TObjectType> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TObjectType init;
+    struct TObjectType *entry;
+};
+
+struct TCondition {
+    int Type;
+    ulong Text;
+    struct TNode *Expression;
+    int Property;
+    int Number;
+};
+
+struct vector<TCondition> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TCondition init;
+    struct TCondition *entry;
+};
+
+struct priority_queue<long_unsigned_int,TAttackWave*> { // Original name: priority_queue<long unsigned int,TAttackWave*>
+    struct vector<priority_queue_entry<long_unsigned_int,_TAttackWave*>_> *Entry;
+    int Entries;
+};
+
+struct matrix3d<TSector*> {
+    int xmin;
+    int ymin;
+    int zmin;
+    int dx;
+    int dy;
+    int dz;
+    struct TSector **entry;
+};
+
+struct TSector {
+    struct Object MapCon[32][32];
+    ulong TimeStamp;
+    uchar Status;
+    uchar MapFlags;
+};
+
+struct vector<long_unsigned_int> { // Original name: vector<long unsigned int>
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    ulong init;
+    ulong *entry;
+};
+
+struct TChannel {
+    ulong Moderator;
+    char ModeratorName[30];
+    struct vector<long_unsigned_int> Subscriber;
+    int Subscribers;
+    struct vector<long_unsigned_int> InvitedPlayer;
+    int InvitedPlayers;
+};
+
+struct vector<TChannel> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TChannel init;
+    struct TChannel *entry;
+};
+
+struct THelpDepot {
+    ulong CharacterID;
+    struct Object Box;
+    int DepotNr;
+};
+
+struct vector<THelpDepot> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct THelpDepot init;
+    struct THelpDepot *entry;
+};
+
+struct matrix<int> {
+    int xmin;
+    int ymin;
+    int dx;
+    int dy;
+    int *entry;
+};
+
+struct listIterator<storeunit<TPlayerIndexLeafNode,_100>_> { // Original name: listIterator<storeunit<TPlayerIndexLeafNode, 100> >
+    struct listnode<storeunit<TPlayerIndexLeafNode,_100>_> *actNode;
+};
+
+struct TPlayerData {
+    ulong CharacterID;
+    pid_t Locked;
+    int Sticky;
+    bool Dirty;
+    int Race;
+    struct TOutfit OriginalOutfit;
+    struct TOutfit CurrentOutfit;
+    time_t LastLoginTime;
+    time_t LastLogoutTime;
+    int startx;
+    int starty;
+    int startz;
+    int posx;
+    int posy;
+    int posz;
+    int Profession;
+    int PlayerkillerEnd;
+    int Actual[25];
+    int Maximum[25];
+    int Minimum[25];
+    int DeltaAct[25];
+    int MagicDeltaAct[25];
+    int Cycle[25];
+    int MaxCycle[25];
+    int Count[25];
+    int MaxCount[25];
+    int AddLevel[25];
+    int Experience[25];
+    int FactorPercent[25];
+    int NextLevel[25];
+    int Delta[25];
+    uchar SpellList[256];
+    int QuestValues[500];
+    int MurderTimestamps[20];
+    uchar *Inventory;
+    int InventorySize;
+    uchar *Depot[9];
+    int DepotSize[9];
+    ulong AccountID;
+    int Sex;
+    char Name[30];
+    uchar Rights[12];
+    char Guild[31];
+    char Rank[31];
+    char Title[31];
+    int Buddies;
+    ulong Buddy[100];
+    char BuddyName[100][30];
+    ulong EarliestYellRound;
+    ulong EarliestTradeChannelRound;
+    ulong EarliestSpellTime;
+    ulong EarliestMultiuseTime;
+    ulong TalkBufferFullTime;
+    ulong MutingEndRound;
+    ulong Addressees[20];
+    ulong AddresseesTimes[20];
+    int NumberOfMutings;
+};
+
+struct vector<TPlayer*> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TPlayer *init;
+    struct TPlayer **entry;
+};
+
+struct TPlayer {
+    struct TCreature super_TCreature;
+    ulong AccountID;
+    char Guild[31];
+    char Rank[31];
+    char Title[31];
+    char IPAddress[16];
+    uchar Rights[12];
+    struct Object Depot;
+    int DepotNr;
+    int DepotSpace;
+    enum RESULT ConstructError;
+    struct TPlayerData *PlayerData;
+    struct Object TradeObject;
+    ulong TradePartner;
+    bool TradeAccepted;
+    int OldState;
+    ulong Request;
+    int RequestTimestamp;
+    ulong RequestProcessingGamemaster;
+    int TutorActivities;
+    uchar SpellList[256];
+    int QuestValues[500];
+    struct Object OpenContainer[16];
+    struct vector<long_unsigned_int> AttackedPlayers;
+    int NumberOfAttackedPlayers;
+    bool Aggressor;
+    struct vector<long_unsigned_int> FormerAttackedPlayers;
+    int NumberOfFormerAttackedPlayers;
+    bool FormerAggressor;
+    ulong FormerLogoutRound;
+    ulong PartyLeader;
+    ulong PartyLeavingRound;
+    ulong TalkBufferFullTime;
+    ulong MutingEndRound;
+    int NumberOfMutings;
+    ulong Addressees[20];
+    ulong AddresseesTimes[20];
+};
+
+struct TParty {
+    ulong Leader;
+    struct vector<long_unsigned_int> Member;
+    int Members;
+    struct vector<long_unsigned_int> InvitedPlayer;
+    int InvitedPlayers;
+};
+
+struct vector<TParty> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TParty init;
+    struct TParty *entry;
+};
+
+struct listIterator<storeunit<TNode,_256>_> { // Original name: listIterator<storeunit<TNode, 256> >
+    struct listnode<storeunit<TNode,_256>_> *actNode;
+};
+
+struct TMark {
+    char Name[20];
+    int x;
+    int y;
+    int z;
+};
+
+struct vector<TMark> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TMark init;
+    struct TMark *entry;
+};
+
+struct store<TNode,256> {
+    struct list<storeunit<TNode,_256>_> *Units;
+    union storeitem<TNode> *firstFreeItem;
+};
+
+struct TMoveUseAction {
+    enum ActionType Action;
+    int Parameters[5];
+};
+
+struct vector<TMoveUseAction> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TMoveUseAction init;
+    struct TMoveUseAction *entry;
+};
+
+struct list<TDynamicStringTableBlock> {
+    struct listnode<TDynamicStringTableBlock> *firstNode;
+    struct listnode<TDynamicStringTableBlock> *lastNode;
+};
+
+struct TMoveUseRule {
+    int FirstCondition;
+    int LastCondition;
+    int FirstAction;
+    int LastAction;
+};
+
+struct vector<TMoveUseRule> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TMoveUseRule init;
+    struct TMoveUseRule *entry;
+};
+
+struct TMoveUseCondition {
+    enum ModifierType Modifier;
+    enum ConditionType Condition;
+    int Parameters[5];
+};
+
+struct vector<TMoveUseCondition> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TMoveUseCondition init;
+    struct TMoveUseCondition *entry;
+};
+
+struct TAction {
+    int Type;
+    ulong Text;
+    int Number;
+    struct TNode *Expression;
+    struct TNode *Expression2;
+    struct TNode *Expression3;
+};
+
+struct vector<TAction> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TAction init;
+    struct TAction *entry;
+};
+
+struct TBehaviour {
+    struct vector<TCondition> Condition;
+    struct vector<TAction> Action;
+    int Conditions;
+    int Actions;
+};
+
+struct vector<TBehaviour> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TBehaviour init;
+    struct TBehaviour *entry;
+};
+
+struct THouseArea {
+    ushort ID;
+    int SQMPrice;
+    int DepotNr;
+};
+
+struct vector<THouseArea> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct THouseArea init;
+    struct THouseArea *entry;
+};
+
+struct priority_queue<long_unsigned_int,long_unsigned_int> { // Original name: priority_queue<long unsigned int,long unsigned int>
+    struct vector<priority_queue_entry<long_unsigned_int,_long_unsigned_int>_> *Entry;
+    int Entries;
+};
+
+struct listIterator<storeunit<TPlayerIndexInternalNode,_100>_> { // Original name: listIterator<storeunit<TPlayerIndexInternalNode, 100> >
+    struct listnode<storeunit<TPlayerIndexInternalNode,_100>_> *actNode;
+};
+
+
+struct TDepotInfo {
+    char Town[20];
+    int Size;
+};
+
+struct vector<TDepotInfo> {
+    int min;
+    int max;
+    int start;
+    int space;
+    int block;
+    bool initialized;
+    struct TDepotInfo init;
+    struct TDepotInfo *entry;
+};
+
+struct fifoIterator<TStatement> {
+    struct fifo<TStatement> *Fifo;
+    int Position;
+};
+
+struct fifo<TStatement> {
+    struct TStatement *Entry;
+    int Size;
+    int Head;
+    int Tail;
+};
+
+struct TStatement {
+    ulong StatementID;
+    ulong TimeStamp;
+    ulong CharacterID;
+    int Mode;
+    int Channel;
+    ulong Text;
+    bool Reported;
+};
+
+struct fifoIterator<TListener> {
+    struct fifo<TListener> *Fifo;
+    int Position;
+};
+
+struct TWriteStream {
+    int (**_vptr.TWriteStream)(...);
+};
+
+struct TReadStream {
+    int (**_vptr.TReadStream)(...);
+};
+
+struct TReadBuffer {
+    struct TReadStream super_TReadStream;
+    uchar *Data;
+    int Size;
+    int Position;
+};
+
+struct TWriteBuffer {
+    struct TWriteStream super_TWriteStream;
+    uchar *Data;
+    int Size;
+    int Position;
+};
+
+struct TDynamicWriteBuffer {
+    struct TWriteBuffer super_TWriteBuffer;
+};
+
+struct TDirectReplyData {
+    ulong CharacterID;
+    char Message[100];
+};
+
+struct TWriterThreadReply {
+    enum TWriterThreadReplyType ReplyType;
+    void *Data;
+};
+
+struct TWriterThreadOrder {
+    enum TWriterThreadOrderType OrderType;
+    void *Data;
+};
+
+struct TPunishmentOrderData {
+    ulong GamemasterID;
+    char GamemasterName[30];
+    char CriminalName[30];
+    char CriminalIPAddress[16];
+    int Reason;
+    int Action;
+    char Comment[200];
+    int NumberOfStatements;
+    struct vector<TReportedStatement> *ReportedStatements;
+    ulong StatementID;
+    bool IPBanishment;
+};
+
+struct TLogoutOrderData {
+    ulong CharacterID;
+    int Level;
+    int Profession;
+    time_t LastLoginTime;
+    int TutorActivities;
+    char Residence[30];
+};
+
+struct TCharacterDeathOrderData {
+    ulong CharacterID;
+    int Level;
+    ulong Offender;
+    char Remark[30];
+    bool Unjustified;
+    time_t Time;
+};
+
+struct TNameLockOrderData {
+    ulong GamemasterID;
+    char GamemasterName[30];
+    char CharacterName[30];
+    bool OldNameVisible;
+};
+
+struct TNotationOrderData {
+    ulong GamemasterID;
+    char GamemasterName[30];
+    char CharacterName[30];
+    char Comment[200];
+};
+
+struct TProtocolThreadOrder {
+    char ProtocolName[20];
+    char Text[256];
+};
+
+struct TPlayerlistOrderData {
+    int NumberOfPlayers;
+    char *PlayerNames;
+    int *PlayerLevels;
+    int *PlayerProfessions;
+};
+
+struct TBuddyOrderData {
+    ulong AccountID;
+    ulong Buddy;
+};
+
+struct TKillStatisticsOrderData {
+    int NumberOfRaces;
+    char *RaceNames;
+    int *KilledPlayers;
+    int *KilledCreatures;
+};
+
+struct TMoveUseDatabase {
+    struct vector<TMoveUseRule> Rules;
+    int NumberOfRules;
+};
+
+struct TObject {
+    ulong ObjectID;
+    struct Object NextObject;
+    struct Object Container;
+    struct ObjectType Type;
+    ulong Attributes[4];
+};
+
+struct TObjectBlock {
+    struct TObject Object[32768];
+};
+
+struct TFindCreatures {
+    int startx;
+    int starty;
+    int endx;
+    int endy;
+    int blockx;
+    int blocky;
+    ulong ActID;
+    ulong SkipID;
+    int Mask;
+    bool finished;
+};
+
+typedef int (ThreadFunction)(void *);
+struct TThreadStarter {
+    ThreadFunction *Function;
+    void *Argument;
+    bool Detach;
+};
+
+struct TReaderThreadOrder {
+    enum TReaderThreadOrderType OrderType;
+    int SectorX;
+    int SectorY;
+    int SectorZ;
+    ulong CharacterID;
+};
+
+struct TReaderThreadReply {
+    enum TReaderThreadReplyType ReplyType;
+    int SectorX;
+    int SectorY;
+    int SectorZ;
+    uchar *Data;
+    int Size;
+};
+
+struct TWriteBinaryFile {
+    struct TWriteStream super_TWriteStream;
+    undefined field1_0x1;
+    undefined field2_0x2;
+    undefined field3_0x3;
+    FILE *File;
+    char Filename[4096];
+};
+
+struct TWriteScriptFile {
+    FILE *File;
+    char Filename[4096];
+    int Line;
+};
+
+struct TReadBinaryFile {
+    struct TReadStream super_TReadStream;
+    undefined field1_0x1;
+    undefined field2_0x2;
+    undefined field3_0x3;
+    FILE *File;
+    char Filename[4096];
+    int FileSize;
+};
+
+struct TReadScriptFile {
+    enum TOKEN Token;
+    FILE *File[3];
+    char Filename[3][4096];
+    int Line[3];
+    char String[4000];
+    int RecursionDepth;
+    uchar *Bytes;
+    int Number;
+    int CoordX;
+    int CoordY;
+    int CoordZ;
+    char Special;
+};
+
+struct TNPC {
+    struct TNonplayer super_TNonplayer;
+    ulong Interlocutor;
+    int Topic;
+    int Price;
+    int Amount;
+    int TypeID;
+    ulong Data;
+    ulong LastTalk;
+    struct vector<long_unsigned_int> QueuedPlayers;
+    struct vector<long_unsigned_int> QueuedAddresses;
+    int QueueLength;
+    struct TBehaviourDatabase *Behaviour;
+};
+
+struct TBehaviourDatabase {
+    struct vector<TBehaviour> Behaviour;
+    int Behaviours;
+};
+
+struct TMonster {
+    struct TNonplayer super_TNonplayer;
+    int Home;
+    ulong Master;
+    ulong Target;
+};
+
+struct TRaceData {
+    char Name[30];
+    char Article[3];
+    struct TOutfit Outfit;
+    struct ObjectType MaleCorpse;
+    struct ObjectType FemaleCorpse;
+    enum BloodType Blood;
+    int ExperiencePoints;
+    int FleeThreshold;
+    int Attack;
+    int Defend;
+    int Armor;
+    int Poison;
+    int SummonCost;
+    int LoseTarget;
+    int Strategy[4];
+    bool KickBoxes;
+    bool KickCreatures;
+    bool SeeInvisible;
+    bool Unpushable;
+    bool DistanceFighting;
+    bool NoSummon;
+    bool NoIllusion;
+    bool NoConvince;
+    bool NoBurning;
+    bool NoPoison;
+    bool NoEnergy;
+    bool NoHit;
+    bool NoLifeDrain;
+    bool NoParalyze;
+    int Skills;
+    struct vector<TSkillData> Skill;
+    int Talks;
+    struct vector<long_unsigned_int> Talk;
+    int Items;
+    struct vector<TItemData> Item;
+    int Spells;
+    struct vector<TSpellData> Spell;
+};
+
+struct TQueryManagerConnection {
+    int BufferSize;
+    uchar *Buffer;
+    struct TReadBuffer ReadBuffer;
+    struct TWriteBuffer WriteBuffer;
+    int Socket;
+    bool QueryOk;
+    undefined field6_0x2d;
+    undefined field7_0x2e;
+    undefined field8_0x2f;
+};
+
+struct TQueryManagerSettings {
+    char Host[50];
+    int Port;
+    char Password[30];
+};
+
+struct TQueryManagerPoolConnection {
+    struct TQueryManagerConnectionPool *QueryManagerConnectionPool;
+    struct TQueryManagerConnection *QueryManagerConnection;
+};
+
+struct TQueryManagerConnectionPool {
+    int NumberOfConnections;
+    struct TQueryManagerConnection *QueryManagerConnection;
+    bool *QueryManagerConnectionFree;
+    struct Semaphore FreeQueryManagerConnections;
+    struct Semaphore QueryManagerConnectionMutex;
+};
+
+// NOTE(fusion): Probably bigint structures for RSA decoding.
+struct vlong_flex_unit {
+    uint n;
+    uint *a;
+    uint z;
+};
+
+struct vlong {
+    int (**_vptr.vlong)(...);
+    struct vlong_value *value;
+    int negative;
+};
+
+struct vlong_value {
+    struct vlong_flex_unit super_vlong_flex_unit;
+    uint share;
+};
+
+struct vlong_montgomery {
+    struct vlong R;
+    struct vlong R1;
+    struct vlong m;
+    struct vlong n1;
+    struct vlong T;
+    struct vlong k;
+    uint N;
+};
+
+// NOTE(fusion): Oh yes.
+struct TRSAPrivateKey {
+    int (**_vptr.TRSAPrivateKey)(...);
+    struct vlong m_PrimeP;
+    struct vlong m_PrimeQ;
+    struct vlong m_U;
+    struct vlong m_DP;
+    struct vlong m_DQ;
+};
+
+struct TShortway {
+    struct matrix<TShortwayPoint> *Map;
+    struct TShortwayPoint *FirstToExpand;
+    struct TCreature *cr;
+    int VisibleX;
+    int VisibleY;
+    int StartX;
+    int StartY;
+    int StartZ;
+    int MinWaypoints;
+};
-- 
cgit v1.2.3