diff --git a/Include/Core/Classes/AbstractBufferProvider.hpp b/Include/Core/Classes/AbstractBufferProvider.hpp index a0d84d7..45138f4 100644 --- a/Include/Core/Classes/AbstractBufferProvider.hpp +++ b/Include/Core/Classes/AbstractBufferProvider.hpp @@ -11,9 +11,14 @@ namespace Internal class AbstractBufferProvider : public Object { public: - AbstractBufferProvider(); AbstractBufferProvider(const void* Obj); - AbstractBufferProvider(const AbstractBufferProvider& A); + + AbstractBufferProvider() = default; + AbstractBufferProvider(AbstractBufferProvider&& Obj) = default; + AbstractBufferProvider(const AbstractBufferProvider& Obj) = default; + AbstractBufferProvider& operator=(AbstractBufferProvider&& Obj) = default; + AbstractBufferProvider& operator=(const AbstractBufferProvider& Obj) = default; + static Class GetClass(); std::vector GetPixels() const; diff --git a/Include/Core/Classes/AbstractByteBuffer.hpp b/Include/Core/Classes/AbstractByteBuffer.hpp index 44da364..b814c4b 100644 --- a/Include/Core/Classes/AbstractByteBuffer.hpp +++ b/Include/Core/Classes/AbstractByteBuffer.hpp @@ -9,9 +9,14 @@ namespace Internal class AbstractByteBuffer : public Object { public: - AbstractByteBuffer(); AbstractByteBuffer(const void* Obj); - AbstractByteBuffer(const AbstractByteBuffer& A); + + AbstractByteBuffer() = default; + AbstractByteBuffer(AbstractByteBuffer&& Obj) = default; + AbstractByteBuffer(const AbstractByteBuffer& Obj) = default; + AbstractByteBuffer& operator=(AbstractByteBuffer&& Obj) = default; + AbstractByteBuffer& operator=(const AbstractByteBuffer& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/Animation.hpp b/Include/Core/Classes/Animation.hpp index 93afe69..cdc25c0 100644 --- a/Include/Core/Classes/Animation.hpp +++ b/Include/Core/Classes/Animation.hpp @@ -11,9 +11,14 @@ namespace Internal class Animation : public CacheableNode { public: - Animation(); Animation(const void* Obj); - Animation(const Animation& A); + + Animation() = default; + Animation(Animation&& Obj) = default; + Animation(const Animation& Obj) = default; + Animation& operator=(Animation&& Obj) = default; + Animation& operator=(const Animation& Obj) = default; + static Class GetClass(); std::vector GetFrameIDs() const; diff --git a/Include/Core/Classes/AttackOption.hpp b/Include/Core/Classes/AttackOption.hpp index a48a80d..08b00d7 100644 --- a/Include/Core/Classes/AttackOption.hpp +++ b/Include/Core/Classes/AttackOption.hpp @@ -10,9 +10,14 @@ namespace Internal class AttackOption : public Object { public: - AttackOption(); AttackOption(const void* Obj); - AttackOption(const AttackOption& A); + + AttackOption() = default; + AttackOption(AttackOption&& Obj) = default; + AttackOption(const AttackOption& Obj) = default; + AttackOption& operator=(AttackOption&& Obj) = default; + AttackOption& operator=(const AttackOption& Obj) = default; + static Class GetClass(); std::int32_t GetType() const; diff --git a/Include/Core/Classes/Cache.hpp b/Include/Core/Classes/Cache.hpp index e66e0e0..a3393bd 100644 --- a/Include/Core/Classes/Cache.hpp +++ b/Include/Core/Classes/Cache.hpp @@ -11,9 +11,14 @@ namespace Internal class Cache : public Object { public: - Cache(); Cache(const void* Obj); - Cache(const Cache& C); + + Cache() = default; + Cache(Cache&& Obj) = default; + Cache(const Cache& Obj) = default; + Cache& operator=(Cache&& Obj) = default; + Cache& operator=(const Cache& Obj) = default; + static Class GetClass(); HashTable GetHashTable() const; diff --git a/Include/Core/Classes/CacheableNode.hpp b/Include/Core/Classes/CacheableNode.hpp index 249bdd8..b80f45c 100644 --- a/Include/Core/Classes/CacheableNode.hpp +++ b/Include/Core/Classes/CacheableNode.hpp @@ -9,9 +9,14 @@ namespace Internal class CacheableNode : public Node { public: - CacheableNode(); CacheableNode(const void* Obj); - CacheableNode(const CacheableNode& C); + + CacheableNode() = default; + CacheableNode(CacheableNode&& Obj) = default; + CacheableNode(const CacheableNode& Obj) = default; + CacheableNode& operator=(CacheableNode&& Obj) = default; + CacheableNode& operator=(const CacheableNode& Obj) = default; + static Class GetClass(); CacheableNode GetNext() const; diff --git a/Include/Core/Classes/Character.hpp b/Include/Core/Classes/Character.hpp index fd4c56c..af72571 100644 --- a/Include/Core/Classes/Character.hpp +++ b/Include/Core/Classes/Character.hpp @@ -13,9 +13,14 @@ namespace Internal class Character : public Renderable { public: - Character(); Character(const void* Obj); - Character(const Character& C); + + Character() = default; + Character(Character&& Obj) = default; + Character(const Character& Obj) = default; + Character& operator=(Character&& Obj) = default; + Character& operator=(const Character& Obj) = default; + static Class GetClass(); std::int32_t GetAngle() const; diff --git a/Include/Core/Classes/ChatLineBuffer.hpp b/Include/Core/Classes/ChatLineBuffer.hpp index 306ee79..5b2ef55 100644 --- a/Include/Core/Classes/ChatLineBuffer.hpp +++ b/Include/Core/Classes/ChatLineBuffer.hpp @@ -12,9 +12,14 @@ namespace Internal class ChatLineBuffer : public Object { public: - ChatLineBuffer(); ChatLineBuffer(const void* Obj); - ChatLineBuffer(const ChatLineBuffer& C); + + ChatLineBuffer() = default; + ChatLineBuffer(ChatLineBuffer&& Obj) = default; + ChatLineBuffer(const ChatLineBuffer& Obj) = default; + ChatLineBuffer& operator=(ChatLineBuffer&& Obj) = default; + ChatLineBuffer& operator=(const ChatLineBuffer& Obj) = default; + static Class GetClass(); std::int32_t GetLength() const; diff --git a/Include/Core/Classes/ClanMember.hpp b/Include/Core/Classes/ClanMember.hpp index b1ea698..618e4d6 100644 --- a/Include/Core/Classes/ClanMember.hpp +++ b/Include/Core/Classes/ClanMember.hpp @@ -10,9 +10,14 @@ namespace Internal class ClanMember : public Talkable { public: - ClanMember(); ClanMember(const void* Obj); - ClanMember(const ClanMember& C); + + ClanMember() = default; + ClanMember(ClanMember&& Obj) = default; + ClanMember(const ClanMember& Obj) = default; + ClanMember& operator=(ClanMember&& Obj) = default; + ClanMember& operator=(const ClanMember& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/ClanMemberList.hpp b/Include/Core/Classes/ClanMemberList.hpp index 69378b5..a547238 100644 --- a/Include/Core/Classes/ClanMemberList.hpp +++ b/Include/Core/Classes/ClanMemberList.hpp @@ -9,9 +9,9 @@ namespace Internal class ClanMemberList : public NameableContainer { public: - ClanMemberList(); ClanMemberList(const void* Obj); - ClanMemberList(const ClanMemberList& C); + + static Class GetClass(); }; diff --git a/Include/Core/Classes/CollisionData.hpp b/Include/Core/Classes/CollisionData.hpp index 73cb128..5952945 100644 --- a/Include/Core/Classes/CollisionData.hpp +++ b/Include/Core/Classes/CollisionData.hpp @@ -11,9 +11,14 @@ namespace Internal class CollisionData : public Object { public: - CollisionData(); CollisionData(const void* Obj); - CollisionData(const CollisionData& C); + + CollisionData() = default; + CollisionData(CollisionData&& Obj) = default; + CollisionData(const CollisionData& Obj) = default; + CollisionData& operator=(CollisionData&& Obj) = default; + CollisionData& operator=(const CollisionData& Obj) = default; + static Class GetClass(); std::vector> GetFlags() const; diff --git a/Include/Core/Classes/CombatInfo.hpp b/Include/Core/Classes/CombatInfo.hpp index bae938e..5a5e783 100644 --- a/Include/Core/Classes/CombatInfo.hpp +++ b/Include/Core/Classes/CombatInfo.hpp @@ -11,9 +11,14 @@ namespace Internal class CombatInfo : public Node { public: - CombatInfo(); CombatInfo(const void* Obj); - CombatInfo(const CombatInfo& C); + + CombatInfo() = default; + CombatInfo(CombatInfo&& Obj) = default; + CombatInfo(const CombatInfo& Obj) = default; + CombatInfo& operator=(CombatInfo&& Obj) = default; + CombatInfo& operator=(const CombatInfo& Obj) = default; + static Class GetClass(); LinkedList GetHealthBar() const; diff --git a/Include/Core/Classes/DecorativeObject.hpp b/Include/Core/Classes/DecorativeObject.hpp index dc00005..e3aaa2e 100644 --- a/Include/Core/Classes/DecorativeObject.hpp +++ b/Include/Core/Classes/DecorativeObject.hpp @@ -11,9 +11,14 @@ namespace Internal class DecorativeObject : public Object { public: - DecorativeObject(); DecorativeObject(const void* Obj); - DecorativeObject(const DecorativeObject& D); + + DecorativeObject() = default; + DecorativeObject(DecorativeObject&& Obj) = default; + DecorativeObject(const DecorativeObject& Obj) = default; + DecorativeObject& operator=(DecorativeObject&& Obj) = default; + DecorativeObject& operator=(const DecorativeObject& Obj) = default; + static Class GetClass(); std::int32_t GetAngle() const; diff --git a/Include/Core/Classes/Deque.hpp b/Include/Core/Classes/Deque.hpp index 22fd634..f052b91 100644 --- a/Include/Core/Classes/Deque.hpp +++ b/Include/Core/Classes/Deque.hpp @@ -10,9 +10,14 @@ namespace Internal class Deque : public Object { public: - Deque(); Deque(const void* Obj); - Deque(const Deque& D); + + Deque() = default; + Deque(Deque&& Obj) = default; + Deque(const Deque& Obj) = default; + Deque& operator=(Deque&& Obj) = default; + Deque& operator=(const Deque& Obj) = default; + static Class GetClass(); Node GetHead() const; diff --git a/Include/Core/Classes/DirectByteBuffer.hpp b/Include/Core/Classes/DirectByteBuffer.hpp index 3d18c38..7d81779 100644 --- a/Include/Core/Classes/DirectByteBuffer.hpp +++ b/Include/Core/Classes/DirectByteBuffer.hpp @@ -10,9 +10,14 @@ namespace Internal class DirectByteBuffer : public AbstractByteBuffer { public: - DirectByteBuffer(); DirectByteBuffer(const void* Obj); - DirectByteBuffer(const DirectByteBuffer& D); + + DirectByteBuffer() = default; + DirectByteBuffer(DirectByteBuffer&& Obj) = default; + DirectByteBuffer(const DirectByteBuffer& Obj) = default; + DirectByteBuffer& operator=(DirectByteBuffer&& Obj) = default; + DirectByteBuffer& operator=(const DirectByteBuffer& Obj) = default; + static Class GetClass(); ByteBuffer GetBuffer() const; diff --git a/Include/Core/Classes/DynamicObject.hpp b/Include/Core/Classes/DynamicObject.hpp index 530d1ae..3499e32 100644 --- a/Include/Core/Classes/DynamicObject.hpp +++ b/Include/Core/Classes/DynamicObject.hpp @@ -10,9 +10,14 @@ namespace Internal class DynamicObject : public Renderable { public: - DynamicObject(); DynamicObject(const void* Obj); - DynamicObject(const DynamicObject& D); + + DynamicObject() = default; + DynamicObject(DynamicObject&& Obj) = default; + DynamicObject(const DynamicObject& Obj) = default; + DynamicObject& operator=(DynamicObject&& Obj) = default; + DynamicObject& operator=(const DynamicObject& Obj) = default; + static Class GetClass(); std::int32_t GetID() const; diff --git a/Include/Core/Classes/ExchangeOffer.hpp b/Include/Core/Classes/ExchangeOffer.hpp index cd284c0..99632aa 100644 --- a/Include/Core/Classes/ExchangeOffer.hpp +++ b/Include/Core/Classes/ExchangeOffer.hpp @@ -10,9 +10,14 @@ namespace Internal class ExchangeOffer : public Object { public: - ExchangeOffer(); ExchangeOffer(const void* Obj); - ExchangeOffer(const ExchangeOffer& E); + + ExchangeOffer() = default; + ExchangeOffer(ExchangeOffer&& Obj) = default; + ExchangeOffer(const ExchangeOffer& Obj) = default; + ExchangeOffer& operator=(ExchangeOffer&& Obj) = default; + ExchangeOffer& operator=(const ExchangeOffer& Obj) = default; + static Class GetClass(); std::int32_t GetAmountTraded() const; diff --git a/Include/Core/Classes/Font.hpp b/Include/Core/Classes/Font.hpp index c09cfe2..4ecf303 100644 --- a/Include/Core/Classes/Font.hpp +++ b/Include/Core/Classes/Font.hpp @@ -9,9 +9,14 @@ namespace Internal class Font : public FontFamily { public: - Font(); Font(const void* Obj); - Font(const Font& F); + + Font() = default; + Font(Font&& Obj) = default; + Font(const Font& Obj) = default; + Font& operator=(Font&& Obj) = default; + Font& operator=(const Font& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/FontFamily.hpp b/Include/Core/Classes/FontFamily.hpp index 7c87622..a3b6ce3 100644 --- a/Include/Core/Classes/FontFamily.hpp +++ b/Include/Core/Classes/FontFamily.hpp @@ -11,9 +11,14 @@ namespace Internal class FontFamily : public Rasterizer2D { public: - FontFamily(); FontFamily(const void* Obj); - FontFamily(const FontFamily& F); + + FontFamily() = default; + FontFamily(FontFamily&& Obj) = default; + FontFamily(const FontFamily& Obj) = default; + FontFamily& operator=(FontFamily&& Obj) = default; + FontFamily& operator=(const FontFamily& Obj) = default; + static Class GetClass(); std::vector GetGlyphHeightOffsets() const; diff --git a/Include/Core/Classes/FontName.hpp b/Include/Core/Classes/FontName.hpp index 00c8bcb..fa573d3 100644 --- a/Include/Core/Classes/FontName.hpp +++ b/Include/Core/Classes/FontName.hpp @@ -10,9 +10,14 @@ namespace Internal class FontName : public Object { public: - FontName(); FontName(const void* Obj); - FontName(const FontName& F); + + FontName() = default; + FontName(FontName&& Obj) = default; + FontName(const FontName& Obj) = default; + FontName& operator=(FontName&& Obj) = default; + FontName& operator=(const FontName& Obj) = default; + static Class GetClass(); std::string GetName() const; diff --git a/Include/Core/Classes/Fonts.hpp b/Include/Core/Classes/Fonts.hpp index 19e197e..6f2ba9c 100644 --- a/Include/Core/Classes/Fonts.hpp +++ b/Include/Core/Classes/Fonts.hpp @@ -10,9 +10,14 @@ namespace Internal class Fonts : public Object { public: - Fonts(); Fonts(const void* Obj); - Fonts(const Fonts& F); + + Fonts() = default; + Fonts(Fonts&& Obj) = default; + Fonts(const Fonts& Obj) = default; + Fonts& operator=(Fonts&& Obj) = default; + Fonts& operator=(const Fonts& Obj) = default; + static Class GetClass(); Map GetFontMap() const; diff --git a/Include/Core/Classes/Frame.hpp b/Include/Core/Classes/Frame.hpp index b32db32..f4df6d4 100644 --- a/Include/Core/Classes/Frame.hpp +++ b/Include/Core/Classes/Frame.hpp @@ -12,9 +12,14 @@ namespace Internal class Frame : public Object { public: - Frame(); Frame(const void* Obj); - Frame(const Frame& F); + + Frame() = default; + Frame(Frame&& Obj) = default; + Frame(const Frame& Obj) = default; + Frame& operator=(Frame&& Obj) = default; + Frame& operator=(const Frame& Obj) = default; + static Class GetClass(); std::vector GetIndices() const; diff --git a/Include/Core/Classes/FrameMap.hpp b/Include/Core/Classes/FrameMap.hpp index db9f6a8..be85de2 100644 --- a/Include/Core/Classes/FrameMap.hpp +++ b/Include/Core/Classes/FrameMap.hpp @@ -11,9 +11,14 @@ namespace Internal class FrameMap : public Node { public: - FrameMap(); FrameMap(const void* Obj); - FrameMap(const FrameMap& F); + + FrameMap() = default; + FrameMap(FrameMap&& Obj) = default; + FrameMap(const FrameMap& Obj) = default; + FrameMap& operator=(FrameMap&& Obj) = default; + FrameMap& operator=(const FrameMap& Obj) = default; + static Class GetClass(); std::vector> GetList() const; diff --git a/Include/Core/Classes/Frames.hpp b/Include/Core/Classes/Frames.hpp index 6141ffe..db007df 100644 --- a/Include/Core/Classes/Frames.hpp +++ b/Include/Core/Classes/Frames.hpp @@ -11,9 +11,14 @@ namespace Internal class Frames : public CacheableNode { public: - Frames(); Frames(const void* Obj); - Frames(const Frames& F); + + Frames() = default; + Frames(Frames&& Obj) = default; + Frames(const Frames& Obj) = default; + Frames& operator=(Frames&& Obj) = default; + Frames& operator=(const Frames& Obj) = default; + static Class GetClass(); std::vector GetSkeletons() const; diff --git a/Include/Core/Classes/Friend.hpp b/Include/Core/Classes/Friend.hpp index 2a75904..55211ef 100644 --- a/Include/Core/Classes/Friend.hpp +++ b/Include/Core/Classes/Friend.hpp @@ -10,9 +10,14 @@ namespace Internal class Friend : public Talkable { public: - Friend(); Friend(const void* Obj); - Friend(const Friend& F); + + Friend() = default; + Friend(Friend&& Obj) = default; + Friend(const Friend& Obj) = default; + Friend& operator=(Friend&& Obj) = default; + Friend& operator=(const Friend& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/FriendList.hpp b/Include/Core/Classes/FriendList.hpp index 9c92683..61dd939 100644 --- a/Include/Core/Classes/FriendList.hpp +++ b/Include/Core/Classes/FriendList.hpp @@ -9,9 +9,14 @@ namespace Internal class FriendList : public NameableContainer { public: - FriendList(); FriendList(const void* Obj); - FriendList(const FriendList& F); + + FriendList() = default; + FriendList(FriendList&& Obj) = default; + FriendList(const FriendList& Obj) = default; + FriendList& operator=(FriendList&& Obj) = default; + FriendList& operator=(const FriendList& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/GameObject.hpp b/Include/Core/Classes/GameObject.hpp index a0235c5..4847c49 100644 --- a/Include/Core/Classes/GameObject.hpp +++ b/Include/Core/Classes/GameObject.hpp @@ -11,9 +11,14 @@ namespace Internal class GameObject : public Object { public: - GameObject(); GameObject(const void* Obj); - GameObject(const GameObject& G); + + GameObject() = default; + GameObject(GameObject&& Obj) = default; + GameObject(const GameObject& Obj) = default; + GameObject& operator=(GameObject&& Obj) = default; + GameObject& operator=(const GameObject& Obj) = default; + static Class GetClass(); std::int32_t GetAngle() const; diff --git a/Include/Core/Classes/GameShell.hpp b/Include/Core/Classes/GameShell.hpp index 5826be4..6e7c738 100644 --- a/Include/Core/Classes/GameShell.hpp +++ b/Include/Core/Classes/GameShell.hpp @@ -10,9 +10,14 @@ namespace Internal class GameShell : public Object { public: - GameShell(); GameShell(const void* Obj); - GameShell(const GameShell& G); + + GameShell() = default; + GameShell(GameShell&& Obj) = default; + GameShell(const GameShell& Obj) = default; + GameShell& operator=(GameShell&& Obj) = default; + GameShell& operator=(const GameShell& Obj) = default; + static Class GetClass(); Canvas GetCanvas() const; diff --git a/Include/Core/Classes/GraphicsObject.hpp b/Include/Core/Classes/GraphicsObject.hpp index 00f188b..ebebdba 100644 --- a/Include/Core/Classes/GraphicsObject.hpp +++ b/Include/Core/Classes/GraphicsObject.hpp @@ -11,9 +11,14 @@ namespace Internal class GraphicsObject : public Renderable { public: - GraphicsObject(); GraphicsObject(const void* Obj); - GraphicsObject(const GraphicsObject& G); + + GraphicsObject() = default; + GraphicsObject(GraphicsObject&& Obj) = default; + GraphicsObject(const GraphicsObject& Obj) = default; + GraphicsObject& operator=(GraphicsObject&& Obj) = default; + GraphicsObject& operator=(const GraphicsObject& Obj) = default; + static Class GetClass(); std::int32_t GetAnimationFrame() const; diff --git a/Include/Core/Classes/GroundItem.hpp b/Include/Core/Classes/GroundItem.hpp index 766f266..5fd35d8 100644 --- a/Include/Core/Classes/GroundItem.hpp +++ b/Include/Core/Classes/GroundItem.hpp @@ -10,9 +10,14 @@ namespace Internal class GroundItem : public Renderable { public: - GroundItem(); GroundItem(const void* Obj); - GroundItem(const GroundItem& G); + + GroundItem() = default; + GroundItem(GroundItem&& Obj) = default; + GroundItem(const GroundItem& Obj) = default; + GroundItem& operator=(GroundItem&& Obj) = default; + GroundItem& operator=(const GroundItem& Obj) = default; + static Class GetClass(); std::int32_t GetAmount() const; diff --git a/Include/Core/Classes/GroundObject.hpp b/Include/Core/Classes/GroundObject.hpp index 60cb9fb..1d04bdb 100644 --- a/Include/Core/Classes/GroundObject.hpp +++ b/Include/Core/Classes/GroundObject.hpp @@ -11,9 +11,14 @@ namespace Internal class GroundObject : public Object { public: - GroundObject(); GroundObject(const void* Obj); - GroundObject(const GroundObject& G); + + GroundObject() = default; + GroundObject(GroundObject&& Obj) = default; + GroundObject(const GroundObject& Obj) = default; + GroundObject& operator=(GroundObject&& Obj) = default; + GroundObject& operator=(const GroundObject& Obj) = default; + static Class GetClass(); std::int64_t GetHash() const; diff --git a/Include/Core/Classes/HashTable.hpp b/Include/Core/Classes/HashTable.hpp index 9815f81..2bb9f28 100644 --- a/Include/Core/Classes/HashTable.hpp +++ b/Include/Core/Classes/HashTable.hpp @@ -12,9 +12,14 @@ namespace Internal class HashTable : public Object { public: - HashTable(); HashTable(const void* Obj); - HashTable(const HashTable& H); + + HashTable() = default; + HashTable(HashTable&& Obj) = default; + HashTable(const HashTable& Obj) = default; + HashTable& operator=(HashTable&& Obj) = default; + HashTable& operator=(const HashTable& Obj) = default; + static Class GetClass(); std::vector GetBuckets() const; diff --git a/Include/Core/Classes/HealthBar.hpp b/Include/Core/Classes/HealthBar.hpp index 0660425..0a5e4af 100644 --- a/Include/Core/Classes/HealthBar.hpp +++ b/Include/Core/Classes/HealthBar.hpp @@ -10,9 +10,14 @@ namespace Internal class HealthBar : public Node { public: - HealthBar(); HealthBar(const void* Obj); - HealthBar(const HealthBar& H); + + HealthBar() = default; + HealthBar(HealthBar&& Obj) = default; + HealthBar(const HealthBar& Obj) = default; + HealthBar& operator=(HealthBar&& Obj) = default; + HealthBar& operator=(const HealthBar& Obj) = default; + static Class GetClass(); std::int32_t GetHealthRatio() const; diff --git a/Include/Core/Classes/HealthInfo.hpp b/Include/Core/Classes/HealthInfo.hpp index f5808cc..0b38bbe 100644 --- a/Include/Core/Classes/HealthInfo.hpp +++ b/Include/Core/Classes/HealthInfo.hpp @@ -10,9 +10,14 @@ namespace Internal class HealthInfo : public CacheableNode { public: - HealthInfo(); HealthInfo(const void* Obj); - HealthInfo(const HealthInfo& H); + + HealthInfo() = default; + HealthInfo(HealthInfo&& Obj) = default; + HealthInfo(const HealthInfo& Obj) = default; + HealthInfo& operator=(HealthInfo&& Obj) = default; + HealthInfo& operator=(const HealthInfo& Obj) = default; + static Class GetClass(); std::int32_t GetScale() const; diff --git a/Include/Core/Classes/Ignore.hpp b/Include/Core/Classes/Ignore.hpp index 10c4d17..d5e3f86 100644 --- a/Include/Core/Classes/Ignore.hpp +++ b/Include/Core/Classes/Ignore.hpp @@ -9,9 +9,14 @@ namespace Internal class Ignore : public Nameable { public: - Ignore(); Ignore(const void* Obj); - Ignore(const Ignore& I); + + Ignore() = default; + Ignore(Ignore&& Obj) = default; + Ignore(const Ignore& Obj) = default; + Ignore& operator=(Ignore&& Obj) = default; + Ignore& operator=(const Ignore& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/IgnoreList.hpp b/Include/Core/Classes/IgnoreList.hpp index b66a28c..34ee673 100644 --- a/Include/Core/Classes/IgnoreList.hpp +++ b/Include/Core/Classes/IgnoreList.hpp @@ -9,9 +9,14 @@ namespace Internal class IgnoreList : public NameableContainer { public: - IgnoreList(); IgnoreList(const void* Obj); - IgnoreList(const IgnoreList& I); + + IgnoreList() = default; + IgnoreList(IgnoreList&& Obj) = default; + IgnoreList(const IgnoreList& Obj) = default; + IgnoreList& operator=(IgnoreList&& Obj) = default; + IgnoreList& operator=(const IgnoreList& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/IndexableData.hpp b/Include/Core/Classes/IndexableData.hpp index 8851ec0..b0d7c72 100644 --- a/Include/Core/Classes/IndexableData.hpp +++ b/Include/Core/Classes/IndexableData.hpp @@ -11,9 +11,14 @@ namespace Internal class IndexableData : public Object { public: - IndexableData(); IndexableData(const void* Obj); - IndexableData(const IndexableData& IndexableData); + + IndexableData() = default; + IndexableData(IndexableData&& Obj) = default; + IndexableData(const IndexableData& Obj) = default; + IndexableData& operator=(IndexableData&& Obj) = default; + IndexableData& operator=(const IndexableData& Obj) = default; + static Class GetClass(); std::vector> GetChildren() const; diff --git a/Include/Core/Classes/ItemContainer.hpp b/Include/Core/Classes/ItemContainer.hpp index bd2a211..431a4cb 100644 --- a/Include/Core/Classes/ItemContainer.hpp +++ b/Include/Core/Classes/ItemContainer.hpp @@ -11,9 +11,14 @@ namespace Internal class ItemContainer : public Node { public: - ItemContainer(); ItemContainer(const void* Obj); - ItemContainer(const ItemContainer& I); + + ItemContainer() = default; + ItemContainer(ItemContainer&& Obj) = default; + ItemContainer(const ItemContainer& Obj) = default; + ItemContainer& operator=(ItemContainer&& Obj) = default; + ItemContainer& operator=(const ItemContainer& Obj) = default; + static Class GetClass(); std::vector GetItemAmounts() const; diff --git a/Include/Core/Classes/ItemInfo.hpp b/Include/Core/Classes/ItemInfo.hpp index 409cb3e..b9795e6 100644 --- a/Include/Core/Classes/ItemInfo.hpp +++ b/Include/Core/Classes/ItemInfo.hpp @@ -12,9 +12,14 @@ namespace Internal class ItemInfo : public CacheableNode { public: - ItemInfo(); ItemInfo(const void* Obj); - ItemInfo(const ItemInfo& I); + + ItemInfo() = default; + ItemInfo(ItemInfo&& Obj) = default; + ItemInfo(const ItemInfo& Obj) = default; + ItemInfo& operator=(ItemInfo&& Obj) = default; + ItemInfo& operator=(const ItemInfo& Obj) = default; + static Class GetClass(); std::vector GetGroundActions() const; diff --git a/Include/Core/Classes/LinkedList.hpp b/Include/Core/Classes/LinkedList.hpp index d3c7a42..f27025f 100644 --- a/Include/Core/Classes/LinkedList.hpp +++ b/Include/Core/Classes/LinkedList.hpp @@ -10,9 +10,14 @@ namespace Internal class LinkedList : public Object { public: - LinkedList(); LinkedList(const void* Obj); - LinkedList(const LinkedList& L); + + LinkedList() = default; + LinkedList(LinkedList&& Obj) = default; + LinkedList(const LinkedList& Obj) = default; + LinkedList& operator=(LinkedList&& Obj) = default; + LinkedList& operator=(const LinkedList& Obj) = default; + static Class GetClass(); Node GetHead() const; diff --git a/Include/Core/Classes/MessageNode.hpp b/Include/Core/Classes/MessageNode.hpp index 692ef4e..a538f7f 100644 --- a/Include/Core/Classes/MessageNode.hpp +++ b/Include/Core/Classes/MessageNode.hpp @@ -11,9 +11,14 @@ namespace Internal class MessageNode : public CacheableNode { public: - MessageNode(); MessageNode(const void* Obj); - MessageNode(const MessageNode& M); + + MessageNode() = default; + MessageNode(MessageNode&& Obj) = default; + MessageNode(const MessageNode& Obj) = default; + MessageNode& operator=(MessageNode&& Obj) = default; + MessageNode& operator=(const MessageNode& Obj) = default; + static Class GetClass(); std::int32_t GetID() const; diff --git a/Include/Core/Classes/Model.hpp b/Include/Core/Classes/Model.hpp index 95441cd..4f0e62f 100644 --- a/Include/Core/Classes/Model.hpp +++ b/Include/Core/Classes/Model.hpp @@ -11,9 +11,14 @@ namespace Internal class Model : public Renderable { public: - Model(); Model(const void* Obj); - Model(const Model& M); + + Model() = default; + Model(Model&& Obj) = default; + Model(const Model& Obj) = default; + Model& operator=(Model&& Obj) = default; + Model& operator=(const Model& Obj) = default; + static Class GetClass(); std::vector> GetFrameMapIndices() const; diff --git a/Include/Core/Classes/NPC.hpp b/Include/Core/Classes/NPC.hpp index 21fe122..21afe51 100644 --- a/Include/Core/Classes/NPC.hpp +++ b/Include/Core/Classes/NPC.hpp @@ -10,9 +10,14 @@ namespace Internal class NPC : public Character { public: - NPC(); NPC(const void* Obj); - NPC(const NPC& N); + + NPC() = default; + NPC(NPC&& Obj) = default; + NPC(const NPC& Obj) = default; + NPC& operator=(NPC&& Obj) = default; + NPC& operator=(const NPC& Obj) = default; + static Class GetClass(); NPCInfo GetNPCInfo() const; diff --git a/Include/Core/Classes/NPCInfo.hpp b/Include/Core/Classes/NPCInfo.hpp index 059588d..e2b0a0b 100644 --- a/Include/Core/Classes/NPCInfo.hpp +++ b/Include/Core/Classes/NPCInfo.hpp @@ -12,9 +12,14 @@ namespace Internal class NPCInfo : public CacheableNode { public: - NPCInfo(); NPCInfo(const void* Obj); - NPCInfo(const NPCInfo& N); + + NPCInfo() = default; + NPCInfo(NPCInfo&& Obj) = default; + NPCInfo(const NPCInfo& Obj) = default; + NPCInfo& operator=(NPCInfo&& Obj) = default; + NPCInfo& operator=(const NPCInfo& Obj) = default; + static Class GetClass(); std::vector GetActions() const; diff --git a/Include/Core/Classes/NamePair.hpp b/Include/Core/Classes/NamePair.hpp index 468b31d..2af461c 100644 --- a/Include/Core/Classes/NamePair.hpp +++ b/Include/Core/Classes/NamePair.hpp @@ -10,9 +10,14 @@ namespace Internal class NamePair : public Object { public: - NamePair(); NamePair(const void* Obj); - NamePair(const NamePair& N); + + NamePair() = default; + NamePair(NamePair&& Obj) = default; + NamePair(const NamePair& Obj) = default; + NamePair& operator=(NamePair&& Obj) = default; + NamePair& operator=(const NamePair& Obj) = default; + static Class GetClass(); std::string GetCleanName() const; diff --git a/Include/Core/Classes/Nameable.hpp b/Include/Core/Classes/Nameable.hpp index 9445a42..0119636 100644 --- a/Include/Core/Classes/Nameable.hpp +++ b/Include/Core/Classes/Nameable.hpp @@ -10,9 +10,14 @@ namespace Internal class Nameable : public Object { public: - Nameable(); Nameable(const void* Obj); - Nameable(const Nameable& N); + + Nameable() = default; + Nameable(Nameable&& Obj) = default; + Nameable(const Nameable& Obj) = default; + Nameable& operator=(Nameable&& Obj) = default; + Nameable& operator=(const Nameable& Obj) = default; + static Class GetClass(); NamePair GetNamePair() const; diff --git a/Include/Core/Classes/NameableContainer.hpp b/Include/Core/Classes/NameableContainer.hpp index 7737ad6..d58c294 100644 --- a/Include/Core/Classes/NameableContainer.hpp +++ b/Include/Core/Classes/NameableContainer.hpp @@ -11,9 +11,14 @@ namespace Internal class NameableContainer : public Object { public: - NameableContainer(); NameableContainer(const void* Obj); - NameableContainer(const NameableContainer& N); + + NameableContainer() = default; + NameableContainer(NameableContainer&& Obj) = default; + NameableContainer(const NameableContainer& Obj) = default; + NameableContainer& operator=(NameableContainer&& Obj) = default; + NameableContainer& operator=(const NameableContainer& Obj) = default; + static Class GetClass(); std::vector GetNameables() const; diff --git a/Include/Core/Classes/Node.hpp b/Include/Core/Classes/Node.hpp index ffc7995..037e93e 100644 --- a/Include/Core/Classes/Node.hpp +++ b/Include/Core/Classes/Node.hpp @@ -10,9 +10,14 @@ namespace Internal class Node : public Object { public: - Node(); Node(const void* Obj); - Node(const Node& N); + + Node() = default; + Node(Node&& Obj) = default; + Node(const Node& Obj) = default; + Node& operator=(Node&& Obj) = default; + Node& operator=(const Node& Obj) = default; + static Class GetClass(); Node GetNext() const; diff --git a/Include/Core/Classes/ObjectInfo.hpp b/Include/Core/Classes/ObjectInfo.hpp index 42139f8..5ae18aa 100644 --- a/Include/Core/Classes/ObjectInfo.hpp +++ b/Include/Core/Classes/ObjectInfo.hpp @@ -12,9 +12,14 @@ namespace Internal class ObjectInfo : public CacheableNode { public: - ObjectInfo(); ObjectInfo(const void* Obj); - ObjectInfo(const ObjectInfo& O); + + ObjectInfo() = default; + ObjectInfo(ObjectInfo&& Obj) = default; + ObjectInfo(const ObjectInfo& Obj) = default; + ObjectInfo& operator=(ObjectInfo&& Obj) = default; + ObjectInfo& operator=(const ObjectInfo& Obj) = default; + static Class GetClass(); std::vector GetActions() const; diff --git a/Include/Core/Classes/Player.hpp b/Include/Core/Classes/Player.hpp index 07627e7..2084b16 100644 --- a/Include/Core/Classes/Player.hpp +++ b/Include/Core/Classes/Player.hpp @@ -14,9 +14,14 @@ namespace Internal class Player : public Character { public: - Player(); Player(const void* Obj); - Player(const Player& P); + + Player() = default; + Player(Player&& Obj) = default; + Player(const Player& Obj) = default; + Player& operator=(Player&& Obj) = default; + Player& operator=(const Player& Obj) = default; + static Class GetClass(); std::vector GetActions() const; diff --git a/Include/Core/Classes/PlayerInfo.hpp b/Include/Core/Classes/PlayerInfo.hpp index a8f6317..b3bb399 100644 --- a/Include/Core/Classes/PlayerInfo.hpp +++ b/Include/Core/Classes/PlayerInfo.hpp @@ -11,9 +11,14 @@ namespace Internal class PlayerInfo : public Object { public: - PlayerInfo(); PlayerInfo(const void* Obj); - PlayerInfo(const PlayerInfo& P); + + PlayerInfo() = default; + PlayerInfo(PlayerInfo&& Obj) = default; + PlayerInfo(const PlayerInfo& Obj) = default; + PlayerInfo& operator=(PlayerInfo&& Obj) = default; + PlayerInfo& operator=(const PlayerInfo& Obj) = default; + static Class GetClass(); std::vector GetEquipment() const; diff --git a/Include/Core/Classes/PlayerManager.hpp b/Include/Core/Classes/PlayerManager.hpp index 6a00dce..21423e6 100644 --- a/Include/Core/Classes/PlayerManager.hpp +++ b/Include/Core/Classes/PlayerManager.hpp @@ -11,9 +11,14 @@ namespace Internal class PlayerManager : public Object { public: - PlayerManager(); PlayerManager(const void* Obj); - PlayerManager(const PlayerManager& P); + + PlayerManager() = default; + PlayerManager(PlayerManager&& Obj) = default; + PlayerManager(const PlayerManager& Obj) = default; + PlayerManager& operator=(PlayerManager&& Obj) = default; + PlayerManager& operator=(const PlayerManager& Obj) = default; + static Class GetClass(); FriendList GetFriendList() const; diff --git a/Include/Core/Classes/Preferences.hpp b/Include/Core/Classes/Preferences.hpp index ed161ee..0b99b90 100644 --- a/Include/Core/Classes/Preferences.hpp +++ b/Include/Core/Classes/Preferences.hpp @@ -12,9 +12,14 @@ namespace Internal class Preferences : public Object { public: - Preferences(); Preferences(const void* Obj); - Preferences(const Preferences& P); + + Preferences() = default; + Preferences(Preferences&& Obj) = default; + Preferences(const Preferences& Obj) = default; + Preferences& operator=(Preferences&& Obj) = default; + Preferences& operator=(const Preferences& Obj) = default; + static Class GetClass(); bool GetHideRoofs() const; diff --git a/Include/Core/Classes/Projectile.hpp b/Include/Core/Classes/Projectile.hpp index 2076d80..3b4f3b6 100644 --- a/Include/Core/Classes/Projectile.hpp +++ b/Include/Core/Classes/Projectile.hpp @@ -10,9 +10,14 @@ namespace Internal class Projectile : public Renderable { public: - Projectile(); Projectile(const void* Obj); - Projectile(const Projectile& P); + + Projectile() = default; + Projectile(Projectile&& Obj) = default; + Projectile(const Projectile& Obj) = default; + Projectile& operator=(Projectile&& Obj) = default; + Projectile& operator=(const Projectile& Obj) = default; + static Class GetClass(); std::int32_t GetAnimationFrame() const; diff --git a/Include/Core/Classes/Queue.hpp b/Include/Core/Classes/Queue.hpp index e765e48..542477d 100644 --- a/Include/Core/Classes/Queue.hpp +++ b/Include/Core/Classes/Queue.hpp @@ -10,9 +10,14 @@ namespace Internal class Queue : public Object { public: - Queue(); Queue(const void* Obj); - Queue(const Queue& Q); + + Queue() = default; + Queue(Queue&& Obj) = default; + Queue(const Queue& Obj) = default; + Queue& operator=(Queue&& Obj) = default; + Queue& operator=(const Queue& Obj) = default; + static Class GetClass(); CacheableNode GetHead() const; diff --git a/Include/Core/Classes/Rasterizer2D.hpp b/Include/Core/Classes/Rasterizer2D.hpp index 68a8ebf..c568c07 100644 --- a/Include/Core/Classes/Rasterizer2D.hpp +++ b/Include/Core/Classes/Rasterizer2D.hpp @@ -9,9 +9,14 @@ namespace Internal class Rasterizer2D : public CacheableNode { public: - Rasterizer2D(); Rasterizer2D(const void* Obj); - Rasterizer2D(const Rasterizer2D& R); + + Rasterizer2D() = default; + Rasterizer2D(Rasterizer2D&& Obj) = default; + Rasterizer2D(const Rasterizer2D& Obj) = default; + Rasterizer2D& operator=(Rasterizer2D&& Obj) = default; + Rasterizer2D& operator=(const Rasterizer2D& Obj) = default; + static Class GetClass(); }; diff --git a/Include/Core/Classes/Region.hpp b/Include/Core/Classes/Region.hpp index 388e172..eb509e9 100644 --- a/Include/Core/Classes/Region.hpp +++ b/Include/Core/Classes/Region.hpp @@ -12,9 +12,14 @@ namespace Internal class Region : public Object { public: - Region(); Region(const void* Obj); - Region(const Region& R); + + Region() = default; + Region(Region&& Obj) = default; + Region(const Region& Obj) = default; + Region& operator=(Region&& Obj) = default; + Region& operator=(const Region& Obj) = default; + static Class GetClass(); std::int32_t GetEntityCount() const; diff --git a/Include/Core/Classes/Renderable.hpp b/Include/Core/Classes/Renderable.hpp index 97147c4..8eb930c 100644 --- a/Include/Core/Classes/Renderable.hpp +++ b/Include/Core/Classes/Renderable.hpp @@ -10,9 +10,14 @@ namespace Internal class Renderable : public CacheableNode { public: - Renderable(); Renderable(const void* Obj); - Renderable(const Renderable& R); + + Renderable() = default; + Renderable(Renderable&& Obj) = default; + Renderable(const Renderable& Obj) = default; + Renderable& operator=(Renderable&& Obj) = default; + Renderable& operator=(const Renderable& Obj) = default; + static Class GetClass(); std::int32_t GetModelHeight() const; diff --git a/Include/Core/Classes/SceneTile.hpp b/Include/Core/Classes/SceneTile.hpp index b64d041..2cc203a 100644 --- a/Include/Core/Classes/SceneTile.hpp +++ b/Include/Core/Classes/SceneTile.hpp @@ -15,9 +15,14 @@ namespace Internal class SceneTile : public Node { public: - SceneTile(); SceneTile(const void* Obj); - SceneTile(const SceneTile& G); + + SceneTile() = default; + SceneTile(SceneTile&& Obj) = default; + SceneTile(const SceneTile& Obj) = default; + SceneTile& operator=(SceneTile&& Obj) = default; + SceneTile& operator=(const SceneTile& Obj) = default; + static Class GetClass(); DecorativeObject GetDecorativeObject() const; diff --git a/Include/Core/Classes/SpotAnimation.hpp b/Include/Core/Classes/SpotAnimation.hpp index 6d97012..e50b6e2 100644 --- a/Include/Core/Classes/SpotAnimation.hpp +++ b/Include/Core/Classes/SpotAnimation.hpp @@ -10,9 +10,14 @@ namespace Internal class SpotAnimation : public CacheableNode { public: - SpotAnimation(); SpotAnimation(const void* Obj); - SpotAnimation(const SpotAnimation& S); + + SpotAnimation() = default; + SpotAnimation(SpotAnimation&& Obj) = default; + SpotAnimation(const SpotAnimation& Obj) = default; + SpotAnimation& operator=(SpotAnimation&& Obj) = default; + SpotAnimation& operator=(const SpotAnimation& Obj) = default; + static Class GetClass(); std::int32_t GetAngle() const; diff --git a/Include/Core/Classes/Sprite.hpp b/Include/Core/Classes/Sprite.hpp index 7fa0903..d3d9399 100644 --- a/Include/Core/Classes/Sprite.hpp +++ b/Include/Core/Classes/Sprite.hpp @@ -11,9 +11,14 @@ namespace Internal class Sprite : public Object { public: - Sprite(); Sprite(const void* Obj); - Sprite(const Sprite& S); + + Sprite() = default; + Sprite(Sprite&& Obj) = default; + Sprite(const Sprite& Obj) = default; + Sprite& operator=(Sprite&& Obj) = default; + Sprite& operator=(const Sprite& Obj) = default; + static Class GetClass(); std::int32_t GetHeight() const; diff --git a/Include/Core/Classes/Talkable.hpp b/Include/Core/Classes/Talkable.hpp index 64fdabb..c0fe4bc 100644 --- a/Include/Core/Classes/Talkable.hpp +++ b/Include/Core/Classes/Talkable.hpp @@ -10,9 +10,14 @@ namespace Internal class Talkable : public Nameable { public: - Talkable(); Talkable(const void* Obj); - Talkable(const Talkable& T); + + Talkable() = default; + Talkable(Talkable&& Obj) = default; + Talkable(const Talkable& Obj) = default; + Talkable& operator=(Talkable&& Obj) = default; + Talkable& operator=(const Talkable& Obj) = default; + static Class GetClass(); std::int32_t GetRank() const; diff --git a/Include/Core/Classes/Varbit.hpp b/Include/Core/Classes/Varbit.hpp index f76fb79..993cdfc 100644 --- a/Include/Core/Classes/Varbit.hpp +++ b/Include/Core/Classes/Varbit.hpp @@ -10,9 +10,14 @@ namespace Internal class Varbit : public CacheableNode { public: - Varbit(); Varbit(const void* Obj); - Varbit(const Varbit& V); + + Varbit() = default; + Varbit(Varbit&& Obj) = default; + Varbit(const Varbit& Obj) = default; + Varbit& operator=(Varbit&& Obj) = default; + Varbit& operator=(const Varbit& Obj) = default; + static Class GetClass(); std::int32_t GetLSB() const; diff --git a/Include/Core/Classes/WallObject.hpp b/Include/Core/Classes/WallObject.hpp index 96b2cc1..0bbebec 100644 --- a/Include/Core/Classes/WallObject.hpp +++ b/Include/Core/Classes/WallObject.hpp @@ -11,9 +11,14 @@ namespace Internal class WallObject : public Object { public: - WallObject(); WallObject(const void* Obj); - WallObject(const WallObject& W); + + WallObject() = default; + WallObject(WallObject&& Obj) = default; + WallObject(const WallObject& Obj) = default; + WallObject& operator=(WallObject&& Obj) = default; + WallObject& operator=(const WallObject& Obj) = default; + static Class GetClass(); std::int32_t GetAngle() const; diff --git a/Include/Core/Classes/Widget.hpp b/Include/Core/Classes/Widget.hpp index 240a13a..5655675 100644 --- a/Include/Core/Classes/Widget.hpp +++ b/Include/Core/Classes/Widget.hpp @@ -12,9 +12,14 @@ namespace Internal class Widget : public Node { public: - Widget(); Widget(const void* Obj); - Widget(const Widget& W); + + Widget() = default; + Widget(Widget&& Obj) = default; + Widget(const Widget& Obj) = default; + Widget& operator=(Widget&& Obj) = default; + Widget& operator=(const Widget& Obj) = default; + static Class GetClass(); std::vector GetActions() const; diff --git a/Include/Core/Classes/WidgetNode.hpp b/Include/Core/Classes/WidgetNode.hpp index 56212ce..2912329 100644 --- a/Include/Core/Classes/WidgetNode.hpp +++ b/Include/Core/Classes/WidgetNode.hpp @@ -10,9 +10,14 @@ namespace Internal class WidgetNode : public Node { public: - WidgetNode(); WidgetNode(const void* Obj); - WidgetNode(const WidgetNode& W); + + WidgetNode() = default; + WidgetNode(WidgetNode&& Obj) = default; + WidgetNode(const WidgetNode& Obj) = default; + WidgetNode& operator=(WidgetNode&& Obj) = default; + WidgetNode& operator=(const WidgetNode& Obj) = default; + static Class GetClass(); std::int32_t GetID() const; diff --git a/Include/Core/Classes/World.hpp b/Include/Core/Classes/World.hpp index a9427fb..70c7614 100644 --- a/Include/Core/Classes/World.hpp +++ b/Include/Core/Classes/World.hpp @@ -11,9 +11,14 @@ namespace Internal class World : public Object { public: - World(); World(const void* Obj); - World(const World& W); + + World() = default; + World(World&& Obj) = default; + World(const World& Obj) = default; + World& operator=(World&& Obj) = default; + World& operator=(const World& Obj) = default; + static Class GetClass(); std::string GetActivity() const; diff --git a/Include/Core/Debug.hpp b/Include/Core/Debug.hpp index 9224979..ac66548 100644 --- a/Include/Core/Debug.hpp +++ b/Include/Core/Debug.hpp @@ -15,26 +15,25 @@ #define DEBUG_VERBOSE_FAIL_NOINFO --Debug::Verbose << __PRETTY_FUNCTION__ << " > Failed" << std::endl; #define DEBUG_VERBOSE_FAIL_EOF --Debug::Verbose << __PRETTY_FUNCTION__ << " > Failed > Reached end of function" << std::endl -class Debug +namespace Debug { - public: - static Logger Info; - static Logger Verbose; - static Logger Warning; - static Logger Error; - static Logger Fatal; - static Logger Internal; - static Logger Paint; + extern Logger Info; + extern Logger Verbose; + extern Logger Warning; + extern Logger Error; + extern Logger Fatal; + extern Logger Internal; + extern Logger Paint; - static void ShowConsole(); - static void HideConsole(); - static void SetVerbose(bool Toggle); + void ShowConsole(); + void HideConsole(); + void SetVerbose(bool Toggle); - static void EnableInput(); - static void DisableInput(); + void EnableInput(); + void DisableInput(); - static void Clear(); - static void Screenshot(const std::string& Path); + void Clear(); + void Screenshot(const std::string& Path); }; diff --git a/Include/Core/JavaClass/ByteBuffer.hpp b/Include/Core/JavaClass/ByteBuffer.hpp index d4c81aa..337e168 100644 --- a/Include/Core/JavaClass/ByteBuffer.hpp +++ b/Include/Core/JavaClass/ByteBuffer.hpp @@ -3,17 +3,23 @@ #include "Object.hpp" #include - -class ByteBuffer : public Object +namespace Internal { - public: - ByteBuffer(); - ByteBuffer(void* Obj); - ByteBuffer(const ByteBuffer& B); + class ByteBuffer : public Object + { + public: + ByteBuffer(const void* Obj); - std::int32_t GetCapacity() const; - std::int8_t Get(std::int32_t Index) const; + ByteBuffer() = default; + ByteBuffer(ByteBuffer&& Obj) = default; + ByteBuffer(const ByteBuffer& Obj) = default; + ByteBuffer& operator=(ByteBuffer&& Obj) = default; + ByteBuffer& operator=(const ByteBuffer& Obj) = default; -}; + std::int32_t GetCapacity() const; + std::int8_t Get(std::int32_t Index) const; + + }; +} #endif // BYTEBUFFER_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Canvas.hpp b/Include/Core/JavaClass/Canvas.hpp index 6a069cc..3d24555 100644 --- a/Include/Core/JavaClass/Canvas.hpp +++ b/Include/Core/JavaClass/Canvas.hpp @@ -4,15 +4,23 @@ #include #include "Object.hpp" -class Canvas : public Object +namespace Internal { - public: - Canvas(); - Canvas(void* Obj); - Canvas(const Canvas& C); - void DispatchEvent(Object Event) const; - std::int32_t GetWidth() const; - std::int32_t GetHeight() const; -}; + class Canvas : public Object + { + public: + Canvas(const void* Obj); + + Canvas() = default; + Canvas(Canvas&& Obj) = default; + Canvas(const Canvas& Obj) = default; + Canvas& operator=(Canvas&& Obj) = default; + Canvas& operator=(const Canvas& Obj) = default; + + void DispatchEvent(Object Event) const; + std::int32_t GetWidth() const; + std::int32_t GetHeight() const; + }; +} #endif // CANVAS_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Class.hpp b/Include/Core/JavaClass/Class.hpp index 9ed5530..4fdd86c 100644 --- a/Include/Core/JavaClass/Class.hpp +++ b/Include/Core/JavaClass/Class.hpp @@ -3,12 +3,19 @@ #include "Object.hpp" -class Class : public Object +namespace Internal { - public: - Class(); - Class(const void* Obj); - Class(const Class& C); -}; + class Class : public Object + { + public: + Class(const void* Obj); + + Class() = default; + Class(Class&& Obj) = default; + Class(const Class& Obj) = default; + Class& operator=(Class&& Obj) = default; + Class& operator=(const Class& Obj) = default; + }; +} #endif // CLASS_HPP_INCLUDED diff --git a/Include/Core/JavaClass/FocusEvent.hpp b/Include/Core/JavaClass/FocusEvent.hpp index 1024863..5d39f9a 100644 --- a/Include/Core/JavaClass/FocusEvent.hpp +++ b/Include/Core/JavaClass/FocusEvent.hpp @@ -4,13 +4,20 @@ #include #include "Object.hpp" -class FocusEvent : public Object +namespace Internal { - public: - FocusEvent(); - FocusEvent(void* Object); - FocusEvent(const FocusEvent& M); - FocusEvent(Object Source, std::int32_t ID); -}; + class FocusEvent : public Object + { + public: + FocusEvent(const void* Object); + FocusEvent(Object Source, std::int32_t ID); + + FocusEvent() = default; + FocusEvent(FocusEvent&& Obj) = default; + FocusEvent(const FocusEvent& Obj) = default; + FocusEvent& operator=(FocusEvent&& Obj) = default; + FocusEvent& operator=(const FocusEvent& Obj) = default; + }; +} #endif // FOCUSEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Integer.hpp b/Include/Core/JavaClass/Integer.hpp index 7ba0a0a..fa89f1f 100644 --- a/Include/Core/JavaClass/Integer.hpp +++ b/Include/Core/JavaClass/Integer.hpp @@ -4,14 +4,22 @@ #include #include "Object.hpp" -class Integer : public Object +namespace Internal { - public: - Integer(); - Integer(void* Obj); - Integer(const Integer& I); - Integer(std::int32_t Value); - std::int32_t GetIntValue() const; -}; + class Integer : public Object + { + public: + Integer(const void* Obj); + Integer(std::int32_t Value); + + Integer() = default; + Integer(Integer&& Obj) = default; + Integer(const Integer& Obj) = default; + Integer& operator=(Integer&& Obj) = default; + Integer& operator=(const Integer& Obj) = default; + + std::int32_t GetIntValue() const; + }; +} #endif // INTEGER_HPP_INCLUDED diff --git a/Include/Core/JavaClass/KeyEvent.hpp b/Include/Core/JavaClass/KeyEvent.hpp index 71a8bdc..d01758b 100644 --- a/Include/Core/JavaClass/KeyEvent.hpp +++ b/Include/Core/JavaClass/KeyEvent.hpp @@ -4,14 +4,21 @@ #include #include "Object.hpp" -class KeyEvent : public Object +namespace Internal { - public: - KeyEvent(); - KeyEvent(void* Obj); - KeyEvent(const KeyEvent& M); - KeyEvent(Object Source, std::int32_t ID, std::int64_t When, std::int32_t Modifiers, - std::int32_t KeyCode, std::uint16_t KeyChar, std::int32_t KeyLocation); -}; + class KeyEvent : public Object + { + public: + KeyEvent(const void* Obj); + KeyEvent(Object Source, std::int32_t ID, std::int64_t When, std::int32_t Modifiers, + std::int32_t KeyCode, std::uint16_t KeyChar, std::int32_t KeyLocation); + + KeyEvent() = default; + KeyEvent(KeyEvent&& Obj) = default; + KeyEvent(const KeyEvent& Obj) = default; + KeyEvent& operator=(KeyEvent&& Obj) = default; + KeyEvent& operator=(const KeyEvent& Obj) = default; + }; +} #endif // KEYEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/LinkedHashMap.hpp b/Include/Core/JavaClass/LinkedHashMap.hpp index 66cc50d..2f5813a 100644 --- a/Include/Core/JavaClass/LinkedHashMap.hpp +++ b/Include/Core/JavaClass/LinkedHashMap.hpp @@ -3,13 +3,21 @@ #include "Object.hpp" -class LinkedHashMap : public Object +namespace Internal { - public: - LinkedHashMap(); - LinkedHashMap(void* Obj); - LinkedHashMap(const LinkedHashMap& L); - Object GetValue(Object Key) const; -}; + class LinkedHashMap : public Object + { + public: + LinkedHashMap(const void* Obj); + + LinkedHashMap() = default; + LinkedHashMap(LinkedHashMap&& Obj) = default; + LinkedHashMap(const LinkedHashMap& Obj) = default; + LinkedHashMap& operator=(LinkedHashMap&& Obj) = default; + LinkedHashMap& operator=(const LinkedHashMap& Obj) = default; + + Object GetValue(Object Key) const; + }; +} #endif // LINKEDHASHMAP_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Map.hpp b/Include/Core/JavaClass/Map.hpp index c0f013e..812ba7b 100644 --- a/Include/Core/JavaClass/Map.hpp +++ b/Include/Core/JavaClass/Map.hpp @@ -5,14 +5,22 @@ #include "Object.hpp" #include "Set.hpp" -class Map : public Object +namespace Internal { - public: - Map(); - Map(void* Obj); - Map(const Map& M); - Object GetValue(Object Key) const; - Set GetKeySet() const; -}; + class Map : public Object + { + public: + Map(const void* Obj); + + Map() = default; + Map(Map&& Obj) = default; + Map(const Map& Obj) = default; + Map& operator=(Map&& Obj) = default; + Map& operator=(const Map& Obj) = default; + + Object GetValue(Object Key) const; + Set GetKeySet() const; + }; +} #endif // MAP_HPP_INCLUDED diff --git a/Include/Core/JavaClass/MouseEvent.hpp b/Include/Core/JavaClass/MouseEvent.hpp index 943d96a..e088ea3 100644 --- a/Include/Core/JavaClass/MouseEvent.hpp +++ b/Include/Core/JavaClass/MouseEvent.hpp @@ -4,15 +4,22 @@ #include #include "Object.hpp" -class MouseEvent : public Object +namespace Internal { - public: - MouseEvent(); - MouseEvent(void* Object); - MouseEvent(const MouseEvent& M); - MouseEvent(Object Source, std::int32_t ID, std::int64_t When, std::int32_t Modifiers, - std::int32_t X, std::int32_t Y, std::int32_t ClickCount, bool PopupTrigger, - std::int32_t Button); -}; + class MouseEvent : public Object + { + public: + MouseEvent(const void* Object); + MouseEvent(Object Source, std::int32_t ID, std::int64_t When, std::int32_t Modifiers, + std::int32_t X, std::int32_t Y, std::int32_t ClickCount, bool PopupTrigger, + std::int32_t Button); + + MouseEvent() = default; + MouseEvent(MouseEvent&& Obj) = default; + MouseEvent(const MouseEvent& Obj) = default; + MouseEvent& operator=(MouseEvent&& Obj) = default; + MouseEvent& operator=(const MouseEvent& Obj) = default; + }; +} #endif // MOUSEEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/MouseWheelEvent.hpp b/Include/Core/JavaClass/MouseWheelEvent.hpp index 1b1f50e..3625154 100644 --- a/Include/Core/JavaClass/MouseWheelEvent.hpp +++ b/Include/Core/JavaClass/MouseWheelEvent.hpp @@ -4,15 +4,22 @@ #include #include "Object.hpp" -class MouseWheelEvent : public Object +namespace Internal { - public: - MouseWheelEvent(); - MouseWheelEvent(void* Object); - MouseWheelEvent(const MouseWheelEvent& M); - MouseWheelEvent(Object Source, std::int32_t ID, std::int64_t When, std::int32_t Modifiers, - std::int32_t X, std::int32_t Y, std::int32_t ClickCount, bool PopupTrigger, - std::int32_t ScrollType, std::int32_t ScrollAmount, std::int32_t WheelRotation); -}; + class MouseWheelEvent : public Object + { + public: + MouseWheelEvent(const void* Object); + MouseWheelEvent(Object Source, std::int32_t ID, std::int64_t When, std::int32_t Modifiers, + std::int32_t X, std::int32_t Y, std::int32_t ClickCount, bool PopupTrigger, + std::int32_t ScrollType, std::int32_t ScrollAmount, std::int32_t WheelRotation); + + MouseWheelEvent() = default; + MouseWheelEvent(MouseWheelEvent&& Obj) = default; + MouseWheelEvent(const MouseWheelEvent& Obj) = default; + MouseWheelEvent& operator=(MouseWheelEvent&& Obj) = default; + MouseWheelEvent& operator=(const MouseWheelEvent& Obj) = default; + }; +} #endif // MOUSEWHEELEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Object.hpp b/Include/Core/JavaClass/Object.hpp index 550f3c6..da671e6 100644 --- a/Include/Core/JavaClass/Object.hpp +++ b/Include/Core/JavaClass/Object.hpp @@ -1,25 +1,29 @@ #ifndef OBJECT_HPP_INCLUDED #define OBJECT_HPP_INCLUDED -class Class; - -class Object +namespace Internal { - public: - void* Obj = nullptr; - Object(); - Object(const void* Obj); - Object(const Object& O); - Object(Object&& O); - Object& operator=(const Object& O); - Object& operator=(Object&& O); - bool operator==(const Object& O) const; - bool operator!=(const Object& O) const; - bool Equals(Object O) const; - bool InstanceOf(Class C) const; - operator bool() const; - operator void*() const; - ~Object(); -}; + class Class; + class Object + { + public: + void* Obj = nullptr; + + Object(const void* Obj = nullptr); + Object(Object&& Obj); + Object(const Object& Obj); + Object& operator=(Object&& Obj); + Object& operator=(const Object& Obj); + + bool operator==(const Object& O) const; + bool operator!=(const Object& O) const; + operator bool() const; + operator void*() const; + + bool Equals(Object O) const; + bool InstanceOf(Class C) const; + virtual ~Object(); + }; +} #endif // OBJECT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Set.hpp b/Include/Core/JavaClass/Set.hpp index 45eb5d6..eb04ff6 100644 --- a/Include/Core/JavaClass/Set.hpp +++ b/Include/Core/JavaClass/Set.hpp @@ -4,13 +4,21 @@ #include #include "Object.hpp" -class Set : public Object +namespace Internal { - public: - Set(); - Set(void* Obj); - Set(const Set& S); - std::vector ToArray() const; -}; + class Set : public Object + { + public: + Set(const void* Obj); + + Set() = default; + Set(Set&& Obj) = default; + Set(const Set& Obj) = default; + Set& operator=(Set&& Obj) = default; + Set& operator=(const Set& Obj) = default; + + std::vector ToArray() const; + }; +} #endif // SET_HPP_INCLUDED diff --git a/Include/Core/Paint.hpp b/Include/Core/Paint.hpp index 1d7d467..daee84a 100644 --- a/Include/Core/Paint.hpp +++ b/Include/Core/Paint.hpp @@ -5,34 +5,34 @@ #include "Types/Convex.hpp" #include "Types/Tile.hpp" -struct Pixel -{ - std::uint8_t Red; - std::uint8_t Green; - std::uint8_t Blue; - std::uint8_t Alpha; -}; /** @addtogroup Core * @{ */ -class Paint +namespace Paint { - public: - static std::uint32_t* GetPixels(); - static void Clear(); - static void DrawDot(const Point& P, double Radius, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawPoint(const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawPoints(const std::vector& Points, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawLine(const Point& A, const Point& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawLines(const std::vector& A, const std::vector& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawBox(const Box& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawSquare(const Box& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawConvex(const Convex& C, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawTile(const Tile& T, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawModel(const std::vector& Model, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawString(const std::string& String, const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); - static void DrawPixels(const std::vector Pixels, std::uint32_t Width, std::uint32_t Height, const Point& P); - static void SwapBuffer(); + struct Pixel + { + std::uint8_t Red; + std::uint8_t Green; + std::uint8_t Blue; + std::uint8_t Alpha; + }; + + std::uint32_t* GetPixels(); + void Clear(); + void DrawDot(const Point& P, double Radius, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawPoint(const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawPoints(const std::vector& Points, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawLine(const Point& A, const Point& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawLines(const std::vector& A, const std::vector& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawBox(const Box& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawSquare(const Box& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawConvex(const Convex& C, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawTile(const Tile& T, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawModel(const std::vector& Model, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawString(const std::string& String, const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); + void DrawPixels(const std::vector Pixels, std::uint32_t Width, std::uint32_t Height, const Point& P); + void SwapBuffer(); }; /** @} */ diff --git a/Include/Game/Interactable/DecorativeObject.hpp b/Include/Game/Interactable/DecorativeObject.hpp index bcba902..a51b2c4 100644 --- a/Include/Game/Interactable/DecorativeObject.hpp +++ b/Include/Game/Interactable/DecorativeObject.hpp @@ -18,7 +18,12 @@ namespace Interactable { public: DecorativeObject(const Internal::DecorativeObject& D); - DecorativeObject(const DecorativeObject& D); + + DecorativeObject() = default; + DecorativeObject(DecorativeObject&& Obj) = default; + DecorativeObject(const DecorativeObject& Obj) = default; + DecorativeObject& operator=(DecorativeObject&& Obj) = default; + DecorativeObject& operator=(const DecorativeObject& Obj) = default; std::int32_t GetID() const; std::string GetName() const; @@ -44,7 +49,6 @@ namespace Interactable bool Interact(const std::string& Option, bool CheckTarget = true) const; bool Interact(const std::vector& Options, bool CheckTarget = true) const; - operator Internal::DecorativeObject() const; }; } diff --git a/Include/Game/Interactable/GameObject.hpp b/Include/Game/Interactable/GameObject.hpp index 42650f8..acd840a 100644 --- a/Include/Game/Interactable/GameObject.hpp +++ b/Include/Game/Interactable/GameObject.hpp @@ -18,7 +18,12 @@ namespace Interactable { public: GameObject(const Internal::GameObject& G); - GameObject(const GameObject& G); + + GameObject() = default; + GameObject(GameObject&& Obj) = default; + GameObject(const GameObject& Obj) = default; + GameObject& operator=(GameObject&& Obj) = default; + GameObject& operator=(const GameObject& Obj) = default; std::int32_t GetID() const; std::string GetName() const; @@ -46,7 +51,6 @@ namespace Interactable bool Interact(const std::string& Option, bool CheckTarget = true) const; bool Interact(const std::vector& Options, bool CheckTarget = true) const; - operator Internal::GameObject() const; }; } diff --git a/Include/Game/Interactable/GroundItem.hpp b/Include/Game/Interactable/GroundItem.hpp index 7575f1a..764d306 100644 --- a/Include/Game/Interactable/GroundItem.hpp +++ b/Include/Game/Interactable/GroundItem.hpp @@ -19,10 +19,14 @@ namespace Interactable private: Tile LocalTile; public: - GroundItem(); GroundItem(const Internal::GroundItem& G); GroundItem(const Internal::GroundItem& G, const Tile& LocalTile); - GroundItem(const GroundItem& G); + + GroundItem() = default; + GroundItem(GroundItem&& Obj) = default; + GroundItem(const GroundItem& Obj) = default; + GroundItem& operator=(GroundItem&& Obj) = default; + GroundItem& operator=(const GroundItem& Obj) = default; std::string GetName() const; Internal::ItemInfo GetInfo() const; @@ -48,7 +52,6 @@ namespace Interactable bool Interact(const std::string& Option, bool CheckTarget = true) const; bool Interact(const std::vector& Options, bool CheckTarget = true) const; - operator Internal::GroundItem() const; }; } diff --git a/Include/Game/Interactable/GroundObject.hpp b/Include/Game/Interactable/GroundObject.hpp index 7995d9a..5d29681 100644 --- a/Include/Game/Interactable/GroundObject.hpp +++ b/Include/Game/Interactable/GroundObject.hpp @@ -18,7 +18,12 @@ namespace Interactable { public: GroundObject(const Internal::GroundObject& G); - GroundObject(const GroundObject& G); + + GroundObject() = default; + GroundObject(GroundObject&& Obj) = default; + GroundObject(const GroundObject& Obj) = default; + GroundObject& operator=(GroundObject&& Obj) = default; + GroundObject& operator=(const GroundObject& Obj) = default; std::int32_t GetID() const; std::string GetName() const; diff --git a/Include/Game/Interactable/Item.hpp b/Include/Game/Interactable/Item.hpp index 8944f49..0d2d45c 100644 --- a/Include/Game/Interactable/Item.hpp +++ b/Include/Game/Interactable/Item.hpp @@ -51,7 +51,6 @@ namespace Interactable bool Valid() const; operator bool() const; - virtual ~Item(); private: std::int32_t Index; std::int32_t ID; diff --git a/Include/Game/Interactable/NPC.hpp b/Include/Game/Interactable/NPC.hpp index 95ab017..fd781aa 100644 --- a/Include/Game/Interactable/NPC.hpp +++ b/Include/Game/Interactable/NPC.hpp @@ -18,7 +18,12 @@ namespace Interactable { public: NPC(const Internal::NPC& N); - NPC(const NPC& N); + + NPC() = default; + NPC(NPC&& Obj) = default; + NPC(const NPC& Obj) = default; + NPC& operator=(NPC&& Obj) = default; + NPC& operator=(const NPC& Obj) = default; std::int32_t GetID() const; std::string GetName() const; @@ -48,7 +53,6 @@ namespace Interactable bool Interact(const std::string& Option, bool CheckTarget = true) const; bool Interact(const std::vector& Options, bool CheckTarget = true) const; - operator Internal::NPC() const; }; } diff --git a/Include/Game/Interactable/Player.hpp b/Include/Game/Interactable/Player.hpp index 3d941ad..e4e0e07 100644 --- a/Include/Game/Interactable/Player.hpp +++ b/Include/Game/Interactable/Player.hpp @@ -18,7 +18,12 @@ namespace Interactable { public: Player(const Internal::Player& P); - Player(const Player& P); + + Player() = default; + Player(Player&& Obj) = default; + Player(const Player& Obj) = default; + Player& operator=(Player&& Obj) = default; + Player& operator=(const Player& Obj) = default; std::string GetName() const; Internal::PlayerInfo GetInfo() const; @@ -47,7 +52,6 @@ namespace Interactable bool Interact(const std::string& Option, bool CheckTarget = true) const; bool Interact(const std::vector& Options, bool CheckTarget = true) const; - operator Internal::Player() const; }; } diff --git a/Include/Game/Interactable/Projectile.hpp b/Include/Game/Interactable/Projectile.hpp index eb71853..4ca23ba 100644 --- a/Include/Game/Interactable/Projectile.hpp +++ b/Include/Game/Interactable/Projectile.hpp @@ -13,7 +13,12 @@ namespace Interactable { public: Projectile(const Internal::Projectile& P); - Projectile(const Projectile& P); + + Projectile() = default; + Projectile(Projectile&& Obj) = default; + Projectile(const Projectile& Obj) = default; + Projectile& operator=(Projectile&& Obj) = default; + Projectile& operator=(const Projectile& Obj) = default; std::vector GetModel() const; Tile GetTile() const; diff --git a/Include/Game/Interactable/WallObject.hpp b/Include/Game/Interactable/WallObject.hpp index a1a7279..35ed67f 100644 --- a/Include/Game/Interactable/WallObject.hpp +++ b/Include/Game/Interactable/WallObject.hpp @@ -18,7 +18,12 @@ namespace Interactable { public: WallObject(const Internal::WallObject& W); - WallObject(const WallObject& W); + + WallObject() = default; + WallObject(WallObject&& Obj) = default; + WallObject(const WallObject& Obj) = default; + WallObject& operator=(WallObject&& Obj) = default; + WallObject& operator=(const WallObject& Obj) = default; std::int32_t GetID() const; std::string GetName() const; @@ -44,7 +49,6 @@ namespace Interactable bool Interact(const std::string& Option, bool CheckTarget = true) const; bool Interact(const std::vector& Options, bool CheckTarget = true) const; - operator Internal::WallObject() const; }; } diff --git a/Include/Game/Interactable/Widget.hpp b/Include/Game/Interactable/Widget.hpp index 293a01d..4b17754 100644 --- a/Include/Game/Interactable/Widget.hpp +++ b/Include/Game/Interactable/Widget.hpp @@ -16,7 +16,12 @@ namespace Interactable { public: Widget(const Internal::Widget& W); - Widget(const Widget& W); + + Widget() = default; + Widget(Widget&& Obj) = default; + Widget(const Widget& Obj) = default; + Widget& operator=(Widget&& Obj) = default; + Widget& operator=(const Widget& Obj) = default; bool IsHidden() const; bool IsVisible() const; @@ -31,7 +36,6 @@ namespace Interactable bool Interact(const std::string& Option) const; bool Interact(const std::vector& Options) const; - operator Internal::Widget() const; }; } diff --git a/Include/Game/Interfaces/Bank.hpp b/Include/Game/Interfaces/Bank.hpp index d05cb0e..a8ebda4 100644 --- a/Include/Game/Interfaces/Bank.hpp +++ b/Include/Game/Interfaces/Bank.hpp @@ -11,110 +11,108 @@ /** @addtogroup Interfaces * @{ */ -class Bank +namespace Bank { - public: + enum BANK_AMOUNT + { + ALL = -1, + ALL_BUT_ONE = 0 + }; - enum BANK_AMOUNT - { - ALL = -1, - ALL_BUT_ONE = 0 - }; + typedef enum WITHDRAW_MODE + { + ITEM, + NOTED + } WITHDRAW_MODE; - typedef enum WITHDRAW_MODE - { - ITEM, - NOTED - } WITHDRAW_MODE; + typedef enum PIN_STEP + { + FIRST, + SECOND, + THIRD, + FOURTH, + SUBMITTING, + TOO_MANY_ATTEMPTS, + BANK_OPEN + } PIN_STEP; - typedef enum PIN_STEP - { - FIRST, - SECOND, - THIRD, - FOURTH, - SUBMITTING, - TOO_MANY_ATTEMPTS, - BANK_OPEN - } PIN_STEP; + bool IsOpen(); + bool Close(bool AllowEsc = true); - static bool IsOpen(); - static bool Close(bool AllowEsc = true); + std::vector GetItemIDs(); + std::vector GetItemNames(); + std::vector GetItemAmounts(); - static std::vector GetItemIDs(); - static std::vector GetItemNames(); - static std::vector GetItemAmounts(); + std::vector GetItems(); + std::vector GetItems(std::int32_t ID); + std::vector GetItems(const std::string& Name); + std::vector GetItems(const std::vector& IDs); + std::vector GetItems(const std::vector& Names); + std::vector GetItems(const std::function& Filter); - static std::vector GetItems(); - static std::vector GetItems(std::int32_t ID); - static std::vector GetItems(const std::string& Name); - static std::vector GetItems(const std::vector& IDs); - static std::vector GetItems(const std::vector& Names); - static std::vector GetItems(const std::function& Filter); + Interactable::Item GetItem(std::int32_t ID); + Interactable::Item GetItem(const std::string& Name); + Interactable::Item GetItem(const std::vector& IDs); + Interactable::Item GetItem(const std::vector& Names); + Interactable::Item GetItem(const std::function& Filter); - static Interactable::Item GetItem(std::int32_t ID); - static Interactable::Item GetItem(const std::string& Name); - static Interactable::Item GetItem(const std::vector& IDs); - static Interactable::Item GetItem(const std::vector& Names); - static Interactable::Item GetItem(const std::function& Filter); + std::int32_t Count(std::int32_t ID); + std::int32_t Count(const std::string& Name); + std::int32_t Count(const Interactable::Item& Item); - static std::int32_t Count(std::int32_t ID); - static std::int32_t Count(const std::string& Name); - static std::int32_t Count(const Interactable::Item& Item); + std::int32_t GetIndexOf(std::int32_t ID); + std::int32_t GetIndexOf(const std::string& Name); - static std::int32_t GetIndexOf(std::int32_t ID); - static std::int32_t GetIndexOf(const std::string& Name); + bool Contains(std::int32_t ID); + bool Contains(const std::string& Name); + bool Contains(const Interactable::Item& Item); + bool Contains(const std::vector& IDs); // true if all items are found at least once + bool Contains(const std::vector& Names); // true if all items are found at least once + bool Contains(const std::vector& Items); - static bool Contains(std::int32_t ID); - static bool Contains(const std::string& Name); - static bool Contains(const Interactable::Item& Item); - static bool Contains(const std::vector& IDs); // true if all items are found at least once - static bool Contains(const std::vector& Names); // true if all items are found at least once - static bool Contains(const std::vector& Items); + bool ContainsAny(const std::vector& IDs); + bool ContainsAny(const std::vector& Names); + bool ContainsAny(const std::vector& Items); - static bool ContainsAny(const std::vector& IDs); - static bool ContainsAny(const std::vector& Names); - static bool ContainsAny(const std::vector& Items); + std::int32_t GetCurrentTab(); + std::int32_t GetTabOf(std::int32_t ID); + std::int32_t GetTabOf(const std::string& Name); + std::int32_t GetTabOf(const Interactable::Item& Item); + bool OpenTab(std::int32_t Tab); - static std::int32_t GetCurrentTab(); - static std::int32_t GetTabOf(std::int32_t ID); - static std::int32_t GetTabOf(const std::string& Name); - static std::int32_t GetTabOf(const Interactable::Item& Item); - static bool OpenTab(std::int32_t Tab); + bool ScrollTo(std::int32_t ID, bool OpenRespectiveTab = false); + bool ScrollTo(const std::string& Name, bool OpenRespectiveTab = false); + bool ScrollTo(const Interactable::Item& Item, bool OpenRespectiveTab = false); - static bool ScrollTo(std::int32_t ID, bool OpenRespectiveTab = false); - static bool ScrollTo(const std::string& Name, bool OpenRespectiveTab = false); - static bool ScrollTo(const Interactable::Item& Item, bool OpenRespectiveTab = false); + // -1 = all, 0 = all-but-one + bool Withdraw(std::int32_t ID, std::int32_t Amount, bool OpenRespectiveTab = false); + bool Withdraw(const std::string& Name, std::int32_t Amount, bool OpenRespectiveTab = false); + bool Withdraw(const Interactable::Item& Item, std::int32_t Amount, bool OpenRespectiveTab = false); - // -1 = all, 0 = all-but-one - static bool Withdraw(std::int32_t ID, std::int32_t Amount, bool OpenRespectiveTab = false); - static bool Withdraw(const std::string& Name, std::int32_t Amount, bool OpenRespectiveTab = false); - static bool Withdraw(const Interactable::Item& Item, std::int32_t Amount, bool OpenRespectiveTab = false); + // -1 = all + bool Deposit(std::int32_t ID, std::int32_t Amount); + bool Deposit(const std::string& Name, std::int32_t Amount); + bool Deposit(const Interactable::Item& Item, std::int32_t Amount); - // -1 = all - static bool Deposit(std::int32_t ID, std::int32_t Amount); - static bool Deposit(const std::string& Name, std::int32_t Amount); - static bool Deposit(const Interactable::Item& Item, std::int32_t Amount); + bool DepositAllExcept(std::int32_t ID, double DepsositAllChance = 0.00); // DepositAllChance = the chance it will click deposit all on the individual item, instead of left clicking if possible. Will deposit all if the current default quantity is not enough to one click it + bool DepositAllExcept(const std::string& Name, double DepsositAllChance = 0.00); + bool DepositAllExcept(const Interactable::Item& Item, double DepsositAllChance = 0.00); + bool DepositAllExcept(const std::vector& IDs, double DepsositAllChance = 0.00); + bool DepositAllExcept(const std::vector& Names, double DepsositAllChance = 0.00); + bool DepositAllExcept(const std::vector& Items, double DepsositAllChance = 0.00); - static bool DepositAllExcept(std::int32_t ID, double DepsositAllChance = 0.00); // DepositAllChance = the chance it will click deposit all on the individual item, instead of left clicking if possible. Will deposit all if the current default quantity is not enough to one click it - static bool DepositAllExcept(const std::string& Name, double DepsositAllChance = 0.00); - static bool DepositAllExcept(const Interactable::Item& Item, double DepsositAllChance = 0.00); - static bool DepositAllExcept(const std::vector& IDs, double DepsositAllChance = 0.00); - static bool DepositAllExcept(const std::vector& Names, double DepsositAllChance = 0.00); - static bool DepositAllExcept(const std::vector& Items, double DepsositAllChance = 0.00); + bool DepositAll(); + bool DepositEquipment(); - static bool DepositAll(); - static bool DepositEquipment(); + WITHDRAW_MODE GetWithdrawMode(); + bool SetWithdrawMode(WITHDRAW_MODE Mode); - static WITHDRAW_MODE GetWithdrawMode(); - static bool SetWithdrawMode(WITHDRAW_MODE Mode); + PIN_STEP GetEnterPinStep(); + bool IsEnterPinOpen(); + bool EnterPin(bool Terminate = true); - static PIN_STEP GetEnterPinStep(); - static bool IsEnterPinOpen(); - static bool EnterPin(bool Terminate = true); - - static std::int32_t GetDefaultWithdrawQuantity(); - static bool SetDefaultWithdrawQuantity(std::int32_t Amount); + std::int32_t GetDefaultWithdrawQuantity(); + bool SetDefaultWithdrawQuantity(std::int32_t Amount); }; /** @} */ diff --git a/Include/Game/Interfaces/Chat.hpp b/Include/Game/Interfaces/Chat.hpp index a2f45a1..2f75999 100644 --- a/Include/Game/Interfaces/Chat.hpp +++ b/Include/Game/Interfaces/Chat.hpp @@ -8,69 +8,66 @@ /** @addtogroup Interfaces * @{ */ -class Chat +namespace Chat { + typedef enum DIALOGUE_STATE + { + IDLE, + CLICK_CONTINUE, + SELECT_OPTION, + PLEASE_WAIT, + ENTER_AMOUNT, + LEVEL_UP + } DIALOGUE_STATE; - public: + typedef enum CHAT_TYPE + { + SERVER = 0, + PUBLIC_MOD = 1, + PUBLIC = 2, + PRIVATE_MESSAGE_RECEIVED = 3, + TRADE_RECEIVED = 4, + PRIVATE_MESSAGE_INFO = 5, + PRIVATE_MESSAGE_SENT = 6, + PRIVATE_MESSAGE_RECEIVED_MOD = 7, + CLANCHAT = 9, + CLANCHAT_INFO = 11, + TRADE_SENT = 12, + ABUSE_REPORT = 26, + EXAMINE_ITEM = 27, + EXAMINE_NPC = 28, + EXAMINE_OBJECT = 29, + FRIENDS_LIST_ADD = 30, + IGNORE_LIST_ADD = 31, + AUTOCHAT = 90, + GAME = 99, + TRADE = 101, + DUEL = 103, + FILTERED = 105, + ACTION = 109, + UNKNOWN = -1 + } CHAT_TYPE; - typedef enum DIALOGUE_STATE - { - IDLE, - CLICK_CONTINUE, - SELECT_OPTION, - PLEASE_WAIT, - ENTER_AMOUNT, - LEVEL_UP - } DIALOGUE_STATE; + std::vector GetMessages(CHAT_TYPE Type, bool Sort = true); + std::vector GetMessages(const std::vector& Type, bool Sort = true); + Internal::MessageNode GetLastMessage(CHAT_TYPE Type); - typedef enum CHAT_TYPE - { - SERVER = 0, - PUBLIC_MOD = 1, - PUBLIC = 2, - PRIVATE_MESSAGE_RECEIVED = 3, - TRADE_RECEIVED = 4, - PRIVATE_MESSAGE_INFO = 5, - PRIVATE_MESSAGE_SENT = 6, - PRIVATE_MESSAGE_RECEIVED_MOD = 7, - CLANCHAT = 9, - CLANCHAT_INFO = 11, - TRADE_SENT = 12, - ABUSE_REPORT = 26, - EXAMINE_ITEM = 27, - EXAMINE_NPC = 28, - EXAMINE_OBJECT = 29, - FRIENDS_LIST_ADD = 30, - IGNORE_LIST_ADD = 31, - AUTOCHAT = 90, - GAME = 99, - TRADE = 101, - DUEL = 103, - FILTERED = 105, - ACTION = 109, - UNKNOWN = -1 - } CHAT_TYPE; + DIALOGUE_STATE GetDialogueState(); + std::vector GetDialogueOptions(); + std::string GetDialogueTitle(); + std::string GetDialogueContent(); - static std::vector GetMessages(CHAT_TYPE Type, bool Sort = true); - static std::vector GetMessages(const std::vector& Type, bool Sort = true); - static Internal::MessageNode GetLastMessage(CHAT_TYPE Type); + std::int32_t GetDialogueOptionIndexOf(const std::string& Option); + std::int32_t GetDialogueOptionIndexOf(const std::vector& Options); - static DIALOGUE_STATE GetDialogueState(); - static std::vector GetDialogueOptions(); - static std::string GetDialogueTitle(); - static std::string GetDialogueContent(); + bool ClickContinue(bool UseKeyboard = false); + bool EnterAmount(std::int32_t Amount); - static std::int32_t GetDialogueOptionIndexOf(const std::string& Option); - static std::int32_t GetDialogueOptionIndexOf(const std::vector& Options); + bool SelectDialogueOption(std::int32_t Index, bool UseKeyboard = false); // Index starts at 0 + bool SelectDialogueOption(const std::string& Option, bool UseKeyboard = false); + bool SelectDialogueOption(const std::vector& Options, bool UseKeyboard = false); - static bool ClickContinue(bool UseKeyboard = false); - static bool EnterAmount(std::int32_t Amount); - - static bool SelectDialogueOption(std::int32_t Index, bool UseKeyboard = false); // Index starts at 0 - static bool SelectDialogueOption(const std::string& Option, bool UseKeyboard = false); - static bool SelectDialogueOption(const std::vector& Options, bool UseKeyboard = false); - - static bool WaitDialogueState(std::uint32_t Duration, std::uint32_t Step, Chat::DIALOGUE_STATE State, bool Result = true); // Waits until the current chat state equals State + bool WaitDialogueState(std::uint32_t Duration, std::uint32_t Step, Chat::DIALOGUE_STATE State, bool Result = true); // Waits until the current chat state equals State }; /** @} */ diff --git a/Include/Game/Interfaces/DepositBox.hpp b/Include/Game/Interfaces/DepositBox.hpp index e038c23..cbe2c71 100644 --- a/Include/Game/Interfaces/DepositBox.hpp +++ b/Include/Game/Interfaces/DepositBox.hpp @@ -3,15 +3,14 @@ /** @addtogroup Interfaces * @{ */ -class DepositBox +namespace DepositBox { - public: - static bool IsOpen(); - static bool Close(bool AllowEsc = true); + bool IsOpen(); + bool Close(bool AllowEsc = true); - static bool DepositAll(); - static bool DepositEquipment(); - static bool DepositLoot(); + bool DepositAll(); + bool DepositEquipment(); + bool DepositLoot(); }; /** @} */ diff --git a/Include/Game/Interfaces/Exchange.hpp b/Include/Game/Interfaces/Exchange.hpp index f9db245..1dafe40 100644 --- a/Include/Game/Interfaces/Exchange.hpp +++ b/Include/Game/Interfaces/Exchange.hpp @@ -9,110 +9,107 @@ /** @addtogroup Interfaces * @{ */ -class Exchange +namespace Exchange { - public: + typedef std::int32_t SLOT; - typedef std::int32_t SLOT; + typedef enum SLOT_STATE + { + STATE_EMPTY = 0, + STARTING_BUY_OFFER = 1, + BUY_OFFER_INCOMPLETE = 2, + BUY_OFFER_UPDATING = 3, + BUY_OFFER_CANCELING = 4, + BUY_OFFER_COMPLETE = 5, + STARTING_SELL_OFFER = 9, + SELL_OFFER_INCOMPLETE = 10, + SELL_OFFER_UPDATING = 11, + SELL_OFFER_CANCELING = 12, + SELL_OFFER_COMPLETE = 13, + STATE_DISABLED = 14, + STATE_UNDEFINED = 15 + } SLOT_STATE; - typedef enum SLOT_STATE - { - STATE_EMPTY = 0, - STARTING_BUY_OFFER = 1, - BUY_OFFER_INCOMPLETE = 2, - BUY_OFFER_UPDATING = 3, - BUY_OFFER_CANCELING = 4, - BUY_OFFER_COMPLETE = 5, - STARTING_SELL_OFFER = 9, - SELL_OFFER_INCOMPLETE = 10, - SELL_OFFER_UPDATING = 11, - SELL_OFFER_CANCELING = 12, - SELL_OFFER_COMPLETE = 13, - STATE_DISABLED = 14, - STATE_UNDEFINED = 15 - } SLOT_STATE; + typedef enum SLOT_MODE + { + BUY = 0, + SELL = 1, + MODE_DISABLED = 2, + MODE_UNDEFINED = 3 + } SLOT_MODE; - typedef enum SLOT_MODE - { - BUY = 0, - SELL = 1, - MODE_DISABLED = 2, - MODE_UNDEFINED = 3 - } SLOT_MODE; + typedef enum COLLECT_METHOD + { + ITEM, + NOTE, + BANK + } COLLECT_METHOD; - typedef enum COLLECT_METHOD - { - ITEM, - NOTE, - BANK - } COLLECT_METHOD; + bool IsOpen(); + bool Open(); + bool Close(); + SLOT_STATE GetSlotState(const Exchange::SLOT Slot); + bool SlotOccupied(const Exchange::SLOT Slot); + std::vector GetAllSlotStates(); + bool AllSlotsOccupied(); + std::int32_t GetOfferIndex(); - static bool IsOpen(); - static bool Open(); - static bool Close(); - static SLOT_STATE GetSlotState(const Exchange::SLOT Slot); - static bool SlotOccupied(const Exchange::SLOT Slot); - static std::vector GetAllSlotStates(); - static bool AllSlotsOccupied(); - static std::int32_t GetOfferIndex(); + SLOT_MODE GetOfferMode(); + std::int32_t GetOfferItemID(); + std::string GetOfferItemName(); + std::int32_t GetOfferAmount(); + std::int32_t GetOfferPrice(); + bool IsOfferOpen(); + bool CloseOffer(); + bool IsOffersOpen(); + bool SlotUsable(const Exchange::SLOT Slot); + bool CanCollect(); - static SLOT_MODE GetOfferMode(); - static std::int32_t GetOfferItemID(); - static std::string GetOfferItemName(); - static std::int32_t GetOfferAmount(); - static std::int32_t GetOfferPrice(); - static bool IsOfferOpen(); - static bool CloseOffer(); - static bool IsOffersOpen(); - static bool SlotUsable(const Exchange::SLOT Slot); - static bool CanCollect(); + bool CollectAll(const bool Inventory = true); + bool Collect(const Exchange::COLLECT_METHOD Method = Exchange::BANK); - static bool CollectAll(const bool Inventory = true); - static bool Collect(const Exchange::COLLECT_METHOD Method = Exchange::BANK); + bool IsBuyOfferOpen(); + bool IsSellOfferOpen(); + bool OpenBuyOffer(const Exchange::SLOT Slot = -1); + bool OpenSellOffer(const Exchange::SLOT Slot = -1); - static bool IsBuyOfferOpen(); - static bool IsSellOfferOpen(); - static bool OpenBuyOffer(const Exchange::SLOT Slot = -1); - static bool OpenSellOffer(const Exchange::SLOT Slot = -1); + Exchange::SLOT GetBuyOffer(std::int32_t ID); + Exchange::SLOT GetBuyOffer(const std::string& Name); + Exchange::SLOT GetBuyOffer(const std::function& Filter); + std::vector GetBuyOffers(std::int32_t ID); + std::vector GetBuyOffers(const std::string& Name); + std::vector GetBuyOffers(const std::function& Filter); - static Exchange::SLOT GetBuyOffer(std::int32_t ID); - static Exchange::SLOT GetBuyOffer(const std::string& Name); - static Exchange::SLOT GetBuyOffer(const std::function& Filter); - static std::vector GetBuyOffers(std::int32_t ID); - static std::vector GetBuyOffers(const std::string& Name); - static std::vector GetBuyOffers(const std::function& Filter); - - static Exchange::SLOT GetSellOffer(std::int32_t ID); - static Exchange::SLOT GetSellOffer(const std::string& Name); - static Exchange::SLOT GetSellOffer(const std::function& Filter); - static std::vector GetSellOffers(std::int32_t ID); - static std::vector GetSellOffers(const std::string& Name); - static std::vector GetSellOffers(const std::function& Filter); + Exchange::SLOT GetSellOffer(std::int32_t ID); + Exchange::SLOT GetSellOffer(const std::string& Name); + Exchange::SLOT GetSellOffer(const std::function& Filter); + std::vector GetSellOffers(std::int32_t ID); + std::vector GetSellOffers(const std::string& Name); + std::vector GetSellOffers(const std::function& Filter); - static bool SetSellItem(const std::string& Name); - static bool SetSellItem(std::int32_t ID); - static bool SetBuyItem(const std::string& Name); - static bool SetOfferAmount(std::uint32_t Amount); - static bool SetOfferPrice(std::uint32_t Price); - static bool SetOfferGuidePrice(); - static bool ConfirmOffer(); + bool SetSellItem(const std::string& Name); + bool SetSellItem(std::int32_t ID); + bool SetBuyItem(const std::string& Name); + bool SetOfferAmount(std::uint32_t Amount); + bool SetOfferPrice(std::uint32_t Price); + bool SetOfferGuidePrice(); + bool ConfirmOffer(); - typedef enum COLLECT_SLOT - { - ONE, - TWO - } COLLECT_SLOT; + typedef enum COLLECT_SLOT + { + ONE, + TWO + } COLLECT_SLOT; - static std::string GetCollectSlotName(Exchange::COLLECT_SLOT Slot); - static std::int32_t GetCollectSlotID(Exchange::COLLECT_SLOT Slot); - static std::int32_t GetCollectSlotAmount(Exchange::COLLECT_SLOT Slot); + std::string GetCollectSlotName(Exchange::COLLECT_SLOT Slot); + std::int32_t GetCollectSlotID(Exchange::COLLECT_SLOT Slot); + std::int32_t GetCollectSlotAmount(Exchange::COLLECT_SLOT Slot); - static bool AbortOffer(const Exchange::SLOT Slot = -1); - - static bool OpenOffer(const Exchange::SLOT Slot); + bool AbortOffer(const Exchange::SLOT Slot = -1); + bool OpenOffer(const Exchange::SLOT Slot); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Clan.hpp b/Include/Game/Interfaces/GameTabs/Clan.hpp index 20585f8..49b6d87 100644 --- a/Include/Game/Interfaces/GameTabs/Clan.hpp +++ b/Include/Game/Interfaces/GameTabs/Clan.hpp @@ -7,13 +7,12 @@ /** @addtogroup GameTabs * @{ */ -class Clan +namespace Clan { - public: - static bool IsOpen(); - static bool Open(); - static std::vector GetAll(); - static std::vector GetAll(const std::function& Filter); + bool IsOpen(); + bool Open(); + std::vector GetAll(); + std::vector GetAll(const std::function& Filter); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Combat.hpp b/Include/Game/Interfaces/GameTabs/Combat.hpp index 0f7539b..2a86972 100644 --- a/Include/Game/Interfaces/GameTabs/Combat.hpp +++ b/Include/Game/Interfaces/GameTabs/Combat.hpp @@ -6,30 +6,29 @@ /** @addtogroup GameTabs * @{ */ -class Combat +namespace Combat { - public: - static bool IsOpen(); - static bool Open(); + bool IsOpen(); + bool Open(); - static std::int32_t GetHealth(); - static std::int32_t GetMaxHealth(); + std::int32_t GetHealth(); + std::int32_t GetMaxHealth(); - static std::int32_t GetSpecialAttack(); - static bool IsSpecialAttacking(); - static bool ToggleSpecialAttack(bool Toggle); + std::int32_t GetSpecialAttack(); + bool IsSpecialAttacking(); + bool ToggleSpecialAttack(bool Toggle); - static bool IsPoisoned(); - static bool HasPoisonImmunity(); + bool IsPoisoned(); + bool HasPoisonImmunity(); - static bool IsAutoRetaliating(); - static bool ToggleAutoRetaliate(bool Toggle); + bool IsAutoRetaliating(); + bool ToggleAutoRetaliate(bool Toggle); - static std::int32_t GetStyleIndex(); - static std::string GetStyleString(); + std::int32_t GetStyleIndex(); + std::string GetStyleString(); - static bool SetStyle(const std::string& Style); - static bool SetStyle(std::int32_t Index); + bool SetStyle(const std::string& Style); + bool SetStyle(std::int32_t Index); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Emotes.hpp b/Include/Game/Interfaces/GameTabs/Emotes.hpp index d222edf..ff9bdda 100644 --- a/Include/Game/Interfaces/GameTabs/Emotes.hpp +++ b/Include/Game/Interfaces/GameTabs/Emotes.hpp @@ -3,11 +3,10 @@ /** @addtogroup GameTabs * @{ */ -class Emotes +namespace Emotes { - public: - static bool IsOpen(); - static bool Open(); + bool IsOpen(); + bool Open(); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Equipment.hpp b/Include/Game/Interfaces/GameTabs/Equipment.hpp index 6169038..1d3f323 100644 --- a/Include/Game/Interfaces/GameTabs/Equipment.hpp +++ b/Include/Game/Interfaces/GameTabs/Equipment.hpp @@ -9,79 +9,78 @@ /** @addtogroup GameTabs * @{ */ -class Equipment +namespace Equipment { - public: - typedef enum SLOT - { - HEAD, - CAPE, - NECK, - WEAPON, - BODY, - SHIELD, - LEGS, - HANDS, - FEET, - RING, - AMMO - } SLOT; + typedef enum SLOT + { + HEAD, + CAPE, + NECK, + WEAPON, + BODY, + SHIELD, + LEGS, + HANDS, + FEET, + RING, + AMMO + } SLOT; - static bool IsOpen(); - static bool Open(); - static bool IsEmpty(); + bool IsOpen(); + bool Open(); + bool IsEmpty(); - static std::vector GetItemIDs(); - static std::vector GetItemNames(); - static std::vector GetItemAmounts(); + std::vector GetItemIDs(); + std::vector GetItemNames(); + std::vector GetItemAmounts(); - static std::vector GetItems(); - static std::vector GetItems(std::int32_t ID); - static std::vector GetItems(const std::string& Name); - static std::vector GetItems(const std::vector& Slots); - static std::vector GetItems(const std::vector& IDs); - static std::vector GetItems(const std::vector& Names); - static std::vector GetItems(const std::function& Filter); + std::vector GetItems(); + std::vector GetItems(std::int32_t ID); + std::vector GetItems(const std::string& Name); + std::vector GetItems(const std::vector& Slots); + std::vector GetItems(const std::vector& IDs); + std::vector GetItems(const std::vector& Names); + std::vector GetItems(const std::function& Filter); - static Interactable::Item GetItem(SLOT Slot); - static Interactable::Item GetItem(std::int32_t ID); - static Interactable::Item GetItem(const std::string& Name); - static Interactable::Item GetItem(const std::vector& IDs); - static Interactable::Item GetItem(const std::vector& Names); - static Interactable::Item GetItem(const std::function& Filter); + Interactable::Item GetItem(SLOT Slot); + Interactable::Item GetItem(std::int32_t ID); + Interactable::Item GetItem(const std::string& Name); + Interactable::Item GetItem(const std::vector& IDs); + Interactable::Item GetItem(const std::vector& Names); + Interactable::Item GetItem(const std::function& Filter); - static std::int32_t Count(SLOT Slot); - static std::int32_t Count(std::int32_t ID); - static std::int32_t Count(const std::string& Name); - static std::int32_t Count(const Interactable::Item& Item); - static std::int32_t Count(const std::vector& IDs); - static std::int32_t Count(const std::vector& Names); - static std::int32_t Count(const std::vector& Items); + std::int32_t Count(SLOT Slot); + std::int32_t Count(std::int32_t ID); + std::int32_t Count(const std::string& Name); + std::int32_t Count(const Interactable::Item& Item); + std::int32_t Count(const std::vector& IDs); + std::int32_t Count(const std::vector& Names); + std::int32_t Count(const std::vector& Items); - static SLOT GetSlotOf(std::int32_t ID); - static SLOT GetSlotOf(const std::string& Name); + SLOT GetSlotOf(std::int32_t ID); + SLOT GetSlotOf(const std::string& Name); - static bool Contains(std::int32_t ID); - static bool Contains(const std::string& Name); - static bool Contains(const Interactable::Item& Item); - static bool Contains(const std::vector& IDs); // true if all items are found at least once - static bool Contains(const std::vector& Names); // true if all items are found at least once - static bool Contains(const std::vector& Items); + bool Contains(std::int32_t ID); + bool Contains(const std::string& Name); + bool Contains(const Interactable::Item& Item); + bool Contains(const std::vector& IDs); // true if all items are found at least once + bool Contains(const std::vector& Names); // true if all items are found at least once + bool Contains(const std::vector& Items); - static bool ContainsAny(const std::vector& IDs); - static bool ContainsAny(const std::vector& Names); - static bool ContainsAny(const std::vector& Items); + bool ContainsAny(const std::vector& IDs); + bool ContainsAny(const std::vector& Names); + bool ContainsAny(const std::vector& Items); - static bool ContainsOnly(std::int32_t ID); - static bool ContainsOnly(const std::string& Name); - static bool ContainsOnly(const Interactable::Item& Item); - static bool ContainsOnly(const std::vector& IDs); - static bool ContainsOnly(const std::vector& Names); - static bool ContainsOnly(const std::vector& Items); + bool ContainsOnly(std::int32_t ID); + bool ContainsOnly(const std::string& Name); + bool ContainsOnly(const Interactable::Item& Item); + bool ContainsOnly(const std::vector& IDs); + bool ContainsOnly(const std::vector& Names); + bool ContainsOnly(const std::vector& Items); - static bool Unequip(std::int32_t ID); - static bool Unequip(const std::string& Name); - static bool Unequip(const Interactable::Item& Item); + bool Unequip(std::int32_t ID); + bool Unequip(const std::string& Name); + bool Unequip(const Interactable::Item& Item); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Friends.hpp b/Include/Game/Interfaces/GameTabs/Friends.hpp index 9542a2d..13e6e12 100644 --- a/Include/Game/Interfaces/GameTabs/Friends.hpp +++ b/Include/Game/Interfaces/GameTabs/Friends.hpp @@ -7,13 +7,12 @@ /** @addtogroup GameTabs * @{ */ -class Friends +namespace Friends { - public: - static bool IsOpen(); - static bool Open(); - static std::vector GetAll(); - static std::vector GetAll(const std::function& Filter); + bool IsOpen(); + bool Open(); + std::vector GetAll(); + std::vector GetAll(const std::function& Filter); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Ignores.hpp b/Include/Game/Interfaces/GameTabs/Ignores.hpp index 9faad25..f2573f0 100644 --- a/Include/Game/Interfaces/GameTabs/Ignores.hpp +++ b/Include/Game/Interfaces/GameTabs/Ignores.hpp @@ -7,13 +7,12 @@ /** @addtogroup GameTabs * @{ */ -class Ignores +namespace Ignores { - public: - static bool IsOpen(); - static bool Open(); - static std::vector GetAll(); - static std::vector GetAll(const std::function& Filter); + bool IsOpen(); + bool Open(); + std::vector GetAll(); + std::vector GetAll(const std::function& Filter); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Inventory.hpp b/Include/Game/Interfaces/GameTabs/Inventory.hpp index 94f83d2..8d5beb9 100644 --- a/Include/Game/Interfaces/GameTabs/Inventory.hpp +++ b/Include/Game/Interfaces/GameTabs/Inventory.hpp @@ -11,93 +11,91 @@ /** @addtogroup GameTabs * @{ */ -class Inventory +namespace Inventory { - public: + bool IsOpen(); + bool Open(); - static bool IsOpen(); - static bool Open(); + std::vector GetItemIDs(); + std::vector GetItemNames(); + std::vector GetItemAmounts(); - static std::vector GetItemIDs(); - static std::vector GetItemNames(); - static std::vector GetItemAmounts(); + std::vector GetItems(); + std::vector GetItems(std::int32_t ID); + std::vector GetItems(const std::string& Name); + std::vector GetItems(const std::vector& IDs); + std::vector GetItems(const std::vector& Names); + std::vector GetItems(const std::function& Filter); - static std::vector GetItems(); - static std::vector GetItems(std::int32_t ID); - static std::vector GetItems(const std::string& Name); - static std::vector GetItems(const std::vector& IDs); - static std::vector GetItems(const std::vector& Names); - static std::vector GetItems(const std::function& Filter); + Interactable::Item GetItem(std::int32_t ID); + Interactable::Item GetItem(const std::string& Name); + Interactable::Item GetItem(const std::vector& IDs); + Interactable::Item GetItem(const std::vector& Names); + Interactable::Item GetItem(const std::function& Filter); - static Interactable::Item GetItem(std::int32_t ID); - static Interactable::Item GetItem(const std::string& Name); - static Interactable::Item GetItem(const std::vector& IDs); - static Interactable::Item GetItem(const std::vector& Names); - static Interactable::Item GetItem(const std::function& Filter); + bool IsEmpty(); + bool IsFull(); - static bool IsEmpty(); - static bool IsFull(); + bool IsItemSelected(); + bool IsItemSelected(std::int32_t ID); + bool IsItemSelected(const std::string& Name); + bool IsItemSelected(const Interactable::Item& Item); - static bool IsItemSelected(); - static bool IsItemSelected(std::int32_t ID); - static bool IsItemSelected(const std::string& Name); - static bool IsItemSelected(const Interactable::Item& Item); + std::string GetItemSelectedName(); - static std::string GetItemSelectedName(); + std::int32_t Count(std::int32_t ID); + std::int32_t Count(const std::string& Name); + std::int32_t Count(const Interactable::Item& Item); + std::int32_t Count(const std::vector& IDs); + std::int32_t Count(const std::vector& Names); + std::int32_t Count(const std::vector& Items); - static std::int32_t Count(std::int32_t ID); - static std::int32_t Count(const std::string& Name); - static std::int32_t Count(const Interactable::Item& Item); - static std::int32_t Count(const std::vector& IDs); - static std::int32_t Count(const std::vector& Names); - static std::int32_t Count(const std::vector& Items); + std::int32_t CountOccupied(); + std::int32_t CountEmpty(); - static std::int32_t CountOccupied(); - static std::int32_t CountEmpty(); + std::int32_t GetIndexOf(std::int32_t ID); + std::int32_t GetIndexOf(const std::string& Name); + std::int32_t GetIndexOf(const std::vector& IDs); // Returns first found ID index + std::int32_t GetIndexOf(const std::vector& Names); // Returns first found Name Index - static std::int32_t GetIndexOf(std::int32_t ID); - static std::int32_t GetIndexOf(const std::string& Name); - static std::int32_t GetIndexOf(const std::vector& IDs); // Returns first found ID index - static std::int32_t GetIndexOf(const std::vector& Names); // Returns first found Name Index + std::vector GetIndicesOf(std::int32_t ID); + std::vector GetIndicesOf(const std::string& Name); + std::vector GetIndicesOf(const std::vector& IDs); + std::vector GetIndicesOf(const std::vector& Names); - static std::vector GetIndicesOf(std::int32_t ID); - static std::vector GetIndicesOf(const std::string& Name); - static std::vector GetIndicesOf(const std::vector& IDs); - static std::vector GetIndicesOf(const std::vector& Names); + std::vector GetSlotBoxes(); + std::vector GetBoxesOf(std::int32_t ID); + std::vector GetBoxesOf(const std::string& Name); - static std::vector GetSlotBoxes(); - static std::vector GetBoxesOf(std::int32_t ID); - static std::vector GetBoxesOf(const std::string& Name); + bool Contains(std::int32_t ID); + bool Contains(const std::string& Name); + bool Contains(const Interactable::Item& Item); + bool Contains(const std::vector& IDs); // true if all items are found at least once + bool Contains(const std::vector& Names); // true if all items are found at least once + bool Contains(const std::vector& Items); - static bool Contains(std::int32_t ID); - static bool Contains(const std::string& Name); - static bool Contains(const Interactable::Item& Item); - static bool Contains(const std::vector& IDs); // true if all items are found at least once - static bool Contains(const std::vector& Names); // true if all items are found at least once - static bool Contains(const std::vector& Items); + bool ContainsAny(const std::vector& IDs); + bool ContainsAny(const std::vector& Names); + bool ContainsAny(const std::vector& Items); - static bool ContainsAny(const std::vector& IDs); - static bool ContainsAny(const std::vector& Names); - static bool ContainsAny(const std::vector& Items); + bool ContainsOnly(std::int32_t ID); + bool ContainsOnly(const std::string& Name); + bool ContainsOnly(const Interactable::Item& Item); + bool ContainsOnly(const std::vector& IDs); + bool ContainsOnly(const std::vector& Names); + bool ContainsOnly(const std::vector& Items); - static bool ContainsOnly(std::int32_t ID); - static bool ContainsOnly(const std::string& Name); - static bool ContainsOnly(const Interactable::Item& Item); - static bool ContainsOnly(const std::vector& IDs); - static bool ContainsOnly(const std::vector& Names); - static bool ContainsOnly(const std::vector& Items); + bool Use(std::int32_t ID, std::int32_t ID2 = -1, bool UseSecondFirst = false); + bool Use(const std::string& Name, const std::string& Name2 = "", bool UseSecondFirst = false); + bool Use(const Interactable::Item& Item, const Interactable::Item& Item2 = Interactable::Item(), bool UseSecondFirst = false); - static bool Use(std::int32_t ID, std::int32_t ID2 = -1, bool UseSecondFirst = false); - static bool Use(const std::string& Name, const std::string& Name2 = "", bool UseSecondFirst = false); - static bool Use(const Interactable::Item& Item, const Interactable::Item& Item2 = Interactable::Item(), bool UseSecondFirst = false); + bool Equip(std::int32_t ID); + bool Equip(const std::string& Name); + bool Equip(const Interactable::Item& Item); - static bool Equip(std::int32_t ID); - static bool Equip(const std::string& Name); - static bool Equip(const Interactable::Item& Item); - - static bool Drop(std::int32_t ID, bool AllowShiftClick = true); - static bool Drop(const std::string& Name, bool AllowShiftClick = true); - static bool Drop(const Interactable::Item& Item, bool AllowShiftClick = true); + bool Drop(std::int32_t ID, bool AllowShiftClick = true); + bool Drop(const std::string& Name, bool AllowShiftClick = true); + bool Drop(const Interactable::Item& Item, bool AllowShiftClick = true); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Logout.hpp b/Include/Game/Interfaces/GameTabs/Logout.hpp index a2abb5d..c309d38 100644 --- a/Include/Game/Interfaces/GameTabs/Logout.hpp +++ b/Include/Game/Interfaces/GameTabs/Logout.hpp @@ -9,24 +9,23 @@ /** @addtogroup GameTabs * @{ */ -class Logout +namespace Logout { - public: - static bool IsOpen(); - static bool Open(); - static bool LogoutPlayer(); + bool IsOpen(); + bool Open(); + bool LogoutPlayer(); - static bool IsWorldSwitcherOpen(bool WaitToLoadWorlds = true); - static bool OpenWorldSwitcher(bool WaitToLoadWorlds = true); + bool IsWorldSwitcherOpen(bool WaitToLoadWorlds = true); + bool OpenWorldSwitcher(bool WaitToLoadWorlds = true); - static bool WorldSwitcherScrollTo(const Internal::World& World); - static bool WorldSwitcherScrollTo(std::int32_t WorldID); + bool WorldSwitcherScrollTo(const Internal::World& World); + bool WorldSwitcherScrollTo(std::int32_t WorldID); - static bool SwitchWorld(const Internal::World& World, bool AllowPVPWorlds = false, bool SetOnlyWarnAboutDangerousWorlds = false); // SetOnlyWarnAboutFutureWorlds will click "Yes. In future, only warn about dangerous worlds." instead of just "yes" - static bool SwitchWorld(std::int32_t WorldID, bool AllowPVPWorlds = false, bool SetOnlyWarnAboutDangerousWorlds = false); // SetOnlyWarnAboutFutureWorlds will click "Yes. In future, only warn about dangerous worlds." instead of just "yes" + bool SwitchWorld(const Internal::World& World, bool AllowPVPWorlds = false, bool SetOnlyWarnAboutDangerousWorlds = false); // SetOnlyWarnAboutFutureWorlds will click "Yes. In future, only warn about dangerous worlds." instead of just "yes" + bool SwitchWorld(std::int32_t WorldID, bool AllowPVPWorlds = false, bool SetOnlyWarnAboutDangerousWorlds = false); // SetOnlyWarnAboutFutureWorlds will click "Yes. In future, only warn about dangerous worlds." instead of just "yes" - static Interactable::Widget GetWorldWidget(const Internal::World& World); - static Interactable::Widget GetWorldWidget(std::int32_t WorldID); + Interactable::Widget GetWorldWidget(const Internal::World& World); + Interactable::Widget GetWorldWidget(std::int32_t WorldID); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Magic.hpp b/Include/Game/Interfaces/GameTabs/Magic.hpp index 677a56e..950d643 100644 --- a/Include/Game/Interfaces/GameTabs/Magic.hpp +++ b/Include/Game/Interfaces/GameTabs/Magic.hpp @@ -7,173 +7,171 @@ /** @addtogroup GameTabs * @{ */ -class Magic +namespace Magic { - public: + typedef enum SPELL + { + NORMAL_LUMBRIDGE_HOME_TELEPORT, + NORMAL_WIND_STRIKE, + NORMAL_CONFUSE, + NORMAL_ENCHANT_CROSSBOW_BOLT, + NORMAL_WATER_STRIKE, + NORMAL_LVL1_ENCHANT, + NORMAL_EARTH_STRIKE, + NORMAL_WEAKEN, + NORMAL_FIRE_STRIKE, + NORMAL_BONES_TO_BANANAS, + NORMAL_WIND_BOLT, + NORMAL_CURSE, + NORMAL_BIND, + NORMAL_LOW_LEVEL_ALCHEMY, + NORMAL_WATER_BOLT, + NORMAL_VARROCK_TELEPORT, + NORMAL_LVL2_ENCHANT, + NORMAL_EARTH_BOLT, + NORMAL_LUMBRIDGE_TELEPORT, + NORMAL_TELEKINETIC_GRAB, + NORMAL_FIRE_BOLT, + NORMAL_FALADOR_TELEPORT, + NORMAL_CRUMBLE_UNDEAD, + NORMAL_TELEPORT_TO_HOUSE, + NORMAL_WIND_BLAST, + NORMAL_SUPERHEAT_ITEM, + NORMAL_CAMELOT_TELEPORT, + NORMAL_WATER_BLAST, + NORMAL_LVL3_ENCHANT, + NORMAL_IBAN_BLAST, + NORMAL_SNARE, + NORMAL_MAGIC_DART, + NORMAL_ARDOUGNE_TELEPORT, + NORMAL_EARTH_BLAST, + NORMAL_HIGH_LEVEL_ALCHEMY, + NORMAL_CHARGE_WATER_ORB, + NORMAL_LVL4_ENCHANT, + NORMAL_WATCHTOWER_TELEPORT, + NORMAL_FIRE_BLAST, + NORMAL_CHARGE_EARTH_ORB, + NORMAL_BONES_TO_PEACHES, + NORMAL_SARADOMIN_STRIKE, + NORMAL_CLAWS_OF_GUTHIX, + NORMAL_FLAMES_OF_ZAMORAK, + NORMAL_TROLLHEIM_TELEPORT, + NORMAL_WIND_WAVE, + NORMAL_CHARGE_FIRE_ORB, + NORMAL_TELEPORT_TO_APE_ATOLL, + NORMAL_WATER_WAVE, + NORMAL_CHARGE_AIR_ORB, + NORMAL_VULNERABILITY, + NORMAL_LVL5_ENCHANT, + NORMAL_TELEPORT_TO_KOUREND, + NORMAL_EARTH_WAVE, + NORMAL_ENFEEBLE, + NORMAL_TELEOTHER_LUMBRIDGE, + NORMAL_FIRE_WAVE, + NORMAL_ENTANGLE, + NORMAL_STUN, + NORMAL_CHARGE, + NORMAL_WIND_SURGE, + NORMAL_TELEOTHER_FALADOR, + NORMAL_WATER_SURGE, + NORMAL_TELE_BLOCK, + NORMAL_TELEPORT_TO_BOUNTY_TARGET, + NORMAL_LVL6_ENCHANT, + NORMAL_TELEOTHER_CAMELOT, + NORMAL_EARTH_SURGE, + NORMAL_LVL7_ENCHANT, + NORMAL_FIRE_SURGE, - typedef enum SPELL - { - NORMAL_LUMBRIDGE_HOME_TELEPORT, - NORMAL_WIND_STRIKE, - NORMAL_CONFUSE, - NORMAL_ENCHANT_CROSSBOW_BOLT, - NORMAL_WATER_STRIKE, - NORMAL_LVL1_ENCHANT, - NORMAL_EARTH_STRIKE, - NORMAL_WEAKEN, - NORMAL_FIRE_STRIKE, - NORMAL_BONES_TO_BANANAS, - NORMAL_WIND_BOLT, - NORMAL_CURSE, - NORMAL_BIND, - NORMAL_LOW_LEVEL_ALCHEMY, - NORMAL_WATER_BOLT, - NORMAL_VARROCK_TELEPORT, - NORMAL_LVL2_ENCHANT, - NORMAL_EARTH_BOLT, - NORMAL_LUMBRIDGE_TELEPORT, - NORMAL_TELEKINETIC_GRAB, - NORMAL_FIRE_BOLT, - NORMAL_FALADOR_TELEPORT, - NORMAL_CRUMBLE_UNDEAD, - NORMAL_TELEPORT_TO_HOUSE, - NORMAL_WIND_BLAST, - NORMAL_SUPERHEAT_ITEM, - NORMAL_CAMELOT_TELEPORT, - NORMAL_WATER_BLAST, - NORMAL_LVL3_ENCHANT, - NORMAL_IBAN_BLAST, - NORMAL_SNARE, - NORMAL_MAGIC_DART, - NORMAL_ARDOUGNE_TELEPORT, - NORMAL_EARTH_BLAST, - NORMAL_HIGH_LEVEL_ALCHEMY, - NORMAL_CHARGE_WATER_ORB, - NORMAL_LVL4_ENCHANT, - NORMAL_WATCHTOWER_TELEPORT, - NORMAL_FIRE_BLAST, - NORMAL_CHARGE_EARTH_ORB, - NORMAL_BONES_TO_PEACHES, - NORMAL_SARADOMIN_STRIKE, - NORMAL_CLAWS_OF_GUTHIX, - NORMAL_FLAMES_OF_ZAMORAK, - NORMAL_TROLLHEIM_TELEPORT, - NORMAL_WIND_WAVE, - NORMAL_CHARGE_FIRE_ORB, - NORMAL_TELEPORT_TO_APE_ATOLL, - NORMAL_WATER_WAVE, - NORMAL_CHARGE_AIR_ORB, - NORMAL_VULNERABILITY, - NORMAL_LVL5_ENCHANT, - NORMAL_TELEPORT_TO_KOUREND, - NORMAL_EARTH_WAVE, - NORMAL_ENFEEBLE, - NORMAL_TELEOTHER_LUMBRIDGE, - NORMAL_FIRE_WAVE, - NORMAL_ENTANGLE, - NORMAL_STUN, - NORMAL_CHARGE, - NORMAL_WIND_SURGE, - NORMAL_TELEOTHER_FALADOR, - NORMAL_WATER_SURGE, - NORMAL_TELE_BLOCK, - NORMAL_TELEPORT_TO_BOUNTY_TARGET, - NORMAL_LVL6_ENCHANT, - NORMAL_TELEOTHER_CAMELOT, - NORMAL_EARTH_SURGE, - NORMAL_LVL7_ENCHANT, - NORMAL_FIRE_SURGE, + LUNAR_LUNAR_HOME_TELEPORT, + LUNAR_BAKE_PIE, + LUNAR_GEOMANCY, + LUNAR_CURE_PLANT, + LUNAR_MONSTER_EXAMINE, + LUNAR_NPC_CONTACT, + LUNAR_CURE_OTHER, + LUNAR_HUMIDIFY, + LUNAR_MOONCLAN_TELEPORT, + LUNAR_TELE_GROUP_MOONCLAN, + LUNAR_CURE_ME, + LUNAR_OURANIA_TELEPORT, + LUNAR_HUNTER_KIT, + LUNAR_WATERBIRTH_TELEPORT, + LUNAR_TELE_GROUP_WATERBIRTH, + LUNAR_CURE_GROUP, + LUNAR_STAT_SPY, + LUNAR_BARBARIAN_TELEPORT, + LUNAR_TELE_GROUP_BARBARIAN, + LUNAR_SPIN_FLAX, + LUNAR_SUPERGLASS_MAKE, + LUNAR_TAN_LEATHER, + LUNAR_KHAZARD_TELEPORT, + LUNAR_TELE_GROUP_KHAZARD, + LUNAR_DREAM, + LUNAR_STRING_JEWELLERY, + LUNAR_STAT_RESTORE_POT_SHARE, + LUNAR_MAGIC_IMBUE, + LUNAR_FERTILE_SOIL, + LUNAR_BOOST_POTION_SHARE, + LUNAR_FISHING_GUILD_TELEPORT, + LUNAR_TELEPORT_TO_BOUNTY_TARGET, + LUNAR_TELE_GROUP_FISHING_GUILD, + LUNAR_PLANK_MAKE, + LUNAR_CATHERBY_TELEPORT, + LUNAR_TELE_GROUP_CATHERBY, + LUNAR_RECHARGE_DRAGONSTONE, + LUNAR_ICE_PLATEAU_TELEPORT, + LUNAR_TELE_GROUP_ICE_PLATEAU, + LUNAR_ENERGY_TRANSFER, + LUNAR_HEAL_OTHER, + LUNAR_VENGEANCE_OTHER, + LUNAR_VENGEANCE, + LUNAR_HEAL_GROUP, + LUNAR_SPELLBOOK_SWAP, - LUNAR_LUNAR_HOME_TELEPORT, - LUNAR_BAKE_PIE, - LUNAR_GEOMANCY, - LUNAR_CURE_PLANT, - LUNAR_MONSTER_EXAMINE, - LUNAR_NPC_CONTACT, - LUNAR_CURE_OTHER, - LUNAR_HUMIDIFY, - LUNAR_MOONCLAN_TELEPORT, - LUNAR_TELE_GROUP_MOONCLAN, - LUNAR_CURE_ME, - LUNAR_OURANIA_TELEPORT, - LUNAR_HUNTER_KIT, - LUNAR_WATERBIRTH_TELEPORT, - LUNAR_TELE_GROUP_WATERBIRTH, - LUNAR_CURE_GROUP, - LUNAR_STAT_SPY, - LUNAR_BARBARIAN_TELEPORT, - LUNAR_TELE_GROUP_BARBARIAN, - LUNAR_SPIN_FLAX, - LUNAR_SUPERGLASS_MAKE, - LUNAR_TAN_LEATHER, - LUNAR_KHAZARD_TELEPORT, - LUNAR_TELE_GROUP_KHAZARD, - LUNAR_DREAM, - LUNAR_STRING_JEWELLERY, - LUNAR_STAT_RESTORE_POT_SHARE, - LUNAR_MAGIC_IMBUE, - LUNAR_FERTILE_SOIL, - LUNAR_BOOST_POTION_SHARE, - LUNAR_FISHING_GUILD_TELEPORT, - LUNAR_TELEPORT_TO_BOUNTY_TARGET, - LUNAR_TELE_GROUP_FISHING_GUILD, - LUNAR_PLANK_MAKE, - LUNAR_CATHERBY_TELEPORT, - LUNAR_TELE_GROUP_CATHERBY, - LUNAR_RECHARGE_DRAGONSTONE, - LUNAR_ICE_PLATEAU_TELEPORT, - LUNAR_TELE_GROUP_ICE_PLATEAU, - LUNAR_ENERGY_TRANSFER, - LUNAR_HEAL_OTHER, - LUNAR_VENGEANCE_OTHER, - LUNAR_VENGEANCE, - LUNAR_HEAL_GROUP, - LUNAR_SPELLBOOK_SWAP, + ANCIENT_ICE_RUSH, + ANCIENT_ICE_BLITZ, + ANCIENT_ICE_BURST, + ANCIENT_ICE_BARRAGE, + ANCIENT_BLOOD_RUSH, + ANCIENT_BLOOD_BLITZ, + ANCIENT_BLOOD_BURST, + ANCIENT_BLOOD_BARRAGE, + ANCIENT_SMOKE_RUSH, + ANCIENT_SMOKE_BLITZ, + ANCIENT_SMOKE_BURST, + ANCIENT_SMOKE_BARRAGE, + ANCIENT_SHADOW_RUSH, + ANCIENT_SHADOW_BLITZ, + ANCIENT_SHADOW_BURST, + ANCIENT_SHADOW_BARRAGE, + ANCIENT_PADDEWWA_TELEPORT, + ANCIENT_SENNTISTEN_TELEPORT, + ANCIENT_KHARYRLL_TELEPORT, + ANCIENT_LASSAR_TELEPORT, + ANCIENT_DAREEYAK_TELEPORT, + ANCIENT_CARRALLANGAR_TELEPORT, + ANCIENT_ANNAKARL_TELEPORT, + ANCIENT_GHORROCK_TELEPORT, + ANCIENT_TELEPORT_TO_BOUNTY_TARGET, + ANCIENT_EDGEVILLE_HOME_TELEPORT, - ANCIENT_ICE_RUSH, - ANCIENT_ICE_BLITZ, - ANCIENT_ICE_BURST, - ANCIENT_ICE_BARRAGE, - ANCIENT_BLOOD_RUSH, - ANCIENT_BLOOD_BLITZ, - ANCIENT_BLOOD_BURST, - ANCIENT_BLOOD_BARRAGE, - ANCIENT_SMOKE_RUSH, - ANCIENT_SMOKE_BLITZ, - ANCIENT_SMOKE_BURST, - ANCIENT_SMOKE_BARRAGE, - ANCIENT_SHADOW_RUSH, - ANCIENT_SHADOW_BLITZ, - ANCIENT_SHADOW_BURST, - ANCIENT_SHADOW_BARRAGE, - ANCIENT_PADDEWWA_TELEPORT, - ANCIENT_SENNTISTEN_TELEPORT, - ANCIENT_KHARYRLL_TELEPORT, - ANCIENT_LASSAR_TELEPORT, - ANCIENT_DAREEYAK_TELEPORT, - ANCIENT_CARRALLANGAR_TELEPORT, - ANCIENT_ANNAKARL_TELEPORT, - ANCIENT_GHORROCK_TELEPORT, - ANCIENT_TELEPORT_TO_BOUNTY_TARGET, - ANCIENT_EDGEVILLE_HOME_TELEPORT, - - NONE - } SPELL; + NONE + } SPELL; - static bool IsOpen(); - static bool Open(); + bool IsOpen(); + bool Open(); - static bool HasLevel(const SPELL& Spell); + bool HasLevel(const SPELL& Spell); - static bool IsSpellSelected(); - static bool IsSpellSelected(const SPELL& Spell); - static bool IsSpellSelected(const std::string& Name); - static std::string GetSelectedSpellName(); - static const SPELL GetSelectedSpell(); + bool IsSpellSelected(); + bool IsSpellSelected(const SPELL& Spell); + bool IsSpellSelected(const std::string& Name); + std::string GetSelectedSpellName(); + const SPELL GetSelectedSpell(); - static bool CastSpell(const SPELL& Spell); - static bool SelectSpell(const SPELL& Spell); + bool CastSpell(const SPELL& Spell); + bool SelectSpell(const SPELL& Spell); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Music.hpp b/Include/Game/Interfaces/GameTabs/Music.hpp index 3caaf63..6f2a09f 100644 --- a/Include/Game/Interfaces/GameTabs/Music.hpp +++ b/Include/Game/Interfaces/GameTabs/Music.hpp @@ -3,11 +3,10 @@ /** @addtogroup GameTabs * @{ */ -class Music +namespace Music { - public: - static bool IsOpen(); - static bool Open(); + bool IsOpen(); + bool Open(); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Options.hpp b/Include/Game/Interfaces/GameTabs/Options.hpp index 954382d..4a6643a 100644 --- a/Include/Game/Interfaces/GameTabs/Options.hpp +++ b/Include/Game/Interfaces/GameTabs/Options.hpp @@ -3,17 +3,16 @@ /** @addtogroup GameTabs * @{ */ -class Options +namespace Options { - public: - static bool IsOpen(); - static bool Open(); + bool IsOpen(); + bool Open(); - static bool GetAcceptAid(); - static bool ToggleAcceptAid(bool Toggle); + bool GetAcceptAid(); + bool ToggleAcceptAid(bool Toggle); - static bool GetRunMode(); - static bool ToggleRunMode(bool Toggle); + bool GetRunMode(); + bool ToggleRunMode(bool Toggle); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Prayer.hpp b/Include/Game/Interfaces/GameTabs/Prayer.hpp index 24e409d..ab22785 100644 --- a/Include/Game/Interfaces/GameTabs/Prayer.hpp +++ b/Include/Game/Interfaces/GameTabs/Prayer.hpp @@ -6,53 +6,50 @@ /** @addtogroup GameTabs * @{ */ -class Prayer +namespace Prayer { - public: - - typedef enum PRAYERS - { - THICK_SKIN, - BURST_OF_STRENGTH, - CLARITY_OF_THOUGHT, - SHARP_EYE, - MYSTIC_WILL, - ROCK_SKIN, - SUPERHUMAN_STRENGTH, - IMPROVED_REFLEXES, - RAPID_RESTORE, - RAPID_HEAL, - PROTECT_ITEM, - HAWK_EYE, - MYSTIC_LORE, - STEEL_SKIN, - ULTIMATE_STRENGTH, - INCREDIBLE_REFLEXES, - PROTECT_FROM_MAGIC, - PROTECT_FROM_MISSILES, - PROTECT_FROM_MELEE, - EAGLE_EYE, - MYSTIC_MIGHT, - RETRIBUTION, - REDEMPTION, - SMITE, - PRESERVE, - CHIVALRY, - PIETY, - RIGOUR, - AUGURY - } PRAYERS; - - static bool IsOpen(); - static bool Open(); - static std::int32_t GetPoints(); - static bool HasLevel(PRAYERS Prayer); - static bool IsActive(PRAYERS Prayer); - static bool AllActive(const std::vector& Prayers); - static bool WaitPrayer(std::uint32_t Duration, std::uint32_t Step, PRAYERS Prayer, bool Active); - static bool Activate(PRAYERS Prayer); - static bool Deactivate(PRAYERS Prayer); + typedef enum PRAYERS + { + THICK_SKIN, + BURST_OF_STRENGTH, + CLARITY_OF_THOUGHT, + SHARP_EYE, + MYSTIC_WILL, + ROCK_SKIN, + SUPERHUMAN_STRENGTH, + IMPROVED_REFLEXES, + RAPID_RESTORE, + RAPID_HEAL, + PROTECT_ITEM, + HAWK_EYE, + MYSTIC_LORE, + STEEL_SKIN, + ULTIMATE_STRENGTH, + INCREDIBLE_REFLEXES, + PROTECT_FROM_MAGIC, + PROTECT_FROM_MISSILES, + PROTECT_FROM_MELEE, + EAGLE_EYE, + MYSTIC_MIGHT, + RETRIBUTION, + REDEMPTION, + SMITE, + PRESERVE, + CHIVALRY, + PIETY, + RIGOUR, + AUGURY + } PRAYERS; + bool IsOpen(); + bool Open(); + std::int32_t GetPoints(); + bool HasLevel(PRAYERS Prayer); + bool IsActive(PRAYERS Prayer); + bool AllActive(const std::vector& Prayers); + bool WaitPrayer(std::uint32_t Duration, std::uint32_t Step, PRAYERS Prayer, bool Active); + bool Activate(PRAYERS Prayer); + bool Deactivate(PRAYERS Prayer); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Quests.hpp b/Include/Game/Interfaces/GameTabs/Quests.hpp index d07af4b..9dae510 100644 --- a/Include/Game/Interfaces/GameTabs/Quests.hpp +++ b/Include/Game/Interfaces/GameTabs/Quests.hpp @@ -3,12 +3,10 @@ /** @addtogroup GameTabs * @{ */ -class Quests +namespace Quests { - public: - - static bool IsOpen(); - static bool Open(); + bool IsOpen(); + bool Open(); }; /** @} */ diff --git a/Include/Game/Interfaces/GameTabs/Stats.hpp b/Include/Game/Interfaces/GameTabs/Stats.hpp index 423e0ef..91cfd90 100644 --- a/Include/Game/Interfaces/GameTabs/Stats.hpp +++ b/Include/Game/Interfaces/GameTabs/Stats.hpp @@ -5,47 +5,44 @@ /** @addtogroup GameTabs * @{ */ -class Stats +namespace Stats { - public: - - typedef enum SKILLS - { - ATTACK, - DEFENCE, - STRENGTH, - HITPOINTS, - RANGE, - PRAYER, - MAGIC, - COOKING, - WOODCUTTING, - FLETCHING, - FISHING, - FIREMAKING, - CRAFTING, - SMITHING, - MINING, - HERBLORE, - AGILITY, - THIEVING, - SLAYER, - FARMING, - RUNECRAFT, - HUNTER, - CONSTRUCTION, - ALL - } SKILLS; - - static bool IsOpen(); - static bool Open(); - static std::int32_t GetWeight(); - static std::int32_t GetRunEnergy(); - static std::int32_t GetCurrentLevel(SKILLS Skill); - static std::int32_t GetRealLevel(SKILLS Skill); - static std::int64_t GetExperience(SKILLS Skill); - static std::int32_t GetExperienceTo(SKILLS Skill, std::int32_t Level); + typedef enum SKILLS + { + ATTACK, + DEFENCE, + STRENGTH, + HITPOINTS, + RANGE, + PRAYER, + MAGIC, + COOKING, + WOODCUTTING, + FLETCHING, + FISHING, + FIREMAKING, + CRAFTING, + SMITHING, + MINING, + HERBLORE, + AGILITY, + THIEVING, + SLAYER, + FARMING, + RUNECRAFT, + HUNTER, + CONSTRUCTION, + ALL + } SKILLS; + bool IsOpen(); + bool Open(); + std::int32_t GetWeight(); + std::int32_t GetRunEnergy(); + std::int32_t GetCurrentLevel(SKILLS Skill); + std::int32_t GetRealLevel(SKILLS Skill); + std::int64_t GetExperience(SKILLS Skill); + std::int32_t GetExperienceTo(SKILLS Skill, std::int32_t Level); }; /** @} */ diff --git a/Include/Game/Interfaces/Login.hpp b/Include/Game/Interfaces/Login.hpp index a461722..5084019 100644 --- a/Include/Game/Interfaces/Login.hpp +++ b/Include/Game/Interfaces/Login.hpp @@ -10,75 +10,72 @@ /** @addtogroup Interfaces * @{ */ -class Login +namespace Login { - public: + typedef enum LOGIN_SCREEN_STATE + { + WELCOME_SCREEN, // 0 + PVP_WORLD, // 1 + ENTER_CREDENTIALS, // 2 + INVALID_CREDENTIALS, // 3 + AUTHENTICATOR, // 4 + FORGOTTEN_PASSWORD, // 5 + RUNESCAPE_UPDATED, + ACCOUNT_LOCKED, + MEMBERS_AREA, + MEMBERS_REQUIRED, + WORLD_SELECT, + ACCOUNT_DISABLED, + CONNECTING, + LOADING, + LOBBY_SCREEN, + LOGGED_IN + } LOGIN_SCREEN_STATE; - typedef enum LOGIN_SCREEN_STATE - { - WELCOME_SCREEN, // 0 - PVP_WORLD, // 1 - ENTER_CREDENTIALS, // 2 - INVALID_CREDENTIALS, // 3 - AUTHENTICATOR, // 4 - FORGOTTEN_PASSWORD, // 5 - RUNESCAPE_UPDATED, - ACCOUNT_LOCKED, - MEMBERS_AREA, - MEMBERS_REQUIRED, - WORLD_SELECT, - ACCOUNT_DISABLED, - CONNECTING, - LOADING, - LOBBY_SCREEN, - LOGGED_IN - } LOGIN_SCREEN_STATE; + LOGIN_SCREEN_STATE GetLoginScreenState(); - static LOGIN_SCREEN_STATE GetLoginScreenState(); + bool LoginPlayer(bool SwitchWorlds = true); + bool EnterCredentials(); - static bool LoginPlayer(bool SwitchWorlds = true); - static bool EnterCredentials(); + bool IsWorldSelectOpen(); + bool OpenWorldSelect(); + bool CloseWorldSelect(); - static bool IsWorldSelectOpen(); - static bool OpenWorldSelect(); - static bool CloseWorldSelect(); + bool SelectWorld(); + bool SelectWorld(Internal::World World); + bool SelectWorld(std::int32_t WorldID); - static bool SelectWorld(); - static bool SelectWorld(Internal::World World); - static bool SelectWorld(std::int32_t WorldID); + /** + * @return X of where the login screen starts + */ + std::int32_t GetScreenX(); + /** + * @return X of where the login window starts + */ + std::int32_t GetWindowX(); - /** - * @return X of where the login screen starts - */ - static std::int32_t GetScreenX(); - /** - * @return X of where the login window starts - */ - static std::int32_t GetWindowX(); + /** + * @return current state of the login caret + * 0: Username line; 1: Password line; + */ + std::int32_t GetCaretState(); - /** - * @return current state of the login caret - * 0: Username line; 1: Password line; - */ - static std::int32_t GetCaretState(); + /** + * @return a vector of login messages + * 0: LoginMessage0; 1: LoginMessage1; 2: LoginMessage2; + */ + std::vector GetLoginMessages(); - /** - * @return a vector of login messages - * 0: LoginMessage0; 1: LoginMessage1; 2: LoginMessage2; - */ - static std::vector GetLoginMessages(); - - /** - * @return a vector of button boxes on the login screen - * 0: Existing User; 1: Login; 2: Cancel; 3: Try Again; 4: World Select; 5: World Select Cancel; - */ - static std::vector GetButtonBoxes(); - - /** - * @return a world box corresponding to the world select screen. - */ - static Box GetWorldBox(std::uint32_t Index); + /** + * @return a vector of button boxes on the login screen + * 0: Existing User; 1: Login; 2: Cancel; 3: Try Again; 4: World Select; 5: World Select Cancel; + */ + std::vector GetButtonBoxes(); + /** + * @return a world box corresponding to the world select screen. + */ + Box GetWorldBox(std::uint32_t Index); }; /** @} */ diff --git a/Include/Game/Interfaces/Mainscreen.hpp b/Include/Game/Interfaces/Mainscreen.hpp index a6f9c09..c54b098 100644 --- a/Include/Game/Interfaces/Mainscreen.hpp +++ b/Include/Game/Interfaces/Mainscreen.hpp @@ -10,42 +10,41 @@ /** @addtogroup Interfaces * @{ */ -class Mainscreen +namespace Mainscreen { - public: - typedef enum SCREEN_STATE - { - LOGIN_SCREEN, - LOBBY_SCREEN, - CONNECTING, - LOADING, - HOPPING, - PLAYING - } SCREEN_STATE; + typedef enum SCREEN_STATE + { + LOGIN_SCREEN, + LOBBY_SCREEN, + CONNECTING, + LOADING, + HOPPING, + PLAYING + } SCREEN_STATE; - typedef enum CROSSHAIR_STATE - { - NONE, - YELLOW, - RED - } CROSSHAIR_STATE; + typedef enum CROSSHAIR_STATE + { + NONE, + YELLOW, + RED + } CROSSHAIR_STATE; - static Mainscreen::SCREEN_STATE GetState(); - static Mainscreen::CROSSHAIR_STATE GetCrosshairState(); + Mainscreen::SCREEN_STATE GetState(); + Mainscreen::CROSSHAIR_STATE GetCrosshairState(); - static bool IsLoggedIn(); - static bool IsMoving(); - static bool IsAnimating(); + bool IsLoggedIn(); + bool IsMoving(); + bool IsAnimating(); - static std::string GetUpText(); - static bool UpTextContains(const std::string& UpText); - static bool UpTextContains(const std::vector& UpTexts); - static bool IsUpText(const std::string& UpText); - static bool IsUpText(const std::vector& UpTexts); - 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::vector& UpTexts); - static bool ClickTile(const Tile& T); + std::string GetUpText(); + bool UpTextContains(const std::string& UpText); + bool UpTextContains(const std::vector& UpTexts); + bool IsUpText(const std::string& UpText); + bool IsUpText(const std::vector& UpTexts); + bool WaitIsUpText(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText); + bool WaitUpTextContains(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText); + bool WaitUpTextContains(std::uint32_t Duration, std::uint32_t Step, const std::vector& UpTexts); + bool ClickTile(const Tile& T); }; /** @} */ diff --git a/Include/Game/Interfaces/Makescreen.hpp b/Include/Game/Interfaces/Makescreen.hpp index b208858..098073e 100644 --- a/Include/Game/Interfaces/Makescreen.hpp +++ b/Include/Game/Interfaces/Makescreen.hpp @@ -6,39 +6,36 @@ /** @addtogroup Interfaces * @{ */ -class Makescreen +namespace Makescreen { - public: + enum MAKE_AMOUNT + { + ALL = -1 + }; - enum MAKE_AMOUNT - { - ALL = -1 - }; + /** + * @brief Returns true if the Makescreen is open + * + * @return true if the makescreen is open + */ + bool IsOpen(); - /** - * @brief Returns true if the Makescreen is open - * - * @return true if the makescreen is open - */ + /** + * @brief Selects or enters the amount passed, and clicks the middle "Make" button, before returning true + * + * @param Amount The amount to select, before clicking the middle "Make" button, passing -1 will use the All button + * @param ClickButtonOverride Forces the function to click the needed amount button again, regardless if it's already selected + * @return true if the function succesfully clicks the "Make" button + * @return false if the makescreen isn't open, or interaction fails + */ + bool Make(std::int32_t Amount, bool ClickButtonOverride = false); - static bool IsOpen(); - - /** - * @brief Selects or enters the amount passed, and clicks the middle "Make" button, before returning true - * - * @param Amount The amount to select, before clicking the middle "Make" button, passing -1 will use the All button - * @param ClickButtonOverride Forces the function to click the needed amount button again, regardless if it's already selected - * @return true if the function succesfully clicks the "Make" button - * @return false if the makescreen isn't open, or interaction fails - */ - static bool Make(std::int32_t Amount, bool ClickButtonOverride = false); - - /** - * @brief Returns the text of the middle widget when the Makescreen is open - * - * @return Text of the middle widget when the Makescreen is open - */ - static std::string GetCraftingName(); + /** + * @brief Returns the text of the middle widget when the Makescreen is open + * + * @return Text of the middle widget when the Makescreen is open + */ + std::string GetCraftingName(); }; /** @} */ diff --git a/Include/Game/Interfaces/Menu.hpp b/Include/Game/Interfaces/Menu.hpp index 2e46983..7e5e299 100644 --- a/Include/Game/Interfaces/Menu.hpp +++ b/Include/Game/Interfaces/Menu.hpp @@ -11,291 +11,289 @@ /** * @brief A class containing various functions for the right-click menu */ -class Menu +namespace Menu { - public: + /** + * @brief Returns true if the right-click menu is open + * + * @return true if the right-click menu is open + */ + bool IsOpen(); - /** - * @brief Returns true if the right-click menu is open - * - * @return true if the right-click menu is open - */ - static bool IsOpen(); + /** + * @brief Opens the menu by right-clicking wherever the mouse currently is + * + * @return true if the menu is currently open or opened by right clicking + * @return false if WaitFunc fails - WaitFunc(1000, 100, Menu::IsOpen, true); + * @note Implements an %Interactable delay if succesful + */ + bool Open(); - /** - * @brief Opens the menu by right-clicking wherever the mouse currently is - * - * @return true if the menu is currently open or opened by right clicking - * @return false if WaitFunc fails - WaitFunc(1000, 100, Menu::IsOpen, true); - * @note Implements an %Interactable delay if succesful - */ - static bool Open(); - - /** - * @brief Closes the menu by moving the mouse to either left or right of the menu, uses the current mouse position as a base point - * - * @return true if the menu isn't open, or closed by moving the mouse - * @return false if the generated point is off-screen, or WaitFunc fails - WaitFunc(1000, 100, Menu::IsOpen, false); - * @note Implements an %Interactable delay if succesful - */ - static bool Close(); + /** + * @brief Closes the menu by moving the mouse to either left or right of the menu, uses the current mouse position as a base point + * + * @return true if the menu isn't open, or closed by moving the mouse + * @return false if the generated point is off-screen, or WaitFunc fails - WaitFunc(1000, 100, Menu::IsOpen, false); + * @note Implements an %Interactable delay if succesful + */ + bool Close(); - /** - * @brief Get the number of menu options - * - * @return the number of menu options - * @note The menu does not need to be open for this to be accurate - */ - static std::int32_t GetCount(); + /** + * @brief Get the number of menu options + * + * @return the number of menu options + * @note The menu does not need to be open for this to be accurate + */ + std::int32_t GetCount(); - /** - * @brief Get the raw, un-filtered menu actions - * - * @description By default the game includes html code in menu actions/targets - * This function returns those actions without the removal of the html code - * @return std::vector of raw menu actions - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::vector GetActionsRaw(); + /** + * @brief Get the raw, un-filtered menu actions + * + * @description By default the game includes html code in menu actions/targets + * This function returns those actions without the removal of the html code + * @return std::vector of raw menu actions + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::vector GetActionsRaw(); - /** - * @brief Get the raw, un-filtered menu targets - * - * @description By default the game includes html code in menu actions/targets - * This function returns those targets without the removal of the html code - * @return std::vector of targets - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::vector GetTargetsRaw(); + /** + * @brief Get the raw, un-filtered menu targets + * + * @description By default the game includes html code in menu actions/targets + * This function returns those targets without the removal of the html code + * @return std::vector of targets + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::vector GetTargetsRaw(); - /** - * @brief Get the menu actions - * - * @description Actions are almost always the very first word in a menu option - * 'Use' - action 'gold bar' - target - * 'Attack' - action 'Guard (level-21)' - target - * @return std::vector array of menu actions - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::vector GetActions(); + /** + * @brief Get the menu actions + * + * @description Actions are almost always the very first word in a menu option + * 'Use' - action 'gold bar' - target + * 'Attack' - action 'Guard (level-21)' - target + * @return std::vector array of menu actions + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::vector GetActions(); - /** - * @brief Get the menu targets - * - * @description Targets are almost always everything after the action - * 'Use' - action 'gold bar' - target - * 'Attack' - action 'Guard (level-21)' - target - * @return std::vector array of menu targets - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::vector GetTargets(); + /** + * @brief Get the menu targets + * + * @description Targets are almost always everything after the action + * 'Use' - action 'gold bar' - target + * 'Attack' - action 'Guard (level-21)' - target + * @return std::vector array of menu targets + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::vector GetTargets(); - /** - * @brief Get the menu options - * - * @description - * 'Use' - action 'gold bar' - target - * 'Attack' - action 'Guard (level-21)' - target - * 'Use gold bar' - option - * 'Attack Guard (level-21)' - option - * @return std::vector array of menu options - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::vector GetOptions(); + /** + * @brief Get the menu options + * + * @description + * 'Use' - action 'gold bar' - target + * 'Attack' - action 'Guard (level-21)' - target + * 'Use gold bar' - option + * 'Attack Guard (level-21)' - option + * @return std::vector array of menu options + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::vector GetOptions(); - /** - * @brief Get the index of the found option - * - * @description This function will find the first menu option containing the string 'Option' - * This means passing 'Att' or 'Attack' will return the first found menu option containing 'Att' or 'Attack' - * If you want to find a very specific menu option, the more the 'Option' string contains, the more specific it'll be - * - * Say for example, you want to attack a guard whose level is 40, and on this one tile, there's 5 different guards, all with different levels - * If you pass 'Attack' as the 'Option' to look for, it'll select the very first guard, regardless of level. - * If you pass 'Attack Guard (level-40)' as the 'Option' to look for, it'll attack the guard whose level is 40. - * @param Option %Menu option to look for, can be very specific, or very lenient - * @return std::int32_t The index of the first found option, -1 if the option wasn't found - * @note Notice that 'Attack Guard (level-40)' has a double space after 'Guard', menu options can vary, in this case the menu option i'm looking for - * has a double space after 'Guard'. - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::int32_t IndexOf(const std::string& Option); + /** + * @brief Get the index of the found option + * + * @description This function will find the first menu option containing the string 'Option' + * This means passing 'Att' or 'Attack' will return the first found menu option containing 'Att' or 'Attack' + * If you want to find a very specific menu option, the more the 'Option' string contains, the more specific it'll be + * + * Say for example, you want to attack a guard whose level is 40, and on this one tile, there's 5 different guards, all with different levels + * If you pass 'Attack' as the 'Option' to look for, it'll select the very first guard, regardless of level. + * If you pass 'Attack Guard (level-40)' as the 'Option' to look for, it'll attack the guard whose level is 40. + * @param Option %Menu option to look for, can be very specific, or very lenient + * @return std::int32_t The index of the first found option, -1 if the option wasn't found + * @note Notice that 'Attack Guard (level-40)' has a double space after 'Guard', menu options can vary, in this case the menu option i'm looking for + * has a double space after 'Guard'. + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::int32_t IndexOf(const std::string& Option); - /** - * @brief Get the index of the first found option - * - * @description This function will return the first found index, of the first found option. - * This function is just Menu::IndexOf(const std::string& Option), but instead of looking for one single option, this function looks for multiple - * - * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be - * @return std::int32_t The index of the first found option, -1 if the option wasn't found - * @see Menu::IndexOf(const std::string& Option) - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::int32_t IndexOf(const std::vector& Options); + /** + * @brief Get the index of the first found option + * + * @description This function will return the first found index, of the first found option. + * This function is just Menu::IndexOf(const std::string& Option), but instead of looking for one single option, this function looks for multiple + * + * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be + * @return std::int32_t The index of the first found option, -1 if the option wasn't found + * @see Menu::IndexOf(const std::string& Option) + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::int32_t IndexOf(const std::vector& Options); - /** - * @brief Looks for a menu option at the passed index, and returns information about the found option - * - * @param Index The index of the menu option to look at - * @return std::tuple - * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found - * std::string [1] = Action that was found at index - * std::string [2] = Target that was found at index - * @see Menu::IndexOf(const std::string& Option) - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::tuple FindOption(std::uint32_t Index); + /** + * @brief Looks for a menu option at the passed index, and returns information about the found option + * + * @param Index The index of the menu option to look at + * @return std::tuple + * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found + * std::string [1] = Action that was found at index + * std::string [2] = Target that was found at index + * @see Menu::IndexOf(const std::string& Option) + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::tuple FindOption(std::uint32_t Index); - /** - * @brief Looks for a menu option containing the passed Option, and returns information about the found option - * - * @param Option %Menu option to look for, the more specific, the more accurate the result will be - * @return std::tuple - * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found - * std::string [1] = Action that was found - * std::string [2] = Target that was found - * @see Menu::IndexOf(const std::string& Option) - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::tuple FindOption(const std::string& Option); + /** + * @brief Looks for a menu option containing the passed Option, and returns information about the found option + * + * @param Option %Menu option to look for, the more specific, the more accurate the result will be + * @return std::tuple + * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found + * std::string [1] = Action that was found + * std::string [2] = Target that was found + * @see Menu::IndexOf(const std::string& Option) + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::tuple FindOption(const std::string& Option); - /** - * @brief Looks for a menu option containing the passed Option, and returns information about the found option - * - * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be - * @return std::tuple - * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found - * std::string [1] = Action that was found - * std::string [2] = Target that was found - * @see Menu::IndexOf(const std::string& Options) - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::tuple FindOption(const std::vector& Options); + /** + * @brief Looks for a menu option containing the passed Option, and returns information about the found option + * + * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be + * @return std::tuple + * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found + * std::string [1] = Action that was found + * std::string [2] = Target that was found + * @see Menu::IndexOf(const std::string& Options) + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::tuple FindOption(const std::vector& Options); - /** - * @brief Looks for a menu option containing the passed Option, and returns information of all options that were found - * - * @param Option %Menu option to look for, the more specific the option, the more accurate the result will be - * @return std::vector> - * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found - * std::string [1] = Action that was found - * std::string [2] = Target that was found - * @warning The result can be inaccurate if the menu isn't open before calling this function - * @see Menu::IndexOf(const std::string& Option) - */ - static std::vector> FindOptions(const std::string& Option); + /** + * @brief Looks for a menu option containing the passed Option, and returns information of all options that were found + * + * @param Option %Menu option to look for, the more specific the option, the more accurate the result will be + * @return std::vector> + * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found + * std::string [1] = Action that was found + * std::string [2] = Target that was found + * @warning The result can be inaccurate if the menu isn't open before calling this function + * @see Menu::IndexOf(const std::string& Option) + */ + std::vector> FindOptions(const std::string& Option); - /** - * @brief Looks for a menu option containing the passed Option, and returns information of all options that were found - * - * @param %Options %Menu options to look for, if the option is found within the menu options, it'll be added to the result array, the more specific the options, the more accurate the result will be - * @return std::vector> - * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found - * std::string [1] = Action that was found - * std::string [2] = Target that was found - * @see Menu::IndexOf(const std::string& Options) - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static std::vector> FindOptions(const std::vector& Options); + /** + * @brief Looks for a menu option containing the passed Option, and returns information of all options that were found + * + * @param %Options %Menu options to look for, if the option is found within the menu options, it'll be added to the result array, the more specific the options, the more accurate the result will be + * @return std::vector> + * std::int32_t [0] = Index of the option that was found, -1 if the option wasn't found + * std::string [1] = Action that was found + * std::string [2] = Target that was found + * @see Menu::IndexOf(const std::string& Options) + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + std::vector> FindOptions(const std::vector& Options); - /** - * @brief Returns true if the menu contains the passed Option - * - * @param Option %Menu option to look for, the more specific the option, the more specific the option, the more accurate the result will be - * @return true if the found index is valid (Index >= 0) - * @see Menu::IndexOf(const std::string& Option) - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static bool Contains(const std::string& Option); + /** + * @brief Returns true if the menu contains the passed Option + * + * @param Option %Menu option to look for, the more specific the option, the more specific the option, the more accurate the result will be + * @return true if the found index is valid (Index >= 0) + * @see Menu::IndexOf(const std::string& Option) + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + bool Contains(const std::string& Option); - /** - * @brief Returns true if the menu contains at least one of the passed Options - * - * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be - * @return true if the found index is valid (Index >= 0) - * @see Menu::IndexOf(const std::string& Options) - * @warning The result can be inaccurate if the menu isn't open before calling this function - */ - static bool Contains(const std::vector& Options); + /** + * @brief Returns true if the menu contains at least one of the passed Options + * + * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be + * @return true if the found index is valid (Index >= 0) + * @see Menu::IndexOf(const std::string& Options) + * @warning The result can be inaccurate if the menu isn't open before calling this function + */ + bool Contains(const std::vector& Options); - /** - * @brief Waits until the menu contains the passed option - * - * @param Duration How long to wait until returning - * @param Step How long to wait until it checks the menu options - * @param Option %Menu option to look for, the more specific the option, the more accurate the result will be - * @return true if the found index is valid (Index >= 0) - * @see Menu::IndexOf(const std::string& Option) - * @see Menu::Contains(const std::string& Option) - */ - static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::string& Option); + /** + * @brief Waits until the menu contains the passed option + * + * @param Duration How long to wait until returning + * @param Step How long to wait until it checks the menu options + * @param Option %Menu option to look for, the more specific the option, the more accurate the result will be + * @return true if the found index is valid (Index >= 0) + * @see Menu::IndexOf(const std::string& Option) + * @see Menu::Contains(const std::string& Option) + */ + bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::string& Option); - /** - * @brief Waits until the menu contains at leaset one of the passed options - * - * @param Duration How long to wait until returning - * @param Step How long to wait until it checks the menu options - * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be - * @return true if the found index is valid (Index >= 0) - * @see Menu::IndexOf(const std::string& Options) - * @see Menu::Contains(const std::string& Options) - */ - static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::vector& Options); + /** + * @brief Waits until the menu contains at leaset one of the passed options + * + * @param Duration How long to wait until returning + * @param Step How long to wait until it checks the menu options + * @param %Options %Menu options to look for, returns on first option found, the more specific the options, the more accurate the result will be + * @return true if the found index is valid (Index >= 0) + * @see Menu::IndexOf(const std::string& Options) + * @see Menu::Contains(const std::string& Options) + */ + bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::vector& Options); - /** - * @brief Selects the menu option by the passed index if the menu is open - * - * @param Index The index of the option - * @param CloseMenu Close the menu if the function fails by using Menu::Close(), true by default - * @return true if the function selected the option by index - * @return false if the menu isn't open, the passed index is invalid (-1), the option box is off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false) - * @note Implements an %Interactable delay if succesful - */ - static bool Select(std::int32_t Index, bool CloseMenu = true); + /** + * @brief Selects the menu option by the passed index if the menu is open + * + * @param Index The index of the option + * @param CloseMenu Close the menu if the function fails by using Menu::Close(), true by default + * @return true if the function selected the option by index + * @return false if the menu isn't open, the passed index is invalid (-1), the option box is off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false) + * @note Implements an %Interactable delay if succesful + */ + bool Select(std::int32_t Index, bool CloseMenu = true); - /** - * @brief Selects the passed menu option if the menu is open - * - * @param Option %Menu option to look for, the more specific the option, the more accurate the result will be - * @param CloseMenu Close the menu if the function fails by using Menu::Close(), true by default - * @return true if the function selected the option by option - * @return false if the menu isn't open, the found option was invalid, the option box is off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false) - * @note Implements an %Interactable delay if succesful - * @see Menu::IndexOf(const std::string& Option) - */ - static bool Select(const std::string& Option, bool CloseMenu = true); + /** + * @brief Selects the passed menu option if the menu is open + * + * @param Option %Menu option to look for, the more specific the option, the more accurate the result will be + * @param CloseMenu Close the menu if the function fails by using Menu::Close(), true by default + * @return true if the function selected the option by option + * @return false if the menu isn't open, the found option was invalid, the option box is off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false) + * @note Implements an %Interactable delay if succesful + * @see Menu::IndexOf(const std::string& Option) + */ + bool Select(const std::string& Option, bool CloseMenu = true); - /** - * @brief Selects the first found option in the menu - * - * @param %Options %Menu options to look for, uses the first option found, the more specific the options, the more accurate the result will be - * @param CloseMenu Close the menu if the function fails using Menu::Close(), true by default - * @return true if the function selected the option by the first found option - * @return false if the menu isn't open, the found option was invalid, the option box is off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false) - * @note Implements an %Interactable delay if succesful - * @see Menu::IndexOf(const std::string& Options) - */ - static bool Select(const std::vector& Options, bool CloseMenu = true); + /** + * @brief Selects the first found option in the menu + * + * @param %Options %Menu options to look for, uses the first option found, the more specific the options, the more accurate the result will be + * @param CloseMenu Close the menu if the function fails using Menu::Close(), true by default + * @return true if the function selected the option by the first found option + * @return false if the menu isn't open, the found option was invalid, the option box is off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false) + * @note Implements an %Interactable delay if succesful + * @see Menu::IndexOf(const std::string& Options) + */ + bool Select(const std::vector& Options, bool CloseMenu = true); - /** - * @brief Get the array of menu option boxes, each box is a menu option - * @return std::vector array of the menu option boxes, returns an empty array if the menu isn't open - */ - static std::vector GetOptionBoxes(); + /** + * @brief Get the array of menu option boxes, each box is a menu option + * @return std::vector array of the menu option boxes, returns an empty array if the menu isn't open + */ + std::vector GetOptionBoxes(); - /** - * @brief Get the full menu box - * @return Box representing the full menu, returns a null box if the menu isn't open - */ - static Box GetBox(); + /** + * @brief Get the full menu box + * @return Box representing the full menu, returns a null box if the menu isn't open + */ + Box GetBox(); }; /** @} */ diff --git a/Include/Game/Interfaces/Minimap.hpp b/Include/Game/Interfaces/Minimap.hpp index 137f4ea..74f3a14 100644 --- a/Include/Game/Interfaces/Minimap.hpp +++ b/Include/Game/Interfaces/Minimap.hpp @@ -9,85 +9,83 @@ /** @addtogroup Interfaces * @{ */ -class Minimap +namespace Minimap { - public: - /** - * @brief Returns the middle point of the minimap - * - * @return the middle point of the minimap - */ - static Point GetMiddle(); - /** - * @brief Returns the plane the local player is on - * - * @return the plane the local player is on - */ - static std::int32_t GetPlane(); - /** - * @brief Returns the tile the local player is on - * - * @return the tile the local player is on - */ - static Tile GetPosition(); - /** - * @brief Returns the tile of the local players destination - * - * @return the tile of the local players destination - */ - static Tile GetDestination(); + /** + * @brief Returns the middle point of the minimap + * + * @return the middle point of the minimap + */ + Point GetMiddle(); + /** + * @brief Returns the plane the local player is on + * + * @return the plane the local player is on + */ + std::int32_t GetPlane(); + /** + * @brief Returns the tile the local player is on + * + * @return the tile the local player is on + */ + Tile GetPosition(); + /** + * @brief Returns the tile of the local players destination + * + * @return the tile of the local players destination + */ + Tile GetDestination(); - /** - * @brief Returns true if the local players position is close to the passed tile, uses pixels as distance - * - * @param T tile to check - * @param Distance in pixels - * @return true if the local players position is close to the passed tile - */ - static bool IsCloseTo(const Tile& T, std::int32_t Distance); - /** - * @brief Returns true if the passed tile is on the minimap - * - * @param T tile to check - * @return true if the passed tile is on the minimap - */ - static bool IsTileOn(const Tile& T); + /** + * @brief Returns true if the local players position is close to the passed tile, uses pixels as distance + * + * @param T tile to check + * @param Distance in pixels + * @return true if the local players position is close to the passed tile + */ + bool IsCloseTo(const Tile& T, std::int32_t Distance); + /** + * @brief Returns true if the passed tile is on the minimap + * + * @param T tile to check + * @return true if the passed tile is on the minimap + */ + bool IsTileOn(const Tile& T); - /** - * @brief When poisoned, clicks on the health orb to cure - * - * @return true if poisoned and if the function successfully clicks the "Cure" option on the orb - */ - static bool ClickCure(); + /** + * @brief When poisoned, clicks on the health orb to cure + * + * @return true if poisoned and if the function successfully clicks the "Cure" option on the orb + */ + bool ClickCure(); - /** - * @brief Clicks on the minimap compass to quickly face North - * - * @return true if the function succesfully clicks the compass, and the camera angle is 0 / North - */ - static bool ClickCompass(); // Clicks north + /** + * @brief Clicks on the minimap compass to quickly face North + * + * @return true if the function succesfully clicks the compass, and the camera angle is 0 / North + */ + bool ClickCompass(); // Clicks north - /** - * @brief Clicks the quick-prayer orb - * - * @return true if the function succesfully clicked the orb - */ - static bool ClickQuickPrayer(); + /** + * @brief Clicks the quick-prayer orb + * + * @return true if the function succesfully clicked the orb + */ + bool ClickQuickPrayer(); - /** - * @brief Clicks the toggle-run orb - * - * @return true if the function succesfully clicked the orb - */ - static bool ClickToggleRun(); + /** + * @brief Clicks the toggle-run orb + * + * @return true if the function succesfully clicked the orb + */ + bool ClickToggleRun(); - static bool ClickTile(const Tile& T, std::int32_t Random = 5); + bool ClickTile(const Tile& T, std::int32_t Random = 5); - static bool WalkPath(const std::vector& Path, std::int32_t Distance, std::int32_t Random); - static bool WalkPath(const std::vector& Path, std::int32_t Distance, std::int32_t Random, std::function Func); - - static bool IsReachable(const Tile& T); + bool WalkPath(const std::vector& Path, std::int32_t Distance, std::int32_t Random); + bool WalkPath(const std::vector& Path, std::int32_t Distance, std::int32_t Random, std::function Func); + bool IsReachable(const Tile& T); }; /** @} */ diff --git a/Include/Game/Interfaces/Trade.hpp b/Include/Game/Interfaces/Trade.hpp index bbb10c9..4bd71d9 100644 --- a/Include/Game/Interfaces/Trade.hpp +++ b/Include/Game/Interfaces/Trade.hpp @@ -5,20 +5,17 @@ #include #include -class Trade +namespace Trade { - public: - static bool IsOpen(); - - static std::vector GetMyOfferItemIDs(); - static std::vector GetMyOfferItemNames(); - static std::vector GetMyOfferItemAmounts(); - - static std::vector GetTheirOfferItemIDs(); - static std::vector GetTheirOfferItemNames(); - static std::vector GetTheirOfferItemAmounts(); + bool IsOpen(); + std::vector GetMyOfferItemIDs(); + std::vector GetMyOfferItemNames(); + std::vector GetMyOfferItemAmounts(); + std::vector GetTheirOfferItemIDs(); + std::vector GetTheirOfferItemNames(); + std::vector GetTheirOfferItemAmounts(); }; #endif // TRADE_HPP_INCLUDED diff --git a/Include/Game/Models/DecorativeObjects.hpp b/Include/Game/Models/DecorativeObjects.hpp index e3a6a14..ebdb318 100644 --- a/Include/Game/Models/DecorativeObjects.hpp +++ b/Include/Game/Models/DecorativeObjects.hpp @@ -9,25 +9,23 @@ /** @addtogroup Models * @{ */ -class DecorativeObjects +namespace DecorativeObjects { - public: + std::vector GetAllWithin(std::int32_t Distance); - static std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); + std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); + std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(); - static std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); - static std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::DecorativeObject Get(const Tile& T); - static Interactable::DecorativeObject Get(std::int32_t ID, std::int32_t Distance = -1); - static Interactable::DecorativeObject Get(const std::string& Name, std::int32_t Distance = -1); - static Interactable::DecorativeObject Get(const std::vector& IDs, std::int32_t Distance = -1); - static Interactable::DecorativeObject Get(const std::vector& Names, std::int32_t Distance = -1); - static Interactable::DecorativeObject Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::DecorativeObject Get(const Tile& T); + Interactable::DecorativeObject Get(std::int32_t ID, std::int32_t Distance = -1); + Interactable::DecorativeObject Get(const std::string& Name, std::int32_t Distance = -1); + Interactable::DecorativeObject Get(const std::vector& IDs, std::int32_t Distance = -1); + Interactable::DecorativeObject Get(const std::vector& Names, std::int32_t Distance = -1); + Interactable::DecorativeObject Get(const std::function& Filter, std::int32_t Distance = -1); }; /** @} */ diff --git a/Include/Game/Models/GameObjects.hpp b/Include/Game/Models/GameObjects.hpp index 5ddb039..caf7f6c 100644 --- a/Include/Game/Models/GameObjects.hpp +++ b/Include/Game/Models/GameObjects.hpp @@ -9,26 +9,24 @@ /** @addtogroup Models * @{ */ -class GameObjects +namespace GameObjects { - public: + std::vector GetAllWithin(std::int32_t Distance); - static std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); + std::vector GetAll(const Tile& T); + std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); + std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(); - static std::vector GetAll(const Tile& T); - static std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); - static std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::GameObject Get(const Tile& T); - static Interactable::GameObject Get(std::int32_t ID, std::int32_t Distance = -1); - static Interactable::GameObject Get(const std::string& Name, std::int32_t Distance = -1); - static Interactable::GameObject Get(const std::vector& IDs, std::int32_t Distance = -1); - static Interactable::GameObject Get(const std::vector& Names, std::int32_t Distance = -1); - static Interactable::GameObject Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::GameObject Get(const Tile& T); + Interactable::GameObject Get(std::int32_t ID, std::int32_t Distance = -1); + Interactable::GameObject Get(const std::string& Name, std::int32_t Distance = -1); + Interactable::GameObject Get(const std::vector& IDs, std::int32_t Distance = -1); + Interactable::GameObject Get(const std::vector& Names, std::int32_t Distance = -1); + Interactable::GameObject Get(const std::function& Filter, std::int32_t Distance = -1); }; /** @} */ diff --git a/Include/Game/Models/GroundItems.hpp b/Include/Game/Models/GroundItems.hpp index 754dcb7..b45d54d 100644 --- a/Include/Game/Models/GroundItems.hpp +++ b/Include/Game/Models/GroundItems.hpp @@ -9,26 +9,24 @@ /** @addtogroup Models * @{ */ -class GroundItems +namespace GroundItems { - public: + std::vector GetAllWithin(std::int32_t Distance); - static std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); + std::vector GetAll(const Tile& T); + std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); + std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(); - static std::vector GetAll(const Tile& T); - static std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); - static std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::GroundItem Get(const Tile& T); - static Interactable::GroundItem Get(std::int32_t ID, std::int32_t Distance = -1); - static Interactable::GroundItem Get(const std::string& Name, std::int32_t Distance = -1); - static Interactable::GroundItem Get(const std::vector& IDs, std::int32_t Distance = -1); - static Interactable::GroundItem Get(const std::vector& Names, std::int32_t Distance = -1); - static Interactable::GroundItem Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::GroundItem Get(const Tile& T); + Interactable::GroundItem Get(std::int32_t ID, std::int32_t Distance = -1); + Interactable::GroundItem Get(const std::string& Name, std::int32_t Distance = -1); + Interactable::GroundItem Get(const std::vector& IDs, std::int32_t Distance = -1); + Interactable::GroundItem Get(const std::vector& Names, std::int32_t Distance = -1); + Interactable::GroundItem Get(const std::function& Filter, std::int32_t Distance = -1); }; /** @} */ diff --git a/Include/Game/Models/GroundObjects.hpp b/Include/Game/Models/GroundObjects.hpp index 79cecc6..ead9a71 100644 --- a/Include/Game/Models/GroundObjects.hpp +++ b/Include/Game/Models/GroundObjects.hpp @@ -9,25 +9,23 @@ /** @addtogroup Models * @{ */ -class GroundObjects +namespace GroundObjects { - public: + std::vector GetAllWithin(std::int32_t Distance); - static std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); + std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); + std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(); - static std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); - static std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::GroundObject Get(const Tile& T); - static Interactable::GroundObject Get(std::int32_t ID, std::int32_t Distance = -1); - static Interactable::GroundObject Get(const std::string& Name, std::int32_t Distance = -1); - static Interactable::GroundObject Get(const std::vector& IDs, std::int32_t Distance = -1); - static Interactable::GroundObject Get(const std::vector& Names, std::int32_t Distance = -1); - static Interactable::GroundObject Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::GroundObject Get(const Tile& T); + Interactable::GroundObject Get(std::int32_t ID, std::int32_t Distance = -1); + Interactable::GroundObject Get(const std::string& Name, std::int32_t Distance = -1); + Interactable::GroundObject Get(const std::vector& IDs, std::int32_t Distance = -1); + Interactable::GroundObject Get(const std::vector& Names, std::int32_t Distance = -1); + Interactable::GroundObject Get(const std::function& Filter, std::int32_t Distance = -1); }; /** @} */ diff --git a/Include/Game/Models/NPCs.hpp b/Include/Game/Models/NPCs.hpp index 3b0e9c5..f39e222 100644 --- a/Include/Game/Models/NPCs.hpp +++ b/Include/Game/Models/NPCs.hpp @@ -10,26 +10,24 @@ /** @addtogroup Models * @{ */ -class NPCs +namespace NPCs { - public: + std::vector GetAllWithin(std::int32_t Distance); - static std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); + std::vector GetAll(const Tile& T); + std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); + std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(); - static std::vector GetAll(const Tile& T); - static std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); - static std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::NPC Get(const Tile& T); - static Interactable::NPC Get(std::int32_t ID, std::int32_t Distance = -1); - static Interactable::NPC Get(const std::string& Name, std::int32_t Distance = -1); - static Interactable::NPC Get(const std::vector& IDs, std::int32_t Distance = -1); - static Interactable::NPC Get(const std::vector& Names, std::int32_t Distance = -1); - static Interactable::NPC Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::NPC Get(const Tile& T); + Interactable::NPC Get(std::int32_t ID, std::int32_t Distance = -1); + Interactable::NPC Get(const std::string& Name, std::int32_t Distance = -1); + Interactable::NPC Get(const std::vector& IDs, std::int32_t Distance = -1); + Interactable::NPC Get(const std::vector& Names, std::int32_t Distance = -1); + Interactable::NPC Get(const std::function& Filter, std::int32_t Distance = -1); }; /** @} */ diff --git a/Include/Game/Models/Players.hpp b/Include/Game/Models/Players.hpp index 19389b6..6d11ab6 100644 --- a/Include/Game/Models/Players.hpp +++ b/Include/Game/Models/Players.hpp @@ -9,23 +9,21 @@ /** @addtogroup Models * @{ */ -class Players +namespace Players { - public: + Interactable::Player GetLocal(); + std::vector GetAllWithin(std::int32_t Distance); - static Interactable::Player GetLocal(); - static std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); + std::vector GetAll(const Tile& Tile); + std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(); - static std::vector GetAll(const Tile& Tile); - static std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::Player Get(const Tile& Tile); - static Interactable::Player Get(const std::string& Name, std::int32_t Distance = -1); - static Interactable::Player Get(const std::vector& Names, std::int32_t Distance = -1); - static Interactable::Player Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::Player Get(const Tile& Tile); + Interactable::Player Get(const std::string& Name, std::int32_t Distance = -1); + Interactable::Player Get(const std::vector& Names, std::int32_t Distance = -1); + Interactable::Player Get(const std::function& Filter, std::int32_t Distance = -1); }; /** @} */ diff --git a/Include/Game/Models/Projectiles.hpp b/Include/Game/Models/Projectiles.hpp index 35d6af2..c462c1c 100644 --- a/Include/Game/Models/Projectiles.hpp +++ b/Include/Game/Models/Projectiles.hpp @@ -7,22 +7,20 @@ #include #include -class Projectiles +namespace Projectiles { - public: + std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); - static std::vector GetAllWithin(std::int32_t Distance); - static std::vector GetAll(); + std::vector GetAll(const Tile& T); + std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(const Tile& T); - static std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::Projectile Get(const Tile& T); - static Interactable::Projectile Get(std::int32_t ID, std::int32_t Distance = -1); - static Interactable::Projectile Get(const std::vector& IDs, std::int32_t Distance = -1); - static Interactable::Projectile Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::Projectile Get(const Tile& T); + Interactable::Projectile Get(std::int32_t ID, std::int32_t Distance = -1); + Interactable::Projectile Get(const std::vector& IDs, std::int32_t Distance = -1); + Interactable::Projectile Get(const std::function& Filter, std::int32_t Distance = -1); }; diff --git a/Include/Game/Models/WallObjects.hpp b/Include/Game/Models/WallObjects.hpp index fae4c38..07991ee 100644 --- a/Include/Game/Models/WallObjects.hpp +++ b/Include/Game/Models/WallObjects.hpp @@ -9,25 +9,23 @@ /** @addtogroup Models * @{ */ -class WallObjects +namespace WallObjects { - public: + std::vector GetAllWithin(std::int32_t Distance); - static std::vector GetAllWithin(std::int32_t Distance); + std::vector GetAll(); + std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); + std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); + std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); + std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - static std::vector GetAll(); - static std::vector GetAll(std::int32_t ID, std::int32_t Distance = -1); - static std::vector GetAll(const std::string& Name, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& IDs, std::int32_t Distance = -1); - static std::vector GetAll(const std::vector& Names, std::int32_t Distance = -1); - static std::vector GetAll(const std::function& Filter, std::int32_t Distance = -1); - - static Interactable::WallObject Get(const Tile& T); - static Interactable::WallObject Get(std::int32_t ID, std::int32_t Distance = -1); - static Interactable::WallObject Get(const std::string& Name, std::int32_t Distance = -1); - static Interactable::WallObject Get(const std::vector& IDs, std::int32_t Distance = -1); - static Interactable::WallObject Get(const std::vector& Names, std::int32_t Distance = -1); - static Interactable::WallObject Get(const std::function& Filter, std::int32_t Distance = -1); + Interactable::WallObject Get(const Tile& T); + Interactable::WallObject Get(std::int32_t ID, std::int32_t Distance = -1); + Interactable::WallObject Get(const std::string& Name, std::int32_t Distance = -1); + Interactable::WallObject Get(const std::vector& IDs, std::int32_t Distance = -1); + Interactable::WallObject Get(const std::vector& Names, std::int32_t Distance = -1); + Interactable::WallObject Get(const std::function& Filter, std::int32_t Distance = -1); }; /** @} */ diff --git a/Include/Game/Tools/Antiban.hpp b/Include/Game/Tools/Antiban.hpp index c5348c2..3ddf2d1 100644 --- a/Include/Game/Tools/Antiban.hpp +++ b/Include/Game/Tools/Antiban.hpp @@ -3,13 +3,12 @@ #include -class Antiban +namespace Antiban { - public: - static void LoseClientFocus(); - static void MouseOffClient(bool LoseFocus = true); - static void SetClientSize(std::int32_t Width, std::int32_t Height); - static void MaximizeClient(); + void LoseClientFocus(); + void MouseOffClient(bool LoseFocus = true); + void SetClientSize(std::int32_t Width, std::int32_t Height); + void MaximizeClient(); }; #endif // ANTIBAN_HPP_INCLUDED diff --git a/Include/Game/Tools/BreakHandler.hpp b/Include/Game/Tools/BreakHandler.hpp index 5c2063a..c63d818 100644 --- a/Include/Game/Tools/BreakHandler.hpp +++ b/Include/Game/Tools/BreakHandler.hpp @@ -4,16 +4,15 @@ #include "../../Core/Types/Timer.hpp" #include "../../Core/Types/Counter.hpp" -class BreakHandler +namespace BreakHandler { - public: - static Counter GetBreakCounter(); - static Timer GetBreakTimer(); + Counter GetBreakCounter(); + Timer GetBreakTimer(); - static bool MiniBreak(bool Logout = true); - static bool ShortBreak(bool Logout = true); - static bool LongBreak(bool Logout = true); - static bool Break(bool LogoutOnLong = true, bool LogoutOnShort = true, bool LogoutOnMini = false); + bool MiniBreak(bool Logout = true); + bool ShortBreak(bool Logout = true); + bool LongBreak(bool Logout = true); + bool Break(bool LogoutOnLong = true, bool LogoutOnShort = true, bool LogoutOnMini = false); }; #endif // BREAKHANDLER_HPP_INCLUDED diff --git a/Include/Game/Tools/Camera.hpp b/Include/Game/Tools/Camera.hpp index 0dbb385..8ab23c9 100644 --- a/Include/Game/Tools/Camera.hpp +++ b/Include/Game/Tools/Camera.hpp @@ -7,114 +7,112 @@ /** @addtogroup Tools * @{ */ -class Camera +namespace Camera { - public: + typedef enum COMPASS_DIRECTION + { + NORTH = 0, + EAST = 90, + SOUTH = 180, + WEST = 270 + } COMPASS_DIRECTION; - typedef enum COMPASS_DIRECTION - { - NORTH = 0, - EAST = 90, - SOUTH = 180, - WEST = 270 - } COMPASS_DIRECTION; + typedef enum CAMERA_PITCH + { + LOWEST = 128, + MIDDLE = 191, + HIGHEST = 383 + } CAMERA_PITCH; - typedef enum CAMERA_PITCH - { - LOWEST = 128, - MIDDLE = 191, - HIGHEST = 383 - } CAMERA_PITCH; + /** + * @brief Returns the cameras X + * + * @return Camera X + */ + std::int32_t GetX(); + /** + * @brief Returns the cameras Z + * + * @return Camera Z + */ + std::int32_t GetY(); + /** + * @brief Returns the cameras Z + * + * @return Camera Z + */ + std::int32_t GetZ(); + /** + * @brief Returns the cameras Yaw + * + * @return Camera Yaw + */ + std::int32_t GetYaw(); - /** - * @brief Returns the cameras X - * - * @return Camera X - */ - static std::int32_t GetX(); - /** - * @brief Returns the cameras Z - * - * @return Camera Z - */ - static std::int32_t GetY(); - /** - * @brief Returns the cameras Z - * - * @return Camera Z - */ - static std::int32_t GetZ(); - /** - * @brief Returns the cameras Yaw - * - * @return Camera Yaw - */ - static std::int32_t GetYaw(); + /** + * @brief Returns the camera/compass angle in degrees + * + * @return the camera/compass angle in degrees + */ + double GetAngle(); + /** + * @brief Returns the camera pitch + * + * @return the camera pitch + */ + std::int32_t GetPitch(); + /** + * @brief Returns the camera zoom as a percentage + * + * @return the camera zoom as a percentage (0.00 - 1.00) + */ + double GetZoom(); - /** - * @brief Returns the camera/compass angle in degrees - * - * @return the camera/compass angle in degrees - */ - static double GetAngle(); - /** - * @brief Returns the camera pitch - * - * @return the camera pitch - */ - static std::int32_t GetPitch(); - /** - * @brief Returns the camera zoom as a percentage - * - * @return the camera zoom as a percentage (0.00 - 1.00) - */ - static double GetZoom(); + /** + * @brief Rotates the camera to the passed angle/degree + * + * @param Angle or degree + * @return true if it rotates within (+/-) 10 of the passed angle + */ + bool RotateTo(std::int32_t Angle); + /** + * @brief Rotates the camera to the passed direction (Camera::NORTH/EAST/SOUTH/WEST) + * + * @param Direction Camera::NORTH / EAST / SOUTH / WEST + * @return true if it rotates within (+/-) 10 of the passed direction + */ + bool RotateTo(COMPASS_DIRECTION Direction); + /** + * @brief Rotates the camera to the passed tile, with an optional desired Angle + * + * @param T tile to rotate to + * @param Angle optional desired angle of where the tile should be in relation to the player, defaulted to 0 or North + * @return true if it rotates within (+/-) 10 of the passed tile and angle + */ + bool RotateTo(const Tile& T, std::int32_t Angle = 0); + /** + * @brief Rotates the camera to the passed tile, with an optional desired direction + * + * @param T tile to rotate to + * @param Direction optional desired angle of where the tile should be in relation to the player (NORTH/EAST/SOUTH/WEST), defaulted to North + * @return true if it rotates within (+/-) 10 of the passed tile and direction + */ + bool RotateTo(const Tile& T, COMPASS_DIRECTION Direction = NORTH); - /** - * @brief Rotates the camera to the passed angle/degree - * - * @param Angle or degree - * @return true if it rotates within (+/-) 10 of the passed angle - */ - static bool RotateTo(std::int32_t Angle); - /** - * @brief Rotates the camera to the passed direction (Camera::NORTH/EAST/SOUTH/WEST) - * - * @param Direction Camera::NORTH / EAST / SOUTH / WEST - * @return true if it rotates within (+/-) 10 of the passed direction - */ - static bool RotateTo(COMPASS_DIRECTION Direction); - /** - * @brief Rotates the camera to the passed tile, with an optional desired Angle - * - * @param T tile to rotate to - * @param Angle optional desired angle of where the tile should be in relation to the player, defaulted to 0 or North - * @return true if it rotates within (+/-) 10 of the passed tile and angle - */ - static bool RotateTo(const Tile& T, std::int32_t Angle = 0); - /** - * @brief Rotates the camera to the passed tile, with an optional desired direction - * - * @param T tile to rotate to - * @param Direction optional desired angle of where the tile should be in relation to the player (NORTH/EAST/SOUTH/WEST), defaulted to North - * @return true if it rotates within (+/-) 10 of the passed tile and direction - */ - static bool RotateTo(const Tile& T, COMPASS_DIRECTION Direction = NORTH); - - /** - * @brief Sets the pitch of the camera - * - * @param Pitch desired pitch - * @return true if the camera sets the pitch (+/-) 10 of the passed pitch - */ - static bool SetPitch(std::int32_t Pitch); - /** - * @brief Sets the pitch of the camera - * - * @param Pitch desired pitch (Camera::LOWEST/MIDDLE/HIGHEST) - * @return true if the camera sets the pitch (+/-) 10 of the passed pitch - */ - static bool SetPitch(CAMERA_PITCH Pitch); + /** + * @brief Sets the pitch of the camera + * + * @param Pitch desired pitch + * @return true if the camera sets the pitch (+/-) 10 of the passed pitch + */ + bool SetPitch(std::int32_t Pitch); + /** + * @brief Sets the pitch of the camera + * + * @param Pitch desired pitch (Camera::LOWEST/MIDDLE/HIGHEST) + * @return true if the camera sets the pitch (+/-) 10 of the passed pitch + */ + bool SetPitch(CAMERA_PITCH Pitch); }; /** @} */ diff --git a/Include/Game/Tools/Interact.hpp b/Include/Game/Tools/Interact.hpp index 4b9f068..2239789 100644 --- a/Include/Game/Tools/Interact.hpp +++ b/Include/Game/Tools/Interact.hpp @@ -9,36 +9,34 @@ /** @addtogroup Tools * @{ */ -class Interact +namespace Interact { - public: + bool MoveMouse(const Point& P); + bool MoveMouse(const Box& B); - static bool MoveMouse(const Point& P); - static bool MoveMouse(const Box& B); + bool Click(const Button& B = BUTTON_LEFT); - static bool Click(const Button& B = BUTTON_LEFT); + bool Click(const Point& P, const Button& B = BUTTON_LEFT); + bool Click(const Point& P, const std::string& Option); + bool Click(const Point& P, const std::vector& Options); - static bool Click(const Point& P, const Button& B = BUTTON_LEFT); - static bool Click(const Point& P, const std::string& Option); - static bool Click(const Point& P, const std::vector& Options); + bool Click(const Box& B, const Button& Button = BUTTON_LEFT); + bool Click(const Box& B, const std::string& Option); + bool Click(const Box& B, const std::vector& Options); - static bool Click(const Box& B, const Button& Button = BUTTON_LEFT); - static bool Click(const Box& B, const std::string& Option); - static bool Click(const Box& B, const std::vector& Options); + bool Click(const Convex& C, const Button& B = BUTTON_LEFT); + bool Click(const Convex& C, const std::string& Option); + bool Click(const Convex& C, const std::vector& Options); - static bool Click(const Convex& C, const Button& B = BUTTON_LEFT); - static bool Click(const Convex& C, const std::string& Option); - static bool Click(const Convex& C, const std::vector& Options); + bool Scroll(const ScrollDirection& Direction); + bool ScrollUntil(const ScrollDirection& Direction, std::int32_t Duration, const std::function& Func); - static bool Scroll(const ScrollDirection& Direction); - static bool ScrollUntil(const ScrollDirection& Direction, std::int32_t Duration, const std::function& Func); - - static bool UpKey(std::int32_t Key); - static bool DownKey(std::int32_t Key); - bool ReleaseKey(std::int32_t Key); - bool HoldKey(std::int32_t Key, std::uint32_t Duration); - static bool TypeKey(std::int32_t Key); - static bool TypeString(const std::string& String, bool PressEnter = false); + bool UpKey(std::int32_t Key); + bool DownKey(std::int32_t Key); + bool ReleaseKey(std::int32_t Key); + bool HoldKey(std::int32_t Key, std::uint32_t Duration); + bool TypeKey(std::int32_t Key); + bool TypeString(const std::string& String, bool PressEnter = false); }; /** @} */ diff --git a/Include/Game/Tools/Pathfinding.hpp b/Include/Game/Tools/Pathfinding.hpp index 832590a..2f69b7a 100644 --- a/Include/Game/Tools/Pathfinding.hpp +++ b/Include/Game/Tools/Pathfinding.hpp @@ -8,136 +8,134 @@ /** * @brief A class allowing easy pathfinding within the local region */ -class Pathfinding +namespace Pathfinding { - public: + enum COLLISION_FLAG + { + OPEN = 0, + CLOSED = 0xFFFFFF, + UNINITIALIZED = 0x1000000, + OCCUPIED = 0x100, + SOLID = 0x20000, + BLOCKED = 0x200000, - enum COLLISION_FLAG - { - OPEN = 0, - CLOSED = 0xFFFFFF, - UNINITIALIZED = 0x1000000, - OCCUPIED = 0x100, - SOLID = 0x20000, - BLOCKED = 0x200000, + NORTH = 0x2, + EAST = 0x8, + SOUTH = 0x20, + WEST = 0x80, - NORTH = 0x2, - EAST = 0x8, - SOUTH = 0x20, - WEST = 0x80, + NORTHEAST = 0x4, + SOUTHEAST = 0x10, + SOUTHWEST = 0x40, + NORTHWEST = 0x1 + }; - NORTHEAST = 0x4, - SOUTHEAST = 0x10, - SOUTHWEST = 0x40, - NORTHWEST = 0x1 - }; + typedef enum PATHFINDER + { + /** Breadth-first search algorithim */ + BREADTH_FIRST_SEARCH + } PATHFINDER; - typedef enum PATHFINDER - { - /** Breadth-first search algorithim */ - BREADTH_FIRST_SEARCH - } PATHFINDER; + enum PATHFIND_OPTION + { + /** Checks collision */ + CHECK_COLLISION = (1 << 1), + /** Checks whitelist */ + CHECK_WHITELIST = (1 << 2), + /** Checks blacklist */ + CHECK_BLACKLIST = (1 << 3), + /** The passed goal is a local tile, the function won't normalize it */ + GOAL_IS_LOCAL = (1 << 4), + /** Returns a path as local tiles */ + RETURN_LOCAL = (1 << 5) + }; - enum PATHFIND_OPTION - { - /** Checks collision */ - CHECK_COLLISION = (1 << 1), - /** Checks whitelist */ - CHECK_WHITELIST = (1 << 2), - /** Checks blacklist */ - CHECK_BLACKLIST = (1 << 3), - /** The passed goal is a local tile, the function won't normalize it */ - GOAL_IS_LOCAL = (1 << 4), - /** Returns a path as local tiles */ - RETURN_LOCAL = (1 << 5) - }; + /** + * @brief A subclass used to store information about tile nodes generated by the Pathfinding class + */ + class TileNode + { + public: + /** @brief The local region X coordinate */ + std::int32_t X; + /** @brief The local region Y coordinate */ + std::int32_t Y; + /** @brief The collision flag associated with the node */ + std::int32_t Flag; + /** @brief For pathfinding use only */ + bool Inspected; + /** @brief True if this node matches the whitelisted tiles set in Pathfinding */ + bool MatchesWhitelist; + /** @brief True if this node matches the blacklisted tiles set in Pathfinding */ + bool MatchesBlacklist; + /** @brief For pathfinding use only */ + std::int32_t Parent[2]; + TileNode(); + TileNode(std::int32_t X, std::int32_t Y, std::int32_t Flag); + /** @brief True if the node is occupied or blocked according to its collision flag*/ + bool IsBlocked() const; + /** @brief Adds ClientX/Y to the local X and Y coordinates of the node, returning a world tile */ + Tile ToWorldTile() const; + bool operator==(const TileNode& N) const; + operator bool() const; + }; - /** - * @brief A subclass used to store information about tile nodes generated by the Pathfinding class - */ - class TileNode - { - public: - /** @brief The local region X coordinate */ - std::int32_t X; - /** @brief The local region Y coordinate */ - std::int32_t Y; - /** @brief The collision flag associated with the node */ - std::int32_t Flag; - /** @brief For pathfinding use only */ - bool Inspected; - /** @brief True if this node matches the whitelisted tiles set in Pathfinding */ - bool MatchesWhitelist; - /** @brief True if this node matches the blacklisted tiles set in Pathfinding */ - bool MatchesBlacklist; - /** @brief For pathfinding use only */ - std::int32_t Parent[2]; - TileNode(); - TileNode(std::int32_t X, std::int32_t Y, std::int32_t Flag); - /** @brief True if the node is occupied or blocked according to its collision flag*/ - bool IsBlocked() const; - /** @brief Adds ClientX/Y to the local X and Y coordinates of the node, returning a world tile */ - Tile ToWorldTile() const; - bool operator==(const TileNode& N) const; - operator bool() const; - }; + /** @brief Returns the region ID the local player is in */ + std::int32_t GetCurrentRegion(); - /** @brief Returns the region ID the local player is in */ - static std::int32_t GetCurrentRegion(); + /** @brief Clears the internal cached nodes, and generates new ones based on the local region */ + void GenerateNodes(); + /** + * @brief Sets the internal Whitelist tiles + * @note This will set the internal Whitelist object to the one passed + * */ + void SetWhitelist(const std::vector& W); + /** + * @brief Sets the internal Blacklist tiles + * @note This will set the internal Blacklist object to the one passed + * */ + void SetBlacklist(const std::vector& B); + /** @brief Returns the internal TileNode cache generated by GenerateNodes() */ + std::vector> GetNodes(); + /** @brief Returns the internal Whitelist cache */ + std::vector GetWhitelist(); + /** @brief Returns the internal Blacklist cache */ + std::vector GetBlacklist(); - /** @brief Clears the internal cached nodes, and generates new ones based on the local region */ - static void GenerateNodes(); - /** - * @brief Sets the internal Whitelist tiles - * @note This will set the internal Whitelist object to the one passed - * */ - static void SetWhitelist(const std::vector& W); - /** - * @brief Sets the internal Blacklist tiles - * @note This will set the internal Blacklist object to the one passed - * */ - static void SetBlacklist(const std::vector& B); - /** @brief Returns the internal TileNode cache generated by GenerateNodes() */ - static std::vector> GetNodes(); - /** @brief Returns the internal Whitelist cache */ - static std::vector GetWhitelist(); - /** @brief Returns the internal Blacklist cache */ - static std::vector GetBlacklist(); + Tile FindWalkableTile(const Tile& T); + Tile FindWalkableTile(const Tile& T, const Tile& Min, const Tile& Max); + std::vector FindWalkableTiles(const Tile& T); + std::vector FindWalkableTiles(const Tile& T, const Tile& Min, const Tile& Max); - static Tile FindWalkableTile(const Tile& T); - static Tile FindWalkableTile(const Tile& T, const Tile& Min, const Tile& Max); - static std::vector FindWalkableTiles(const Tile& T); - static std::vector FindWalkableTiles(const Tile& T, const Tile& Min, const Tile& Max); + std::vector FindPathTo(const Tile& Goal, + std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, + PATHFINDER Finder = BREADTH_FIRST_SEARCH); - static std::vector FindPathTo( const Tile& Goal, - std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, - PATHFINDER Finder = BREADTH_FIRST_SEARCH ); + std::vector FindPathTo(const std::vector& Goals, + std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, + PATHFINDER Finder = BREADTH_FIRST_SEARCH); - static std::vector FindPathTo( const std::vector& Goals, - std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, - PATHFINDER Finder = BREADTH_FIRST_SEARCH ); + std::vector FindNodePathTo(const Tile& Goal, + std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, + PATHFINDER Finder = BREADTH_FIRST_SEARCH); - static std::vector FindNodePathTo( const Tile& Goal, - std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, - PATHFINDER Finder = BREADTH_FIRST_SEARCH ); + std::vector FindNodePathTo(const std::vector& Goals, + std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, + PATHFINDER Finder = BREADTH_FIRST_SEARCH); +/*private: + static std::vector> Nodes; + static std::vector Whitelist; + static std::vector Blacklist; - static std::vector FindNodePathTo( const std::vector& Goals, - std::int32_t Options = CHECK_COLLISION | CHECK_WHITELIST | CHECK_BLACKLIST, - PATHFINDER Finder = BREADTH_FIRST_SEARCH ); - private: - static std::vector> Nodes; - static std::vector Whitelist; - static std::vector Blacklist; + static bool IsInside(std::uint32_t X, std::uint32_t Y); + static std::vector GetNeighborsTo(std::uint32_t X, std::uint32_t Y, bool CheckCollision = true); - static bool IsInside(std::uint32_t X, std::uint32_t Y); - static std::vector GetNeighborsTo(std::uint32_t X, std::uint32_t Y, bool CheckCollision = true); - - static std::vector Finder_BFS( std::uint32_t StartX, std::uint32_t StartY, - std::uint32_t EndX, std::uint32_t EndY, - std::int32_t Options ); - static std::vector Finder_BFS( std::uint32_t StartX, std::uint32_t StartY, - const std::vector>& Ends, - std::int32_t Options ); + static std::vector Finder_BFS( std::uint32_t StartX, std::uint32_t StartY, + std::uint32_t EndX, std::uint32_t EndY, + std::int32_t Options ); + static std::vector Finder_BFS( std::uint32_t StartX, std::uint32_t StartY, + const std::vector>& Ends, + std::int32_t Options );*/ }; #endif // PATHFINDING_HPP_INCLUDED diff --git a/Include/Game/Tools/Profile.hpp b/Include/Game/Tools/Profile.hpp index 685b7bc..c0a5843 100644 --- a/Include/Game/Tools/Profile.hpp +++ b/Include/Game/Tools/Profile.hpp @@ -7,125 +7,122 @@ /** @addtogroup Tools * @{ */ -class Profile +namespace Profile { - public: + std::string GetUsername(); + std::string GetPassword(); + std::string GetBankPin(); + std::int32_t GetWorld(); + void SetWorld(std::int32_t World); + bool GetIsMember(); + bool GetHasPin(); - static std::string GetUsername(); - static std::string GetPassword(); - static std::string GetBankPin(); - static std::int32_t GetWorld(); - static void SetWorld(std::int32_t World); + std::int32_t GetInteractableMean(); + double GetInteractableDeviation(); - static bool GetIsMember(); - static bool GetHasPin(); + std::int32_t GetMoveMean(); + double GetMoveDeviation(); - static std::int32_t GetInteractableMean(); - static double GetInteractableDeviation(); + std::int32_t GetMouseDownMean(); + double GetMouseDownDeviation(); - static std::int32_t GetMoveMean(); - static double GetMoveDeviation(); + std::int32_t GetMouseUpMean(); + double GetMouseUpDeviation(); - static std::int32_t GetMouseDownMean(); - static double GetMouseDownDeviation(); + std::int32_t GetKeyDownMean(); + double GetKeyDownDeviation(); - static std::int32_t GetMouseUpMean(); - static double GetMouseUpDeviation(); + std::int32_t GetKeyUpMean(); + double GetKeyUpDeviation(); - static std::int32_t GetKeyDownMean(); - static double GetKeyDownDeviation(); + std::int32_t GetScrollAmount(); + double GetScrollAmountDeviation(); + std::int32_t GetScrollGapMean(); + double GetScrollGapDeviation(); + std::int32_t GetScrollDelayMean(); + double GetScrollDelayDeviation(); - static std::int32_t GetKeyUpMean(); - static double GetKeyUpDeviation(); + double GetStandardDeviationX(); + double GetStandardDeviationY(); - static std::int32_t GetScrollAmount(); - static double GetScrollAmountDeviation(); - static std::int32_t GetScrollGapMean(); - static double GetScrollGapDeviation(); - static std::int32_t GetScrollDelayMean(); - static double GetScrollDelayDeviation(); + double GetBoxProbabilityX(); + double GetBoxProbabilityY(); - static double GetStandardDeviationX(); - static double GetStandardDeviationY(); + double GetConvexProbabilityX(); + double GetConvexProbabilityY(); - static double GetBoxProbabilityX(); - static double GetBoxProbabilityY(); + double GetItemProbabilityX(); + double GetItemProbabilityY(); - static double GetConvexProbabilityX(); - static double GetConvexProbabilityY(); + double GetMenuProbabilityX(); + double GetMenuProbabilityY(); - static double GetItemProbabilityX(); - static double GetItemProbabilityY(); + double GetWidgetProbabilityX(); + double GetWidgetProbabilityY(); - static double GetMenuProbabilityX(); - static double GetMenuProbabilityY(); + double GetPointGenAccuracy(); - static double GetWidgetProbabilityX(); - static double GetWidgetProbabilityY(); + double GetFatigue(); + double GetFatigueGain(); + double GetFatigueLoss(); + double GetFatigueMax(); - static double GetPointGenAccuracy(); + bool GetMiniBreakEnabled(); + double GetMiniBreakEvery(); + double GetMiniBreakEveryDeviation(); + double GetMiniBreakFor(); + double GetMiniBreakForDeviation(); - static double GetFatigue(); - static double GetFatigueGain(); - static double GetFatigueLoss(); - static double GetFatigueMax(); + bool GetShortBreakEnabled(); + double GetShortBreakEvery(); + double GetShortBreakEveryDeviation(); + double GetShortBreakFor(); + double GetShortBreakForDeviation(); - static bool GetMiniBreakEnabled(); - static double GetMiniBreakEvery(); - static double GetMiniBreakEveryDeviation(); - static double GetMiniBreakFor(); - static double GetMiniBreakForDeviation(); + bool GetLongBreakEnabled(); + double GetLongBreakEvery(); + double GetLongBreakEveryDeviation(); + double GetLongBreakFor(); + double GetLongBreakForDeviation(); - static bool GetShortBreakEnabled(); - static double GetShortBreakEvery(); - static double GetShortBreakEveryDeviation(); - static double GetShortBreakFor(); - static double GetShortBreakForDeviation(); + bool UseProxy(); + std::string GetProxyHost(); + std::string GetProxyPort(); + std::string GetProxyUsername(); + std::string GetProxyPassword(); - static bool GetLongBreakEnabled(); - static double GetLongBreakEvery(); - static double GetLongBreakEveryDeviation(); - static double GetLongBreakFor(); - static double GetLongBreakForDeviation(); + void SetRawInteractableMean(std::int32_t Mean); + std::int32_t GetRawInteractableMean(); + void SetRawInteractableDeviation(double Deviation); + double GetRawInteractableDeviation(); - static bool UseProxy(); - static std::string GetProxyHost(); - static std::string GetProxyPort(); - static std::string GetProxyUsername(); - static std::string GetProxyPassword(); + void SetRawMoveMean(std::int32_t Mean); + std::int32_t GetRawMoveMean(); + void SetRawMoveDeviation(double Deviation); + double GetRawMoveDeviation(); - static void SetRawInteractableMean(std::int32_t Mean); - static std::int32_t GetRawInteractableMean(); - static void SetRawInteractableDeviation(double Deviation); - static double GetRawInteractableDeviation(); + void SetRawMouseDownMean(std::int32_t Mean); + std::int32_t GetRawMouseDownMean(); + void SetRawMouseDownDeviation(double Deviation); + double GetRawMouseDownDeviation(); - static void SetRawMoveMean(std::int32_t Mean); - static std::int32_t GetRawMoveMean(); - static void SetRawMoveDeviation(double Deviation); - static double GetRawMoveDeviation(); + void SetRawMouseUpMean(std::int32_t Mean); + std::int32_t GetRawMouseUpMean(); + void SetRawMouseUpDeviation(double Deviation); + double GetRawMouseUpDeviation(); - static void SetRawMouseDownMean(std::int32_t Mean); - static std::int32_t GetRawMouseDownMean(); - static void SetRawMouseDownDeviation(double Deviation); - static double GetRawMouseDownDeviation(); + void SetRawKeyDownMean(std::int32_t Mean); + std::int32_t GetRawKeyDownMean(); + void SetRawKeyDownDeviation(double Deviation); + double GetRawKeyDownDeviation(); - static void SetRawMouseUpMean(std::int32_t Mean); - static std::int32_t GetRawMouseUpMean(); - static void SetRawMouseUpDeviation(double Deviation); - static double GetRawMouseUpDeviation(); + void SetRawKeyUpMean(std::int32_t Mean); + std::int32_t GetRawKeyUpMean(); + void SetRawKeyUpDeviation(double Deviation); + double GetRawKeyUpDeviation(); - static void SetRawKeyDownMean(std::int32_t Mean); - static std::int32_t GetRawKeyDownMean(); - static void SetRawKeyDownDeviation(double Deviation); - static double GetRawKeyDownDeviation(); - - static void SetRawKeyUpMean(std::int32_t Mean); - static std::int32_t GetRawKeyUpMean(); - static void SetRawKeyUpDeviation(double Deviation); - static double GetRawKeyUpDeviation(); - - static void SetPointGenAccuracy(double Accuracy); + void SetPointGenAccuracy(double Accuracy); }; diff --git a/Include/Game/Tools/RandomHandler.hpp b/Include/Game/Tools/RandomHandler.hpp index 69ea84d..60022c5 100644 --- a/Include/Game/Tools/RandomHandler.hpp +++ b/Include/Game/Tools/RandomHandler.hpp @@ -5,13 +5,12 @@ #include "../../Core/Types/Countdown.hpp" #include -class RandomHandler +namespace RandomHandler { - public: - static void SetCheckDelay(std::int64_t Time); - static Countdown GetCheckCountdown(); - static Counter GetRandomsCounter(); - static bool Check(); + void SetCheckDelay(std::int64_t Time); + Countdown GetCheckCountdown(); + Counter GetRandomsCounter(); + bool Check(); }; #endif // RANDOMHANDLER_HPP_INCLUDED diff --git a/Include/Game/Tools/Settings.hpp b/Include/Game/Tools/Settings.hpp index 4a6492e..27c5804 100644 --- a/Include/Game/Tools/Settings.hpp +++ b/Include/Game/Tools/Settings.hpp @@ -6,19 +6,18 @@ /** @addtogroup Tools * @{ */ -class Settings +namespace Settings { - public: - static std::vector GetAll(); + std::vector GetAll(); - static std::int32_t GetSetting(std::int32_t SettingIndex); - static std::int32_t GetSetting(std::int32_t SettingIndex, std::int32_t BitMask); - static bool GetSettingBit(std::int32_t SettingIndex, std::int32_t BitIndex); + std::int32_t GetSetting(std::int32_t SettingIndex); + std::int32_t GetSetting(std::int32_t SettingIndex, std::int32_t BitMask); + bool GetSettingBit(std::int32_t SettingIndex, std::int32_t BitIndex); - static std::int32_t GetScreenType(); + std::int32_t GetScreenType(); - static bool IsEscToCloseInterfacesOn(); - static bool IsShiftClickToDropOn(); + bool IsEscToCloseInterfacesOn(); + bool IsShiftClickToDropOn(); }; /** @} */ diff --git a/Include/Game/Tools/Widgets.hpp b/Include/Game/Tools/Widgets.hpp index b5c1256..f545d2b 100644 --- a/Include/Game/Tools/Widgets.hpp +++ b/Include/Game/Tools/Widgets.hpp @@ -8,17 +8,15 @@ /** @addtogroup Tools * @{ */ -class Widgets +namespace Widgets { - public: + std::vector> GetAll(); + std::vector GetAll(std::int32_t Parent); + std::vector GetAll(const std::function& Filter); - static std::vector> GetAll(); - static std::vector GetAll(std::int32_t Parent); - static std::vector GetAll(const std::function& Filter); - - static Interactable::Widget Get(std::int32_t Parent, std::int32_t Child = -1); - static Interactable::Widget Get(std::int32_t Parent, std::int32_t Child, std::int32_t Grandchild); - static Interactable::Widget Get(const std::function& Filter); + Interactable::Widget Get(std::int32_t Parent, std::int32_t Child = -1); + Interactable::Widget Get(std::int32_t Parent, std::int32_t Child, std::int32_t Grandchild); + Interactable::Widget Get(const std::function& Filter); }; /** @} */ diff --git a/Include/Game/Tools/Worlds.hpp b/Include/Game/Tools/Worlds.hpp index 0f48f5e..222b6c5 100644 --- a/Include/Game/Tools/Worlds.hpp +++ b/Include/Game/Tools/Worlds.hpp @@ -9,28 +9,27 @@ /** @addtogroup Tools * @{ */ -class Worlds +namespace Worlds { - public: - static bool Refresh(); + bool Refresh(); - static bool SwitchWorld(Internal::World World); - static bool SwitchWorld(std::int32_t WorldID); + bool SwitchWorld(Internal::World World); + bool SwitchWorld(std::int32_t WorldID); - static std::int32_t GetCurrent(); - static std::vector GetAll(); + std::int32_t GetCurrent(); + std::vector GetAll(); - static std::int32_t GetIndexOf(Internal::World World); - static std::int32_t GetIndexOf(std::int32_t WorldID); + std::int32_t GetIndexOf(Internal::World World); + std::int32_t GetIndexOf(std::int32_t WorldID); - static std::vector GetF2P(); - static std::vector GetP2P(); + std::vector GetF2P(); + std::vector GetP2P(); - static bool IsP2P(Internal::World World); - static bool IsP2P(std::int32_t WorldID); + bool IsP2P(Internal::World World); + bool IsP2P(std::int32_t WorldID); - static Internal::World GetBy(std::int32_t WorldID); - static std::vector GetBy(const std::function& Filter); + Internal::World GetBy(std::int32_t WorldID); + std::vector GetBy(const std::function& Filter); }; /** @} */ diff --git a/Library/libAlpacaLibrary.a b/Library/libAlpacaLibrary.a index 77158b3..cc7f052 100644 Binary files a/Library/libAlpacaLibrary.a and b/Library/libAlpacaLibrary.a differ