AlpacaBot
/
AlpacaLibrary
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Release 0.14

master
Kasi 2018-03-18 14:38:29 +00:00
parent b1c93fda90
commit 2550477852
71 changed files with 1055 additions and 859 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Include/Core/Classes/Animation.hpp
View File

@ -6,19 +6,22 @@
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
class Animation : public CacheableNode namespace Internal
{ {
public: class Animation : public CacheableNode
Animation(); {
Animation(const void* Obj); public:
Animation(const Animation& A); Animation();
static Class GetClass(); Animation(const void* Obj);
Animation(const Animation& A);
static Class GetClass();
std::vector<std::int32_t> GetFrameIDs() const; std::vector<std::int32_t> GetFrameIDs() const;
std::vector<std::int32_t> GetInterleave() const; std::vector<std::int32_t> GetInterleave() const;
std::int32_t GetLeftHandItem() const; std::int32_t GetLeftHandItem() const;
std::int32_t GetRightHandItem() const; std::int32_t GetRightHandItem() const;
}; };
}
#endif // ANIMATION_HPP_INCLUDED #endif // ANIMATION_HPP_INCLUDED

19
Include/Core/Classes/AttackOption.hpp
View File

@ -5,16 +5,19 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class AttackOption : public Object namespace Internal
{ {
public: class AttackOption : public Object
AttackOption(); {
AttackOption(const void* Obj); public:
AttackOption(const AttackOption& A); AttackOption();
static Class GetClass(); AttackOption(const void* Obj);
AttackOption(const AttackOption& A);
static Class GetClass();
std::int32_t GetType() const; std::int32_t GetType() const;
}; };
}
#endif // ATTACKOPTION_HPP_INCLUDED #endif // ATTACKOPTION_HPP_INCLUDED

21
Include/Core/Classes/Cache.hpp
View File

@ -6,17 +6,20 @@
#include "HashTable.hpp" #include "HashTable.hpp"
#include "Queue.hpp" #include "Queue.hpp"
class Cache : public Object namespace Internal
{ {
public: class Cache : public Object
Cache(); {
Cache(const void* Obj); public:
Cache(const Cache& C); Cache();
static Class GetClass(); Cache(const void* Obj);
Cache(const Cache& C);
static Class GetClass();
HashTable GetHashTable() const; HashTable GetHashTable() const;
Queue GetQueue() const; Queue GetQueue() const;
}; };
}
#endif // CACHE_HPP_INCLUDED #endif // CACHE_HPP_INCLUDED

21
Include/Core/Classes/CacheableNode.hpp
View File

@ -4,17 +4,20 @@
#include "Node.hpp" #include "Node.hpp"
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
class CacheableNode : public Node namespace Internal
{ {
public: class CacheableNode : public Node
CacheableNode(); {
CacheableNode(const void* Obj); public:
CacheableNode(const CacheableNode& C); CacheableNode();
static Class GetClass(); CacheableNode(const void* Obj);
CacheableNode(const CacheableNode& C);
static Class GetClass();
CacheableNode GetNext() const; CacheableNode GetNext() const;
CacheableNode GetPrev() const; CacheableNode GetPrev() const;
}; };
}
#endif // CACHEABLENODE_HPP_INCLUDED #endif // CACHEABLENODE_HPP_INCLUDED

49
Include/Core/Classes/Character.hpp
View File

@ -8,31 +8,34 @@
#include <string> #include <string>
#include <vector> #include <vector>
class Character : public Renderable namespace Internal
{ {
public: class Character : public Renderable
Character(); {
Character(const void* Obj); public:
Character(const Character& C); Character();
static Class GetClass(); Character(const void* Obj);
Character(const Character& C);
static Class GetClass();
std::int32_t GetAngle() const; std::int32_t GetAngle() const;
std::int32_t GetAnimationDelay() const; std::int32_t GetAnimationDelay() const;
std::int32_t GetAnimationFrame() const; std::int32_t GetAnimationFrame() const;
std::int32_t GetAnimationID() const; std::int32_t GetAnimationID() const;
LinkedList GetCombatInfo() const; LinkedList GetCombatInfo() const;
std::int32_t GetGraphicsFrame() const; std::int32_t GetGraphicsFrame() const;
std::int32_t GetGraphicsID() const; std::int32_t GetGraphicsID() const;
std::int32_t GetInteractIndex() const; std::int32_t GetInteractIndex() const;
std::string GetOverhead() const; std::string GetOverhead() const;
std::vector<std::int32_t> GetPathX() const; std::vector<std::int32_t> GetPathX() const;
std::vector<std::int32_t> GetPathY() const; std::vector<std::int32_t> GetPathY() const;
std::int32_t GetPoseAnimationFrame() const; std::int32_t GetPoseAnimationFrame() const;
std::int32_t GetPoseAnimationID() const; std::int32_t GetPoseAnimationID() const;
std::int32_t GetSubPoseAnimationID() const; std::int32_t GetSubPoseAnimationID() const;
std::int32_t GetX() const; std::int32_t GetX() const;
std::int32_t GetY() const; std::int32_t GetY() const;
}; };
}
#endif // CHARACTER_HPP_INCLUDED #endif // CHARACTER_HPP_INCLUDED

21
Include/Core/Classes/ChatLineBuffer.hpp
View File

@ -7,17 +7,20 @@
#include <vector> #include <vector>
#include "MessageNode.hpp" #include "MessageNode.hpp"
class ChatLineBuffer : public Object namespace Internal
{ {
public: class ChatLineBuffer : public Object
ChatLineBuffer(); {
ChatLineBuffer(const void* Obj); public:
ChatLineBuffer(const ChatLineBuffer& C); ChatLineBuffer();
static Class GetClass(); ChatLineBuffer(const void* Obj);
ChatLineBuffer(const ChatLineBuffer& C);
static Class GetClass();
std::int32_t GetLength() const; std::int32_t GetLength() const;
std::vector<MessageNode> GetLines() const; std::vector<MessageNode> GetLines() const;
}; };
}
#endif // CHATLINEBUFFER_HPP_INCLUDED #endif // CHATLINEBUFFER_HPP_INCLUDED

17
Include/Core/Classes/ClanMember.hpp
View File

@ -5,14 +5,17 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class ClanMember : public Talkable namespace Internal
{ {
public: class ClanMember : public Talkable
ClanMember(); {
ClanMember(const void* Obj); public:
ClanMember(const ClanMember& C); ClanMember();
static Class GetClass(); ClanMember(const void* Obj);
ClanMember(const ClanMember& C);
static Class GetClass();
}; };
}
#endif // CLANMEMBER_HPP_INCLUDED #endif // CLANMEMBER_HPP_INCLUDED

17
Include/Core/Classes/ClanMemberList.hpp
View File

@ -4,14 +4,17 @@
#include "NameableContainer.hpp" #include "NameableContainer.hpp"
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
class ClanMemberList : public NameableContainer namespace Internal
{ {
public: class ClanMemberList : public NameableContainer
ClanMemberList(); {
ClanMemberList(const void* Obj); public:
ClanMemberList(const ClanMemberList& C); ClanMemberList();
static Class GetClass(); ClanMemberList(const void* Obj);
ClanMemberList(const ClanMemberList& C);
static Class GetClass();
}; };
}
#endif // CLANMEMBERLIST_HPP_INCLUDED #endif // CLANMEMBERLIST_HPP_INCLUDED

37
Include/Core/Classes/DecorativeObject.hpp
View File

@ -6,25 +6,28 @@
#include <cstdint> #include <cstdint>
#include "Renderable.hpp" #include "Renderable.hpp"
class DecorativeObject : public Object namespace Internal
{ {
public: class DecorativeObject : public Object
DecorativeObject(); {
DecorativeObject(const void* Obj); public:
DecorativeObject(const DecorativeObject& D); DecorativeObject();
static Class GetClass(); DecorativeObject(const void* Obj);
DecorativeObject(const DecorativeObject& D);
static Class GetClass();
std::int32_t GetAngle() const; std::int32_t GetAngle() const;
std::int32_t GetFlags() const; std::int32_t GetFlags() const;
std::int32_t GetHash() const; std::int32_t GetHash() const;
std::int32_t GetOffsetX() const; std::int32_t GetOffsetX() const;
std::int32_t GetOffsetY() const; std::int32_t GetOffsetY() const;
std::int32_t GetPlane() const; std::int32_t GetPlane() const;
std::int32_t GetRenderInfo() const; std::int32_t GetRenderInfo() const;
Renderable GetRenderable() const; Renderable GetRenderable() const;
std::int32_t GetX() const; std::int32_t GetX() const;
std::int32_t GetY() const; std::int32_t GetY() const;
}; };
}
#endif // DECORATIVEOBJECT_HPP_INCLUDED #endif // DECORATIVEOBJECT_HPP_INCLUDED

21
Include/Core/Classes/Deque.hpp
View File

@ -5,17 +5,20 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include "Node.hpp" #include "Node.hpp"
class Deque : public Object namespace Internal
{ {
public: class Deque : public Object
Deque(); {
Deque(const void* Obj); public:
Deque(const Deque& D); Deque();
static Class GetClass(); Deque(const void* Obj);
Deque(const Deque& D);
static Class GetClass();
Node GetHead() const; Node GetHead() const;
Node GetTail() const; Node GetTail() const;
}; };
}
#endif // DEQUE_HPP_INCLUDED #endif // DEQUE_HPP_INCLUDED

23
Include/Core/Classes/DynamicObject.hpp
View File

@ -5,17 +5,20 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class DynamicObject : public Renderable namespace Internal
{ {
public: class DynamicObject : public Renderable
DynamicObject(); {
DynamicObject(const void* Obj); public:
DynamicObject(const DynamicObject& D); DynamicObject();
static Class GetClass(); DynamicObject(const void* Obj);
DynamicObject(const DynamicObject& D);
static Class GetClass();
std::int32_t GetID() const; std::int32_t GetID() const;
std::int32_t GetOrientation() const; std::int32_t GetOrientation() const;
std::int32_t GetType() const; std::int32_t GetType() const;
}; };
}
#endif // DYNAMICOBJECT_HPP_INCLUDED #endif // DYNAMICOBJECT_HPP_INCLUDED

25
Include/Core/Classes/ExchangeOffer.hpp
View File

@ -5,19 +5,22 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class ExchangeOffer : public Object namespace Internal
{ {
public: class ExchangeOffer : public Object
ExchangeOffer(); {
ExchangeOffer(const void* Obj); public:
ExchangeOffer(const ExchangeOffer& E); ExchangeOffer();
static Class GetClass(); ExchangeOffer(const void* Obj);
ExchangeOffer(const ExchangeOffer& E);
static Class GetClass();
std::int32_t GetAmountTraded() const; std::int32_t GetAmountTraded() const;
std::int32_t GetItemID() const; std::int32_t GetItemID() const;
std::int8_t GetProgress() const; std::int8_t GetProgress() const;
std::int32_t GetTotalAmount() const; std::int32_t GetTotalAmount() const;
}; };
}
#endif // EXCHANGEOFFER_HPP_INCLUDED #endif // EXCHANGEOFFER_HPP_INCLUDED

31
Include/Core/Classes/Frame.hpp
View File

@ -7,22 +7,25 @@
#include <cstdint> #include <cstdint>
#include "FrameMap.hpp" #include "FrameMap.hpp"
class Frame : public Object namespace Internal
{ {
public: class Frame : public Object
Frame(); {
Frame(const void* Obj); public:
Frame(const Frame& F); Frame();
static Class GetClass(); Frame(const void* Obj);
Frame(const Frame& F);
static Class GetClass();
std::vector<std::int32_t> GetIndices() const; std::vector<std::int32_t> GetIndices() const;
bool GetShowing() const; bool GetShowing() const;
FrameMap GetSkin() const; FrameMap GetSkin() const;
std::vector<std::int32_t> GetTranslatorX() const; std::vector<std::int32_t> GetTranslatorX() const;
std::vector<std::int32_t> GetTranslatorY() const; std::vector<std::int32_t> GetTranslatorY() const;
std::vector<std::int32_t> GetTranslatorZ() const; std::vector<std::int32_t> GetTranslatorZ() const;
std::int32_t GetTranslatorsLength() const; std::int32_t GetTranslatorsLength() const;
}; };
}
#endif // FRAME_HPP_INCLUDED #endif // FRAME_HPP_INCLUDED

21
Include/Core/Classes/FrameMap.hpp
View File

@ -6,17 +6,20 @@
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
class FrameMap : public Node namespace Internal
{ {
public: class FrameMap : public Node
FrameMap(); {
FrameMap(const void* Obj); public:
FrameMap(const FrameMap& F); FrameMap();
static Class GetClass(); FrameMap(const void* Obj);
FrameMap(const FrameMap& F);
static Class GetClass();
std::vector<std::vector<std::int32_t>> GetList() const; std::vector<std::vector<std::int32_t>> GetList() const;
std::vector<std::int32_t> GetTypes() const; std::vector<std::int32_t> GetTypes() const;
}; };
}
#endif // FRAMEMAP_HPP_INCLUDED #endif // FRAMEMAP_HPP_INCLUDED

19
Include/Core/Classes/Frames.hpp
View File

@ -6,16 +6,19 @@
#include <vector> #include <vector>
#include "Frame.hpp" #include "Frame.hpp"
class Frames : public CacheableNode namespace Internal
{ {
public: class Frames : public CacheableNode
Frames(); {
Frames(const void* Obj); public:
Frames(const Frames& F); Frames();
static Class GetClass(); Frames(const void* Obj);
Frames(const Frames& F);
static Class GetClass();
std::vector<Frame> GetSkeletons() const; std::vector<Frame> GetSkeletons() const;
}; };
}
#endif // FRAMES_HPP_INCLUDED #endif // FRAMES_HPP_INCLUDED

17
Include/Core/Classes/Friend.hpp
View File

@ -5,14 +5,17 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class Friend : public Talkable namespace Internal
{ {
public: class Friend : public Talkable
Friend(); {
Friend(const void* Obj); public:
Friend(const Friend& F); Friend();
static Class GetClass(); Friend(const void* Obj);
Friend(const Friend& F);
static Class GetClass();
}; };
}
#endif // FRIEND_HPP_INCLUDED #endif // FRIEND_HPP_INCLUDED

17
Include/Core/Classes/FriendList.hpp
View File

@ -4,14 +4,17 @@
#include "NameableContainer.hpp" #include "NameableContainer.hpp"
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
class FriendList : public NameableContainer namespace Internal
{ {
public: class FriendList : public NameableContainer
FriendList(); {
FriendList(const void* Obj); public:
FriendList(const FriendList& F); FriendList();
static Class GetClass(); FriendList(const void* Obj);
FriendList(const FriendList& F);
static Class GetClass();
}; };
}
#endif // FRIENDLIST_HPP_INCLUDED #endif // FRIENDLIST_HPP_INCLUDED

41
Include/Core/Classes/GameObject.hpp
View File

@ -6,27 +6,30 @@
#include <cstdint> #include <cstdint>
#include "Renderable.hpp" #include "Renderable.hpp"
class GameObject : public Object namespace Internal
{ {
public: class GameObject : public Object
GameObject(); {
GameObject(const void* Obj); public:
GameObject(const GameObject& G); GameObject();
static Class GetClass(); GameObject(const void* Obj);
GameObject(const GameObject& G);
static Class GetClass();
std::int32_t GetAngle() const; std::int32_t GetAngle() const;
std::int32_t GetFlags() const; std::int32_t GetFlags() const;
std::int32_t GetHash() const; std::int32_t GetHash() const;
std::int32_t GetHeight() const; std::int32_t GetHeight() const;
std::int32_t GetOffsetX() const; std::int32_t GetOffsetX() const;
std::int32_t GetOffsetY() const; std::int32_t GetOffsetY() const;
std::int32_t GetPlane() const; std::int32_t GetPlane() const;
std::int32_t GetRelativeX() const; std::int32_t GetRelativeX() const;
std::int32_t GetRelativeY() const; std::int32_t GetRelativeY() const;
Renderable GetRenderable() const; Renderable GetRenderable() const;
std::int32_t GetX() const; std::int32_t GetX() const;
std::int32_t GetY() const; std::int32_t GetY() const;
}; };
}
#endif // GAMEOBJECT_HPP_INCLUDED #endif // GAMEOBJECT_HPP_INCLUDED

19
Include/Core/Classes/GameShell.hpp
View File

@ -5,16 +5,19 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include "../JavaClass/Canvas.hpp" #include "../JavaClass/Canvas.hpp"
class GameShell : public Object namespace Internal
{ {
public: class GameShell : public Object
GameShell(); {
GameShell(const void* Obj); public:
GameShell(const GameShell& G); GameShell();
static Class GetClass(); GameShell(const void* Obj);
GameShell(const GameShell& G);
static Class GetClass();
Canvas GetCanvas() const; Canvas GetCanvas() const;
}; };
}
#endif // GAMESHELL_HPP_INCLUDED #endif // GAMESHELL_HPP_INCLUDED

33
Include/Core/Classes/GraphicsObject.hpp
View File

@ -6,23 +6,26 @@
#include "Animation.hpp" #include "Animation.hpp"
#include <cstdint> #include <cstdint>
class GraphicsObject : public Renderable namespace Internal
{ {
public: class GraphicsObject : public Renderable
GraphicsObject(); {
GraphicsObject(const void* Obj); public:
GraphicsObject(const GraphicsObject& G); GraphicsObject();
static Class GetClass(); GraphicsObject(const void* Obj);
GraphicsObject(const GraphicsObject& G);
static Class GetClass();
Animation GetAnimation() const; Animation GetAnimation() const;
std::int32_t GetAnimationFrame() const; std::int32_t GetAnimationFrame() const;
bool GetFinished() const; bool GetFinished() const;
std::int32_t GetHeight() const; std::int32_t GetHeight() const;
std::int32_t GetID() const; std::int32_t GetID() const;
std::int32_t GetPlane() const; std::int32_t GetPlane() const;
std::int32_t GetX() const; std::int32_t GetX() const;
std::int32_t GetY() const; std::int32_t GetY() const;
}; };
}
#endif // GRAPHICSOBJECT_HPP_INCLUDED #endif // GRAPHICSOBJECT_HPP_INCLUDED

21
Include/Core/Classes/GroundItem.hpp
View File

@ -5,17 +5,20 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class GroundItem : public Renderable namespace Internal
{ {
public: class GroundItem : public Renderable
GroundItem(); {
GroundItem(const void* Obj); public:
GroundItem(const GroundItem& G); GroundItem();
static Class GetClass(); GroundItem(const void* Obj);
GroundItem(const GroundItem& G);
static Class GetClass();
std::int32_t GetAmount() const; std::int32_t GetAmount() const;
std::int32_t GetID() const; std::int32_t GetID() const;
}; };
}
#endif // GROUNDITEM_HPP_INCLUDED #endif // GROUNDITEM_HPP_INCLUDED

29
Include/Core/Classes/GroundObject.hpp
View File

@ -6,21 +6,24 @@
#include <cstdint> #include <cstdint>
#include "Renderable.hpp" #include "Renderable.hpp"
class GroundObject : public Object namespace Internal
{ {
public: class GroundObject : public Object
GroundObject(); {
GroundObject(const void* Obj); public:
GroundObject(const GroundObject& G); GroundObject();
static Class GetClass(); GroundObject(const void* Obj);
GroundObject(const GroundObject& G);
static Class GetClass();
std::int32_t GetHash() const; std::int32_t GetHash() const;
std::int32_t GetPlane() const; std::int32_t GetPlane() const;
std::int32_t GetRenderInfo() const; std::int32_t GetRenderInfo() const;
Renderable GetRenderable() const; Renderable GetRenderable() const;
std::int32_t GetX() const; std::int32_t GetX() const;
std::int32_t GetY() const; std::int32_t GetY() const;
}; };
}
#endif // GROUNDOBJECT_HPP_INCLUDED #endif // GROUNDOBJECT_HPP_INCLUDED

23
Include/Core/Classes/HashTable.hpp
View File

@ -7,18 +7,21 @@
#include "Node.hpp" #include "Node.hpp"
#include <cstdint> #include <cstdint>
class HashTable : public Object namespace Internal
{ {
public: class HashTable : public Object
HashTable(); {
HashTable(const void* Obj); public:
HashTable(const HashTable& H); HashTable();
static Class GetClass(); HashTable(const void* Obj);
HashTable(const HashTable& H);
static Class GetClass();
std::vector<Node> GetBuckets() const; std::vector<Node> GetBuckets() const;
std::int32_t GetIndex() const; std::int32_t GetIndex() const;
std::int32_t GetSize() const; std::int32_t GetSize() const;
}; };
}
#endif // HASHTABLE_HPP_INCLUDED #endif // HASHTABLE_HPP_INCLUDED

17
Include/Core/Classes/Ignore.hpp
View File

@ -4,14 +4,17 @@
#include "Nameable.hpp" #include "Nameable.hpp"
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
class Ignore : public Nameable namespace Internal
{ {
public: class Ignore : public Nameable
Ignore(); {
Ignore(const void* Obj); public:
Ignore(const Ignore& I); Ignore();
static Class GetClass(); Ignore(const void* Obj);
Ignore(const Ignore& I);
static Class GetClass();
}; };
}
#endif // IGNORE_HPP_INCLUDED #endif // IGNORE_HPP_INCLUDED

17
Include/Core/Classes/IgnoreList.hpp
View File

@ -4,14 +4,17 @@
#include "NameableContainer.hpp" #include "NameableContainer.hpp"
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
class IgnoreList : public NameableContainer namespace Internal
{ {
public: class IgnoreList : public NameableContainer
IgnoreList(); {
IgnoreList(const void* Obj); public:
IgnoreList(const IgnoreList& I); IgnoreList();
static Class GetClass(); IgnoreList(const void* Obj);
IgnoreList(const IgnoreList& I);
static Class GetClass();
}; };
}
#endif // IGNORELIST_HPP_INCLUDED #endif // IGNORELIST_HPP_INCLUDED

21
Include/Core/Classes/ItemContainer.hpp
View File

@ -6,17 +6,20 @@
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
class ItemContainer : public Node namespace Internal
{ {
public: class ItemContainer : public Node
ItemContainer(); {
ItemContainer(const void* Obj); public:
ItemContainer(const ItemContainer& I); ItemContainer();
static Class GetClass(); ItemContainer(const void* Obj);
ItemContainer(const ItemContainer& I);
static Class GetClass();
std::vector<std::int32_t> GetItemAmounts() const; std::vector<std::int32_t> GetItemAmounts() const;
std::vector<std::int32_t> GetItemIDs() const; std::vector<std::int32_t> GetItemIDs() const;
}; };
}
#endif // ITEMCONTAINER_HPP_INCLUDED #endif // ITEMCONTAINER_HPP_INCLUDED

39
Include/Core/Classes/ItemInfo.hpp
View File

@ -7,26 +7,29 @@
#include <string> #include <string>
#include <cstdint> #include <cstdint>
class ItemInfo : public CacheableNode namespace Internal
{ {
public: class ItemInfo : public CacheableNode
ItemInfo(); {
ItemInfo(const void* Obj); public:
ItemInfo(const ItemInfo& I); ItemInfo();
static Class GetClass(); ItemInfo(const void* Obj);
ItemInfo(const ItemInfo& I);
static Class GetClass();
std::vector<std::string> GetGroundActions() const; std::vector<std::string> GetGroundActions() const;
std::int32_t GetID() const; std::int32_t GetID() const;
std::vector<std::string> GetInventoryActions() const; std::vector<std::string> GetInventoryActions() const;
bool GetMembers() const; bool GetMembers() const;
std::string GetName() const; std::string GetName() const;
std::int32_t GetNoteID() const; std::int32_t GetNoteID() const;
std::int32_t GetPrice() const; std::int32_t GetPrice() const;
std::int32_t GetSpriteID() const; std::int32_t GetSpriteID() const;
std::vector<std::int32_t> GetStackAmounts() const; std::vector<std::int32_t> GetStackAmounts() const;
std::vector<std::int32_t> GetStackModelIDs() const; std::vector<std::int32_t> GetStackModelIDs() const;
std::int32_t GetStackable() const; std::int32_t GetStackable() const;
}; };
}
#endif // ITEMINFO_HPP_INCLUDED #endif // ITEMINFO_HPP_INCLUDED

21
Include/Core/Classes/LinkedList.hpp
View File

@ -5,17 +5,20 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include "Node.hpp" #include "Node.hpp"
class LinkedList : public Object namespace Internal
{ {
public: class LinkedList : public Object
LinkedList(); {
LinkedList(const void* Obj); public:
LinkedList(const LinkedList& L); LinkedList();
static Class GetClass(); LinkedList(const void* Obj);
LinkedList(const LinkedList& L);
static Class GetClass();
Node GetHead() const; Node GetHead() const;
Node GetTail() const; Node GetTail() const;
}; };
}
#endif // LINKEDLIST_HPP_INCLUDED #endif // LINKEDLIST_HPP_INCLUDED

29
Include/Core/Classes/MessageNode.hpp
View File

@ -6,21 +6,24 @@
#include <cstdint> #include <cstdint>
#include <string> #include <string>
class MessageNode : public CacheableNode namespace Internal
{ {
public: class MessageNode : public CacheableNode
MessageNode(); {
MessageNode(const void* Obj); public:
MessageNode(const MessageNode& M); MessageNode();
static Class GetClass(); MessageNode(const void* Obj);
MessageNode(const MessageNode& M);
static Class GetClass();
std::int32_t GetID() const; std::int32_t GetID() const;
std::string GetName() const; std::string GetName() const;
std::string GetSender() const; std::string GetSender() const;
std::string GetText() const; std::string GetText() const;
std::int32_t GetTick() const; std::int32_t GetTick() const;
std::int32_t GetType() const; std::int32_t GetType() const;
}; };
}
#endif // MESSAGENODE_HPP_INCLUDED #endif // MESSAGENODE_HPP_INCLUDED

35
Include/Core/Classes/Model.hpp
View File

@ -6,24 +6,27 @@
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
class Model : public Renderable namespace Internal
{ {
public: class Model : public Renderable
Model(); {
Model(const void* Obj); public:
Model(const Model& M); Model();
static Class GetClass(); Model(const void* Obj);
Model(const Model& M);
static Class GetClass();
std::vector<std::vector<std::int32_t>> GetFrameMapIndices() const; std::vector<std::vector<std::int32_t>> GetFrameMapIndices() const;
std::vector<std::int32_t> GetIndicesA() const; std::vector<std::int32_t> GetIndicesA() const;
std::vector<std::int32_t> GetIndicesB() const; std::vector<std::int32_t> GetIndicesB() const;
std::vector<std::int32_t> GetIndicesC() const; std::vector<std::int32_t> GetIndicesC() const;
std::int32_t GetIndicesLength() const; std::int32_t GetIndicesLength() const;
std::int32_t GetVerticesLength() const; std::int32_t GetVerticesLength() const;
std::vector<std::int32_t> GetVerticesX() const; std::vector<std::int32_t> GetVerticesX() const;
std::vector<std::int32_t> GetVerticesY() const; std::vector<std::int32_t> GetVerticesY() const;
std::vector<std::int32_t> GetVerticesZ() const; std::vector<std::int32_t> GetVerticesZ() const;
}; };
}
#endif // MODEL_HPP_INCLUDED #endif // MODEL_HPP_INCLUDED

19
Include/Core/Classes/NPC.hpp
View File

@ -5,16 +5,19 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include "NPCInfo.hpp" #include "NPCInfo.hpp"
class NPC : public Character namespace Internal
{ {
public: class NPC : public Character
NPC(); {
NPC(const void* Obj); public:
NPC(const NPC& N); NPC();
static Class GetClass(); NPC(const void* Obj);
NPC(const NPC& N);
static Class GetClass();
NPCInfo GetInfo() const; NPCInfo GetInfo() const;
}; };
}
#endif // NPC_HPP_INCLUDED #endif // NPC_HPP_INCLUDED

41
Include/Core/Classes/NPCInfo.hpp
View File

@ -7,27 +7,30 @@
#include <string> #include <string>
#include <cstdint> #include <cstdint>
class NPCInfo : public CacheableNode namespace Internal
{ {
public: class NPCInfo : public CacheableNode
NPCInfo(); {
NPCInfo(const void* Obj); public:
NPCInfo(const NPCInfo& N); NPCInfo();
static Class GetClass(); NPCInfo(const void* Obj);
NPCInfo(const NPCInfo& N);
static Class GetClass();
std::vector<std::string> GetActions() const; std::vector<std::string> GetActions() const;
std::int32_t GetCombatLevel() const; std::int32_t GetCombatLevel() const;
std::int32_t GetID() const; std::int32_t GetID() const;
std::vector<std::int32_t> GetImposterIDs() const; std::vector<std::int32_t> GetImposterIDs() const;
bool GetMinimapVisible() const; bool GetMinimapVisible() const;
std::vector<std::int32_t> GetModelIDs() const; std::vector<std::int32_t> GetModelIDs() const;
std::string GetName() const; std::string GetName() const;
std::int32_t GetScaleX() const; std::int32_t GetScaleX() const;
std::int32_t GetScaleY() const; std::int32_t GetScaleY() const;
std::int32_t GetSettingID() const; std::int32_t GetSettingID() const;
std::int32_t GetVarbitID() const; std::int32_t GetVarbitID() const;
bool GetVisible() const; bool GetVisible() const;
}; };
}
#endif // NPCINFO_HPP_INCLUDED #endif // NPCINFO_HPP_INCLUDED

21
Include/Core/Classes/NamePair.hpp
View File

@ -5,17 +5,20 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <string> #include <string>
class NamePair : public Object namespace Internal
{ {
public: class NamePair : public Object
NamePair(); {
NamePair(const void* Obj); public:
NamePair(const NamePair& N); NamePair();
static Class GetClass(); NamePair(const void* Obj);
NamePair(const NamePair& N);
static Class GetClass();
std::string GetCleanName() const; std::string GetCleanName() const;
std::string GetName() const; std::string GetName() const;
}; };
}
#endif // NAMEPAIR_HPP_INCLUDED #endif // NAMEPAIR_HPP_INCLUDED

20
Include/Core/Classes/Nameable.hpp
View File

@ -5,17 +5,19 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include "NamePair.hpp" #include "NamePair.hpp"
class Nameable : public Object namespace Internal
{ {
public: class Nameable : public Object
Nameable(); {
Nameable(const void* Obj); public:
Nameable(const Nameable& N); Nameable();
static Class GetClass(); Nameable(const void* Obj);
Nameable(const Nameable& N);
static Class GetClass();
NamePair GetNamePair() const; NamePair GetNamePair() const;
};
};
}
#endif // NAMEABLE_HPP_INCLUDED #endif // NAMEABLE_HPP_INCLUDED

21
Include/Core/Classes/NameableContainer.hpp
View File

@ -6,17 +6,20 @@
#include <vector> #include <vector>
#include "Nameable.hpp" #include "Nameable.hpp"
class NameableContainer : public Object namespace Internal
{ {
public: class NameableContainer : public Object
NameableContainer(); {
NameableContainer(const void* Obj); public:
NameableContainer(const NameableContainer& N); NameableContainer();
static Class GetClass(); NameableContainer(const void* Obj);
NameableContainer(const NameableContainer& N);
static Class GetClass();
std::vector<Nameable> GetNameables() const; std::vector<Nameable> GetNameables() const;
std::int32_t GetSize() const; std::int32_t GetSize() const;
}; };
}
#endif // NAMEABLECONTAINER_HPP_INCLUDED #endif // NAMEABLECONTAINER_HPP_INCLUDED

23
Include/Core/Classes/Node.hpp
View File

@ -5,18 +5,21 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class Node : public Object namespace Internal
{ {
public: class Node : public Object
Node(); {
Node(const void* Obj); public:
Node(const Node& N); Node();
static Class GetClass(); Node(const void* Obj);
Node(const Node& N);
static Class GetClass();
Node GetNext() const; Node GetNext() const;
Node GetPrev() const; Node GetPrev() const;
std::int64_t GetUID() const; std::int64_t GetUID() const;
}; };
}
#endif // NODE_HPP_INCLUDED #endif // NODE_HPP_INCLUDED

33
Include/Core/Classes/ObjectInfo.hpp
View File

@ -7,23 +7,26 @@
#include <string> #include <string>
#include <cstdint> #include <cstdint>
class ObjectInfo : public CacheableNode namespace Internal
{ {
public: class ObjectInfo : public CacheableNode
ObjectInfo(); {
ObjectInfo(const void* Obj); public:
ObjectInfo(const ObjectInfo& O); ObjectInfo();
static Class GetClass(); ObjectInfo(const void* Obj);
ObjectInfo(const ObjectInfo& O);
static Class GetClass();
std::vector<std::string> GetActions() const; std::vector<std::string> GetActions() const;
std::int32_t GetID() const; std::int32_t GetID() const;
std::vector<std::int32_t> GetImposterIDs() const; std::vector<std::int32_t> GetImposterIDs() const;
std::vector<std::int32_t> GetModelIDs() const; std::vector<std::int32_t> GetModelIDs() const;
std::string GetName() const; std::string GetName() const;
std::vector<std::int32_t> GetObjectTypes() const; std::vector<std::int32_t> GetObjectTypes() const;
std::int32_t GetSettingID() const; std::int32_t GetSettingID() const;
std::int32_t GetVarbitID() const; std::int32_t GetVarbitID() const;
}; };
}
#endif // OBJECTINFO_HPP_INCLUDED #endif // OBJECTINFO_HPP_INCLUDED

35
Include/Core/Classes/Player.hpp
View File

@ -9,24 +9,27 @@
#include "PlayerInfo.hpp" #include "PlayerInfo.hpp"
#include "NamePair.hpp" #include "NamePair.hpp"
class Player : public Character namespace Internal
{ {
public: class Player : public Character
Player(); {
Player(const void* Obj); public:
Player(const Player& P); Player();
static Class GetClass(); Player(const void* Obj);
Player(const Player& P);
static Class GetClass();
std::vector<std::string> GetActions() const; std::vector<std::string> GetActions() const;
std::int32_t GetCombatLevel() const; std::int32_t GetCombatLevel() const;
bool GetHidden() const; bool GetHidden() const;
PlayerInfo GetInfo() const; PlayerInfo GetInfo() const;
NamePair GetNamePair() const; NamePair GetNamePair() const;
std::int32_t GetOverheadIcon() const; std::int32_t GetOverheadIcon() const;
std::int32_t GetSkullIcon() const; std::int32_t GetSkullIcon() const;
std::int32_t GetTeam() const; std::int32_t GetTeam() const;
std::int32_t GetTotalLevel() const; std::int32_t GetTotalLevel() const;
}; };
}
#endif // PLAYER_HPP_INCLUDED #endif // PLAYER_HPP_INCLUDED

27
Include/Core/Classes/PlayerInfo.hpp
View File

@ -6,20 +6,23 @@
#include <vector> #include <vector>
#include <cstdint> #include <cstdint>
class PlayerInfo : public Object namespace Internal
{ {
public: class PlayerInfo : public Object
PlayerInfo(); {
PlayerInfo(const void* Obj); public:
PlayerInfo(const PlayerInfo& P); PlayerInfo();
static Class GetClass(); PlayerInfo(const void* Obj);
PlayerInfo(const PlayerInfo& P);
static Class GetClass();
std::vector<std::int32_t> GetEquipment() const; std::vector<std::int32_t> GetEquipment() const;
bool GetGender() const; bool GetGender() const;
std::int64_t GetHash() const; std::int64_t GetHash() const;
std::int64_t GetModelID() const; std::int64_t GetModelID() const;
std::int32_t GetNPCModelID() const; std::int32_t GetNPCModelID() const;
}; };
}
#endif // PLAYERINFO_HPP_INCLUDED #endif // PLAYERINFO_HPP_INCLUDED

21
Include/Core/Classes/PlayerManager.hpp
View File

@ -6,17 +6,20 @@
#include "FriendList.hpp" #include "FriendList.hpp"
#include "IgnoreList.hpp" #include "IgnoreList.hpp"
class PlayerManager : public Object namespace Internal
{ {
public: class PlayerManager : public Object
PlayerManager(); {
PlayerManager(const void* Obj); public:
PlayerManager(const PlayerManager& P); PlayerManager();
static Class GetClass(); PlayerManager(const void* Obj);
PlayerManager(const PlayerManager& P);
static Class GetClass();
FriendList GetFriendList() const; FriendList GetFriendList() const;
IgnoreList GetIgnoreList() const; IgnoreList GetIgnoreList() const;
}; };
}
#endif // PLAYERMANAGER_HPP_INCLUDED #endif // PLAYERMANAGER_HPP_INCLUDED

29
Include/Core/Classes/Preferences.hpp
View File

@ -7,21 +7,24 @@
#include <cstdint> #include <cstdint>
#include <string> #include <string>
class Preferences : public Object namespace Internal
{ {
public: class Preferences : public Object
Preferences(); {
Preferences(const void* Obj); public:
Preferences(const Preferences& P); Preferences();
static Class GetClass(); Preferences(const void* Obj);
Preferences(const Preferences& P);
static Class GetClass();
bool GetHideRoofs() const; bool GetHideRoofs() const;
bool GetMuted() const; bool GetMuted() const;
LinkedHashMap GetPreferences() const; LinkedHashMap GetPreferences() const;
std::int32_t GetScreenType() const; std::int32_t GetScreenType() const;
std::string GetUsernameCached() const; std::string GetUsernameCached() const;
bool GetUsernameHidden() const; bool GetUsernameHidden() const;
}; };
}
#endif // PREFERENCES_HPP_INCLUDED #endif // PREFERENCES_HPP_INCLUDED

19
Include/Core/Classes/Queue.hpp
View File

@ -5,16 +5,19 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include "CacheableNode.hpp" #include "CacheableNode.hpp"
class Queue : public Object namespace Internal
{ {
public: class Queue : public Object
Queue(); {
Queue(const void* Obj); public:
Queue(const Queue& Q); Queue();
static Class GetClass(); Queue(const void* Obj);
Queue(const Queue& Q);
static Class GetClass();
CacheableNode GetHead() const; CacheableNode GetHead() const;
}; };
}
#endif // QUEUE_HPP_INCLUDED #endif // QUEUE_HPP_INCLUDED

21
Include/Core/Classes/Region.hpp
View File

@ -7,17 +7,20 @@
#include "GameObject.hpp" #include "GameObject.hpp"
#include "SceneTile.hpp" #include "SceneTile.hpp"
class Region : public Object namespace Internal
{ {
public: class Region : public Object
Region(); {
Region(const void* Obj); public:
Region(const Region& R); Region();
static Class GetClass(); Region(const void* Obj);
Region(const Region& R);
static Class GetClass();
std::vector<GameObject> GetGameObjects() const; std::vector<GameObject> GetGameObjects() const;
std::vector<std::vector<std::vector<SceneTile>>> GetSceneTiles() const; std::vector<std::vector<std::vector<SceneTile>>> GetSceneTiles() const;
}; };
}
#endif // REGION_HPP_INCLUDED #endif // REGION_HPP_INCLUDED

19
Include/Core/Classes/Renderable.hpp
View File

@ -5,16 +5,19 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class Renderable : public CacheableNode namespace Internal
{ {
public: class Renderable : public CacheableNode
Renderable(); {
Renderable(const void* Obj); public:
Renderable(const Renderable& R); Renderable();
static Class GetClass(); Renderable(const void* Obj);
Renderable(const Renderable& R);
static Class GetClass();
std::int32_t GetModelHeight() const; std::int32_t GetModelHeight() const;
}; };
}
#endif // RENDERABLE_HPP_INCLUDED #endif // RENDERABLE_HPP_INCLUDED

31
Include/Core/Classes/SceneTile.hpp
View File

@ -10,22 +10,25 @@
#include <cstdint> #include <cstdint>
#include "WallObject.hpp" #include "WallObject.hpp"
class SceneTile : public Node namespace Internal
{ {
public: class SceneTile : public Node
SceneTile(); {
SceneTile(const void* Obj); public:
SceneTile(const SceneTile& G); SceneTile();
static Class GetClass(); SceneTile(const void* Obj);
SceneTile(const SceneTile& G);
static Class GetClass();
DecorativeObject GetDecorativeObject() const; DecorativeObject GetDecorativeObject() const;
std::vector<GameObject> GetGameObjects() const; std::vector<GameObject> GetGameObjects() const;
GroundObject GetGroundObject() const; GroundObject GetGroundObject() const;
std::int32_t GetPlane() const; std::int32_t GetPlane() const;
WallObject GetWallObject() const; WallObject GetWallObject() const;
std::int32_t GetX() const; std::int32_t GetX() const;
std::int32_t GetY() const; std::int32_t GetY() const;
}; };
}
#endif // SCENETILE_HPP_INCLUDED #endif // SCENETILE_HPP_INCLUDED

27
Include/Core/Classes/SpotAnimation.hpp
View File

@ -5,20 +5,23 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class SpotAnimation : public CacheableNode namespace Internal
{ {
public: class SpotAnimation : public CacheableNode
SpotAnimation(); {
SpotAnimation(const void* Obj); public:
SpotAnimation(const SpotAnimation& S); SpotAnimation();
static Class GetClass(); SpotAnimation(const void* Obj);
SpotAnimation(const SpotAnimation& S);
static Class GetClass();
std::int32_t GetAngle() const; std::int32_t GetAngle() const;
std::int32_t GetAnimationID() const; std::int32_t GetAnimationID() const;
std::int32_t GetID() const; std::int32_t GetID() const;
std::int32_t GetScaleX() const; std::int32_t GetScaleX() const;
std::int32_t GetScaleY() const; std::int32_t GetScaleY() const;
}; };
}
#endif // SPOTANIMATION_HPP_INCLUDED #endif // SPOTANIMATION_HPP_INCLUDED

23
Include/Core/Classes/Sprite.hpp
View File

@ -6,18 +6,21 @@
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
class Sprite : public Object namespace Internal
{ {
public: class Sprite : public Object
Sprite(); {
Sprite(const void* Obj); public:
Sprite(const Sprite& S); Sprite();
static Class GetClass(); Sprite(const void* Obj);
Sprite(const Sprite& S);
static Class GetClass();
std::int32_t GetHeight() const; std::int32_t GetHeight() const;
std::vector<std::int32_t> GetPixels() const; std::vector<std::int32_t> GetPixels() const;
std::int32_t GetWidth() const; std::int32_t GetWidth() const;
}; };
}
#endif // SPRITE_HPP_INCLUDED #endif // SPRITE_HPP_INCLUDED

21
Include/Core/Classes/Talkable.hpp
View File

@ -5,17 +5,20 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class Talkable : public Nameable namespace Internal
{ {
public: class Talkable : public Nameable
Talkable(); {
Talkable(const void* Obj); public:
Talkable(const Talkable& T); Talkable();
static Class GetClass(); Talkable(const void* Obj);
Talkable(const Talkable& T);
static Class GetClass();
std::int32_t GetRank() const; std::int32_t GetRank() const;
std::int32_t GetWorld() const; std::int32_t GetWorld() const;
}; };
}
#endif // TALKABLE_HPP_INCLUDED #endif // TALKABLE_HPP_INCLUDED

23
Include/Core/Classes/Varbit.hpp
View File

@ -5,18 +5,21 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class Varbit : public CacheableNode namespace Internal
{ {
public: class Varbit : public CacheableNode
Varbit(); {
Varbit(const void* Obj); public:
Varbit(const Varbit& V); Varbit();
static Class GetClass(); Varbit(const void* Obj);
Varbit(const Varbit& V);
static Class GetClass();
std::int32_t GetLSB() const; std::int32_t GetLSB() const;
std::int32_t GetMSB() const; std::int32_t GetMSB() const;
std::int32_t GetSettingID() const; std::int32_t GetSettingID() const;
}; };
}
#endif // VARBIT_HPP_INCLUDED #endif // VARBIT_HPP_INCLUDED

33
Include/Core/Classes/WallObject.hpp
View File

@ -6,23 +6,26 @@
#include <cstdint> #include <cstdint>
#include "Renderable.hpp" #include "Renderable.hpp"
class WallObject : public Object namespace Internal
{ {
public: class WallObject : public Object
WallObject(); {
WallObject(const void* Obj); public:
WallObject(const WallObject& W); WallObject();
static Class GetClass(); WallObject(const void* Obj);
WallObject(const WallObject& W);
static Class GetClass();
std::int32_t GetAngle() const; std::int32_t GetAngle() const;
std::int32_t GetFlags() const; std::int32_t GetFlags() const;
std::int32_t GetHash() const; std::int32_t GetHash() const;
std::int32_t GetHeight() const; std::int32_t GetHeight() const;
std::int32_t GetPlane() const; std::int32_t GetPlane() const;
Renderable GetRenderable() const; Renderable GetRenderable() const;
std::int32_t GetX() const; std::int32_t GetX() const;
std::int32_t GetY() const; std::int32_t GetY() const;
}; };
}
#endif // WALLOBJECT_HPP_INCLUDED #endif // WALLOBJECT_HPP_INCLUDED

63
Include/Core/Classes/Widget.hpp
View File

@ -7,38 +7,41 @@
#include <string> #include <string>
#include <cstdint> #include <cstdint>
class Widget : public Node namespace Internal
{ {
public: class Widget : public Node
Widget(); {
Widget(const void* Obj); public:
Widget(const Widget& W); Widget();
static Class GetClass(); Widget(const void* Obj);
Widget(const Widget& W);
static Class GetClass();
std::vector<std::string> GetActions() const; std::vector<std::string> GetActions() const;
std::int32_t GetBorderThickness() const; std::int32_t GetBorderThickness() const;
std::int32_t GetBoxIndex() const; std::int32_t GetBoxIndex() const;
std::vector<Widget> GetChildren() const; std::vector<Widget> GetChildren() const;
std::int32_t GetHeight() const; std::int32_t GetHeight() const;
bool GetHidden() const; bool GetHidden() const;
std::int32_t GetID() const; std::int32_t GetID() const;
std::int32_t GetItemAmount() const; std::int32_t GetItemAmount() const;
std::vector<std::int32_t> GetItemAmounts() const; std::vector<std::int32_t> GetItemAmounts() const;
std::int32_t GetItemID() const; std::int32_t GetItemID() const;
std::vector<std::int32_t> GetItemIDs() const; std::vector<std::int32_t> GetItemIDs() const;
std::string GetName() const; std::string GetName() const;
Widget GetParent() const; Widget GetParent() const;
std::int32_t GetParentID() const; std::int32_t GetParentID() const;
std::int32_t GetRelativeX() const; std::int32_t GetRelativeX() const;
std::int32_t GetRelativeY() const; std::int32_t GetRelativeY() const;
std::int32_t GetScrollX() const; std::int32_t GetScrollX() const;
std::int32_t GetScrollY() const; std::int32_t GetScrollY() const;
std::int32_t GetShadowColor() const; std::int32_t GetShadowColor() const;
std::int32_t GetSpriteID() const; std::int32_t GetSpriteID() const;
std::int32_t GetStackType() const; std::int32_t GetStackType() const;
std::string GetText() const; std::string GetText() const;
std::int32_t GetWidth() const; std::int32_t GetWidth() const;
}; };
}
#endif // WIDGET_HPP_INCLUDED #endif // WIDGET_HPP_INCLUDED

19
Include/Core/Classes/WidgetNode.hpp
View File

@ -5,15 +5,18 @@
#include "../JavaClass/Class.hpp" #include "../JavaClass/Class.hpp"
#include <cstdint> #include <cstdint>
class WidgetNode : public Node namespace Internal
{ {
public: class WidgetNode : public Node
WidgetNode(); {
WidgetNode(const void* Obj); public:
WidgetNode(const WidgetNode& W); WidgetNode();
static Class GetClass(); WidgetNode(const void* Obj);
WidgetNode(const WidgetNode& W);
static Class GetClass();
std::int32_t GetID() const; std::int32_t GetID() const;
}; };
}
#endif // WIDGETNODE_HPP_INCLUDED #endif // WIDGETNODE_HPP_INCLUDED

31
Include/Core/Classes/World.hpp
View File

@ -6,22 +6,25 @@
#include <string> #include <string>
#include <cstdint> #include <cstdint>
class World : public Object namespace Internal
{ {
public: class World : public Object
World(); {
World(const void* Obj); public:
World(const World& W); World();
static Class GetClass(); World(const void* Obj);
World(const World& W);
static Class GetClass();
std::string GetActivity() const; std::string GetActivity() const;
std::string GetAddress() const; std::string GetAddress() const;
std::int32_t GetID() const; std::int32_t GetID() const;
std::int32_t GetIndex() const; std::int32_t GetIndex() const;
std::int32_t GetLocation() const; std::int32_t GetLocation() const;
std::int32_t GetMask() const; std::int32_t GetMask() const;
std::int32_t GetPlayerCount() const; std::int32_t GetPlayerCount() const;
}; };
}
#endif // WORLD_HPP_INCLUDED #endif // WORLD_HPP_INCLUDED

275
Include/Core/Internal.hpp
View File

@ -82,143 +82,150 @@
#include "Classes/WidgetNode.hpp" #include "Classes/WidgetNode.hpp"
#include "Classes/World.hpp" #include "Classes/World.hpp"
extern GameShell Client;
Cache GetAnimationCache(); namespace Internal
std::int32_t GetCameraPitch(); {
std::int32_t GetCameraX();
std::int32_t GetCameraY();
std::int32_t GetCameraYaw();
std::int32_t GetCameraZ();
Map GetChatLineCache();
std::int32_t GetClientPlane();
Preferences GetClientPreferences();
std::int32_t GetClientX();
std::int32_t GetClientY();
std::int32_t GetCrosshairState();
std::vector<std::int32_t> GetCurrentLevels();
std::int32_t GetCurrentWorld();
bool GetDraggingItem();
Cache GetDynamicObjectCache();
std::vector<ExchangeOffer> GetExchangeOffers();
std::vector<std::int32_t> GetExperiences();
bool GetFocused();
Cache GetFramesCache();
std::int32_t GetGameState();
std::int32_t GetGameTick();
Deque GetGraphicsObjects();
std::vector<std::vector<std::vector<Deque>>> GetGroundItems();
HashTable GetItemContainers();
Cache GetItemModelCache();
std::int32_t GetItemSelected();
std::int32_t GetItemSelectedIndex();
Cache GetItemSpriteCache();
std::vector<std::int32_t> GetLevels();
ClanMemberList GetLocalClanMemberList();
std::int32_t GetLocalDestinationX();
std::int32_t GetLocalDestinationY();
Player GetLocalPlayer();
PlayerManager GetLocalPlayerManager();
Region GetLocalRegion();
std::int32_t GetLoginCaret();
std::string GetLoginMessage0();
std::string GetLoginMessage1();
std::string GetLoginMessage2();
std::int32_t GetLoginScreenX();
std::int32_t GetLoginState();
std::int32_t GetLoginWindow();
std::int32_t GetMapAngle();
std::vector<std::string> GetMenuActions();
std::int32_t GetMenuCount();
std::int32_t GetMenuHeight();
std::vector<std::string> GetMenuTargets();
bool GetMenuVisible();
std::int32_t GetMenuWidth();
std::int32_t GetMenuX();
std::int32_t GetMenuY();
std::int32_t GetMouseX();
std::int32_t GetMouseY();
AttackOption GetNPCAttackOption();
std::vector<std::int32_t> GetNPCIndices();
Cache GetNPCModelCache();
std::vector<NPC> GetNPCs();
std::string GetPassword();
AttackOption GetPlayerAttackOption();
Cache GetPlayerModelCache();
std::vector<Player> GetPlayers();
std::int32_t GetPressedItemIndex();
std::int32_t GetRunEnergy();
std::string GetSelectedItemName();
std::string GetSelectedSpellName();
std::vector<std::int32_t> GetSettings();
bool GetSpellSelected();
Cache GetSpotAnimationCache();
Cache GetSpotAnimationModelCache();
std::vector<std::vector<std::vector<std::int32_t>>> GetTileHeights();
std::vector<std::vector<std::vector<std::int8_t>>> GetTileSettings();
std::string GetUsername();
Cache GetVarbitCache();
std::vector<std::int32_t> GetVarbitSettings();
std::int32_t GetViewportHeight();
std::int32_t GetViewportScale();
std::int32_t GetViewportWidth();
std::int32_t GetWeight();
HashTable GetWidgetNodeCache();
std::vector<std::vector<Widget>> GetWidgets();
std::vector<std::int32_t> GetWidgetsHeight();
std::vector<std::int32_t> GetWidgetsWidth();
std::vector<std::int32_t> GetWidgetsX();
std::vector<std::int32_t> GetWidgetsY();
bool GetWorldSelectOpen();
std::vector<World> GetWorlds();
ItemInfo GetItemInfo(std::int32_t ID);
NPCInfo GetNPCInfo(std::int32_t ID);
ObjectInfo GetObjectInfo(std::int32_t ID);
bool LoadWorlds();
void SetWorld(const World& W);
extern GameShell Client;
Widget GetWidget(std::int32_t Container, std::int32_t Component); Cache GetAnimationCache();
Widget GetWidgetParent(const Widget& W); std::int32_t GetCameraPitch();
std::int32_t GetWidgetX(const Widget& W); std::int32_t GetCameraX();
std::int32_t GetWidgetY(const Widget& W); std::int32_t GetCameraY();
bool GetWidgetHidden(const Widget& W); std::int32_t GetCameraYaw();
Box GetWidgetBox(const Widget& W); std::int32_t GetCameraZ();
ItemContainer GetItemContainer(std::int32_t ID); Map GetChatLineCache();
NPC GetNPC(std::int32_t Index); std::int32_t GetClientPlane();
std::vector<Point> ProjectModel(const Model& M, std::int32_t LocalX, std::int32_t LocalY, Preferences GetClientPreferences();
std::int32_t LocalZ, std::int32_t Angle); std::int32_t GetClientX();
Model GetPlayerModel(std::int64_t ID); std::int32_t GetClientY();
Model GetNPCModel(std::int32_t ID); std::int32_t GetCrosshairState();
Varbit GetVarbit(std::int32_t ID); std::vector<std::int32_t> GetCurrentLevels();
Animation GetAnimation(std::int32_t ID); std::int32_t GetCurrentWorld();
Frames GetFrames(std::int32_t ID); bool GetDraggingItem();
Model GetItemModel(std::int32_t ID); Cache GetDynamicObjectCache();
Model GetItemModel(std::int32_t ID, std::int32_t Amount); std::vector<ExchangeOffer> GetExchangeOffers();
SpotAnimation GetSpotAnimation(std::int32_t ID); std::vector<std::int32_t> GetExperiences();
Model GetSpotAnimationModel(std::int32_t ID); bool GetFocused();
Model GetGameObjectModel(const GameObject& O); Cache GetFramesCache();
Model GetWallObjectModel(const WallObject& O); std::int32_t GetGameState();
Model GetDecorativeObjectModel(const DecorativeObject& O); std::int32_t GetGameTick();
Model GetGroundObjectModel(const GroundObject& O); Deque GetGraphicsObjects();
Model GetDynamicObjectModel(std::int32_t ID); std::vector<std::vector<std::vector<Deque>>> GetGroundItems();
std::vector<std::vector<Deque>> GetGroundItems(std::int32_t Plane); HashTable GetItemContainers();
Deque GetGroundItems(std::int32_t X, std::int32_t Y); Cache GetItemInfoCache();
Deque GetGroundItems(std::int32_t X, std::int32_t Y, std::int32_t Plane); Cache GetItemModelCache();
std::vector<Point> GetPlayerModel(const Player& P); std::int32_t GetItemSelected();
std::vector<Point> GetNPCModel(const NPC& N); std::int32_t GetItemSelectedIndex();
std::vector<Point> GetGraphicsObjectModel(const GraphicsObject& O); Cache GetItemSpriteCache();
SceneTile GetSceneTile(std::int32_t X, std::int32_t Y, std::int32_t Plane); std::vector<std::int32_t> GetLevels();
std::vector<std::vector<SceneTile>> GetSceneTiles(std::int32_t Plane); ClanMemberList GetLocalClanMemberList();
Point TileToMinimap(const Tile& T); std::int32_t GetLocalDestinationX();
std::int32_t GetTileItemHeight(std::int32_t X, std::int32_t Y, std::int32_t Plane); std::int32_t GetLocalDestinationY();
Sprite GetItemSprite(std::int32_t ID, std::int32_t Amount, std::int32_t BorderThickness, Player GetLocalPlayer();
std::int32_t ShadowColor, std::int32_t StackType); PlayerManager GetLocalPlayerManager();
Convex GetItemSpriteConvex(const Sprite& S); Region GetLocalRegion();
std::int32_t GetLoginCaret();
std::int32_t GetSettings(std::int32_t ID); std::string GetLoginMessage0();
std::int32_t GetVarbitSettings(std::int32_t VarbitSettingIndex); std::string GetLoginMessage1();
Point TileToMainscreen(const Tile& T, std::int32_t X, std::int32_t Y, std::int32_t Z); std::string GetLoginMessage2();
std::int32_t GetLoginScreenX();
std::int32_t GetLoginState();
std::int32_t GetLoginWindow();
std::int32_t GetMapAngle();
std::vector<std::string> GetMenuActions();
std::int32_t GetMenuCount();
std::int32_t GetMenuHeight();
std::vector<std::string> GetMenuTargets();
bool GetMenuVisible();
std::int32_t GetMenuWidth();
std::int32_t GetMenuX();
std::int32_t GetMenuY();
std::int32_t GetMouseX();
std::int32_t GetMouseY();
AttackOption GetNPCAttackOption();
std::vector<std::int32_t> GetNPCIndices();
Cache GetNPCModelCache();
std::vector<NPC> GetNPCs();
Cache GetObjectInfoCache();
std::string GetPassword();
AttackOption GetPlayerAttackOption();
Cache GetPlayerModelCache();
std::vector<Player> GetPlayers();
std::int32_t GetPressedItemIndex();
std::int32_t GetRunEnergy();
std::string GetSelectedItemName();
std::string GetSelectedSpellName();
std::vector<std::int32_t> GetSettings();
bool GetSpellSelected();
Cache GetSpotAnimationCache();
Cache GetSpotAnimationModelCache();
std::vector<std::vector<std::vector<std::int32_t>>> GetTileHeights();
std::vector<std::vector<std::vector<std::int8_t>>> GetTileSettings();
std::string GetUsername();
Cache GetVarbitCache();
std::vector<std::int32_t> GetVarbitSettings();
std::int32_t GetViewportHeight();
std::int32_t GetViewportScale();
std::int32_t GetViewportWidth();
std::int32_t GetWeight();
HashTable GetWidgetNodeCache();
std::vector<std::vector<Widget>> GetWidgets();
std::vector<std::int32_t> GetWidgetsHeight();
std::vector<std::int32_t> GetWidgetsWidth();
std::vector<std::int32_t> GetWidgetsX();
std::vector<std::int32_t> GetWidgetsY();
bool GetWorldSelectOpen();
std::vector<World> GetWorlds();
ItemInfo LoadItemInfo(std::int32_t ID);
NPCInfo LoadNPCInfo(std::int32_t ID);
ObjectInfo LoadObjectInfo(std::int32_t ID);
bool LoadWorlds();
void SetWorld(const World& W);
ItemInfo GetItemInfo(std::int32_t ID);
NPCInfo GetNPCInfo(std::int32_t ID);
ObjectInfo GetObjectInfo(std::int32_t ID);
Widget GetWidget(std::int32_t Container, std::int32_t Component);
Widget GetWidgetParent(const Widget& W);
std::int32_t GetWidgetX(const Widget& W);
std::int32_t GetWidgetY(const Widget& W);
bool GetWidgetHidden(const Widget& W);
Box GetWidgetBox(const Widget& W);
ItemContainer GetItemContainer(std::int32_t ID);
NPC GetNPC(std::int32_t Index);
std::vector<Point> ProjectModel(const Model& M, std::int32_t LocalX, std::int32_t LocalY,
std::int32_t LocalZ, std::int32_t Angle);
Model GetPlayerModel(std::int64_t ID);
Model GetNPCModel(std::int32_t ID);
Varbit GetVarbit(std::int32_t ID);
Animation GetAnimation(std::int32_t ID);
Frames GetFrames(std::int32_t ID);
Model GetItemModel(std::int32_t ID);
Model GetItemModel(std::int32_t ID, std::int32_t Amount);
SpotAnimation GetSpotAnimation(std::int32_t ID);
Model GetSpotAnimationModel(std::int32_t ID);
Model GetGameObjectModel(const GameObject& O);
Model GetWallObjectModel(const WallObject& O);
Model GetDecorativeObjectModel(const DecorativeObject& O);
Model GetGroundObjectModel(const GroundObject& O);
Model GetDynamicObjectModel(std::int32_t ID);
std::vector<std::vector<Deque>> GetGroundItems(std::int32_t Plane);
Deque GetGroundItems(std::int32_t X, std::int32_t Y);
Deque GetGroundItems(std::int32_t X, std::int32_t Y, std::int32_t Plane);
std::vector<Point> GetPlayerModel(const Player& P);
std::vector<Point> GetNPCModel(const NPC& N);
std::vector<Point> GetGraphicsObjectModel(const GraphicsObject& O);
SceneTile GetSceneTile(std::int32_t X, std::int32_t Y, std::int32_t Plane);
std::vector<std::vector<SceneTile>> GetSceneTiles(std::int32_t Plane);
Point TileToMinimap(const Tile& T);
std::int32_t GetTileItemHeight(std::int32_t X, std::int32_t Y, std::int32_t Plane);
Sprite GetItemSprite(std::int32_t ID, std::int32_t Amount, std::int32_t BorderThickness,
std::int32_t ShadowColor, std::int32_t StackType);
Convex GetItemSpriteConvex(const Sprite& S);
std::int32_t GetSettings(std::int32_t ID);
std::int32_t GetVarbitSettings(std::int32_t VarbitSettingIndex);
Point TileToMainscreen(const Tile& T, std::int32_t X, std::int32_t Y, std::int32_t Z);
}
#endif // INTERNAL_HPP_INCLUDED #endif // INTERNAL_HPP_INCLUDED

2
Include/Game/Core.hpp
View File

@ -37,6 +37,8 @@
#include "Models/NPCs.hpp" #include "Models/NPCs.hpp"
#include "Models/Players.hpp" #include "Models/Players.hpp"
#include "Interactable/GameObject.hpp"
// //
// DoxyGen // DoxyGen
//======================================================= //=======================================================

29
Include/Game/Interactable/GameObject.hpp Normal file
View File

@ -0,0 +1,29 @@
#ifndef INTERACTABLEGAMEOBJECT_HPP_INCLUDED
#define INTERACTABLEGAMEOBJECT_HPP_INCLUDED
#include "../../Core/Classes/GameObject.hpp"
#include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Convex.hpp"
#include <cstdint>
namespace Interactable
{
class GameObject : public Internal::GameObject
{
public:
GameObject(const Internal::GameObject& G);
GameObject(const GameObject& G);
std::int32_t GetID() const;
std::string GetName() const;
Tile GetTile() const;
Internal::ObjectInfo GetInfo() const;
std::vector<Point> GetModel() const;
Convex GetConvex() const;
};
}
#endif // INTERACTABLEGAMEOBJECT_HPP_INCLUDED

6
Include/Game/Interfaces/Chat.hpp
View File

@ -46,9 +46,9 @@ class Chat
} CHAT_TYPE; } CHAT_TYPE;
static std::vector<MessageNode> GetMessages(CHAT_TYPE Type); static std::vector<Internal::MessageNode> GetMessages(CHAT_TYPE Type);
static std::vector<MessageNode> GetMessages(CHAT_TYPE Type, bool Sort); static std::vector<Internal::MessageNode> GetMessages(CHAT_TYPE Type, bool Sort);
static MessageNode GetLastMessage(CHAT_TYPE Type); static Internal::MessageNode GetLastMessage(CHAT_TYPE Type);
static DIALOGUE_STATE GetDialogueState(); static DIALOGUE_STATE GetDialogueState();
static std::vector<std::string> GetDialogueOptions(); static std::vector<std::string> GetDialogueOptions();

4
Include/Game/Interfaces/GameTabs/Clan.hpp
View File

@ -12,8 +12,8 @@ class Clan
public: public:
static bool IsOpen(); static bool IsOpen();
static bool Open(); static bool Open();
static std::vector<ClanMember> GetAll(); static std::vector<Internal::ClanMember> GetAll();
static std::vector<ClanMember> GetAll(const std::function<bool (ClanMember&)>& Filter); static std::vector<Internal::ClanMember> GetAll(const std::function<bool (Internal::ClanMember&)>& Filter);
}; };
/** @} */ /** @} */

4
Include/Game/Interfaces/GameTabs/Friends.hpp
View File

@ -12,8 +12,8 @@ class Friends
public: public:
static bool IsOpen(); static bool IsOpen();
static bool Open(); static bool Open();
static std::vector<Friend> GetAll(); static std::vector<Internal::Friend> GetAll();
static std::vector<Friend> GetAll(const std::function<bool (Friend&)>& Filter); static std::vector<Internal::Friend> GetAll(const std::function<bool (Internal::Friend&)>& Filter);
}; };
/** @} */ /** @} */

4
Include/Game/Interfaces/GameTabs/Ignores.hpp
View File

@ -12,8 +12,8 @@ class Ignores
public: public:
static bool IsOpen(); static bool IsOpen();
static bool Open(); static bool Open();
static std::vector<Ignore> GetAll(); static std::vector<Internal::Ignore> GetAll();
static std::vector<Ignore> GetAll(const std::function<bool (Ignore&)>& Filter); static std::vector<Internal::Ignore> GetAll(const std::function<bool (Internal::Ignore&)>& Filter);
}; };
/** @} */ /** @} */

8
Include/Game/Interfaces/GameTabs/Logout.hpp
View File

@ -21,16 +21,16 @@ class Logout
static bool OpenWorldSwitcher(); static bool OpenWorldSwitcher();
static bool OpenWorldSwitcher(bool OpenInventory); static bool OpenWorldSwitcher(bool OpenInventory);
static bool WorldSwitcherScrollTo(World World); static bool WorldSwitcherScrollTo(Internal::World World);
static bool WorldSwitcherScrollTo(std::int32_t WorldID); static bool WorldSwitcherScrollTo(std::int32_t WorldID);
static bool SwitchWorld(World World); static bool SwitchWorld(Internal::World World);
static bool SwitchWorld(std::int32_t WorldID); static bool SwitchWorld(std::int32_t WorldID);
static std::vector<std::int32_t> GetFavoriteWorlds(); static std::vector<std::int32_t> GetFavoriteWorlds();
static Widget GetWorldWidget(World World); static Internal::Widget GetWorldWidget(Internal::World World);
static Widget GetWorldWidget(std::int32_t WorldID); static Internal::Widget GetWorldWidget(std::int32_t WorldID);
}; };
/** @} */ /** @} */

2
Include/Game/Interfaces/Login.hpp
View File

@ -41,7 +41,7 @@ class Login
static bool EnterCredentials(); static bool EnterCredentials();
static bool SelectWorld(); static bool SelectWorld();
static bool SelectWorld(World World); static bool SelectWorld(Internal::World World);
static bool SelectWorld(std::int32_t WorldID); static bool SelectWorld(std::int32_t WorldID);
static bool OpenWorldSelect(); static bool OpenWorldSelect();
static bool OpenWorldSelect(bool Close); static bool OpenWorldSelect(bool Close);

8
Include/Game/Interfaces/Mainscreen.hpp
View File

@ -35,11 +35,11 @@ class Mainscreen
static bool WaitIsUpText(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText); static bool WaitIsUpText(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText);
static bool WaitUpTextContains(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText); static bool WaitUpTextContains(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText);
static Character GetInteractingByIndex(std::uint32_t Index); static Internal::Character GetInteractingByIndex(std::uint32_t Index);
static Character GetInteracting(); //Returns the Character interacting with the Local Player static Internal::Character GetInteracting(); //Returns the Character interacting with the Local Player
static Character GetInteractingWith(const Character& C); //Returns the Character interactinng with the Character static Internal::Character GetInteractingWith(const Internal::Character& C); //Returns the Character interactinng with the Character
static bool IsInteracting(const Character& A, const Character& B); // True if A is interacting with B static bool IsInteracting(const Internal::Character& A, const Internal::Character& B); // True if A is interacting with B
static std::int32_t CameraX(); static std::int32_t CameraX();
static std::int32_t CameraY(); static std::int32_t CameraY();

28
Include/Game/Models/GroundItems.hpp
View File

@ -14,23 +14,23 @@
class GroundItems class GroundItems
{ {
public: public:
static std::vector<GroundItem> GetAll(); static std::vector<Internal::GroundItem> GetAll();
static std::vector<GroundItem> GetAll(Tile T); static std::vector<Internal::GroundItem> GetAll(Tile T);
static std::vector<GroundItem> GetAll(std::int32_t ID); static std::vector<Internal::GroundItem> GetAll(std::int32_t ID);
static std::vector<GroundItem> GetAll(const std::string& Name); static std::vector<Internal::GroundItem> GetAll(const std::string& Name);
static std::vector<GroundItem> GetAll(const std::vector<std::int32_t>& IDs); static std::vector<Internal::GroundItem> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<GroundItem> GetAll(const std::vector<std::string>& Names); static std::vector<Internal::GroundItem> GetAll(const std::vector<std::string>& Names);
static std::vector<GroundItem> GetAll(const std::function<bool (GroundItem&)>& Filter); static std::vector<Internal::GroundItem> GetAll(const std::function<bool (Internal::GroundItem&)>& Filter);
static GroundItem Get(Tile T); static Internal::GroundItem Get(Tile T);
static GroundItem Get(std::int32_t ID); static Internal::GroundItem Get(std::int32_t ID);
static GroundItem Get(const std::string& Name); static Internal::GroundItem Get(const std::string& Name);
static GroundItem Get(const std::vector<std::int32_t>& IDs); static Internal::GroundItem Get(const std::vector<std::int32_t>& IDs);
static GroundItem Get(const std::vector<std::string>& Names); static Internal::GroundItem Get(const std::vector<std::string>& Names);
static Tile GetTileOf(GroundItem G); static Tile GetTileOf(Internal::GroundItem G);
static Convex GetConvexOf(GroundItem G); static Convex GetConvexOf(Internal::GroundItem G);
}; };
/** @} */ /** @} */

32
Include/Game/Models/NPCs.hpp
View File

@ -15,25 +15,25 @@
class NPCs class NPCs
{ {
public: public:
static std::vector<NPC> GetAll(); static std::vector<Internal::NPC> GetAll();
static std::vector<NPC> GetAll(const Tile& Tile); static std::vector<Internal::NPC> GetAll(const Tile& Tile);
static std::vector<NPC> GetAll(std::int32_t ID); static std::vector<Internal::NPC> GetAll(std::int32_t ID);
static std::vector<NPC> GetAll(const std::string& Name); static std::vector<Internal::NPC> GetAll(const std::string& Name);
static std::vector<NPC> GetAll(const std::vector<std::int32_t>& IDs); static std::vector<Internal::NPC> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<NPC> GetAll(const std::vector<std::string>& Names); static std::vector<Internal::NPC> GetAll(const std::vector<std::string>& Names);
static std::vector<NPC> GetAll(const std::function<bool (NPC&)>& Filter); static std::vector<Internal::NPC> GetAll(const std::function<bool (Internal::NPC&)>& Filter);
static NPC Get(); static Internal::NPC Get();
static NPC Get(const Tile& Tile); static Internal::NPC Get(const Tile& Tile);
static NPC Get(std::int32_t ID); static Internal::NPC Get(std::int32_t ID);
static NPC Get(const std::string& Name); static Internal::NPC Get(const std::string& Name);
static NPC Get(const std::vector<std::int32_t>& IDs); static Internal::NPC Get(const std::vector<std::int32_t>& IDs);
static NPC Get(const std::vector<std::string>& Names); static Internal::NPC Get(const std::vector<std::string>& Names);
static NPC Get(const std::function<bool (NPC&)>& Filter); static Internal::NPC Get(const std::function<bool (Internal::NPC&)>& Filter);
static Tile GetTileOf(const NPC& NPC); static Tile GetTileOf(const Internal::NPC& NPC);
static Convex GetConvexOf(const NPC& NPC); static Convex GetConvexOf(const Internal::NPC& NPC);
}; };
/** @} */ /** @} */

26
Include/Game/Models/Players.hpp
View File

@ -14,22 +14,22 @@
class Players class Players
{ {
public: public:
static Player GetLocal(); static Internal::Player GetLocal();
static std::vector<Player> GetAll(); static std::vector<Internal::Player> GetAll();
static std::vector<Player> GetAll(const Tile& Tile); static std::vector<Internal::Player> GetAll(const Tile& Tile);
static std::vector<Player> GetAll(const std::string& Name); static std::vector<Internal::Player> GetAll(const std::string& Name);
static std::vector<Player> GetAll(const std::vector<std::string>& Names); static std::vector<Internal::Player> GetAll(const std::vector<std::string>& Names);
static std::vector<Player> GetAll(const std::function<bool (Player&)>& Filter); static std::vector<Internal::Player> GetAll(const std::function<bool (Internal::Player&)>& Filter);
static Player Get(); static Internal::Player Get();
static Player Get(const Tile& Tile); static Internal::Player Get(const Tile& Tile);
static Player Get(const std::string& Name); static Internal::Player Get(const std::string& Name);
static Player Get(const std::vector<std::string>& Names); static Internal::Player Get(const std::vector<std::string>& Names);
static Player Get(const std::function<bool (Player&)>& Filter); static Internal::Player Get(const std::function<bool (Internal::Player&)>& Filter);
static Tile GetTileOf(const Player& P); static Tile GetTileOf(const Internal::Player& P);
static Convex GetConvexOf(const Player& P); static Convex GetConvexOf(const Internal::Player& P);
}; };
/** @} */ /** @} */

42
Include/Game/Models/SceneObjects.hpp
View File

@ -36,10 +36,10 @@ class SceneObjects
static std::vector<Object> GetAll(const std::vector<std::int32_t>& PossibleIDs, OBJECT_TYPE ObjectTypes = ALL); static std::vector<Object> GetAll(const std::vector<std::int32_t>& PossibleIDs, OBJECT_TYPE ObjectTypes = ALL);
static std::vector<Object> GetAll(const std::vector<std::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL); static std::vector<Object> GetAll(const std::vector<std::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL);
static std::vector<GameObject> GetAll(const std::function<bool (GameObject&)>& Filter); static std::vector<Internal::GameObject> GetAll(const std::function<bool (Internal::GameObject&)>& Filter);
static std::vector<DecorativeObject> GetAll(const std::function<bool (DecorativeObject&)>& Filter); static std::vector<Internal::DecorativeObject> GetAll(const std::function<bool (Internal::DecorativeObject&)>& Filter);
static std::vector<GroundObject> GetAll(const std::function<bool (GroundObject&)>& Filter); static std::vector<Internal::GroundObject> GetAll(const std::function<bool (Internal::GroundObject&)>& Filter);
static std::vector<WallObject> GetAll(const std::function<bool (WallObject&)>& Filter); static std::vector<Internal::WallObject> GetAll(const std::function<bool (Internal::WallObject&)>& Filter);
static Object Get(const Tile& T, OBJECT_TYPE ObjectTypes = ALL); static Object Get(const Tile& T, OBJECT_TYPE ObjectTypes = ALL);
static Object Get(std::int32_t ID, OBJECT_TYPE ObjectTypes = ALL); static Object Get(std::int32_t ID, OBJECT_TYPE ObjectTypes = ALL);
@ -47,26 +47,26 @@ class SceneObjects
static Object Get(const std::vector<std::int32_t>& PossibleIDs, OBJECT_TYPE ObjectTypes = ALL); static Object Get(const std::vector<std::int32_t>& PossibleIDs, OBJECT_TYPE ObjectTypes = ALL);
static Object Get(const std::vector<std::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL); static Object Get(const std::vector<std::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL);
static GameObject Get(const std::function<bool (GameObject&)>& Filter); static Internal::GameObject Get(const std::function<bool (Internal::GameObject&)>& Filter);
static DecorativeObject Get(const std::function<bool (DecorativeObject&)>& Filter); static Internal::DecorativeObject Get(const std::function<bool (Internal::DecorativeObject&)>& Filter);
static GroundObject Get(const std::function<bool (GroundObject&)>& Filter); static Internal::GroundObject Get(const std::function<bool (Internal::GroundObject&)>& Filter);
static WallObject Get(const std::function<bool (WallObject&)>& Filter); static Internal::WallObject Get(const std::function<bool (Internal::WallObject&)>& Filter);
static ObjectInfo GetInfoOf(const Object& O); static Internal::ObjectInfo GetInfoOf(const Object& O);
static ObjectInfo GetInfoOf(const GameObject& G); static Internal::ObjectInfo GetInfoOf(const Internal::GameObject& G);
static ObjectInfo GetInfoOf(const DecorativeObject& D); static Internal::ObjectInfo GetInfoOf(const Internal::DecorativeObject& D);
static ObjectInfo GetInfoOf(const GroundObject& G); static Internal::ObjectInfo GetInfoOf(const Internal::GroundObject& G);
static ObjectInfo GetInfoOf(const WallObject& W); static Internal::ObjectInfo GetInfoOf(const Internal::WallObject& W);
static Tile GetTileOf(const GameObject& G); static Tile GetTileOf(const Internal::GameObject& G);
static Tile GetTileOf(const DecorativeObject& D); static Tile GetTileOf(const Internal::DecorativeObject& D);
static Tile GetTileOf(const GroundObject& G); static Tile GetTileOf(const Internal::GroundObject& G);
static Tile GetTileOf(const WallObject& W); static Tile GetTileOf(const Internal::WallObject& W);
static Convex GetConvexOf(const GameObject& G); static Convex GetConvexOf(const Internal::GameObject& G);
static Convex GetConvexOf(const DecorativeObject& D); static Convex GetConvexOf(const Internal::DecorativeObject& D);
static Convex GetConvexOf(const GroundObject& G); static Convex GetConvexOf(const Internal::GroundObject& G);
static Convex GetConvexOf(const WallObject& W); static Convex GetConvexOf(const Internal::WallObject& W);
}; };
/** @} */ /** @} */

42
Include/Game/Tools/Interact.hpp
View File

@ -30,37 +30,37 @@ class Interact
static bool Click(Box B, const std::string& Action, const std::string& Target = ""); static bool Click(Box B, const std::string& Action, const std::string& Target = "");
static bool Click(Box B, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""}); static bool Click(Box B, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""});
static bool Click(Widget W, Button Button = BUTTON_LEFT); static bool Click(Internal::Widget W, Button Button = BUTTON_LEFT);
static bool Click(Widget W, const std::string& Action, const std::string& Target = ""); static bool Click(Internal::Widget W, const std::string& Action, const std::string& Target = "");
static bool Click(Widget W, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""}); static bool Click(Internal::Widget W, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""});
static bool Click(Convex C, Button Button = BUTTON_LEFT); static bool Click(Convex C, Button Button = BUTTON_LEFT);
static bool Click(Convex C, const std::string& Action, const std::string& Target = ""); static bool Click(Convex C, const std::string& Action, const std::string& Target = "");
static bool Click(Convex C, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""}); static bool Click(Convex C, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""});
static bool Click(GroundItem G, Button Button = BUTTON_LEFT); static bool Click(Internal::GroundItem G, Button Button = BUTTON_LEFT);
static bool Click(GroundItem G, const std::string& Action); static bool Click(Internal::GroundItem G, const std::string& Action);
static bool Click(GroundItem G, const std::vector<std::string>& PossibleActions); static bool Click(Internal::GroundItem G, const std::vector<std::string>& PossibleActions);
static bool Click(NPC N, Button Button = BUTTON_LEFT); static bool Click(Internal::NPC N, Button Button = BUTTON_LEFT);
static bool Click(NPC N, const std::string& Action); static bool Click(Internal::NPC N, const std::string& Action);
static bool Click(NPC N, const std::vector<std::string>& PossibleActions); static bool Click(Internal::NPC N, const std::vector<std::string>& PossibleActions);
static bool Click(Player P, Button Button = BUTTON_LEFT); static bool Click(Internal::Player P, Button Button = BUTTON_LEFT);
static bool Click(Player P, const std::string& Action); static bool Click(Internal::Player P, const std::string& Action);
static bool Click(Player P, const std::vector<std::string>& PossibleActions); static bool Click(Internal::Player P, const std::vector<std::string>& PossibleActions);
static bool Click(GameObject G, Button Button = BUTTON_LEFT); static bool Click(Internal::GameObject G, Button Button = BUTTON_LEFT);
static bool Click(GameObject G, const std::string& Action); static bool Click(Internal::GameObject G, const std::string& Action);
static bool Click(GameObject G, const std::vector<std::string>& PossibleActions); static bool Click(Internal::GameObject G, const std::vector<std::string>& PossibleActions);
static bool Click(GroundObject G, Button Button = BUTTON_LEFT); static bool Click(Internal::GroundObject G, Button Button = BUTTON_LEFT);
static bool Click(GroundObject G, const std::string& Action); static bool Click(Internal::GroundObject G, const std::string& Action);
static bool Click(GroundObject G, const std::vector<std::string>& PossibleActions); static bool Click(Internal::GroundObject G, const std::vector<std::string>& PossibleActions);
static bool Click(WallObject W, Button Button = BUTTON_LEFT); static bool Click(Internal::WallObject W, Button Button = BUTTON_LEFT);
static bool Click(WallObject W, const std::string& Action); static bool Click(Internal::WallObject W, const std::string& Action);
static bool Click(WallObject W, const std::vector<std::string>& PossibleActions); static bool Click(Internal::WallObject W, const std::vector<std::string>& PossibleActions);
static bool UpKey(std::int32_t Key); static bool UpKey(std::int32_t Key);
static bool DownKey(std::int32_t Key); static bool DownKey(std::int32_t Key);

20
Include/Game/Tools/Widgets.hpp
View File

@ -19,7 +19,7 @@ class Widgets
* bool InventoryHidden = Widgets::IsHidden(Inventory); * bool InventoryHidden = Widgets::IsHidden(Inventory);
* @endcode * @endcode
*/ */
static bool IsHidden(const Widget& W); static bool IsHidden(const Internal::Widget& W);
/** /**
* @brief Returns the Box of the passed Widget * @brief Returns the Box of the passed Widget
* @code * @code
@ -27,7 +27,7 @@ class Widgets
* Box BankInventoryBox = Widgets::GetBox(BankInventory); * Box BankInventoryBox = Widgets::GetBox(BankInventory);
* @endcode * @endcode
*/ */
static Box GetBox(const Widget& W); static Box GetBox(const Internal::Widget& W);
/** /**
* @brief Returns the absolute X of the passed Widget * @brief Returns the absolute X of the passed Widget
* @code * @code
@ -35,7 +35,7 @@ class Widgets
* std::int32_t BankInventoryX = Widgets::GetX(BankInventory); * std::int32_t BankInventoryX = Widgets::GetX(BankInventory);
* @endcode * @endcode
*/ */
static std::int32_t GetX(const Widget& W); static std::int32_t GetX(const Internal::Widget& W);
/** /**
* @brief Returns the absolute Y of the passed Widget * @brief Returns the absolute Y of the passed Widget
* @code * @code
@ -43,34 +43,34 @@ class Widgets
* std::int32_t BankInventoryY = Widgets::GetX(BankInventory); * std::int32_t BankInventoryY = Widgets::GetX(BankInventory);
* @endcode * @endcode
*/ */
static std::int32_t GetY(const Widget& W); static std::int32_t GetY(const Internal::Widget& W);
/** /**
* @brief (Temp) Returns the ItemIDs of the passed Widget * @brief (Temp) Returns the ItemIDs of the passed Widget
* @note Temporary function, this should be used over Widget.GetItemIDs() * @note Temporary function, this should be used over Widget.GetItemIDs()
*/ */
static std::vector<std::int32_t> GetItemIDs(const Widget& W); static std::vector<std::int32_t> GetItemIDs(const Internal::Widget& W);
/** /**
* @brief Returns a vector of All Loaded Widgets * @brief Returns a vector of All Loaded Widgets
* @code std::vector<Widget> Widgets = Widgets::GetAll(); @endcode * @code std::vector<Widget> Widgets = Widgets::GetAll(); @endcode
*/ */
static std::vector<Widget> GetAll(); static std::vector<Internal::Widget> GetAll();
/** /**
* @brief Returns the specified Widget by Parent ID * @brief Returns the specified Widget by Parent ID
* @code Widget BankParent = Widgets::Get(15); @endcode * @code Widget BankParent = Widgets::Get(15); @endcode
*/ */
static Widget Get(std::int32_t Parent); static Internal::Widget Get(std::int32_t Parent);
/** /**
* @brief Returns the specified Widget by Parent, and Child ID * @brief Returns the specified Widget by Parent, and Child ID
* @code Widget BankInventory = Widgets::Get(15, 3); @endcode * @code Widget BankInventory = Widgets::Get(15, 3); @endcode
*/ */
static Widget Get(std::int32_t Parent, std::int32_t Child); static Internal::Widget Get(std::int32_t Parent, std::int32_t Child);
/** /**
* @brief Returns the specified Widget by Parent, and Child, and Grandchild ID * @brief Returns the specified Widget by Parent, and Child, and Grandchild ID
* @code Widget BankCloseButton = Widgets::Get(12, 3, 11); @endcode * @code Widget BankCloseButton = Widgets::Get(12, 3, 11); @endcode
*/ */
static Widget Get(std::int32_t Parent, std::int32_t Child, std::int32_t Grandchild); static Internal::Widget Get(std::int32_t Parent, std::int32_t Child, std::int32_t Grandchild);
/** /**
* @brief Returns a vector of all Widgets that pass the specified Filter @see LibraryFilterLambdas * @brief Returns a vector of all Widgets that pass the specified Filter @see LibraryFilterLambdas
* @code * @code
@ -78,7 +78,7 @@ class Widgets
* std::vector<Widget> Widgets = Widgets::Get(WTextEquals); @endcode * std::vector<Widget> Widgets = Widgets::Get(WTextEquals); @endcode
* Will return all Widgets whose Text equals Enter Amount * Will return all Widgets whose Text equals Enter Amount
*/ */
static std::vector<Widget> Get(const std::function<bool (Widget&)>& Filter); static std::vector<Internal::Widget> Get(const std::function<bool (Internal::Widget&)>& Filter);
}; };

16
Include/Game/Tools/Worlds.hpp
View File

@ -15,23 +15,23 @@ class Worlds
static bool Refresh(); static bool Refresh();
static bool Refresh(bool ExitWorldSelection); static bool Refresh(bool ExitWorldSelection);
static bool SwitchWorld(World World); static bool SwitchWorld(Internal::World World);
static bool SwitchWorld(std::int32_t WorldID); static bool SwitchWorld(std::int32_t WorldID);
static std::int32_t GetCurrent(); static std::int32_t GetCurrent();
static std::vector<World> GetAll(); static std::vector<Internal::World> GetAll();
static std::int32_t GetIndexOf(World World); static std::int32_t GetIndexOf(Internal::World World);
static std::int32_t GetIndexOf(std::int32_t WorldID); static std::int32_t GetIndexOf(std::int32_t WorldID);
static std::vector<World> GetF2P(); static std::vector<Internal::World> GetF2P();
static std::vector<World> GetP2P(); static std::vector<Internal::World> GetP2P();
static bool IsP2P(World World); static bool IsP2P(Internal::World World);
static bool IsP2P(std::int32_t WorldID); static bool IsP2P(std::int32_t WorldID);
static World GetBy(std::int32_t WorldID); static Internal::World GetBy(std::int32_t WorldID);
static std::vector<World> GetBy(const std::function<bool (World&)>& Filter); static std::vector<Internal::World> GetBy(const std::function<bool (Internal::World&)>& Filter);
}; };
/** @} */ /** @} */

BIN
Library/libAlpacaLibrary.a
View File

Binary file not shown.