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

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

@ -6,8 +6,10 @@
#include <vector>
#include <cstdint>
class Animation : public CacheableNode
namespace Internal
{
class Animation : public CacheableNode
{
public:
Animation();
Animation(const void* Obj);
@ -19,6 +21,7 @@ class Animation : public CacheableNode
std::int32_t GetLeftHandItem() const;
std::int32_t GetRightHandItem() const;
};
};
}
#endif // ANIMATION_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class AttackOption : public Object
namespace Internal
{
class AttackOption : public Object
{
public:
AttackOption();
AttackOption(const void* Obj);
@ -15,6 +17,7 @@ class AttackOption : public Object
std::int32_t GetType() const;
};
};
}
#endif // ATTACKOPTION_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include "HashTable.hpp"
#include "Queue.hpp"
class Cache : public Object
namespace Internal
{
class Cache : public Object
{
public:
Cache();
Cache(const void* Obj);
@ -17,6 +19,7 @@ class Cache : public Object
HashTable GetHashTable() const;
Queue GetQueue() const;
};
};
}
#endif // CACHE_HPP_INCLUDED

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

@ -4,8 +4,10 @@
#include "Node.hpp"
#include "../JavaClass/Class.hpp"
class CacheableNode : public Node
namespace Internal
{
class CacheableNode : public Node
{
public:
CacheableNode();
CacheableNode(const void* Obj);
@ -15,6 +17,7 @@ class CacheableNode : public Node
CacheableNode GetNext() const;
CacheableNode GetPrev() const;
};
};
}
#endif // CACHEABLENODE_HPP_INCLUDED

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

@ -8,8 +8,10 @@
#include <string>
#include <vector>
class Character : public Renderable
namespace Internal
{
class Character : public Renderable
{
public:
Character();
Character(const void* Obj);
@ -33,6 +35,7 @@ class Character : public Renderable
std::int32_t GetX() const;
std::int32_t GetY() const;
};
};
}
#endif // CHARACTER_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include <vector>
#include "MessageNode.hpp"
class ChatLineBuffer : public Object
namespace Internal
{
class ChatLineBuffer : public Object
{
public:
ChatLineBuffer();
ChatLineBuffer(const void* Obj);
@ -18,6 +20,7 @@ class ChatLineBuffer : public Object
std::int32_t GetLength() const;
std::vector<MessageNode> GetLines() const;
};
};
}
#endif // CHATLINEBUFFER_HPP_INCLUDED

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

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

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

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

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

@ -6,8 +6,10 @@
#include <cstdint>
#include "Renderable.hpp"
class DecorativeObject : public Object
namespace Internal
{
class DecorativeObject : public Object
{
public:
DecorativeObject();
DecorativeObject(const void* Obj);
@ -25,6 +27,7 @@ class DecorativeObject : public Object
std::int32_t GetX() const;
std::int32_t GetY() const;
};
};
}
#endif // DECORATIVEOBJECT_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include "Node.hpp"
class Deque : public Object
namespace Internal
{
class Deque : public Object
{
public:
Deque();
Deque(const void* Obj);
@ -16,6 +18,7 @@ class Deque : public Object
Node GetHead() const;
Node GetTail() const;
};
};
}
#endif // DEQUE_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class DynamicObject : public Renderable
namespace Internal
{
class DynamicObject : public Renderable
{
public:
DynamicObject();
DynamicObject(const void* Obj);
@ -16,6 +18,7 @@ class DynamicObject : public Renderable
std::int32_t GetID() const;
std::int32_t GetOrientation() const;
std::int32_t GetType() const;
};
};
}
#endif // DYNAMICOBJECT_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class ExchangeOffer : public Object
namespace Internal
{
class ExchangeOffer : public Object
{
public:
ExchangeOffer();
ExchangeOffer(const void* Obj);
@ -18,6 +20,7 @@ class ExchangeOffer : public Object
std::int8_t GetProgress() const;
std::int32_t GetTotalAmount() const;
};
};
}
#endif // EXCHANGEOFFER_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include <cstdint>
#include "FrameMap.hpp"
class Frame : public Object
namespace Internal
{
class Frame : public Object
{
public:
Frame();
Frame(const void* Obj);
@ -23,6 +25,7 @@ class Frame : public Object
std::vector<std::int32_t> GetTranslatorZ() const;
std::int32_t GetTranslatorsLength() const;
};
};
}
#endif // FRAME_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <vector>
#include <cstdint>
class FrameMap : public Node
namespace Internal
{
class FrameMap : public Node
{
public:
FrameMap();
FrameMap(const void* Obj);
@ -17,6 +19,7 @@ class FrameMap : public Node
std::vector<std::vector<std::int32_t>> GetList() const;
std::vector<std::int32_t> GetTypes() const;
};
};
}
#endif // FRAMEMAP_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <vector>
#include "Frame.hpp"
class Frames : public CacheableNode
namespace Internal
{
class Frames : public CacheableNode
{
public:
Frames();
Frames(const void* Obj);
@ -16,6 +18,7 @@ class Frames : public CacheableNode
std::vector<Frame> GetSkeletons() const;
};
};
}
#endif // FRAMES_HPP_INCLUDED

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

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

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

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

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

@ -6,8 +6,10 @@
#include <cstdint>
#include "Renderable.hpp"
class GameObject : public Object
namespace Internal
{
class GameObject : public Object
{
public:
GameObject();
GameObject(const void* Obj);
@ -27,6 +29,7 @@ class GameObject : public Object
std::int32_t GetX() const;
std::int32_t GetY() const;
};
};
}
#endif // GAMEOBJECT_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include "../JavaClass/Canvas.hpp"
class GameShell : public Object
namespace Internal
{
class GameShell : public Object
{
public:
GameShell();
GameShell(const void* Obj);
@ -15,6 +17,7 @@ class GameShell : public Object
Canvas GetCanvas() const;
};
};
}
#endif // GAMESHELL_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include "Animation.hpp"
#include <cstdint>
class GraphicsObject : public Renderable
namespace Internal
{
class GraphicsObject : public Renderable
{
public:
GraphicsObject();
GraphicsObject(const void* Obj);
@ -23,6 +25,7 @@ class GraphicsObject : public Renderable
std::int32_t GetX() const;
std::int32_t GetY() const;
};
};
}
#endif // GRAPHICSOBJECT_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class GroundItem : public Renderable
namespace Internal
{
class GroundItem : public Renderable
{
public:
GroundItem();
GroundItem(const void* Obj);
@ -16,6 +18,7 @@ class GroundItem : public Renderable
std::int32_t GetAmount() const;
std::int32_t GetID() const;
};
};
}
#endif // GROUNDITEM_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <cstdint>
#include "Renderable.hpp"
class GroundObject : public Object
namespace Internal
{
class GroundObject : public Object
{
public:
GroundObject();
GroundObject(const void* Obj);
@ -21,6 +23,7 @@ class GroundObject : public Object
std::int32_t GetX() const;
std::int32_t GetY() const;
};
};
}
#endif // GROUNDOBJECT_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include "Node.hpp"
#include <cstdint>
class HashTable : public Object
namespace Internal
{
class HashTable : public Object
{
public:
HashTable();
HashTable(const void* Obj);
@ -19,6 +21,7 @@ class HashTable : public Object
std::int32_t GetIndex() const;
std::int32_t GetSize() const;
};
};
}
#endif // HASHTABLE_HPP_INCLUDED

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

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

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

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

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

@ -6,8 +6,10 @@
#include <vector>
#include <cstdint>
class ItemContainer : public Node
namespace Internal
{
class ItemContainer : public Node
{
public:
ItemContainer();
ItemContainer(const void* Obj);
@ -17,6 +19,7 @@ class ItemContainer : public Node
std::vector<std::int32_t> GetItemAmounts() const;
std::vector<std::int32_t> GetItemIDs() const;
};
};
}
#endif // ITEMCONTAINER_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include <string>
#include <cstdint>
class ItemInfo : public CacheableNode
namespace Internal
{
class ItemInfo : public CacheableNode
{
public:
ItemInfo();
ItemInfo(const void* Obj);
@ -27,6 +29,7 @@ class ItemInfo : public CacheableNode
std::vector<std::int32_t> GetStackModelIDs() const;
std::int32_t GetStackable() const;
};
};
}
#endif // ITEMINFO_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include "Node.hpp"
class LinkedList : public Object
namespace Internal
{
class LinkedList : public Object
{
public:
LinkedList();
LinkedList(const void* Obj);
@ -16,6 +18,7 @@ class LinkedList : public Object
Node GetHead() const;
Node GetTail() const;
};
};
}
#endif // LINKEDLIST_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <cstdint>
#include <string>
class MessageNode : public CacheableNode
namespace Internal
{
class MessageNode : public CacheableNode
{
public:
MessageNode();
MessageNode(const void* Obj);
@ -21,6 +23,7 @@ class MessageNode : public CacheableNode
std::int32_t GetTick() const;
std::int32_t GetType() const;
};
};
}
#endif // MESSAGENODE_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <vector>
#include <cstdint>
class Model : public Renderable
namespace Internal
{
class Model : public Renderable
{
public:
Model();
Model(const void* Obj);
@ -24,6 +26,7 @@ class Model : public Renderable
std::vector<std::int32_t> GetVerticesY() const;
std::vector<std::int32_t> GetVerticesZ() const;
};
};
}
#endif // MODEL_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include "NPCInfo.hpp"
class NPC : public Character
namespace Internal
{
class NPC : public Character
{
public:
NPC();
NPC(const void* Obj);
@ -15,6 +17,7 @@ class NPC : public Character
NPCInfo GetInfo() const;
};
};
}
#endif // NPC_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include <string>
#include <cstdint>
class NPCInfo : public CacheableNode
namespace Internal
{
class NPCInfo : public CacheableNode
{
public:
NPCInfo();
NPCInfo(const void* Obj);
@ -28,6 +30,7 @@ class NPCInfo : public CacheableNode
std::int32_t GetVarbitID() const;
bool GetVisible() const;
};
};
}
#endif // NPCINFO_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <string>
class NamePair : public Object
namespace Internal
{
class NamePair : public Object
{
public:
NamePair();
NamePair(const void* Obj);
@ -16,6 +18,7 @@ class NamePair : public Object
std::string GetCleanName() const;
std::string GetName() const;
};
};
}
#endif // NAMEPAIR_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include "NamePair.hpp"
class Nameable : public Object
namespace Internal
{
class Nameable : public Object
{
public:
Nameable();
Nameable(const void* Obj);
@ -15,7 +17,7 @@ class Nameable : public Object
NamePair GetNamePair() const;
};
};
}
#endif // NAMEABLE_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <vector>
#include "Nameable.hpp"
class NameableContainer : public Object
namespace Internal
{
class NameableContainer : public Object
{
public:
NameableContainer();
NameableContainer(const void* Obj);
@ -17,6 +19,7 @@ class NameableContainer : public Object
std::vector<Nameable> GetNameables() const;
std::int32_t GetSize() const;
};
};
}
#endif // NAMEABLECONTAINER_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class Node : public Object
namespace Internal
{
class Node : public Object
{
public:
Node();
Node(const void* Obj);
@ -17,6 +19,7 @@ class Node : public Object
Node GetPrev() const;
std::int64_t GetUID() const;
};
};
}
#endif // NODE_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include <string>
#include <cstdint>
class ObjectInfo : public CacheableNode
namespace Internal
{
class ObjectInfo : public CacheableNode
{
public:
ObjectInfo();
ObjectInfo(const void* Obj);
@ -24,6 +26,7 @@ class ObjectInfo : public CacheableNode
std::int32_t GetSettingID() const;
std::int32_t GetVarbitID() const;
};
};
}
#endif // OBJECTINFO_HPP_INCLUDED

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

@ -9,8 +9,10 @@
#include "PlayerInfo.hpp"
#include "NamePair.hpp"
class Player : public Character
namespace Internal
{
class Player : public Character
{
public:
Player();
Player(const void* Obj);
@ -27,6 +29,7 @@ class Player : public Character
std::int32_t GetTeam() const;
std::int32_t GetTotalLevel() const;
};
};
}
#endif // PLAYER_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <vector>
#include <cstdint>
class PlayerInfo : public Object
namespace Internal
{
class PlayerInfo : public Object
{
public:
PlayerInfo();
PlayerInfo(const void* Obj);
@ -20,6 +22,7 @@ class PlayerInfo : public Object
std::int64_t GetModelID() const;
std::int32_t GetNPCModelID() const;
};
};
}
#endif // PLAYERINFO_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include "FriendList.hpp"
#include "IgnoreList.hpp"
class PlayerManager : public Object
namespace Internal
{
class PlayerManager : public Object
{
public:
PlayerManager();
PlayerManager(const void* Obj);
@ -17,6 +19,7 @@ class PlayerManager : public Object
FriendList GetFriendList() const;
IgnoreList GetIgnoreList() const;
};
};
}
#endif // PLAYERMANAGER_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include <cstdint>
#include <string>
class Preferences : public Object
namespace Internal
{
class Preferences : public Object
{
public:
Preferences();
Preferences(const void* Obj);
@ -22,6 +24,7 @@ class Preferences : public Object
std::string GetUsernameCached() const;
bool GetUsernameHidden() const;
};
};
}
#endif // PREFERENCES_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include "CacheableNode.hpp"
class Queue : public Object
namespace Internal
{
class Queue : public Object
{
public:
Queue();
Queue(const void* Obj);
@ -15,6 +17,7 @@ class Queue : public Object
CacheableNode GetHead() const;
};
};
}
#endif // QUEUE_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include "GameObject.hpp"
#include "SceneTile.hpp"
class Region : public Object
namespace Internal
{
class Region : public Object
{
public:
Region();
Region(const void* Obj);
@ -18,6 +20,7 @@ class Region : public Object
std::vector<GameObject> GetGameObjects() const;
std::vector<std::vector<std::vector<SceneTile>>> GetSceneTiles() const;
};
};
}
#endif // REGION_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class Renderable : public CacheableNode
namespace Internal
{
class Renderable : public CacheableNode
{
public:
Renderable();
Renderable(const void* Obj);
@ -15,6 +17,7 @@ class Renderable : public CacheableNode
std::int32_t GetModelHeight() const;
};
};
}
#endif // RENDERABLE_HPP_INCLUDED

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

@ -10,8 +10,10 @@
#include <cstdint>
#include "WallObject.hpp"
class SceneTile : public Node
namespace Internal
{
class SceneTile : public Node
{
public:
SceneTile();
SceneTile(const void* Obj);
@ -26,6 +28,7 @@ class SceneTile : public Node
std::int32_t GetX() const;
std::int32_t GetY() const;
};
};
}
#endif // SCENETILE_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class SpotAnimation : public CacheableNode
namespace Internal
{
class SpotAnimation : public CacheableNode
{
public:
SpotAnimation();
SpotAnimation(const void* Obj);
@ -19,6 +21,7 @@ class SpotAnimation : public CacheableNode
std::int32_t GetScaleX() const;
std::int32_t GetScaleY() const;
};
};
}
#endif // SPOTANIMATION_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <cstdint>
#include <vector>
class Sprite : public Object
namespace Internal
{
class Sprite : public Object
{
public:
Sprite();
Sprite(const void* Obj);
@ -18,6 +20,7 @@ class Sprite : public Object
std::vector<std::int32_t> GetPixels() const;
std::int32_t GetWidth() const;
};
};
}
#endif // SPRITE_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class Talkable : public Nameable
namespace Internal
{
class Talkable : public Nameable
{
public:
Talkable();
Talkable(const void* Obj);
@ -16,6 +18,7 @@ class Talkable : public Nameable
std::int32_t GetRank() const;
std::int32_t GetWorld() const;
};
};
}
#endif // TALKABLE_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class Varbit : public CacheableNode
namespace Internal
{
class Varbit : public CacheableNode
{
public:
Varbit();
Varbit(const void* Obj);
@ -17,6 +19,7 @@ class Varbit : public CacheableNode
std::int32_t GetMSB() const;
std::int32_t GetSettingID() const;
};
};
}
#endif // VARBIT_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <cstdint>
#include "Renderable.hpp"
class WallObject : public Object
namespace Internal
{
class WallObject : public Object
{
public:
WallObject();
WallObject(const void* Obj);
@ -23,6 +25,7 @@ class WallObject : public Object
std::int32_t GetX() const;
std::int32_t GetY() const;
};
};
}
#endif // WALLOBJECT_HPP_INCLUDED

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

@ -7,8 +7,10 @@
#include <string>
#include <cstdint>
class Widget : public Node
namespace Internal
{
class Widget : public Node
{
public:
Widget();
Widget(const void* Obj);
@ -39,6 +41,7 @@ class Widget : public Node
std::string GetText() const;
std::int32_t GetWidth() const;
};
};
}
#endif // WIDGET_HPP_INCLUDED

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

@ -5,8 +5,10 @@
#include "../JavaClass/Class.hpp"
#include <cstdint>
class WidgetNode : public Node
namespace Internal
{
class WidgetNode : public Node
{
public:
WidgetNode();
WidgetNode(const void* Obj);
@ -14,6 +16,7 @@ class WidgetNode : public Node
static Class GetClass();
std::int32_t GetID() const;
};
};
}
#endif // WIDGETNODE_HPP_INCLUDED

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

@ -6,8 +6,10 @@
#include <string>
#include <cstdint>
class World : public Object
namespace Internal
{
class World : public Object
{
public:
World();
World(const void* Obj);
@ -22,6 +24,7 @@ class World : public Object
std::int32_t GetMask() const;
std::int32_t GetPlayerCount() const;
};
};
}
#endif // WORLD_HPP_INCLUDED

273
Include/Core/Internal.hpp
View File

@ -82,143 +82,150 @@
#include "Classes/WidgetNode.hpp"
#include "Classes/World.hpp"
extern GameShell Client;
Cache GetAnimationCache();
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);
namespace Internal
{
extern GameShell Client;
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,
Cache GetAnimationCache();
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 GetItemInfoCache();
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();
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,
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);
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

2
Include/Game/Core.hpp
View File

@ -37,6 +37,8 @@
#include "Models/NPCs.hpp"
#include "Models/Players.hpp"
#include "Interactable/GameObject.hpp"
//
// 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;
static std::vector<MessageNode> GetMessages(CHAT_TYPE Type);
static std::vector<MessageNode> GetMessages(CHAT_TYPE Type, bool Sort);
static MessageNode GetLastMessage(CHAT_TYPE Type);
static std::vector<Internal::MessageNode> GetMessages(CHAT_TYPE Type);
static std::vector<Internal::MessageNode> GetMessages(CHAT_TYPE Type, bool Sort);
static Internal::MessageNode GetLastMessage(CHAT_TYPE Type);
static DIALOGUE_STATE GetDialogueState();
static std::vector<std::string> GetDialogueOptions();

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

@ -12,8 +12,8 @@ class Clan
public:
static bool IsOpen();
static bool Open();
static std::vector<ClanMember> GetAll();
static std::vector<ClanMember> GetAll(const std::function<bool (ClanMember&)>& Filter);
static std::vector<Internal::ClanMember> GetAll();
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:
static bool IsOpen();
static bool Open();
static std::vector<Friend> GetAll();
static std::vector<Friend> GetAll(const std::function<bool (Friend&)>& Filter);
static std::vector<Internal::Friend> GetAll();
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:
static bool IsOpen();
static bool Open();
static std::vector<Ignore> GetAll();
static std::vector<Ignore> GetAll(const std::function<bool (Ignore&)>& Filter);
static std::vector<Internal::Ignore> GetAll();
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(bool OpenInventory);
static bool WorldSwitcherScrollTo(World World);
static bool WorldSwitcherScrollTo(Internal::World World);
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 std::vector<std::int32_t> GetFavoriteWorlds();
static Widget GetWorldWidget(World World);
static Widget GetWorldWidget(std::int32_t WorldID);
static Internal::Widget GetWorldWidget(Internal::World World);
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 SelectWorld();
static bool SelectWorld(World World);
static bool SelectWorld(Internal::World World);
static bool SelectWorld(std::int32_t WorldID);
static bool OpenWorldSelect();
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 WaitUpTextContains(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText);
static Character GetInteractingByIndex(std::uint32_t Index);
static 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 GetInteractingByIndex(std::uint32_t Index);
static Internal::Character GetInteracting(); //Returns the Character interacting with the Local Player
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 CameraY();

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

@ -14,23 +14,23 @@
class GroundItems
{
public:
static std::vector<GroundItem> GetAll();
static std::vector<GroundItem> GetAll(Tile T);
static std::vector<GroundItem> GetAll(std::int32_t ID);
static std::vector<GroundItem> GetAll(const std::string& Name);
static std::vector<GroundItem> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<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();
static std::vector<Internal::GroundItem> GetAll(Tile T);
static std::vector<Internal::GroundItem> GetAll(std::int32_t ID);
static std::vector<Internal::GroundItem> GetAll(const std::string& Name);
static std::vector<Internal::GroundItem> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::GroundItem> GetAll(const std::vector<std::string>& Names);
static std::vector<Internal::GroundItem> GetAll(const std::function<bool (Internal::GroundItem&)>& Filter);
static GroundItem Get(Tile T);
static GroundItem Get(std::int32_t ID);
static GroundItem Get(const std::string& Name);
static GroundItem Get(const std::vector<std::int32_t>& IDs);
static GroundItem Get(const std::vector<std::string>& Names);
static Internal::GroundItem Get(Tile T);
static Internal::GroundItem Get(std::int32_t ID);
static Internal::GroundItem Get(const std::string& Name);
static Internal::GroundItem Get(const std::vector<std::int32_t>& IDs);
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
{
public:
static std::vector<NPC> GetAll();
static std::vector<NPC> GetAll(const Tile& Tile);
static std::vector<NPC> GetAll(std::int32_t ID);
static std::vector<NPC> GetAll(const std::string& Name);
static std::vector<NPC> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<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();
static std::vector<Internal::NPC> GetAll(const Tile& Tile);
static std::vector<Internal::NPC> GetAll(std::int32_t ID);
static std::vector<Internal::NPC> GetAll(const std::string& Name);
static std::vector<Internal::NPC> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::NPC> GetAll(const std::vector<std::string>& Names);
static std::vector<Internal::NPC> GetAll(const std::function<bool (Internal::NPC&)>& Filter);
static NPC Get();
static NPC Get(const Tile& Tile);
static NPC Get(std::int32_t ID);
static NPC Get(const std::string& Name);
static NPC Get(const std::vector<std::int32_t>& IDs);
static NPC Get(const std::vector<std::string>& Names);
static NPC Get(const std::function<bool (NPC&)>& Filter);
static Internal::NPC Get();
static Internal::NPC Get(const Tile& Tile);
static Internal::NPC Get(std::int32_t ID);
static Internal::NPC Get(const std::string& Name);
static Internal::NPC Get(const std::vector<std::int32_t>& IDs);
static Internal::NPC Get(const std::vector<std::string>& Names);
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
{
public:
static Player GetLocal();
static std::vector<Player> GetAll();
static std::vector<Player> GetAll(const Tile& Tile);
static std::vector<Player> GetAll(const std::string& Name);
static std::vector<Player> GetAll(const std::vector<std::string>& Names);
static std::vector<Player> GetAll(const std::function<bool (Player&)>& Filter);
static Internal::Player GetLocal();
static std::vector<Internal::Player> GetAll();
static std::vector<Internal::Player> GetAll(const Tile& Tile);
static std::vector<Internal::Player> GetAll(const std::string& Name);
static std::vector<Internal::Player> GetAll(const std::vector<std::string>& Names);
static std::vector<Internal::Player> GetAll(const std::function<bool (Internal::Player&)>& Filter);
static Player Get();
static Player Get(const Tile& Tile);
static Player Get(const std::string& Name);
static Player Get(const std::vector<std::string>& Names);
static Player Get(const std::function<bool (Player&)>& Filter);
static Internal::Player Get();
static Internal::Player Get(const Tile& Tile);
static Internal::Player Get(const std::string& Name);
static Internal::Player Get(const std::vector<std::string>& Names);
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::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL);
static std::vector<GameObject> GetAll(const std::function<bool (GameObject&)>& Filter);
static std::vector<DecorativeObject> GetAll(const std::function<bool (DecorativeObject&)>& Filter);
static std::vector<GroundObject> GetAll(const std::function<bool (GroundObject&)>& Filter);
static std::vector<WallObject> GetAll(const std::function<bool (WallObject&)>& Filter);
static std::vector<Internal::GameObject> GetAll(const std::function<bool (Internal::GameObject&)>& Filter);
static std::vector<Internal::DecorativeObject> GetAll(const std::function<bool (Internal::DecorativeObject&)>& Filter);
static std::vector<Internal::GroundObject> GetAll(const std::function<bool (Internal::GroundObject&)>& 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(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::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL);
static GameObject Get(const std::function<bool (GameObject&)>& Filter);
static DecorativeObject Get(const std::function<bool (DecorativeObject&)>& Filter);
static GroundObject Get(const std::function<bool (GroundObject&)>& Filter);
static WallObject Get(const std::function<bool (WallObject&)>& Filter);
static Internal::GameObject Get(const std::function<bool (Internal::GameObject&)>& Filter);
static Internal::DecorativeObject Get(const std::function<bool (Internal::DecorativeObject&)>& Filter);
static Internal::GroundObject Get(const std::function<bool (Internal::GroundObject&)>& Filter);
static Internal::WallObject Get(const std::function<bool (Internal::WallObject&)>& Filter);
static ObjectInfo GetInfoOf(const Object& O);
static ObjectInfo GetInfoOf(const GameObject& G);
static ObjectInfo GetInfoOf(const DecorativeObject& D);
static ObjectInfo GetInfoOf(const GroundObject& G);
static ObjectInfo GetInfoOf(const WallObject& W);
static Internal::ObjectInfo GetInfoOf(const Object& O);
static Internal::ObjectInfo GetInfoOf(const Internal::GameObject& G);
static Internal::ObjectInfo GetInfoOf(const Internal::DecorativeObject& D);
static Internal::ObjectInfo GetInfoOf(const Internal::GroundObject& G);
static Internal::ObjectInfo GetInfoOf(const Internal::WallObject& W);
static Tile GetTileOf(const GameObject& G);
static Tile GetTileOf(const DecorativeObject& D);
static Tile GetTileOf(const GroundObject& G);
static Tile GetTileOf(const WallObject& W);
static Tile GetTileOf(const Internal::GameObject& G);
static Tile GetTileOf(const Internal::DecorativeObject& D);
static Tile GetTileOf(const Internal::GroundObject& G);
static Tile GetTileOf(const Internal::WallObject& W);
static Convex GetConvexOf(const GameObject& G);
static Convex GetConvexOf(const DecorativeObject& D);
static Convex GetConvexOf(const GroundObject& G);
static Convex GetConvexOf(const WallObject& W);
static Convex GetConvexOf(const Internal::GameObject& G);
static Convex GetConvexOf(const Internal::DecorativeObject& D);
static Convex GetConvexOf(const Internal::GroundObject& G);
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::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""});
static bool Click(Widget W, Button Button = BUTTON_LEFT);
static bool Click(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, Button Button = BUTTON_LEFT);
static bool Click(Internal::Widget W, const std::string& Action, const std::string& Target = "");
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, 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(GroundItem G, Button Button = BUTTON_LEFT);
static bool Click(GroundItem G, const std::string& Action);
static bool Click(GroundItem G, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::GroundItem G, Button Button = BUTTON_LEFT);
static bool Click(Internal::GroundItem G, const std::string& Action);
static bool Click(Internal::GroundItem G, const std::vector<std::string>& PossibleActions);
static bool Click(NPC N, Button Button = BUTTON_LEFT);
static bool Click(NPC N, const std::string& Action);
static bool Click(NPC N, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::NPC N, Button Button = BUTTON_LEFT);
static bool Click(Internal::NPC N, const std::string& Action);
static bool Click(Internal::NPC N, const std::vector<std::string>& PossibleActions);
static bool Click(Player P, Button Button = BUTTON_LEFT);
static bool Click(Player P, const std::string& Action);
static bool Click(Player P, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::Player P, Button Button = BUTTON_LEFT);
static bool Click(Internal::Player P, const std::string& Action);
static bool Click(Internal::Player P, const std::vector<std::string>& PossibleActions);
static bool Click(GameObject G, Button Button = BUTTON_LEFT);
static bool Click(GameObject G, const std::string& Action);
static bool Click(GameObject G, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::GameObject G, Button Button = BUTTON_LEFT);
static bool Click(Internal::GameObject G, const std::string& Action);
static bool Click(Internal::GameObject G, const std::vector<std::string>& PossibleActions);
static bool Click(GroundObject G, Button Button = BUTTON_LEFT);
static bool Click(GroundObject G, const std::string& Action);
static bool Click(GroundObject G, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::GroundObject G, Button Button = BUTTON_LEFT);
static bool Click(Internal::GroundObject G, const std::string& Action);
static bool Click(Internal::GroundObject G, const std::vector<std::string>& PossibleActions);
static bool Click(WallObject W, Button Button = BUTTON_LEFT);
static bool Click(WallObject W, const std::string& Action);
static bool Click(WallObject W, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::WallObject W, Button Button = BUTTON_LEFT);
static bool Click(Internal::WallObject W, const std::string& Action);
static bool Click(Internal::WallObject W, const std::vector<std::string>& PossibleActions);
static bool UpKey(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);
* @endcode
*/
static bool IsHidden(const Widget& W);
static bool IsHidden(const Internal::Widget& W);
/**
* @brief Returns the Box of the passed Widget
* @code
@ -27,7 +27,7 @@ class Widgets
* Box BankInventoryBox = Widgets::GetBox(BankInventory);
* @endcode
*/
static Box GetBox(const Widget& W);
static Box GetBox(const Internal::Widget& W);
/**
* @brief Returns the absolute X of the passed Widget
* @code
@ -35,7 +35,7 @@ class Widgets
* std::int32_t BankInventoryX = Widgets::GetX(BankInventory);
* @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
* @code
@ -43,34 +43,34 @@ class Widgets
* std::int32_t BankInventoryY = Widgets::GetX(BankInventory);
* @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
* @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
* @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
* @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
* @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
* @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
* @code
@ -78,7 +78,7 @@ class Widgets
* std::vector<Widget> Widgets = Widgets::Get(WTextEquals); @endcode
* 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(bool ExitWorldSelection);
static bool SwitchWorld(World World);
static bool SwitchWorld(Internal::World World);
static bool SwitchWorld(std::int32_t WorldID);
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::vector<World> GetF2P();
static std::vector<World> GetP2P();
static std::vector<Internal::World> GetF2P();
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 World GetBy(std::int32_t WorldID);
static std::vector<World> GetBy(const std::function<bool (World&)>& Filter);
static Internal::World GetBy(std::int32_t WorldID);
static std::vector<Internal::World> GetBy(const std::function<bool (Internal::World&)>& Filter);
};
/** @} */

BIN
Library/libAlpacaLibrary.a
View File

Binary file not shown.