diff options
Diffstat (limited to 'reference/types.hh')
| -rw-r--r-- | reference/types.hh | 1712 |
1 files changed, 1712 insertions, 0 deletions
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; +}; |