From 58cc534814f421a2b5357cbcc18796cc56a99d6c Mon Sep 17 00:00:00 2001 From: Kasi Date: Mon, 25 Dec 2017 23:49:48 +0000 Subject: [PATCH] Release 0.01 --- Include/Core/Classes/Animation.hpp | 24 ++ Include/Core/Classes/Cache.hpp | 22 ++ Include/Core/Classes/CacheableNode.hpp | 20 ++ Include/Core/Classes/Character.hpp | 36 +++ Include/Core/Classes/ChatLineBuffer.hpp | 23 ++ Include/Core/Classes/ClanMember.hpp | 23 ++ Include/Core/Classes/DecorativeModel.hpp | 30 ++ Include/Core/Classes/Deque.hpp | 21 ++ Include/Core/Classes/DynamicModel.hpp | 21 ++ Include/Core/Classes/ExchangeOffer.hpp | 23 ++ Include/Core/Classes/Frame.hpp | 28 ++ Include/Core/Classes/FrameMap.hpp | 22 ++ Include/Core/Classes/Frames.hpp | 21 ++ Include/Core/Classes/Friend.hpp | 24 ++ Include/Core/Classes/GameModel.hpp | 32 +++ Include/Core/Classes/GameShell.hpp | 20 ++ Include/Core/Classes/GroundItem.hpp | 21 ++ Include/Core/Classes/GroundModel.hpp | 26 ++ Include/Core/Classes/HashTable.hpp | 24 ++ Include/Core/Classes/Ignore.hpp | 21 ++ Include/Core/Classes/ItemContainer.hpp | 22 ++ Include/Core/Classes/ItemInfo.hpp | 32 +++ Include/Core/Classes/LinkedList.hpp | 21 ++ Include/Core/Classes/MessageNode.hpp | 26 ++ Include/Core/Classes/Model.hpp | 29 ++ Include/Core/Classes/NPC.hpp | 20 ++ Include/Core/Classes/NPCInfo.hpp | 33 +++ Include/Core/Classes/Node.hpp | 22 ++ Include/Core/Classes/ObjectInfo.hpp | 29 ++ Include/Core/Classes/Player.hpp | 31 +++ Include/Core/Classes/PlayerInfo.hpp | 25 ++ Include/Core/Classes/Preferences.hpp | 24 ++ Include/Core/Classes/Queue.hpp | 20 ++ Include/Core/Classes/Region.hpp | 23 ++ Include/Core/Classes/Renderable.hpp | 20 ++ Include/Core/Classes/SceneTile.hpp | 31 +++ Include/Core/Classes/Sprite.hpp | 23 ++ Include/Core/Classes/Varbit.hpp | 22 ++ Include/Core/Classes/WallModel.hpp | 28 ++ Include/Core/Classes/Widget.hpp | 44 +++ Include/Core/Classes/WidgetNode.hpp | 19 ++ Include/Core/Classes/World.hpp | 27 ++ Include/Core/Debug.hpp | 21 ++ Include/Core/Input.hpp | 68 +++++ Include/Core/Internal.hpp | 218 +++++++++++++++ Include/Core/JavaClass/Canvas.hpp | 18 ++ Include/Core/JavaClass/Class.hpp | 14 + Include/Core/JavaClass/FocusEvent.hpp | 16 ++ Include/Core/JavaClass/Integer.hpp | 17 ++ Include/Core/JavaClass/KeyEvent.hpp | 17 ++ Include/Core/JavaClass/LinkedHashMap.hpp | 15 + Include/Core/JavaClass/Map.hpp | 18 ++ Include/Core/JavaClass/MouseEvent.hpp | 18 ++ Include/Core/JavaClass/MouseWheelEvent.hpp | 18 ++ Include/Core/JavaClass/Object.hpp | 25 ++ Include/Core/JavaClass/Set.hpp | 16 ++ Include/Core/Math.hpp | 22 ++ Include/Core/Paint.hpp | 24 ++ Include/Core/Script.hpp | 84 ++++++ Include/Core/Time.hpp | 18 ++ Include/Core/Types/Area.hpp | 84 ++++++ Include/Core/Types/Box.hpp | 159 +++++++++++ Include/Core/Types/Convex.hpp | 67 +++++ Include/Core/Types/Countdown.hpp | 31 +++ Include/Core/Types/Counter.hpp | 61 ++++ Include/Core/Types/Logger.hpp | 55 ++++ Include/Core/Types/Point.hpp | 87 ++++++ Include/Core/Types/Tile.hpp | 72 +++++ Include/Core/Types/Timer.hpp | 88 ++++++ Include/Game/Core.hpp | 166 +++++++++++ Include/Game/Interfaces/Bank.hpp | 263 ++++++++++++++++++ Include/Game/Interfaces/Chat.hpp | 66 +++++ Include/Game/Interfaces/DepositBox.hpp | 19 ++ Include/Game/Interfaces/GameTabs/Clan.hpp | 21 ++ Include/Game/Interfaces/GameTabs/Combat.hpp | 34 +++ Include/Game/Interfaces/GameTabs/Emotes.hpp | 15 + .../Game/Interfaces/GameTabs/Equipment.hpp | 63 +++++ Include/Game/Interfaces/GameTabs/Friends.hpp | 21 ++ Include/Game/Interfaces/GameTabs/Ignores.hpp | 21 ++ .../Game/Interfaces/GameTabs/Inventory.hpp | 98 +++++++ Include/Game/Interfaces/GameTabs/Logout.hpp | 38 +++ Include/Game/Interfaces/GameTabs/Magic.hpp | 172 ++++++++++++ Include/Game/Interfaces/GameTabs/Music.hpp | 15 + Include/Game/Interfaces/GameTabs/Options.hpp | 21 ++ Include/Game/Interfaces/GameTabs/Prayer.hpp | 58 ++++ Include/Game/Interfaces/GameTabs/Quests.hpp | 15 + Include/Game/Interfaces/GameTabs/Stats.hpp | 52 ++++ Include/Game/Interfaces/Login.hpp | 85 ++++++ Include/Game/Interfaces/Mainscreen.hpp | 53 ++++ Include/Game/Interfaces/Menu.hpp | 51 ++++ Include/Game/Interfaces/Minimap.hpp | 35 +++ Include/Game/Models/GroundItems.hpp | 37 +++ Include/Game/Models/NPCs.hpp | 40 +++ Include/Game/Models/Players.hpp | 37 +++ Include/Game/Models/SceneObjects.hpp | 67 +++++ Include/Game/Tools/BreakHandler.hpp | 18 ++ Include/Game/Tools/Interact.hpp | 77 +++++ Include/Game/Tools/Profile.hpp | 82 ++++++ Include/Game/Tools/RandomHandler.hpp | 17 ++ Include/Game/Tools/Settings.hpp | 22 ++ Include/Game/Tools/Tools.hpp | 20 ++ Include/Game/Tools/Widgets.hpp | 81 ++++++ Include/Game/Tools/Worlds.hpp | 39 +++ Library/libAlpacaLibrary.a | Bin 0 -> 2349688 bytes 104 files changed, 4323 insertions(+) create mode 100644 Include/Core/Classes/Animation.hpp create mode 100644 Include/Core/Classes/Cache.hpp create mode 100644 Include/Core/Classes/CacheableNode.hpp create mode 100644 Include/Core/Classes/Character.hpp create mode 100644 Include/Core/Classes/ChatLineBuffer.hpp create mode 100644 Include/Core/Classes/ClanMember.hpp create mode 100644 Include/Core/Classes/DecorativeModel.hpp create mode 100644 Include/Core/Classes/Deque.hpp create mode 100644 Include/Core/Classes/DynamicModel.hpp create mode 100644 Include/Core/Classes/ExchangeOffer.hpp create mode 100644 Include/Core/Classes/Frame.hpp create mode 100644 Include/Core/Classes/FrameMap.hpp create mode 100644 Include/Core/Classes/Frames.hpp create mode 100644 Include/Core/Classes/Friend.hpp create mode 100644 Include/Core/Classes/GameModel.hpp create mode 100644 Include/Core/Classes/GameShell.hpp create mode 100644 Include/Core/Classes/GroundItem.hpp create mode 100644 Include/Core/Classes/GroundModel.hpp create mode 100644 Include/Core/Classes/HashTable.hpp create mode 100644 Include/Core/Classes/Ignore.hpp create mode 100644 Include/Core/Classes/ItemContainer.hpp create mode 100644 Include/Core/Classes/ItemInfo.hpp create mode 100644 Include/Core/Classes/LinkedList.hpp create mode 100644 Include/Core/Classes/MessageNode.hpp create mode 100644 Include/Core/Classes/Model.hpp create mode 100644 Include/Core/Classes/NPC.hpp create mode 100644 Include/Core/Classes/NPCInfo.hpp create mode 100644 Include/Core/Classes/Node.hpp create mode 100644 Include/Core/Classes/ObjectInfo.hpp create mode 100644 Include/Core/Classes/Player.hpp create mode 100644 Include/Core/Classes/PlayerInfo.hpp create mode 100644 Include/Core/Classes/Preferences.hpp create mode 100644 Include/Core/Classes/Queue.hpp create mode 100644 Include/Core/Classes/Region.hpp create mode 100644 Include/Core/Classes/Renderable.hpp create mode 100644 Include/Core/Classes/SceneTile.hpp create mode 100644 Include/Core/Classes/Sprite.hpp create mode 100644 Include/Core/Classes/Varbit.hpp create mode 100644 Include/Core/Classes/WallModel.hpp create mode 100644 Include/Core/Classes/Widget.hpp create mode 100644 Include/Core/Classes/WidgetNode.hpp create mode 100644 Include/Core/Classes/World.hpp create mode 100644 Include/Core/Debug.hpp create mode 100644 Include/Core/Input.hpp create mode 100644 Include/Core/Internal.hpp create mode 100644 Include/Core/JavaClass/Canvas.hpp create mode 100644 Include/Core/JavaClass/Class.hpp create mode 100644 Include/Core/JavaClass/FocusEvent.hpp create mode 100644 Include/Core/JavaClass/Integer.hpp create mode 100644 Include/Core/JavaClass/KeyEvent.hpp create mode 100644 Include/Core/JavaClass/LinkedHashMap.hpp create mode 100644 Include/Core/JavaClass/Map.hpp create mode 100644 Include/Core/JavaClass/MouseEvent.hpp create mode 100644 Include/Core/JavaClass/MouseWheelEvent.hpp create mode 100644 Include/Core/JavaClass/Object.hpp create mode 100644 Include/Core/JavaClass/Set.hpp create mode 100644 Include/Core/Math.hpp create mode 100644 Include/Core/Paint.hpp create mode 100644 Include/Core/Script.hpp create mode 100644 Include/Core/Time.hpp create mode 100644 Include/Core/Types/Area.hpp create mode 100644 Include/Core/Types/Box.hpp create mode 100644 Include/Core/Types/Convex.hpp create mode 100644 Include/Core/Types/Countdown.hpp create mode 100644 Include/Core/Types/Counter.hpp create mode 100644 Include/Core/Types/Logger.hpp create mode 100644 Include/Core/Types/Point.hpp create mode 100644 Include/Core/Types/Tile.hpp create mode 100644 Include/Core/Types/Timer.hpp create mode 100644 Include/Game/Core.hpp create mode 100644 Include/Game/Interfaces/Bank.hpp create mode 100644 Include/Game/Interfaces/Chat.hpp create mode 100644 Include/Game/Interfaces/DepositBox.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Clan.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Combat.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Emotes.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Equipment.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Friends.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Ignores.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Inventory.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Logout.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Magic.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Music.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Options.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Prayer.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Quests.hpp create mode 100644 Include/Game/Interfaces/GameTabs/Stats.hpp create mode 100644 Include/Game/Interfaces/Login.hpp create mode 100644 Include/Game/Interfaces/Mainscreen.hpp create mode 100644 Include/Game/Interfaces/Menu.hpp create mode 100644 Include/Game/Interfaces/Minimap.hpp create mode 100644 Include/Game/Models/GroundItems.hpp create mode 100644 Include/Game/Models/NPCs.hpp create mode 100644 Include/Game/Models/Players.hpp create mode 100644 Include/Game/Models/SceneObjects.hpp create mode 100644 Include/Game/Tools/BreakHandler.hpp create mode 100644 Include/Game/Tools/Interact.hpp create mode 100644 Include/Game/Tools/Profile.hpp create mode 100644 Include/Game/Tools/RandomHandler.hpp create mode 100644 Include/Game/Tools/Settings.hpp create mode 100644 Include/Game/Tools/Tools.hpp create mode 100644 Include/Game/Tools/Widgets.hpp create mode 100644 Include/Game/Tools/Worlds.hpp create mode 100644 Library/libAlpacaLibrary.a diff --git a/Include/Core/Classes/Animation.hpp b/Include/Core/Classes/Animation.hpp new file mode 100644 index 0000000..1f74974 --- /dev/null +++ b/Include/Core/Classes/Animation.hpp @@ -0,0 +1,24 @@ +#ifndef ANIMATION_HPP_INCLUDED +#define ANIMATION_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class Animation : public CacheableNode +{ + public: + Animation(); + Animation(const void* Obj); + Animation(const Animation& A); + static Class GetClass(); + + std::vector GetFrameIDs() const; + std::vector GetInterleave() const; + std::int32_t GetLeftHandItem() const; + std::int32_t GetRightHandItem() const; + +}; + +#endif // ANIMATION_HPP_INCLUDED diff --git a/Include/Core/Classes/Cache.hpp b/Include/Core/Classes/Cache.hpp new file mode 100644 index 0000000..c0c7597 --- /dev/null +++ b/Include/Core/Classes/Cache.hpp @@ -0,0 +1,22 @@ +#ifndef CACHE_HPP_INCLUDED +#define CACHE_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include "HashTable.hpp" +#include "Queue.hpp" + +class Cache : public Object +{ + public: + Cache(); + Cache(const void* Obj); + Cache(const Cache& C); + static Class GetClass(); + + HashTable GetHashTable() const; + Queue GetQueue() const; + +}; + +#endif // CACHE_HPP_INCLUDED diff --git a/Include/Core/Classes/CacheableNode.hpp b/Include/Core/Classes/CacheableNode.hpp new file mode 100644 index 0000000..4dcb2b6 --- /dev/null +++ b/Include/Core/Classes/CacheableNode.hpp @@ -0,0 +1,20 @@ +#ifndef CACHEABLENODE_HPP_INCLUDED +#define CACHEABLENODE_HPP_INCLUDED + +#include "Node.hpp" +#include "../JavaClass/Class.hpp" + +class CacheableNode : public Node +{ + public: + CacheableNode(); + CacheableNode(const void* Obj); + CacheableNode(const CacheableNode& C); + static Class GetClass(); + + CacheableNode GetNext() const; + CacheableNode GetPrev() const; + +}; + +#endif // CACHEABLENODE_HPP_INCLUDED diff --git a/Include/Core/Classes/Character.hpp b/Include/Core/Classes/Character.hpp new file mode 100644 index 0000000..0520af2 --- /dev/null +++ b/Include/Core/Classes/Character.hpp @@ -0,0 +1,36 @@ +#ifndef CHARACTER_HPP_INCLUDED +#define CHARACTER_HPP_INCLUDED + +#include "Renderable.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "LinkedList.hpp" +#include +#include + +class Character : public Renderable +{ + public: + Character(); + Character(const void* Obj); + Character(const Character& C); + static Class GetClass(); + + std::int32_t GetAngle() const; + std::int32_t GetAnimation() const; + std::int32_t GetAnimationDelay() const; + std::int32_t GetAnimationFrame() const; + LinkedList GetCombatInfo() const; + std::int32_t GetInteractIndex() const; + std::string GetOverhead() const; + std::vector GetPathX() const; + std::vector GetPathY() const; + std::int32_t GetPoseAnimation() const; + std::int32_t GetSubAnimationFrame() const; + std::int32_t GetSubPoseAnimation() const; + std::int32_t GetX() const; + std::int32_t GetY() const; + +}; + +#endif // CHARACTER_HPP_INCLUDED diff --git a/Include/Core/Classes/ChatLineBuffer.hpp b/Include/Core/Classes/ChatLineBuffer.hpp new file mode 100644 index 0000000..1bfc312 --- /dev/null +++ b/Include/Core/Classes/ChatLineBuffer.hpp @@ -0,0 +1,23 @@ +#ifndef CHATLINEBUFFER_HPP_INCLUDED +#define CHATLINEBUFFER_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include +#include "MessageNode.hpp" + +class ChatLineBuffer : public Object +{ + public: + ChatLineBuffer(); + ChatLineBuffer(const void* Obj); + ChatLineBuffer(const ChatLineBuffer& C); + static Class GetClass(); + + std::int32_t GetLength() const; + std::vector GetLines() const; + +}; + +#endif // CHATLINEBUFFER_HPP_INCLUDED diff --git a/Include/Core/Classes/ClanMember.hpp b/Include/Core/Classes/ClanMember.hpp new file mode 100644 index 0000000..5dff0a4 --- /dev/null +++ b/Include/Core/Classes/ClanMember.hpp @@ -0,0 +1,23 @@ +#ifndef CLANMEMBER_HPP_INCLUDED +#define CLANMEMBER_HPP_INCLUDED + +#include "Node.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class ClanMember : public Node +{ + public: + ClanMember(); + ClanMember(const void* Obj); + ClanMember(const ClanMember& C); + static Class GetClass(); + + std::string GetName() const; + std::int8_t GetRank() const; + std::int32_t GetWorld() const; + +}; + +#endif // CLANMEMBER_HPP_INCLUDED diff --git a/Include/Core/Classes/DecorativeModel.hpp b/Include/Core/Classes/DecorativeModel.hpp new file mode 100644 index 0000000..8bb782a --- /dev/null +++ b/Include/Core/Classes/DecorativeModel.hpp @@ -0,0 +1,30 @@ +#ifndef DECORATIVEMODEL_HPP_INCLUDED +#define DECORATIVEMODEL_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "Renderable.hpp" + +class DecorativeModel : public Object +{ + public: + DecorativeModel(); + DecorativeModel(const void* Obj); + DecorativeModel(const DecorativeModel& D); + static Class GetClass(); + + std::int32_t GetAngle() const; + std::int32_t GetFlags() const; + std::int32_t GetHash() const; + std::int32_t GetOffsetX() const; + std::int32_t GetOffsetY() const; + std::int32_t GetPlane() const; + std::int32_t GetRenderInfo() const; + Renderable GetRenderable() const; + std::int32_t GetX() const; + std::int32_t GetY() const; + +}; + +#endif // DECORATIVEMODEL_HPP_INCLUDED diff --git a/Include/Core/Classes/Deque.hpp b/Include/Core/Classes/Deque.hpp new file mode 100644 index 0000000..8ed2e41 --- /dev/null +++ b/Include/Core/Classes/Deque.hpp @@ -0,0 +1,21 @@ +#ifndef DEQUE_HPP_INCLUDED +#define DEQUE_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include "Node.hpp" + +class Deque : public Object +{ + public: + Deque(); + Deque(const void* Obj); + Deque(const Deque& D); + static Class GetClass(); + + Node GetHead() const; + Node GetTail() const; + +}; + +#endif // DEQUE_HPP_INCLUDED diff --git a/Include/Core/Classes/DynamicModel.hpp b/Include/Core/Classes/DynamicModel.hpp new file mode 100644 index 0000000..9cc4147 --- /dev/null +++ b/Include/Core/Classes/DynamicModel.hpp @@ -0,0 +1,21 @@ +#ifndef DYNAMICMODEL_HPP_INCLUDED +#define DYNAMICMODEL_HPP_INCLUDED + +#include "Renderable.hpp" +#include "../JavaClass/Class.hpp" +#include + +class DynamicModel : public Renderable +{ + public: + DynamicModel(); + DynamicModel(const void* Obj); + DynamicModel(const DynamicModel& D); + static Class GetClass(); + + std::int32_t GetID() const; + std::int32_t GetOrientation() const; + std::int32_t GetType() const; +}; + +#endif // DYNAMICMODEL_HPP_INCLUDED diff --git a/Include/Core/Classes/ExchangeOffer.hpp b/Include/Core/Classes/ExchangeOffer.hpp new file mode 100644 index 0000000..bfd9912 --- /dev/null +++ b/Include/Core/Classes/ExchangeOffer.hpp @@ -0,0 +1,23 @@ +#ifndef EXCHANGEOFFER_HPP_INCLUDED +#define EXCHANGEOFFER_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include + +class ExchangeOffer : public Object +{ + public: + ExchangeOffer(); + ExchangeOffer(const void* Obj); + ExchangeOffer(const ExchangeOffer& E); + static Class GetClass(); + + std::int32_t GetAmountTraded() const; + std::int32_t GetItemID() const; + std::int8_t GetProgress() const; + std::int32_t GetTotalAmount() const; + +}; + +#endif // EXCHANGEOFFER_HPP_INCLUDED diff --git a/Include/Core/Classes/Frame.hpp b/Include/Core/Classes/Frame.hpp new file mode 100644 index 0000000..6463b1a --- /dev/null +++ b/Include/Core/Classes/Frame.hpp @@ -0,0 +1,28 @@ +#ifndef FRAME_HPP_INCLUDED +#define FRAME_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include +#include "FrameMap.hpp" + +class Frame : public Object +{ + public: + Frame(); + Frame(const void* Obj); + Frame(const Frame& F); + static Class GetClass(); + + std::vector GetIndices() const; + bool GetShowing() const; + FrameMap GetSkin() const; + std::vector GetTranslatorX() const; + std::vector GetTranslatorY() const; + std::vector GetTranslatorZ() const; + std::int32_t GetTranslatorsLength() const; + +}; + +#endif // FRAME_HPP_INCLUDED diff --git a/Include/Core/Classes/FrameMap.hpp b/Include/Core/Classes/FrameMap.hpp new file mode 100644 index 0000000..b9e81a5 --- /dev/null +++ b/Include/Core/Classes/FrameMap.hpp @@ -0,0 +1,22 @@ +#ifndef FRAMEMAP_HPP_INCLUDED +#define FRAMEMAP_HPP_INCLUDED + +#include "Node.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class FrameMap : public Node +{ + public: + FrameMap(); + FrameMap(const void* Obj); + FrameMap(const FrameMap& F); + static Class GetClass(); + + std::vector> GetList() const; + std::vector GetTypes() const; + +}; + +#endif // FRAMEMAP_HPP_INCLUDED diff --git a/Include/Core/Classes/Frames.hpp b/Include/Core/Classes/Frames.hpp new file mode 100644 index 0000000..1d50977 --- /dev/null +++ b/Include/Core/Classes/Frames.hpp @@ -0,0 +1,21 @@ +#ifndef FRAMES_HPP_INCLUDED +#define FRAMES_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "Frame.hpp" + +class Frames : public CacheableNode +{ + public: + Frames(); + Frames(const void* Obj); + Frames(const Frames& F); + static Class GetClass(); + + std::vector GetSkeletons() const; + +}; + +#endif // FRAMES_HPP_INCLUDED diff --git a/Include/Core/Classes/Friend.hpp b/Include/Core/Classes/Friend.hpp new file mode 100644 index 0000000..c9627da --- /dev/null +++ b/Include/Core/Classes/Friend.hpp @@ -0,0 +1,24 @@ +#ifndef FRIEND_HPP_INCLUDED +#define FRIEND_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class Friend : public Object +{ + public: + Friend(); + Friend(const void* Obj); + Friend(const Friend& F); + static Class GetClass(); + + std::string GetName() const; + std::string GetPreviousName() const; + std::int32_t GetRank() const; + std::int32_t GetWorld() const; + +}; + +#endif // FRIEND_HPP_INCLUDED diff --git a/Include/Core/Classes/GameModel.hpp b/Include/Core/Classes/GameModel.hpp new file mode 100644 index 0000000..d77093f --- /dev/null +++ b/Include/Core/Classes/GameModel.hpp @@ -0,0 +1,32 @@ +#ifndef GAMEMODEL_HPP_INCLUDED +#define GAMEMODEL_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "Renderable.hpp" + +class GameModel : public Object +{ + public: + GameModel(); + GameModel(const void* Obj); + GameModel(const GameModel& G); + static Class GetClass(); + + std::int32_t GetAngle() const; + std::int32_t GetFlags() const; + std::int32_t GetHash() const; + std::int32_t GetHeight() const; + std::int32_t GetOffsetX() const; + std::int32_t GetOffsetY() const; + std::int32_t GetPlane() const; + std::int32_t GetRelativeX() const; + std::int32_t GetRelativeY() const; + Renderable GetRenderable() const; + std::int32_t GetX() const; + std::int32_t GetY() const; + +}; + +#endif // GAMEMODEL_HPP_INCLUDED diff --git a/Include/Core/Classes/GameShell.hpp b/Include/Core/Classes/GameShell.hpp new file mode 100644 index 0000000..305d42b --- /dev/null +++ b/Include/Core/Classes/GameShell.hpp @@ -0,0 +1,20 @@ +#ifndef GAMESHELL_HPP_INCLUDED +#define GAMESHELL_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include "../JavaClass/Canvas.hpp" + +class GameShell : public Object +{ + public: + GameShell(); + GameShell(const void* Obj); + GameShell(const GameShell& G); + static Class GetClass(); + + Canvas GetCanvas() const; + +}; + +#endif // GAMESHELL_HPP_INCLUDED diff --git a/Include/Core/Classes/GroundItem.hpp b/Include/Core/Classes/GroundItem.hpp new file mode 100644 index 0000000..7624deb --- /dev/null +++ b/Include/Core/Classes/GroundItem.hpp @@ -0,0 +1,21 @@ +#ifndef GROUNDITEM_HPP_INCLUDED +#define GROUNDITEM_HPP_INCLUDED + +#include "Renderable.hpp" +#include "../JavaClass/Class.hpp" +#include + +class GroundItem : public Renderable +{ + public: + GroundItem(); + GroundItem(const void* Obj); + GroundItem(const GroundItem& G); + static Class GetClass(); + + std::int32_t GetAmount() const; + std::int32_t GetID() const; + +}; + +#endif // GROUNDITEM_HPP_INCLUDED diff --git a/Include/Core/Classes/GroundModel.hpp b/Include/Core/Classes/GroundModel.hpp new file mode 100644 index 0000000..72db3ce --- /dev/null +++ b/Include/Core/Classes/GroundModel.hpp @@ -0,0 +1,26 @@ +#ifndef GROUNDMODEL_HPP_INCLUDED +#define GROUNDMODEL_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "Renderable.hpp" + +class GroundModel : public Object +{ + public: + GroundModel(); + GroundModel(const void* Obj); + GroundModel(const GroundModel& G); + static Class GetClass(); + + std::int32_t GetHash() const; + std::int32_t GetPlane() const; + std::int32_t GetRenderInfo() const; + Renderable GetRenderable() const; + std::int32_t GetX() const; + std::int32_t GetY() const; + +}; + +#endif // GROUNDMODEL_HPP_INCLUDED diff --git a/Include/Core/Classes/HashTable.hpp b/Include/Core/Classes/HashTable.hpp new file mode 100644 index 0000000..6c1e00d --- /dev/null +++ b/Include/Core/Classes/HashTable.hpp @@ -0,0 +1,24 @@ +#ifndef HASHTABLE_HPP_INCLUDED +#define HASHTABLE_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "Node.hpp" +#include + +class HashTable : public Object +{ + public: + HashTable(); + HashTable(const void* Obj); + HashTable(const HashTable& H); + static Class GetClass(); + + std::vector GetBuckets() const; + std::int32_t GetIndex() const; + std::int32_t GetSize() const; + +}; + +#endif // HASHTABLE_HPP_INCLUDED diff --git a/Include/Core/Classes/Ignore.hpp b/Include/Core/Classes/Ignore.hpp new file mode 100644 index 0000000..ec2d38a --- /dev/null +++ b/Include/Core/Classes/Ignore.hpp @@ -0,0 +1,21 @@ +#ifndef IGNORE_HPP_INCLUDED +#define IGNORE_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include + +class Ignore : public Object +{ + public: + Ignore(); + Ignore(const void* Obj); + Ignore(const Ignore& I); + static Class GetClass(); + + std::string GetName() const; + std::string GetPreviousName() const; + +}; + +#endif // IGNORE_HPP_INCLUDED diff --git a/Include/Core/Classes/ItemContainer.hpp b/Include/Core/Classes/ItemContainer.hpp new file mode 100644 index 0000000..9a0acc9 --- /dev/null +++ b/Include/Core/Classes/ItemContainer.hpp @@ -0,0 +1,22 @@ +#ifndef ITEMCONTAINER_HPP_INCLUDED +#define ITEMCONTAINER_HPP_INCLUDED + +#include "Node.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class ItemContainer : public Node +{ + public: + ItemContainer(); + ItemContainer(const void* Obj); + ItemContainer(const ItemContainer& I); + static Class GetClass(); + + std::vector GetItemAmounts() const; + std::vector GetItemIDs() const; + +}; + +#endif // ITEMCONTAINER_HPP_INCLUDED diff --git a/Include/Core/Classes/ItemInfo.hpp b/Include/Core/Classes/ItemInfo.hpp new file mode 100644 index 0000000..84daff4 --- /dev/null +++ b/Include/Core/Classes/ItemInfo.hpp @@ -0,0 +1,32 @@ +#ifndef ITEMINFO_HPP_INCLUDED +#define ITEMINFO_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include +#include +#include + +class ItemInfo : public CacheableNode +{ + public: + ItemInfo(); + ItemInfo(const void* Obj); + ItemInfo(const ItemInfo& I); + static Class GetClass(); + + std::vector GetGroundActions() const; + std::int32_t GetID() const; + std::vector GetInventoryActions() const; + bool GetMembers() const; + std::string GetName() const; + std::int32_t GetNoteID() const; + std::int32_t GetPrice() const; + std::int32_t GetSpriteID() const; + std::vector GetStackAmounts() const; + std::vector GetStackModelIDs() const; + std::int32_t GetStackable() const; + +}; + +#endif // ITEMINFO_HPP_INCLUDED diff --git a/Include/Core/Classes/LinkedList.hpp b/Include/Core/Classes/LinkedList.hpp new file mode 100644 index 0000000..d927b28 --- /dev/null +++ b/Include/Core/Classes/LinkedList.hpp @@ -0,0 +1,21 @@ +#ifndef LINKEDLIST_HPP_INCLUDED +#define LINKEDLIST_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include "Node.hpp" + +class LinkedList : public Object +{ + public: + LinkedList(); + LinkedList(const void* Obj); + LinkedList(const LinkedList& L); + static Class GetClass(); + + Node GetHead() const; + Node GetTail() const; + +}; + +#endif // LINKEDLIST_HPP_INCLUDED diff --git a/Include/Core/Classes/MessageNode.hpp b/Include/Core/Classes/MessageNode.hpp new file mode 100644 index 0000000..7d0f49b --- /dev/null +++ b/Include/Core/Classes/MessageNode.hpp @@ -0,0 +1,26 @@ +#ifndef MESSAGENODE_HPP_INCLUDED +#define MESSAGENODE_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class MessageNode : public CacheableNode +{ + public: + MessageNode(); + MessageNode(const void* Obj); + MessageNode(const MessageNode& M); + static Class GetClass(); + + std::int32_t GetID() const; + std::string GetName() const; + std::string GetSender() const; + std::string GetText() const; + std::int32_t GetTick() const; + std::int32_t GetType() const; + +}; + +#endif // MESSAGENODE_HPP_INCLUDED diff --git a/Include/Core/Classes/Model.hpp b/Include/Core/Classes/Model.hpp new file mode 100644 index 0000000..934c3db --- /dev/null +++ b/Include/Core/Classes/Model.hpp @@ -0,0 +1,29 @@ +#ifndef MODEL_HPP_INCLUDED +#define MODEL_HPP_INCLUDED + +#include "Renderable.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class Model : public Renderable +{ + public: + Model(); + Model(const void* Obj); + Model(const Model& M); + static Class GetClass(); + + std::vector> GetFrameMapIndices() const; + std::vector GetIndicesA() const; + std::vector GetIndicesB() const; + std::vector GetIndicesC() const; + std::int32_t GetIndicesLength() const; + std::int32_t GetVerticesLength() const; + std::vector GetVerticesX() const; + std::vector GetVerticesY() const; + std::vector GetVerticesZ() const; + +}; + +#endif // MODEL_HPP_INCLUDED diff --git a/Include/Core/Classes/NPC.hpp b/Include/Core/Classes/NPC.hpp new file mode 100644 index 0000000..6b7bf60 --- /dev/null +++ b/Include/Core/Classes/NPC.hpp @@ -0,0 +1,20 @@ +#ifndef NPC_HPP_INCLUDED +#define NPC_HPP_INCLUDED + +#include "Character.hpp" +#include "../JavaClass/Class.hpp" +#include "NPCInfo.hpp" + +class NPC : public Character +{ + public: + NPC(); + NPC(const void* Obj); + NPC(const NPC& N); + static Class GetClass(); + + NPCInfo GetInfo() const; + +}; + +#endif // NPC_HPP_INCLUDED diff --git a/Include/Core/Classes/NPCInfo.hpp b/Include/Core/Classes/NPCInfo.hpp new file mode 100644 index 0000000..4ad1bc1 --- /dev/null +++ b/Include/Core/Classes/NPCInfo.hpp @@ -0,0 +1,33 @@ +#ifndef NPCINFO_HPP_INCLUDED +#define NPCINFO_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include +#include +#include + +class NPCInfo : public CacheableNode +{ + public: + NPCInfo(); + NPCInfo(const void* Obj); + NPCInfo(const NPCInfo& N); + static Class GetClass(); + + std::vector GetActions() const; + std::int32_t GetCombatLevel() const; + std::int32_t GetID() const; + std::vector GetImposterIDs() const; + bool GetMinimapVisible() const; + std::vector GetModelIDs() const; + std::string GetName() const; + std::int32_t GetResizeX() const; + std::int32_t GetResizeY() const; + std::int32_t GetSettingID() const; + std::int32_t GetVarbitID() const; + bool GetVisible() const; + +}; + +#endif // NPCINFO_HPP_INCLUDED diff --git a/Include/Core/Classes/Node.hpp b/Include/Core/Classes/Node.hpp new file mode 100644 index 0000000..fe07117 --- /dev/null +++ b/Include/Core/Classes/Node.hpp @@ -0,0 +1,22 @@ +#ifndef NODE_HPP_INCLUDED +#define NODE_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include + +class Node : public Object +{ + public: + Node(); + Node(const void* Obj); + Node(const Node& N); + static Class GetClass(); + + Node GetNext() const; + Node GetPrev() const; + std::int64_t GetUID() const; + +}; + +#endif // NODE_HPP_INCLUDED diff --git a/Include/Core/Classes/ObjectInfo.hpp b/Include/Core/Classes/ObjectInfo.hpp new file mode 100644 index 0000000..cd59642 --- /dev/null +++ b/Include/Core/Classes/ObjectInfo.hpp @@ -0,0 +1,29 @@ +#ifndef OBJECTINFO_HPP_INCLUDED +#define OBJECTINFO_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include +#include +#include + +class ObjectInfo : public CacheableNode +{ + public: + ObjectInfo(); + ObjectInfo(const void* Obj); + ObjectInfo(const ObjectInfo& O); + static Class GetClass(); + + std::vector GetActions() const; + std::int32_t GetID() const; + std::vector GetImposterIDs() const; + std::vector GetModelIDs() const; + std::string GetName() const; + std::vector GetObjectTypes() const; + std::int32_t GetSettingID() const; + std::int32_t GetVarbitID() const; + +}; + +#endif // OBJECTINFO_HPP_INCLUDED diff --git a/Include/Core/Classes/Player.hpp b/Include/Core/Classes/Player.hpp new file mode 100644 index 0000000..6aa9c71 --- /dev/null +++ b/Include/Core/Classes/Player.hpp @@ -0,0 +1,31 @@ +#ifndef PLAYER_HPP_INCLUDED +#define PLAYER_HPP_INCLUDED + +#include "Character.hpp" +#include "../JavaClass/Class.hpp" +#include +#include +#include +#include "PlayerInfo.hpp" + +class Player : public Character +{ + public: + Player(); + Player(const void* Obj); + Player(const Player& P); + static Class GetClass(); + + std::vector GetActions() const; + std::int32_t GetCombatLevel() const; + bool GetHidden() const; + PlayerInfo GetInfo() const; + std::string GetName() const; + std::int32_t GetOverheadIcon() const; + std::int32_t GetSkullIcon() const; + std::int32_t GetTeam() const; + std::int32_t GetTotalLevel() const; + +}; + +#endif // PLAYER_HPP_INCLUDED diff --git a/Include/Core/Classes/PlayerInfo.hpp b/Include/Core/Classes/PlayerInfo.hpp new file mode 100644 index 0000000..8ed353f --- /dev/null +++ b/Include/Core/Classes/PlayerInfo.hpp @@ -0,0 +1,25 @@ +#ifndef PLAYERINFO_HPP_INCLUDED +#define PLAYERINFO_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class PlayerInfo : public Object +{ + public: + PlayerInfo(); + PlayerInfo(const void* Obj); + PlayerInfo(const PlayerInfo& P); + static Class GetClass(); + + std::vector GetEquipment() const; + bool GetGender() const; + std::int64_t GetHash() const; + std::int64_t GetModelID() const; + std::int32_t GetNPCModelID() const; + +}; + +#endif // PLAYERINFO_HPP_INCLUDED diff --git a/Include/Core/Classes/Preferences.hpp b/Include/Core/Classes/Preferences.hpp new file mode 100644 index 0000000..a8dab2b --- /dev/null +++ b/Include/Core/Classes/Preferences.hpp @@ -0,0 +1,24 @@ +#ifndef PREFERENCES_HPP_INCLUDED +#define PREFERENCES_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include "../JavaClass/LinkedHashMap.hpp" +#include + +class Preferences : public Object +{ + public: + Preferences(); + Preferences(const void* Obj); + Preferences(const Preferences& P); + static Class GetClass(); + + bool GetHideRoofs() const; + bool GetMuted() const; + LinkedHashMap GetPreferences() const; + std::int32_t GetScreenType() const; + +}; + +#endif // PREFERENCES_HPP_INCLUDED diff --git a/Include/Core/Classes/Queue.hpp b/Include/Core/Classes/Queue.hpp new file mode 100644 index 0000000..27e05ca --- /dev/null +++ b/Include/Core/Classes/Queue.hpp @@ -0,0 +1,20 @@ +#ifndef QUEUE_HPP_INCLUDED +#define QUEUE_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include "CacheableNode.hpp" + +class Queue : public Object +{ + public: + Queue(); + Queue(const void* Obj); + Queue(const Queue& Q); + static Class GetClass(); + + CacheableNode GetHead() const; + +}; + +#endif // QUEUE_HPP_INCLUDED diff --git a/Include/Core/Classes/Region.hpp b/Include/Core/Classes/Region.hpp new file mode 100644 index 0000000..693526f --- /dev/null +++ b/Include/Core/Classes/Region.hpp @@ -0,0 +1,23 @@ +#ifndef REGION_HPP_INCLUDED +#define REGION_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "GameModel.hpp" +#include "SceneTile.hpp" + +class Region : public Object +{ + public: + Region(); + Region(const void* Obj); + Region(const Region& R); + static Class GetClass(); + + std::vector GetGameModels() const; + std::vector>> GetSceneTiles() const; + +}; + +#endif // REGION_HPP_INCLUDED diff --git a/Include/Core/Classes/Renderable.hpp b/Include/Core/Classes/Renderable.hpp new file mode 100644 index 0000000..39c1fd9 --- /dev/null +++ b/Include/Core/Classes/Renderable.hpp @@ -0,0 +1,20 @@ +#ifndef RENDERABLE_HPP_INCLUDED +#define RENDERABLE_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include + +class Renderable : public CacheableNode +{ + public: + Renderable(); + Renderable(const void* Obj); + Renderable(const Renderable& R); + static Class GetClass(); + + std::int32_t GetModelHeight() const; + +}; + +#endif // RENDERABLE_HPP_INCLUDED diff --git a/Include/Core/Classes/SceneTile.hpp b/Include/Core/Classes/SceneTile.hpp new file mode 100644 index 0000000..1c5aa17 --- /dev/null +++ b/Include/Core/Classes/SceneTile.hpp @@ -0,0 +1,31 @@ +#ifndef SCENETILE_HPP_INCLUDED +#define SCENETILE_HPP_INCLUDED + +#include "Node.hpp" +#include "../JavaClass/Class.hpp" +#include "DecorativeModel.hpp" +#include +#include "GameModel.hpp" +#include "GroundModel.hpp" +#include +#include "WallModel.hpp" + +class SceneTile : public Node +{ + public: + SceneTile(); + SceneTile(const void* Obj); + SceneTile(const SceneTile& G); + static Class GetClass(); + + DecorativeModel GetDecorativeModel() const; + std::vector GetGameModels() const; + GroundModel GetGroundModel() const; + std::int32_t GetPlane() const; + WallModel GetWallModel() const; + std::int32_t GetX() const; + std::int32_t GetY() const; + +}; + +#endif // SCENETILE_HPP_INCLUDED diff --git a/Include/Core/Classes/Sprite.hpp b/Include/Core/Classes/Sprite.hpp new file mode 100644 index 0000000..fcd19a2 --- /dev/null +++ b/Include/Core/Classes/Sprite.hpp @@ -0,0 +1,23 @@ +#ifndef SPRITE_HPP_INCLUDED +#define SPRITE_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class Sprite : public Object +{ + public: + Sprite(); + Sprite(const void* Obj); + Sprite(const Sprite& S); + static Class GetClass(); + + std::int32_t GetHeight() const; + std::vector GetPixels() const; + std::int32_t GetWidth() const; + +}; + +#endif // SPRITE_HPP_INCLUDED diff --git a/Include/Core/Classes/Varbit.hpp b/Include/Core/Classes/Varbit.hpp new file mode 100644 index 0000000..8d624b2 --- /dev/null +++ b/Include/Core/Classes/Varbit.hpp @@ -0,0 +1,22 @@ +#ifndef VARBIT_HPP_INCLUDED +#define VARBIT_HPP_INCLUDED + +#include "CacheableNode.hpp" +#include "../JavaClass/Class.hpp" +#include + +class Varbit : public CacheableNode +{ + public: + Varbit(); + Varbit(const void* Obj); + Varbit(const Varbit& V); + static Class GetClass(); + + std::int32_t GetLSB() const; + std::int32_t GetMSB() const; + std::int32_t GetSettingID() const; + +}; + +#endif // VARBIT_HPP_INCLUDED diff --git a/Include/Core/Classes/WallModel.hpp b/Include/Core/Classes/WallModel.hpp new file mode 100644 index 0000000..523ec69 --- /dev/null +++ b/Include/Core/Classes/WallModel.hpp @@ -0,0 +1,28 @@ +#ifndef WALLMODEL_HPP_INCLUDED +#define WALLMODEL_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include "Renderable.hpp" + +class WallModel : public Object +{ + public: + WallModel(); + WallModel(const void* Obj); + WallModel(const WallModel& W); + static Class GetClass(); + + std::int32_t GetAngle() const; + std::int32_t GetFlags() const; + std::int32_t GetHash() const; + std::int32_t GetHeight() const; + std::int32_t GetPlane() const; + Renderable GetRenderable() const; + std::int32_t GetX() const; + std::int32_t GetY() const; + +}; + +#endif // WALLMODEL_HPP_INCLUDED diff --git a/Include/Core/Classes/Widget.hpp b/Include/Core/Classes/Widget.hpp new file mode 100644 index 0000000..2655d8e --- /dev/null +++ b/Include/Core/Classes/Widget.hpp @@ -0,0 +1,44 @@ +#ifndef WIDGET_HPP_INCLUDED +#define WIDGET_HPP_INCLUDED + +#include "Node.hpp" +#include "../JavaClass/Class.hpp" +#include +#include +#include + +class Widget : public Node +{ + public: + Widget(); + Widget(const void* Obj); + Widget(const Widget& W); + static Class GetClass(); + + std::vector GetActions() const; + std::int32_t GetBorderThickness() const; + std::int32_t GetBoxIndex() const; + std::vector GetChildren() const; + std::int32_t GetHeight() const; + bool GetHidden() const; + std::int32_t GetID() const; + std::int32_t GetItemAmount() const; + std::vector GetItemAmounts() const; + std::int32_t GetItemID() const; + std::vector GetItemIDs() const; + std::string GetName() const; + Widget GetParent() const; + std::int32_t GetParentID() const; + std::int32_t GetRelativeX() const; + std::int32_t GetRelativeY() const; + std::int32_t GetScrollX() const; + std::int32_t GetScrollY() const; + std::int32_t GetShadowColor() const; + std::int32_t GetSpriteID() const; + std::int32_t GetStackType() const; + std::string GetText() const; + std::int32_t GetWidth() const; + +}; + +#endif // WIDGET_HPP_INCLUDED diff --git a/Include/Core/Classes/WidgetNode.hpp b/Include/Core/Classes/WidgetNode.hpp new file mode 100644 index 0000000..f260852 --- /dev/null +++ b/Include/Core/Classes/WidgetNode.hpp @@ -0,0 +1,19 @@ +#ifndef WIDGETNODE_HPP_INCLUDED +#define WIDGETNODE_HPP_INCLUDED + +#include "Node.hpp" +#include "../JavaClass/Class.hpp" +#include + +class WidgetNode : public Node +{ + public: + WidgetNode(); + WidgetNode(const void* Obj); + WidgetNode(const WidgetNode& W); + static Class GetClass(); + + std::int32_t GetID() const; +}; + +#endif // WIDGETNODE_HPP_INCLUDED diff --git a/Include/Core/Classes/World.hpp b/Include/Core/Classes/World.hpp new file mode 100644 index 0000000..56c3f2b --- /dev/null +++ b/Include/Core/Classes/World.hpp @@ -0,0 +1,27 @@ +#ifndef WORLD_HPP_INCLUDED +#define WORLD_HPP_INCLUDED + +#include "../JavaClass/Object.hpp" +#include "../JavaClass/Class.hpp" +#include +#include + +class World : public Object +{ + public: + World(); + World(const void* Obj); + World(const World& W); + static Class GetClass(); + + std::string GetActivity() const; + std::string GetAddress() const; + std::int32_t GetID() const; + std::int32_t GetIndex() const; + std::int32_t GetLocation() const; + std::int32_t GetMask() const; + std::int32_t GetPlayerCount() const; + +}; + +#endif // WORLD_HPP_INCLUDED diff --git a/Include/Core/Debug.hpp b/Include/Core/Debug.hpp new file mode 100644 index 0000000..85ed0e1 --- /dev/null +++ b/Include/Core/Debug.hpp @@ -0,0 +1,21 @@ +#ifndef DEBUG_HPP_INCLUDED +#define DEBUG_HPP_INCLUDED + +#include "../../Include/Core/Types/Logger.hpp" + +class Debug +{ + public: + static Logger Info; + static Logger Verbose; + static Logger Warning; + static Logger Error; + static Logger Fatal; + + static void ShowConsole(); + static void HideConsole(); + static void SetVerbose(bool Toggle); +}; + + +#endif // DEBUG_HPP_INCLUDED diff --git a/Include/Core/Input.hpp b/Include/Core/Input.hpp new file mode 100644 index 0000000..81e6869 --- /dev/null +++ b/Include/Core/Input.hpp @@ -0,0 +1,68 @@ +#ifndef INPUT_HPP_INCLUDED +#define INPUT_HPP_INCLUDED + +#include "Types/Point.hpp" +#include +#include + +typedef enum ScrollDirection +{ + SCROLL_DOWN = 0, + SCROLL_UP = 1 +} ScrollDirection; + +typedef enum Button +{ + BUTTON_NONE = 0, + BUTTON_LEFT = 1, + BUTTON_MIDDLE = 2, + BUTTON_RIGHT = 3 +} Button; + +typedef enum Key +{ + KEY_BACKSPACE = 8, + KEY_TAB = 9, + KEY_NEWLINE = 10, + KEY_SHIFT = 16, + KEY_CTRL = 17, + KEY_ALT = 18, + KEY_ESC = 27, + KEY_DEL = 127, + KEY_LEFT = 256, + KEY_UP = 257, + KEY_RIGHT = 258, + KEY_DOWN = 259, + KEY_F1 = 260, + KEY_F2 = 261, + KEY_F3 = 262, + KEY_F4 = 263, + KEY_F5 = 264, + KEY_F6 = 265, + KEY_F7 = 266, + KEY_F8 = 267, + KEY_F9 = 268, + KEY_F10 = 269, + KEY_F11 = 270, + KEY_F12 = 271 +} Key; + +void SetupInput(); +void GainFocus(); +void LoseFocus(); +bool IsKeyDown(std::int32_t K); +void ScrollUp(); +void ScrollDown(); +void MouseDown(std::int32_t B); +void MouseUp(std::int32_t B); +void MouseClick(std::int32_t B); +void MouseMove(Point P); +void MouseMove(std::int32_t X, std::int32_t Y); +void KeyDown(std::int32_t K); +void KeyUp(std::int32_t K); +void KeyHold(std::int32_t K, std::uint32_t Duration); +void KeyRelease(std::int32_t K); +bool ShiftNeeded(std::int32_t K); +Point GetMousePos(); + +#endif // INPUT_HPP_INCLUDED diff --git a/Include/Core/Internal.hpp b/Include/Core/Internal.hpp new file mode 100644 index 0000000..801ab21 --- /dev/null +++ b/Include/Core/Internal.hpp @@ -0,0 +1,218 @@ +#ifndef INTERNAL_HPP_INCLUDED +#define INTERNAL_HPP_INCLUDED + +#include "Debug.hpp" +#include "Input.hpp" +#include "Math.hpp" +#include "Paint.hpp" +#include "Script.hpp" +#include "Time.hpp" + +#include "Types/Tile.hpp" +#include "Types/Point.hpp" +#include "Types/Box.hpp" +#include "Types/Timer.hpp" +#include "Types/Counter.hpp" +#include "Types/Countdown.hpp" +#include "Types/Convex.hpp" +#include "Types/Area.hpp" +#include "Types/Logger.hpp" + + +#include "JavaClass/Canvas.hpp" +#include "JavaClass/FocusEvent.hpp" +#include "JavaClass/Integer.hpp" +#include "JavaClass/KeyEvent.hpp" +#include "JavaClass/LinkedHashMap.hpp" +#include "JavaClass/Map.hpp" +#include "JavaClass/MouseEvent.hpp" +#include "JavaClass/MouseWheelEvent.hpp" +#include "JavaClass/Object.hpp" + +#include "Classes/Animation.hpp" +#include "Classes/Cache.hpp" +#include "Classes/CacheableNode.hpp" +#include "Classes/Character.hpp" +#include "Classes/ChatLineBuffer.hpp" +#include "Classes/ClanMember.hpp" +#include "Classes/DecorativeModel.hpp" +#include "Classes/Deque.hpp" +#include "Classes/DynamicModel.hpp" +#include "Classes/ExchangeOffer.hpp" +#include "Classes/Frame.hpp" +#include "Classes/FrameMap.hpp" +#include "Classes/Frames.hpp" +#include "Classes/Friend.hpp" +#include "Classes/GameModel.hpp" +#include "Classes/GameShell.hpp" +#include "Classes/GroundItem.hpp" +#include "Classes/GroundModel.hpp" +#include "Classes/HashTable.hpp" +#include "Classes/Ignore.hpp" +#include "Classes/ItemContainer.hpp" +#include "Classes/ItemInfo.hpp" +#include "Classes/LinkedList.hpp" +#include "Classes/MessageNode.hpp" +#include "Classes/Model.hpp" +#include "Classes/Node.hpp" +#include "Classes/NPC.hpp" +#include "Classes/NPCInfo.hpp" +#include "Classes/ObjectInfo.hpp" +#include "Classes/Player.hpp" +#include "Classes/PlayerInfo.hpp" +#include "Classes/Preferences.hpp" +#include "Classes/Queue.hpp" +#include "Classes/Region.hpp" +#include "Classes/Renderable.hpp" +#include "Classes/SceneTile.hpp" +#include "Classes/Sprite.hpp" +#include "Classes/Varbit.hpp" +#include "Classes/WallModel.hpp" +#include "Classes/Widget.hpp" +#include "Classes/WidgetNode.hpp" +#include "Classes/World.hpp" + +extern GameShell Client; + +Cache GetAnimationCache(); +std::int32_t GetCameraPitch(); +std::int32_t GetCameraX(); +std::int32_t GetCameraY(); +std::int32_t GetCameraYaw(); +std::int32_t GetCameraZ(); +Map GetChatLineCache(); +std::vector GetClanMembers(); +std::int32_t GetClientPlane(); +Preferences GetClientPreferences(); +std::int32_t GetClientX(); +std::int32_t GetClientY(); +std::vector GetCurrentLevels(); +std::int32_t GetCurrentWorld(); +Cache GetDynamicModelCache(); +std::vector GetExchangeOffers(); +std::vector GetExperiences(); +bool GetFocused(); +Cache GetFramesCache(); +std::vector GetFriends(); +std::int32_t GetGameState(); +std::int32_t GetGameTick(); +std::vector>> GetGroundItems(); +std::vector GetIgnores(); +HashTable GetItemContainers(); +Cache GetItemModelCache(); +std::int32_t GetItemSelected(); +std::int32_t GetItemSelectedIndex(); +Cache GetItemSpriteCache(); +std::vector GetLevels(); +std::int32_t GetLocalDestinationX(); +std::int32_t GetLocalDestinationY(); +Player GetLocalPlayer(); +Region GetLocalRegion(); +std::int32_t GetLoginCaret(); +std::string GetLoginMessage0(); +std::string GetLoginMessage1(); +std::string GetLoginMessage2(); +std::int32_t GetLoginScreenX(); +std::int32_t GetLoginState(); +std::int32_t GetLoginWindow(); +std::int32_t GetMapAngle(); +std::vector GetMenuActions(); +std::int32_t GetMenuCount(); +std::int32_t GetMenuHeight(); +std::vector GetMenuTargets(); +bool GetMenuVisible(); +std::int32_t GetMenuWidth(); +std::int32_t GetMenuX(); +std::int32_t GetMenuY(); +Cache GetModelCache(); +std::vector GetNPCIndices(); +Cache GetNPCModelCache(); +std::vector GetNPCs(); +std::string GetPassword(); +Cache GetPlayerModelCache(); +std::vector GetPlayers(); +std::int32_t GetRunEnergy(); +std::string GetSelectedItemName(); +std::string GetSelectedSpellName(); +std::vector GetSettings(); +bool GetSpellSelected(); +std::vector>> GetTileHeights(); +std::vector>> GetTileSettings(); +std::string GetUsername(); +Cache GetVarbitCache(); +std::vector GetVarbitSettings(); +std::int32_t GetViewportHeight(); +std::int32_t GetViewportScale(); +std::int32_t GetViewportWidth(); +std::int32_t GetWeight(); +HashTable GetWidgetNodeCache(); +std::vector> GetWidgets(); +std::vector GetWidgetsHeight(); +std::vector GetWidgetsWidth(); +std::vector GetWidgetsX(); +std::vector GetWidgetsY(); +bool GetWorldSelectOpen(); +std::vector GetWorlds(); +ItemInfo GetItemInfo(std::int32_t ID); +NPCInfo GetNPCInfo(std::int32_t ID); +ObjectInfo GetObjectInfo(std::int32_t ID); +bool LoadWorlds(); +void SetWorld(World W); + + +Widget GetWidget(std::int32_t Container, std::int32_t Component); +Widget GetWidgetParent(Widget W); +std::int32_t GetWidgetX(Widget W); +std::int32_t GetWidgetY(Widget W); +bool GetWidgetHidden(Widget W); +Box GetWidgetBox(Widget W); +ItemContainer GetItemContainer(std::int32_t ID); +NPC GetNPC(std::int32_t Index); +std::int32_t GetTileHeight(std::int32_t X, std::int32_t Y, std::int32_t Z, + std::vector>>& TileHeights, + std::vector>>& TileSettings); +Point WorldToScreen(std::int32_t X, std::int32_t Y, std::int32_t Z, + std::vector>>& TileHeights, + std::vector>>& TileSettings, + std::int32_t CameraX, std::int32_t CameraY, std::int32_t CameraZ, + std::int32_t Pitch, std::int32_t Yaw, std::int32_t Scale, + std::int32_t ViewportWidth, std::int32_t ViewportHeight, + std::int32_t ScreenType, std::int32_t Plane); +Point WorldToScreenEx(std::int32_t X, std::int32_t Y, std::int32_t Z, + std::vector>>& TileHeights, + std::vector>>& TileSettings, + std::int32_t CameraX, std::int32_t CameraY, std::int32_t CameraZ, + std::int32_t Pitch, std::int32_t Yaw, std::int32_t Scale, + std::int32_t ViewportWidth, std::int32_t ViewportHeight, + std::int32_t ScreenType, std::int32_t Plane, + std::int32_t PositionX, std::int32_t PositionY); +void RotateVertices(std::vector& X, std::vector& Y, + std::vector& Z, std::int32_t Angle); +std::vector ProjectModel(Model M, std::int32_t LocalX, std::int32_t LocalY, + std::int32_t LocalZ, std::int32_t Angle); +Model GetPlayerModel(std::int64_t ID); +Model GetNPCModel(std::int32_t ID); +Varbit GetVarbit(std::int32_t ID); +Animation GetAnimation(std::int32_t ID); +Frames GetFrames(std::int32_t ID); +Model GetItemModel(std::int32_t ID); +Model GetItemModel(std::int32_t ID, std::int32_t Amount); +Model GetGameModel(GameModel O); +Model GetWallModel(WallModel O); +Model GetDecorativeModel(DecorativeModel O); +Model GetGroundModel(GroundModel O); +Model GetDynamicModel(std::int32_t ID); +std::vector> GetGroundItems(std::int32_t Plane); +Deque GetGroundItems(std::int32_t X, std::int32_t Y); +Deque GetGroundItems(std::int32_t X, std::int32_t Y, std::int32_t Plane); +std::vector GetPlayerModel(Player P); +std::vector GetNPCModel(NPC N); +SceneTile GetSceneTile(std::int32_t X, std::int32_t Y, std::int32_t Plane); +std::vector> GetSceneTiles(std::int32_t Plane); +Point TileToMinimap(Tile T); +std::int32_t GetTileItemHeight(std::int32_t X, std::int32_t Y, std::int32_t Plane); +Sprite GetItemSprite(std::int32_t ID, std::int32_t Amount, std::int32_t BorderThickness, + std::int32_t ShadowColor, std::int32_t StackType); +Convex GetItemSpriteConvex(Sprite S); + +#endif // INTERNAL_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Canvas.hpp b/Include/Core/JavaClass/Canvas.hpp new file mode 100644 index 0000000..6a069cc --- /dev/null +++ b/Include/Core/JavaClass/Canvas.hpp @@ -0,0 +1,18 @@ +#ifndef CANVAS_HPP_INCLUDED +#define CANVAS_HPP_INCLUDED + +#include +#include "Object.hpp" + +class Canvas : public Object +{ + public: + Canvas(); + Canvas(void* Obj); + Canvas(const Canvas& C); + 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 new file mode 100644 index 0000000..9ed5530 --- /dev/null +++ b/Include/Core/JavaClass/Class.hpp @@ -0,0 +1,14 @@ +#ifndef CLASS_HPP_INCLUDED +#define CLASS_HPP_INCLUDED + +#include "Object.hpp" + +class Class : public Object +{ + public: + Class(); + Class(const void* Obj); + Class(const Class& C); +}; + +#endif // CLASS_HPP_INCLUDED diff --git a/Include/Core/JavaClass/FocusEvent.hpp b/Include/Core/JavaClass/FocusEvent.hpp new file mode 100644 index 0000000..1024863 --- /dev/null +++ b/Include/Core/JavaClass/FocusEvent.hpp @@ -0,0 +1,16 @@ +#ifndef FOCUSEVENT_HPP_INCLUDED +#define FOCUSEVENT_HPP_INCLUDED + +#include +#include "Object.hpp" + +class FocusEvent : public Object +{ + public: + FocusEvent(); + FocusEvent(void* Object); + FocusEvent(const FocusEvent& M); + FocusEvent(Object Source, std::int32_t ID); +}; + +#endif // FOCUSEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Integer.hpp b/Include/Core/JavaClass/Integer.hpp new file mode 100644 index 0000000..7ba0a0a --- /dev/null +++ b/Include/Core/JavaClass/Integer.hpp @@ -0,0 +1,17 @@ +#ifndef INTEGER_HPP_INCLUDED +#define INTEGER_HPP_INCLUDED + +#include +#include "Object.hpp" + +class Integer : public Object +{ + public: + Integer(); + Integer(void* Obj); + Integer(const Integer& I); + Integer(std::int32_t Value); + std::int32_t GetIntValue() const; +}; + +#endif // INTEGER_HPP_INCLUDED diff --git a/Include/Core/JavaClass/KeyEvent.hpp b/Include/Core/JavaClass/KeyEvent.hpp new file mode 100644 index 0000000..71a8bdc --- /dev/null +++ b/Include/Core/JavaClass/KeyEvent.hpp @@ -0,0 +1,17 @@ +#ifndef KEYEVENT_HPP_INCLUDED +#define KEYEVENT_HPP_INCLUDED + +#include +#include "Object.hpp" + +class KeyEvent : public Object +{ + 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); +}; + +#endif // KEYEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/LinkedHashMap.hpp b/Include/Core/JavaClass/LinkedHashMap.hpp new file mode 100644 index 0000000..66cc50d --- /dev/null +++ b/Include/Core/JavaClass/LinkedHashMap.hpp @@ -0,0 +1,15 @@ +#ifndef LINKEDHASHMAP_HPP_INCLUDED +#define LINKEDHASHMAP_HPP_INCLUDED + +#include "Object.hpp" + +class LinkedHashMap : public Object +{ + public: + LinkedHashMap(); + LinkedHashMap(void* Obj); + LinkedHashMap(const LinkedHashMap& L); + Object GetValue(Object Key) const; +}; + +#endif // LINKEDHASHMAP_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Map.hpp b/Include/Core/JavaClass/Map.hpp new file mode 100644 index 0000000..c0f013e --- /dev/null +++ b/Include/Core/JavaClass/Map.hpp @@ -0,0 +1,18 @@ +#ifndef MAP_HPP_INCLUDED +#define MAP_HPP_INCLUDED + +#include +#include "Object.hpp" +#include "Set.hpp" + +class Map : public Object +{ + public: + Map(); + Map(void* Obj); + Map(const Map& M); + 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 new file mode 100644 index 0000000..943d96a --- /dev/null +++ b/Include/Core/JavaClass/MouseEvent.hpp @@ -0,0 +1,18 @@ +#ifndef MOUSEEVENT_HPP_INCLUDED +#define MOUSEEVENT_HPP_INCLUDED + +#include +#include "Object.hpp" + +class MouseEvent : public Object +{ + 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); +}; + +#endif // MOUSEEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/MouseWheelEvent.hpp b/Include/Core/JavaClass/MouseWheelEvent.hpp new file mode 100644 index 0000000..1b1f50e --- /dev/null +++ b/Include/Core/JavaClass/MouseWheelEvent.hpp @@ -0,0 +1,18 @@ +#ifndef MOUSEWHEELEVENT_HPP_INCLUDED +#define MOUSEWHEELEVENT_HPP_INCLUDED + +#include +#include "Object.hpp" + +class MouseWheelEvent : public Object +{ + 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); +}; + +#endif // MOUSEWHEELEVENT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Object.hpp b/Include/Core/JavaClass/Object.hpp new file mode 100644 index 0000000..6121517 --- /dev/null +++ b/Include/Core/JavaClass/Object.hpp @@ -0,0 +1,25 @@ +#ifndef OBJECT_HPP_INCLUDED +#define OBJECT_HPP_INCLUDED + +class Class; + +class Object +{ + public: + void* Obj; + + Object(); + Object(const void* Obj); + Object(const Object& O); + void* Get() const; + Object& operator=(const 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; + virtual ~Object(); +}; + +#endif // OBJECT_HPP_INCLUDED diff --git a/Include/Core/JavaClass/Set.hpp b/Include/Core/JavaClass/Set.hpp new file mode 100644 index 0000000..45eb5d6 --- /dev/null +++ b/Include/Core/JavaClass/Set.hpp @@ -0,0 +1,16 @@ +#ifndef SET_HPP_INCLUDED +#define SET_HPP_INCLUDED + +#include +#include "Object.hpp" + +class Set : public Object +{ + public: + Set(); + Set(void* Obj); + Set(const Set& S); + std::vector ToArray() const; +}; + +#endif // SET_HPP_INCLUDED diff --git a/Include/Core/Math.hpp b/Include/Core/Math.hpp new file mode 100644 index 0000000..f83caa9 --- /dev/null +++ b/Include/Core/Math.hpp @@ -0,0 +1,22 @@ +#ifndef MATH_HPP_INCLUDED +#define MATH_HPP_INCLUDED + +#include +#include + +#include "Types/Point.hpp" + +/** @addtogroup Math +* @{ */ + +std::int32_t BinomialRandom(std::int32_t Min, std::int32_t Max, double Probability); +std::int32_t UniformRandom(std::int32_t Min, std::int32_t Max); +double UniformRandom(); +std::int32_t NormalRandom(std::int32_t Mean, double StandardDeviation); +std::int32_t NormalRandom(std::int32_t Low, std::int32_t High, double PercentageDeviation); +std::vector Spiral(Point Start, Box Area); +std::vector ConvexHull(std::vector Points); + +/** @} */ + +#endif // MATH_HPP_INCLUDED diff --git a/Include/Core/Paint.hpp b/Include/Core/Paint.hpp new file mode 100644 index 0000000..9903cd3 --- /dev/null +++ b/Include/Core/Paint.hpp @@ -0,0 +1,24 @@ +#ifndef PAINT_HPP_INCLUDED +#define PAINT_HPP_INCLUDED + +#include +#include "Types/Convex.hpp" + +/** @addtogroup Core +* @{ */ +class Paint +{ + public: + static void Clear(); + 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(Convex& C, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha); +}; + +/** @} */ + +#endif // PAINT_HPP_INCLUDED diff --git a/Include/Core/Script.hpp b/Include/Core/Script.hpp new file mode 100644 index 0000000..6dbd2fe --- /dev/null +++ b/Include/Core/Script.hpp @@ -0,0 +1,84 @@ +#ifndef SCRIPT_HPP_INCLUDED +#define SCRIPT_HPP_INCLUDED + +#include +#include +#include "Types/Timer.hpp" + +typedef struct +{ + std::string Name = ""; + std::string Description = ""; + std::string Version = ""; + std::string Category = ""; + std::string Author = ""; + std::string UID = ""; + std::string ForumPage = ""; +} ScriptInfo; + +typedef struct +{ + std::string Username; + std::string Password; + bool Member; + bool HasPin; + std::string BankPin; + std::string World; + bool UseProxy; + std::string ProxyHost; + std::string ProxyPort; + std::int32_t ActionDelayMean; + float ActionDelayDeviation; + std::int32_t MoveDelayMean; + float MoveDelayDeviation; + std::int32_t MouseDownDelayMean; + float MouseDownDelayDeviation; + std::int32_t MouseUpDelayMean; + float MouseUpDelayDeviation; + std::int32_t KeyDownDelayMean; + float KeyDownDelayDeviation; + std::int32_t KeyUpDelayMean; + float KeyUpDelayDeviation; + std::int32_t ScrollDelayMean; + float ScrollDelayDeviation; + float StandardDeviationX; + float StandardDeviationY; + float BoxProbabilityX; + float BoxProbabilityY; + float ConvexProbabilityX; + float ConvexProbabilityY; + float ItemProbabilityX; + float ItemProbabilityY; + float MenuProbabilityX; + float MenuProbabilityY; + float WidgetProbabilityX; + float WidgetProbabilityY; + float MissFollowUp; + float FatigueGain; + float FatigueLoss; + float FatigueMax; + bool ShortBreakEnabled; + float ShortBreakEvery; + float ShortBreakEveryDeviation; + float ShortBreakFor; + float ShortBreakForDeviation; + bool LongBreakEnabled; + float LongBreakEvery; + float LongBreakEveryDeviation; + float LongBreakFor; + float LongBreakForDeviation; +} PlayerProfile; + +Timer GetScriptTimer(); +void SetScriptInfo(ScriptInfo); +void GetScriptInfo(ScriptInfo&); +void SetPlayerProfile(PlayerProfile); +void RequestArgument(std::string Argument, std::string Description); +std::vector GetArguments(); +std::vector GetArgumentDescriptions(); +void SetArgument(std::string Argument, std::string Value); +std::string GetArgument(std::string Argument); +std::uint32_t GetLoopDelay(); +void SetLoopDelay(std::uint32_t Delay); + +#endif // SCRIPT_HPP_INCLUDED diff --git a/Include/Core/Time.hpp b/Include/Core/Time.hpp new file mode 100644 index 0000000..113d904 --- /dev/null +++ b/Include/Core/Time.hpp @@ -0,0 +1,18 @@ +#ifndef TIME_HPP_INCLUDED +#define TIME_HPP_INCLUDED + +#include +#include + +/** @addtogroup Time +* @{ */ + +void Wait(std::int64_t Duration); +std::uint64_t CurrentTimeMillis(); +std::uint64_t CurrentTimeNanos(); +bool WaitFunc(std::uint32_t Duration, std::uint32_t Step, std::function Func); +bool WaitFunc(std::uint32_t Duration, std::uint32_t Step, std::function Func, bool Result); + +/** @} */ + +#endif // TIME_HPP_INCLUDED diff --git a/Include/Core/Types/Area.hpp b/Include/Core/Types/Area.hpp new file mode 100644 index 0000000..8045d17 --- /dev/null +++ b/Include/Core/Types/Area.hpp @@ -0,0 +1,84 @@ +#ifndef AREA_HPP_INCLUDED +#define AREA_HPP_INCLUDED + +#include "Tile.hpp" +#include "Convex.hpp" +#include +#include + +/** @addtogroup Types +* @{ */ +class Area : public Convex +{ + public: + /** + * @brief The Plane the Area is located on + * @par Description + * The Plane the Area is located on + */ + std::int32_t Plane; + + /** + * @brief Default Constructor, constructs an Area with -1 as the TopLeft and BottomRight Tile + * @par Description + * Default Constructor, constructs an Area with -1 as the TopLeft and BottomRight Tile + */ + Area(); + /** + * @brief Constructs an Area based on a TopLeft tile and a BottomRight tile, sets the internal Plane to the plane of the TopLeft tile + * @param Tile TopLeft Top Left tile of the Area + * @param Tile BottomRight Bottom Right tile of the Area + */ + Area(Tile TopLeft, Tile BottomRight); + /** + * @brief Constructs an Area based on a TopLeft tile and a BottomRight tile, sets the internal Plane to the plane of the TopLeft tile + * @param std::vector TileVertices + */ + Area(std::vector TileVertices); + /** + * @brief Constructs an Area, by copying another + * @param const Area& A The Area to "copy" + */ + Area(const Area& A); + + /** + * @brief Returns True if the Area contains a Tile, does check the Tiles Plane + * @return True if the Area contains a Tile, does check the Tiles Plane + * @par Example + * @code + * Area A(Tile(100, 100, 0), Tile(200, 200, 0)); + * Debug::Info << A.contains(Tile(150, 150, 0)); + * @endcode + */ + bool Contains(const Tile& T) const; + /** + * @brief Returns the middle Tile of the Area + * @return The middle Tile of the Area + * @par Example + * @code + * Area A(Tile(100, 100, 0), Tile(200, 200, 0)); + * Debug::Info << A.GetMiddle()); + * @endcode + */ + Tile GetMiddle() const; + /** + * @brief Returns a random Tile using Hybrid Distribution + * @return A random Tile using Hybrid Distribution + * @par Example + * @code + * Area A(Tile(100, 100, 0), Tile(200, 200, 0)); + * Debug::Info << A.GetHybridRandomTile(0.20, 0.20, 0.50, false)); + * @endcode + * @see @ref HybridRandomDocs + * @see @ref MissChanceFollowupDocs + */ + Tile GetHybridRandomTile(double ProbabilityX, double ProbabilityY, double StandardDeviationX, double StandardDeviationY, bool CheckMissFollowupChance = true) const; + + friend std::ostream& operator<<(std::ostream& OS, const Area& A); + + ~Area(); +}; + +/** @} */ + +#endif // AREA_HPP_INCLUDED diff --git a/Include/Core/Types/Box.hpp b/Include/Core/Types/Box.hpp new file mode 100644 index 0000000..96670d2 --- /dev/null +++ b/Include/Core/Types/Box.hpp @@ -0,0 +1,159 @@ +#ifndef BOX_HPP_INCLUDED +#define BOX_HPP_INCLUDED + +#include +#include +#include "Point.hpp" + +class Point; + +/** @addtogroup Types +* @{ */ +class Box +{ + public: + /** + * @brief The X of where the Box starts + * @par Description + * The X of where the Box starts + */ + std::int32_t X; + /** + * @brief The Y of where the Box starts + * @par Description + * The Y of where the Box starts + */ + std::int32_t Y; + /** + * @brief The Width of the Box + * @par Description + * The Width of the Box + */ + std::int32_t Width; + /** + * @brief The Height of the Box + * @par Description + * The Height of the Box + */ + std::int32_t Height; + + /** + * @brief Default Constructor, constructs a Box with -1 as the X, Y, Width, and Height + * @par Description + * Default Constructor, constructs a Box with -1 as the X, Y, Width, and Height + */ + Box(); + /** + * @brief Constructs a Box based on X, Y, Width, and Height + * @param std::int32_t X The X of where the Box begins + * @param std::int32_t Y The Y of where the Box begins + * @param std::int32_t Width The Width of the Box to be constructed + * @param std::int32_t Height The Height of the Box to be constructed + */ + Box(std::int32_t X, std::int32_t Y, std::int32_t Width, std::int32_t Height); + /** + * @brief Constructs a Box, by copying another + * @param const Box& B The Box to "copy" + */ + Box(const Box& B); + + /** + * @brief Returns a random Point using Uniform Distribution + * @return A random Point using Uniform Distribution + * @see @ref UniformRandomDocs + * @see @ref MissChanceFollowupDocs + */ + Point GetUniformRandomPoint() const; + /** + * @brief Returns a random Point using Binomial Distribution + * @return A random Point using Binomial Distribution + * @see @ref BinomialRandomDocs + * @see @ref MissChanceFollowupDocs + */ + Point GetBinomialRandomPoint(double ProbabilityX, double ProbabilityY) const; + /** + * @brief Returns a random Point using Normal Distribution + * @return A random Point using Normal Distribution + * @see @ref NormalRandomDocs + * @see @ref MissChanceFollowupDocs + */ + Point GetNormalRandomPoint(double PercentageDeviationX, double PercentageDeviationY) const; + /** + * @brief Returns a random Point using Hybrid Distribution + * @return A random Point using Hybrid Distribution + * @see @ref HybridRandomDocs + * @see @ref MissChanceFollowupDocs + */ + Point GetHybridRandomPoint(double ProbilityX, double ProbilityY, double StandardDeviationX, double StandardDeviationY, bool CheckMissFollowupChance = true) const; + + /** + * @brief Returns True if the Box contains a Point + * @return True if the Box contains a Point + * @par Example + * @code + * Box B(25, 25, 100, 100); + * Debug::Info << B.contains(Point(30, 30)); + * @endcode + */ + bool Contains(Point P) const; + /** + * @brief Returns True if the Box contains both X, and Y + * @return True if the Box contains both X, and Y + * @par Example + * @code + * Box B(25, 25, 100, 100); + * Debug::Info << B.contains(30, 30); + * @endcode + */ + bool Contains(std::int32_t X, std::int32_t Y) const; + /** + * @brief Returns True if the Box contains another Box + * @return True if the Box contains another Box + * @par Example + * @code + * Box A(25, 25, 100, 100); + * Box B(30, 30, 10, 10); + * Debug::Info << A.contains(B); + * @endcode + */ + bool Contains(Box Box) const; + /** + * @brief Returns the X2 of the Box + * @return The X2 of the Box + * @par Example + * @code + * Box B(25, 25, 100, 100); + * Debug::Info << B.GetX2() << ", " << B.GetY2(); + * @endcode + */ + std::int32_t GetX2() const; + /** + * @brief Returns the Y2 of the Box + * @return The Y2 of the Box + * @par Example + * @code + * Box B(25, 25, 100, 100); + * Debug::Info << B.GetX2() << ", " << B.GetY2(); + * @endcode + */ + std::int32_t GetY2() const; + /** + * @brief Returns True if the Box is within the bounds of Client Canvas + * @return True if the Box is within the bounds of Client Canvas + */ + bool OnScreen() const; + /** + * @brief Returns True if the Box's X, Y, Width, and Height are greater than greater than or equal to 0 + * @return True if the Box's X, Y, Width, and Height are greater than or equal to 0 + */ + bool IsValid() const; + bool operator==(const Box& B) const; + bool operator!=(const Box& B) const; + friend std::ostream& operator<<(std::ostream& OS, const Box& B); + operator bool() const; + ~Box(); +}; + +/** @} */ + +#endif // BOX_HPP_INCLUDED diff --git a/Include/Core/Types/Convex.hpp b/Include/Core/Types/Convex.hpp new file mode 100644 index 0000000..52e011c --- /dev/null +++ b/Include/Core/Types/Convex.hpp @@ -0,0 +1,67 @@ +#ifndef CONVEX_HPP_INCLUDED +#define CONVEX_HPP_INCLUDED + +#include +#include "Point.hpp" +#include "Box.hpp" + +/** @addtogroup Types +* @{ */ +class Convex +{ + public: + std::vector Vertices; + + /** + * @brief Default Constructor, constructs a Convex with null Vertices + * @par Description + * Default Constructor, constructs a Convex with null Vertices + */ + Convex(); + Convex(std::vector Vertices); + /** + * @brief Constructs a Convex, by copying another + * @param const Convex& C The Convex to "copy" + */ + Convex(const Convex& C); + + /** + * @brief Returns True if the Convex has more than two Vertices + * @return True if the Convex has more than two Vertices + */ + virtual bool Valid() const; + /** + * @brief Returns True if the Convex contains a Point + * @return True if the Convex contains a Point + */ + virtual bool Contains(const Point& P) const; + /** + * @brief Returns the middle Point of the Convex + * @return The middle Point of the Convex + */ + Point GetMiddle() const; + /** + * @brief Returns a Box of the Convex + * @return A Box of the Convex + */ + Box GetBox() const; + /** + * @brief Returns a random Point using Hybrid Distribution + * @return A random Point using Hybrid Distribution + * @see @ref HybridRandomDocs + * @see @ref MissChanceFollowupDocs + */ + Point GetHybridRandomPoint(double ProbabilityX, double ProbabilityY, double StandardDeviationX, double StandardDeviationY, bool CheckMissFollowupChance = true) const; + + Convex operator+(const Point& P) const; + Convex operator-(const Point& P) const; + Convex& operator+=(const Point& P); + Convex& operator-=(const Point& P); + friend std::ostream& operator<<(std::ostream& OS, const Convex& C); + operator bool() const; + virtual ~Convex(); +}; + +/** @} */ + +#endif // CONVEX_HPP_INCLUDED diff --git a/Include/Core/Types/Countdown.hpp b/Include/Core/Types/Countdown.hpp new file mode 100644 index 0000000..c458609 --- /dev/null +++ b/Include/Core/Types/Countdown.hpp @@ -0,0 +1,31 @@ +#ifndef COUNTDOWN_HPP_INCLUDED +#define COUNTDOWN_HPP_INCLUDED + +#include +#include + +/** @addtogroup Types +* @{ */ +class Countdown +{ + public: + Countdown(); + Countdown(std::uint64_t Time); + void Reset(); + void SetTime(std::uint64_t Time); + std::uint64_t GetTimeRemaining() const; + std::uint64_t GetStartTime() const; + bool IsFinished() const; + + friend std::ostream& operator<<(std::ostream& OS, const Countdown& C); + operator bool() const; + + ~Countdown(); + private: + std::uint64_t Time; + std::uint64_t StartTime; +}; + +/** @} */ + +#endif // COUNTDOWN_HPP_INCLUDED diff --git a/Include/Core/Types/Counter.hpp b/Include/Core/Types/Counter.hpp new file mode 100644 index 0000000..6ae960d --- /dev/null +++ b/Include/Core/Types/Counter.hpp @@ -0,0 +1,61 @@ +#ifndef COUNTER_HPP_INCLUDED +#define COUNTER_HPP_INCLUDED + +#include +#include + +/** @addtogroup Types +* @{ */ +/** +* @brief A Counter can be used, well as a Counter. You construct it with MaxIterations, the counter is marked as finished whenever the current Iterations reach, or exceed MaxIterations. +* You can use @ref Increment to increase, and @ref Reset to reset the current Iterations. +* You can also use @ref IsFinished to check the current state of the Counter. +*/ +class Counter +{ + public: + /** + * @brief Default Counter constructor with MaxIterations as 0 + */ + Counter(); + /** + * @brief Constructs a Counter with + * @param std::int32_t MaxIterations Maximum amount of Iterations before the counter is Finished + */ + Counter(std::int32_t MaxIterations); + /** + * @brief Resets the Counter's current Iterations to 0 + * @par Description + * Resets the Counter's current Iterations to 0 + */ + void Reset(); + /** + * @brief Increases the Counter's current Iterations by Amount, and returns true if the Counter isn't Finished + * @return True if the Counter isn't Finished, after it increments the Counter's current Iterations + */ + bool Increment(std::int32_t Amount = 1); + /** + * @brief Returns True if the Counter's current Iterations equals the MaxIterations Paramater passed in the Constructor + * @return True if the Counter's current Iterations equals the MaxIterations Paramater passed in the Constructor + */ + bool IsFinished() const; + /** + * @brief Returns the Counter's current Iterations + * @return Returns the Counter's current Iterations + */ + std::int32_t GetIterations() const; + /** + * @brief Returns the Counter's maximum Iterations + * @return Returns the Counter's maximum Iterations + */ + std::int32_t GetMaxIterations() const; + friend std::ostream& operator<<(std::ostream& OS, const Counter& C); + ~Counter(); + private: + std::int32_t MaxIterations; + std::int32_t Iterations; +}; + +/** @} */ + +#endif // COUNTER_HPP_INCLUDED diff --git a/Include/Core/Types/Logger.hpp b/Include/Core/Types/Logger.hpp new file mode 100644 index 0000000..0d50685 --- /dev/null +++ b/Include/Core/Types/Logger.hpp @@ -0,0 +1,55 @@ +#ifndef LOGGER_HPP_INCLUDED +#define LOGGER_HPP_INCLUDED + +#include +#include + +/** @addtogroup Types +* @{ */ +class Logger : public std::ostream, public std::streambuf +{ + public: + /** + * @brief Constructs a Logger, with a Prefix + * @param std::string Prefix The Prefix that's added before a message + * @param bool Enabled Enabled the printing of output sent to the logger, if false no output will be printed + * @par Detailed Description + * Loggers can be used to make it easier to identify whats what in the Log. + * We urge you to instead use our default Loggers, for sake of consistency, however we will not keep you from using the Logger class. + * You will need to add whitespace to the end of a Prefix, if you want to space out the Prefix and the Message. + * @par Example + * @code + * Logger LevelUp("[LEVEL] Gained a Level Up in the Skill"); + * LevelUp << "Mining" << std::endl; + * @endcode + */ + Logger(std::string Prefix, bool Enabled = true); + /** + * @brief Constructs a Logger, with a function pointer that returns a String + * @param std::string (*Func)() Prefix The Prefix that's added before a message + * @param bool Enabled Enabled the printing of output sent to the logger, if false no output will be printed + */ + Logger(std::string (*Func)(), bool Enabled = true); + /** + * @brief Sets the Enabled state of a logger + * @par Description + * Toggles the state of Enabled in a logger + */ + void SetEnabled(bool Toggle); + /** + * @brief Returns True if the Logger is Enabled + * @return True if the Logger is Enabled + */ + bool IsEnabled() const; + virtual std::streambuf::int_type overflow(std::streambuf::int_type Char = std::streambuf::traits_type::eof()); + ~Logger(); + private: + std::string Prefix = ""; + std::string (*FuncPtr)() = nullptr; + bool Enabled; + bool NewLine = true; +}; + +/** @} */ + +#endif // LOGGER_HPP_INCLUDED diff --git a/Include/Core/Types/Point.hpp b/Include/Core/Types/Point.hpp new file mode 100644 index 0000000..9823ec0 --- /dev/null +++ b/Include/Core/Types/Point.hpp @@ -0,0 +1,87 @@ +#ifndef POINT_HPP_INCLUDED +#define POINT_HPP_INCLUDED + +#include +#include "Box.hpp" + +class Box; + +/** @addtogroup Types +* @{ */ +class Point +{ + public: + /** + * @brief The X of the Point + * @par Description + * The X of the Point + */ + std::int32_t X; + /** + * @brief The Y of the Point + * @par Description + * The Y of the Point + */ + std::int32_t Y; + + /** + * @brief Default Constructor, constructs a Point with -1 as the X, Y, and Plane + * @par Description + * Default Constructor, constructs a Point with -1 as the X, Y, and Plane + */ + Point(); + /** + * @brief Constructs a Point based on an X and Y + * @param std::int32_t X The X of the Point + * @param std::int32_t Y The Y of the Point + */ + Point(std::int32_t X, std::int32_t Y); + /** + * @brief Constructs a Point, by copying another + * @param const Point& P The Point to "copy" + */ + Point(const Point& P); + + /** + * @brief Returns the distance from one Point to another + * @return The distance from one Point to another + */ + std::int32_t DistanceFrom(Point P) const; + /** + * @brief Returns True if the Point is inside the passed Box + * @return True if the Point is inside the passed Box + */ + bool InBox(Box B) const; + /** + * @brief Returns True if the Point is inside a Circle defined by a starting Point, and Radius + * @return True if the Point is inside a Circle defined by a starting Point, and Radius + */ + bool InCircle(Point P, std::int32_t Radius) const; + /** + * @brief Returns True if the Point is less than 0, not equal to + * @return True if the Point is less than 0, not equal to + */ + bool IsNegative() const; + /** + * @brief Returns True if the Point is greater than 0, not equal to + * @return True if the Point is greater than 0, not equal to + */ + bool IsPositive() const; + /** + * @brief Returns True if the Point is within the bounds of Client Canvas + * @return True if the Point is within the bounds of Client Canvas + */ + bool OnScreen() const; + bool operator==(const Point& P) const; + bool operator!=(const Point& P) const; + Point operator+(const Point& P) const; + Point operator-(const Point& P) const; + Point& operator+=(const Point& P); + Point& operator-=(const Point& P); + friend std::ostream& operator<<(std::ostream& OS, const Point& P); + ~Point(); +}; + +/** @} */ + +#endif // POINT_HPP_INCLUDED diff --git a/Include/Core/Types/Tile.hpp b/Include/Core/Types/Tile.hpp new file mode 100644 index 0000000..e2be106 --- /dev/null +++ b/Include/Core/Types/Tile.hpp @@ -0,0 +1,72 @@ +#ifndef TILE_HPP_INCLUDED +#define TILE_HPP_INCLUDED + +#include +#include + +/** @addtogroup Types +* @{ */ +class Tile +{ + public: + /** + * @brief The X of the Tile + * @par Description + * The X of the Tile + */ + std::int32_t X; + /** + * @brief The Y of the Tile + * @par Description + * The Y of the Tile + */ + std::int32_t Y; + /** + * @brief The Plane the Tile is on + * @par Description + * The Plane the Tile is on + */ + std::int32_t Plane; + + /** + * @brief Default Constructor, constructs a Tile with -1 as the X, Y, and Plane + * @par Description + * Default Constructor, constructs a Tile with -1 as the X, Y, and Plane + */ + Tile(); + /** + * @brief Constructs a Tile based on an X, Y, and a Plane + * @param std::int32_t X The X of the Tile + * @param std::int32_t Y The Y of the Tile + * @param std::int32_t Y The Plane the Tile is on + */ + Tile(std::int32_t X, std::int32_t Y, std::int32_t Plane); + /** + * @brief Constructs a Tile, by copying another + * @param const Tile& T The Tile to "copy" + */ + Tile(const Tile& T); + /** + * @brief Returns the distance from one Tile to another + * @return The distance from one Tile to another + */ + std::int32_t DistanceFrom(Tile T) const; + /** + * @brief Returns True if the Tile is less than 0, not equal to + * @return True if the Tile is less than 0, not equal to + */ + bool IsNegative() const; + /** + * @brief Returns True if the Tile is greater than 0, not equal to + * @return True if the Tile is greater than 0, not equal to + */ + bool IsPositive() const; + bool operator==(const Tile& T) const; + bool operator!=(const Tile& T) const; + friend std::ostream& operator<<(std::ostream& OS, const Tile& T); + ~Tile(); +}; + +/** @} */ + +#endif // TILE_HPP_INCLUDED diff --git a/Include/Core/Types/Timer.hpp b/Include/Core/Types/Timer.hpp new file mode 100644 index 0000000..eef4861 --- /dev/null +++ b/Include/Core/Types/Timer.hpp @@ -0,0 +1,88 @@ +#ifndef TIMER_HPP_INCLUDED +#define TIMER_HPP_INCLUDED + +#include +#include + +/** @addtogroup Types +* @{ */ +class Timer +{ + public: + + /** + * @brief Constructs a Timer, and optionally starts it + * @param bool Start + * @par Description + * Constructs a Timer, and starts it + */ + Timer(bool Start = true); + + /** + * @brief Restarts the Timer + * @par Detailed Description + * Sets the Timer start time to the current time + */ + void Restart(); + + /** + * @brief Increases the Timer's elapsed time by MS + * @return Returns the Time's elapsed time by MS + * @par Description + * Increases the Timer's elapsed time by MS + */ + std::int64_t FastForward(std::uint32_t Duration); + + /** + * @brief Decreases the Timer's elapsed time by MS + * @return Returns the Time's elapsed time by MS + * @par Description + * Decreases the Timer's elapsed time by MS + */ + std::int64_t Rewind(std::uint32_t Duration); + + /** + * @brief Pauses the Timer + * @return Returns the Time's elapsed time by MS + * @par Description + * Pauses the Timer + */ + std::int64_t Suspend(); + + /** + * @brief Resumes the Timer + * @return Returns the Timer's elapsed time by MS + * @par Description + * Resumes the Timer + */ + std::int64_t Resume(); + + /** + * @brief Returns when the Timer started, in MS + * @return When the Timer started, in MS + */ + std::uint64_t GetStartTime() const; + + /** + * @brief Returns the Timer's elapsed Time, in MS + * @return The Timer's elapsed Time, in MS + */ + std::int64_t GetTimeElapsed() const; + + /** + * @brief Returns True if the Timer is currently Paused + * @return True if the Timer is currently Paused + */ + bool Paused() const; + + friend std::ostream& operator<<(std::ostream& OS, const Timer& T); + ~Timer(); + private: + std::uint64_t StartTime; + std::uint64_t PauseTime; + std::int64_t Offset; +}; + +/** @} */ + +#endif // TIMER_HPP_INCLUDED diff --git a/Include/Game/Core.hpp b/Include/Game/Core.hpp new file mode 100644 index 0000000..3942adb --- /dev/null +++ b/Include/Game/Core.hpp @@ -0,0 +1,166 @@ +#ifndef CORE_HPP_INCLUDED +#define CORE_HPP_INCLUDED + +#include "../Core/Internal.hpp" + +#include "Tools/BreakHandler.hpp" +#include "Tools/Interact.hpp" +#include "Tools/Profile.hpp" +#include "Tools/Settings.hpp" +#include "Tools/Widgets.hpp" +#include "Tools/Worlds.hpp" + +#include "Interfaces/Bank.hpp" +#include "Interfaces/Chat.hpp" +#include "Interfaces/DepositBox.hpp" +#include "Interfaces/Login.hpp" +#include "Interfaces/Mainscreen.hpp" +#include "Interfaces/Menu.hpp" +#include "Interfaces/Minimap.hpp" +#include "Interfaces/GameTabs/Clan.hpp" +#include "Interfaces/GameTabs/Combat.hpp" +#include "Interfaces/GameTabs/Emotes.hpp" +#include "Interfaces/GameTabs/Equipment.hpp" +#include "Interfaces/GameTabs/Friends.hpp" +#include "Interfaces/GameTabs/Ignores.hpp" +#include "Interfaces/GameTabs/Inventory.hpp" +#include "Interfaces/GameTabs/Logout.hpp" +#include "Interfaces/GameTabs/Magic.hpp" +#include "Interfaces/GameTabs/Music.hpp" +#include "Interfaces/GameTabs/Options.hpp" +#include "Interfaces/GameTabs/Prayer.hpp" +#include "Interfaces/GameTabs/Quests.hpp" +#include "Interfaces/GameTabs/Stats.hpp" + +#include "Models/SceneObjects.hpp" +#include "Models/GroundItems.hpp" +#include "Models/NPCs.hpp" +#include "Models/Players.hpp" + +// +// DoxyGen +//======================================================= +// Pages +//======================================================= +/** +* @mainpage +* Mainpage Docs +* +* @page About About +* About +* +* @page GettingStarted Getting Started +* Getting Started +* +* @page RandomMethodDocs Random Distribution Methods +* @tableofcontents +* @section UniformRandomDocs Uniform Random Distribution +* Uniform Random Documentation +* @section BinomialRandomDocs Binomial Random Distribution +* Binomial Random Documentation +* @section NormalRandomDocs Normal Random Distribution +* Normal Random Documentation +* @section HybridRandomDocs Hybrid Random Distribution +* Hybrid Random Documentation +* @section MissChanceFollowupDocs MissChanceFollowup +* MissChanceFollowupDocs +* +* @page DetailedFuncDocs Detailed Function Documentation +* @tableofcontents +* @section ItemContainers Item Containers +* @subsection ICUsing Using Item Containers +* @subsection ICLibFunctions Lib functions that use an Internal Item Container +* Some classes have functions that Interface a class-related Item Container, an example +* being Bank::GetItemIDs(), which return an array of all ItemIDs found in the Bank Item Container. These interfaced-functions +* can be found in @ref Bank, @ref Inventory, and @ref Equipment +* +* Element positions in the returned arrays (ItemIDs, ItemNames, ItemAmounts) almost always correspond to their positions in the +* visual Game Interface. If there isn't an Item in a Container position, it's -1 for ItemIDs and Amounts, and simply a blank +* String ("") for ItemNames. Remember, arrays in C++ start at 0. +* +* Classes that Interface an Item Container will have a GetIndexOf() function, @ref Inventory::GetIndexOf() and +* @ref Bank::GetIndexOf() are examples. These two functions will return the Index of the passed Item (By ID, or Name) +* relative to the Item Container array, for example if Coins are in Inventory slot 5, using @ref Inventory::GetIndexOf("Coins") +* should return 4. +* +* Here is a more extensive example, where we grab the Item amount of Coins in our Inventory; +* +* @code +* std::int32_t CoinsIndex = Inventory::GetIndexOf("Coins"); +* std::vector Amounts = Inventory::GetItemAmounts(); +* if ((CoinsIndex != -1) && (CoindsIndex <= Amounts.size())) //A range check will never hurt +* { +* std::cout << "Coins has an Index of " << CoinsIndex << " relative to the Inventory Item Container Array" << std::endl; +* std::cout << "There are " << Amounts[Index] << " coins in our Inventory" << std::endl; +* } +* @endcode +* +* Here is a list of all class functions that Interface an internally-used Item Container. +* - Item IDs +* - @ref Bank::GetItemIDs() +* - @ref Inventory::GetItemIDs() +* - @ref Equipment::GetItemIDs() +* . +* - Item Names +* - @ref Bank::GetItemNames() +* - @ref Inventory::GetItemNames() +* - @ref Equipment::GetItemNames() +* . +* - Item Amounts +* - @ref Bank::GetItemAmounts() +* - @ref Inventory::GetItemAmounts() +* - @ref Equipment::GetItemAmounts() +* . +* @subsection Examples +* +*/ +//======================================================= +// Groups +//======================================================= +/** +* @defgroup Core Core +* +* @defgroup Types Types +* @brief @b Types Module +* @ingroup Core +* +* @defgroup Math Math +* @brief @b Math Module +* @ingroup Core +* +* @defgroup Time Time +* @brief @b Time Module +* @ingroup Core +* +* @defgroup Game Game +* +* @defgroup Interfaces Interfaces +* @brief @b Interfaces Module +* @ingroup Game +* +* @defgroup Models Models +* @brief @b Models Module +* @ingroup Game +* +* @defgroup Tools Tools +* @brief @b Tools Module +* @ingroup Game +* +*/ +//======================================================= +// SubGroups +//======================================================= +/** +* @defgroup GameTabs GameTabs +* @brief @b GameTabs Module +* @ingroup Interfaces +* +**/ +//======================================================= +// Examples +//======================================================= +/** +* @example ScriptExample.cpp +**/ + +#endif // CORE_HPP_INCLUDED diff --git a/Include/Game/Interfaces/Bank.hpp b/Include/Game/Interfaces/Bank.hpp new file mode 100644 index 0000000..0e795e0 --- /dev/null +++ b/Include/Game/Interfaces/Bank.hpp @@ -0,0 +1,263 @@ +#ifndef BANK_HPP_INCLUDED +#define BANK_HPP_INCLUDED + +#include "../../Core/Types/Convex.hpp" +#include +#include +#include + +/** @addtogroup Interfaces +* @{ */ +/** +* @note All methods require the Bank to be currently Open to successfully return a proper result +*/ +class Bank +{ + public: + /** + * @brief Returns True if the Bank is currently Open + * @return True if the Bank is currently Open + * @par Example + * @code + * if (Bank::IsOpen) + * return Bank::Close(); + * @endcode + */ + static bool IsOpen(); + + /** + * @brief Attempts to Close the Bank if it's Currently Open, returns True if the Bank is currently Closed + * @return Returns True if the is successfully Closed, or the Bank is already Closed + * @par Example + * @code + * if (Bank::IsOpen) + * return Bank::Close(); + * @endcode + */ + static bool Close(); + + /** + * @brief Returns an array of all Item IDs in the Bank Inventory Container + * @return An array of all Item IDs in the Bank Inventory Container + * @par Example + * @code + * std::int32_t Index = Bank::GetIndexOf(995); + * std::vector BankContainerItemIDs = Bank::GetItemIDs(); + * if ((Index != -1) && (Index <= BankContainerItemIDs.size())) + * std::cout << "Item with ID " << BankContainerItemIDs[Index] << " is in the " << Index << "th position in Bank" << std::endl; + * @endcode + * @see @ref ICLibFunctions + */ + static std::vector GetItemIDs(); + /** + * @brief Returns an array of all Item Names in the Bank Inventory Container + * @return An array of all Item Names in the Bank Inventory Container + * @par Example + * @code + * std::int32_t Index = Bank::GetIndexOf("Coins"); + * std::vector BankContainerItemNames = Bank::GetItemNames(); + * if ((Index != -1) && (Index <= BankContainerItemNames.size())) + * std::cout << "Item with Name " << BankContainerItemNames[Index] << " is in the " << Index << "th position in Bank" << std::endl; + * @endcode + * @see @ref ICLibFunctions + */ + static std::vector GetItemNames(); + /** + * @brief Returns an array of all Item Names in the Bank Inventory Container + * @return An array of all Item Names in the Bank Inventory Container + * @par Example + * @code + * std::int32_t Index = Bank::GetIndexOf("Coins"); + * std::vector BankContainerItemNames = Bank::GetItemNames(); + * if ((Index != -1) && (Index <= BankContainerItemNames.size())) + * std::cout << "Item with Name " << BankContainerItemNames[Index] << " is in the " << Index << "th position in Bank" << std::endl; + * @endcode + * @see @ref ICLibFunctions + */ + static std::vector GetItemAmounts(); + + /** + * @brief Returns the total Item Amount of the specified Item matching the passed ID in the Bank + * @return The total Item Amount of the specified Item matching the passed ID in the Bank + * @par Example + * @code + * if (Bank::GetItemAmount(995) <= 100000) + * return false; + * @endcode + */ + static std::int32_t GetItemAmount(std::int32_t ID); + + /** + * @brief Returns the total Item Amount of the specified Item matching the passed Name in the Bank + * @return The total Item Amount of the specified Item matching the passed Name in the Bank + * @par Example + * @code + * if (Bank::GetItemAmount(995) <= 100000) + * return false; + * @endcode + */ + static std::int32_t GetItemAmount(const std::string& Name); + + /** + * @brief Returns the Index of the first occurrence of the specified Item matching the passed ID in the GetItemIDs() array + * @return The Index of the first occurrence of the specified Item matching the passed ID in the GetItemIDs() array + * @note Returns -1 if no occurrence of the specified Item matching the passed ID is found in the GetItemIDs() array + */ + static std::int32_t GetIndexOf(std::int32_t ID); + + /** + * @brief Returns the Index of the first occurrence of the specified Item matching the passed Name in the GetItemIDs() array + * @return The Index of the first occurrence of the specified Item matching the passed Name in the GetItemIDs() array + * @note Returns -1 if no occurrence of the specified Item matching the passed Name is found in the GetItemIDs() array + */ + static std::int32_t GetIndexOf(const std::string& Name); + + static Convex GetConvexOf(std::int32_t ID); + static Convex GetConvexOf(const std::string& Name); + + + /** + * @brief Returns True if the Bank contains the specified Item matching the passed ID + * @return True if the Bank contains the specified Item matching the passed ID + * @par Example + * @code + * if (Bank::Contains(995)) + * return Bank::WithdrawAllOf(995); + * @endcode + */ + static bool Contains(std::int32_t ID); + + /** + * @brief Returns True if the Bank contains the specified Item matching the passed Name + * @return True if the Bank contains the specified Item matching the passed Name + * @par Example + * @code + * if (Bank::Contains("Coins")) + * return Bank::WithdrawAllOf("Coins"); + * @endcode + */ + static bool Contains(const std::string& Name); + + /** + * @brief Returns True if the Bank contains any of the specified Item matching the passed IDs + * @return True if the Bank contains any of the specified Item matching the passed IDs + * @par Example + * @code + * if (!Bank::Contains(std::vector { 995, 207, 584 })) + * return false; + * @endcode + */ + static bool Contains(const std::vector& IDs); + + /** + * @brief Returns True if the Bank contains any of the specified Item matching the passed Names + * @return True if the Bank contains any of the specified Item matching the passed Names + * @par Example + * @code + * if (!Bank::Contains(std::vector { "Coins", "Oak Logs", "Air Runes" })) + * return false; + * @endcode + */ + static bool Contains(const std::vector& Names); + + /** + * @brief Returns the currently active Bank Tab + * @return The currently active Bank Tab + * @note Returns -1 if no currently active Bank Tab is found + * @par Example + * @code + * if (Bank::GetCurrentTab() == 0) + * Debug("The All tab is open"); + * @endcode + */ + static std::int32_t GetCurrentTab(); + + /** + * @brief Returns the Tab Index of the specified Item matching the passed ID + * @return The Tab Index of the specified Item matching the passed ID + * @par Example + * @code + * std::int32_t TabWithCoins = Bank::GetTabOf(995); + * if (Bank::GetCurrentTab() != TabWithCoins) + * return Bank::OpenTab(TabWithCoins); + * @endcode + */ + static std::int32_t GetTabOf(std::int32_t ID); + + /** + * @brief Returns the Tab Index of the specified Item Name + * @return The Tab Index of the specified Item Name + * @par Example + * @code + * std::int32_t TabWithCoins = Bank::GetTabOf("Coins"); + * if (Bank::GetCurrentTab() != TabWithCoins) + * return Bank::OpenTab(TabWithCoins); + * @endcode + */ + static std::int32_t GetTabOf(const std::string& Name); + + /** + * @brief Attempts to Open the specified Bank Tab, 0 being all items + * @return True if it successfully opens the specified Bank Tab + * @par Example + * @code + * if ((Bank::IsOpen()) && (Bank::GetCurrentTab() != 0)) + * return Bank::OpenTab(0); + * @endcode + */ + static bool OpenTab(std::int32_t Tab); + + /** + * @brief Attempts to Scroll to the specified Item matching the passed ID + * @return True if it successfully scrolls to the specified Item matching the passed ID + * @note Returns True if the Item is already in view + * @par Example + * @code + * if (Bank::Contains(995)) + * return Bank::ScrolTo(995); + * @endcode + */ + static bool ScrollTo(std::int32_t ID); + + /** + * @brief Attempts to Scroll to the specified Item matching the passed Name + * @return True if it successfully scrolls to the specified Item matching the passed Name + * @note Returns True if the Item is already in view + * @par Example + * @code + * if (Bank::Contains("Coins")) + * return Bank::ScrolTo("Coins"); + * @endcode + */ + static bool ScrollTo(const std::string& Name); + /** + * @brief Attempts to Scroll to the specified Item matching the passed Name, and optionally Opens the Tab + * @return True if it successfully scrolls to the specified Item matching the passed Name + * @note Returns True if the Item is already in view + * @par Example + * @code + * if (Bank::Contains("Coins")) + * return Bank::ScrolTo("Coins"); + * @endcode + */ + static bool ScrollTo(std::int32_t ID, bool OpenTab); + static bool ScrollTo(const std::string& Name, bool OpenTab); + + static bool WithdrawAllOf(std::int32_t ID); + static bool WithdrawAllOf(const std::string& Name); + static bool WithdrawXOf(std::int32_t ID, std::int32_t Amount); + static bool WithdrawXOf(const std::string& Name, std::int32_t Amount); + static bool WithdrawAllButOneOf(std::int32_t ID); + static bool WithdrawAllButOneOf(const std::string& Name); + + static bool DepositAllOf(std::int32_t ID); + static bool DepositAllOf(const std::string& Name); + static bool DepositXOf(std::int32_t ID, std::int32_t Amount); + static bool DepositXOf(const std::string& Name, std::int32_t Amount); + static bool DepositAll(); + static bool DepositEquipment(); +}; + +/** @} */ + +#endif // BANK_HPP_INCLUDED diff --git a/Include/Game/Interfaces/Chat.hpp b/Include/Game/Interfaces/Chat.hpp new file mode 100644 index 0000000..95f3193 --- /dev/null +++ b/Include/Game/Interfaces/Chat.hpp @@ -0,0 +1,66 @@ +#ifndef CHAT_HPP_INCLUDED +#define CHAT_HPP_INCLUDED + +#include "../../Core/Classes/MessageNode.hpp" +#include +#include +#include + +/** @addtogroup Interfaces +* @{ */ +class Chat +{ + + public: + + typedef enum DIALOGUE_STATE + { + IDLE, + CLICK_CONTINUE, + SELECT_OPTION, + ENTER_AMOUNT + } DIALOGUE_STATE; + + typedef enum CHAT_TYPE + { + SYSTEM = 200, + PUBLIC_CHAT = 201, + PRIVATE_CHAT = 202, + CLAN_CHAT = 203, + + _SYSTEM = 0, + _PUBLIC_CHAT = 2, + _PRIVATE_CHAT_INCOMING = 3, + _PRIVATE_CHAT_SYSTEM = 5, + _PRIVATE_CHAT_OUTGOING = 6, + _CLAN_CHAT = 9, + _CLAN_CHAT_SYSTEM = 11, + _BROADCAST_SYSTEM = 14, + _EXAMINE_ITEM = 27, + _EXAMINE_NPC = 28, + _EXAMINE_GAMEOBJECT = 29, + _PRIVATE_CHAT_SYSTEM2 = 30, + _AUTO_CHAT = 90, + _TRADE_INCOMING = 101, + _TRADE = 102 + } CHAT_TYPE; + + + static std::vector GetMessages(CHAT_TYPE Type); + static std::vector GetMessages(CHAT_TYPE Type, bool Sort); + static MessageNode GetLastMessage(CHAT_TYPE Type); + + static DIALOGUE_STATE GetDialogueState(); + static std::vector GetDialogueOptions(); + static std::string GetDialogueTitle(); + static std::string GetDialogueMessage(); + static bool ClickContinue(); + static bool EnterAmount(std::int32_t Amount); + static bool SelectDialogueOption(const std::string& Option); + static bool SelectDialogueOption(const std::vector& Options); + static bool SelectDialogueOption(std::uint32_t OptionIndex); +}; + +/** @} */ + +#endif // CHAT_HPP_INCLUDED diff --git a/Include/Game/Interfaces/DepositBox.hpp b/Include/Game/Interfaces/DepositBox.hpp new file mode 100644 index 0000000..6fd48b1 --- /dev/null +++ b/Include/Game/Interfaces/DepositBox.hpp @@ -0,0 +1,19 @@ +#ifndef DEPOSITBOX_HPP +#define DEPOSITBOX_HPP + +/** @addtogroup Interfaces +* @{ */ +class DepositBox +{ + public: + static bool IsOpen(); + static bool Close(); + + static bool DepositAll(); + static bool DepositEquipment(); + static bool DepositLoot(); +}; + +/** @} */ + +#endif // DEPOSITBOX_HPP diff --git a/Include/Game/Interfaces/GameTabs/Clan.hpp b/Include/Game/Interfaces/GameTabs/Clan.hpp new file mode 100644 index 0000000..3aaac56 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Clan.hpp @@ -0,0 +1,21 @@ +#ifndef CLAN_HPP_INCLUDED +#define CLAN_HPP_INCLUDED + +#include "../../../Core/Classes/ClanMember.hpp" +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Clan +{ + public: + static bool IsOpen(); + static bool Open(); + static std::vector GetAll(); + static std::vector GetAll(const std::function& Filter); +}; + +/** @} */ + +#endif // CLAN_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Combat.hpp b/Include/Game/Interfaces/GameTabs/Combat.hpp new file mode 100644 index 0000000..1684322 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Combat.hpp @@ -0,0 +1,34 @@ +#ifndef COMBAT_HPP_INCLUDED +#define COMBAT_HPP_INCLUDED + +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Combat +{ + public: + static bool IsOpen(); + static bool Open(); + + static std::int32_t GetHealth(); + static std::int32_t GetMaxHealth(); + + static std::int32_t GetSpecialAttack(); + static bool IsSpecialAttacking(); + static bool ToggleSpecialAttack(bool Toggle); + + static bool IsPoisoned(); + static bool HasPoisonImmunity(); + + static bool GetAutoRetaliate(); + static bool ToggleAutoRetaliate(bool Toggle); + + static std::string GetStyle(); + static bool SetStyle(const std::string& Style); +}; + +/** @} */ + +#endif // COMBAT_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Emotes.hpp b/Include/Game/Interfaces/GameTabs/Emotes.hpp new file mode 100644 index 0000000..d222edf --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Emotes.hpp @@ -0,0 +1,15 @@ +#ifndef EMOTES_HPP_INCLUDED +#define EMOTES_HPP_INCLUDED + +/** @addtogroup GameTabs +* @{ */ +class Emotes +{ + public: + static bool IsOpen(); + static bool Open(); +}; + +/** @} */ + +#endif // EMOTES_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Equipment.hpp b/Include/Game/Interfaces/GameTabs/Equipment.hpp new file mode 100644 index 0000000..c1b21cc --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Equipment.hpp @@ -0,0 +1,63 @@ +#ifndef EQUIPMENT_HPP_INCLUDED +#define EQUIPMENT_HPP_INCLUDED + +#include +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Equipment +{ + public: + typedef enum SLOTS + { + HEAD, + CAPE, + NECK, + WEAPON, + BODY, + SHIELD, + LEGS, + HANDS, + FEET, + RING, + AMMO + } SLOTS; + + static bool IsOpen(); + static bool Open(); + static bool IsEmpty(); + + static std::vector GetItemIDs(); + static std::vector GetItemNames(); + static std::vector GetItemAmounts(); + + static std::int32_t GetItemID(SLOTS Slot); + static std::string GetItemName(SLOTS Slot); + + static std::int32_t GetItemAmount(SLOTS Slot); + static std::int32_t GetItemAmount(std::int32_t ID); + static std::int32_t GetItemAmount(const std::string& Name); + + static SLOTS GetSlotOf(std::int32_t ID); + static SLOTS GetSlotOf(const std::string& Name); + + static bool Contains(std::int32_t ID); + static bool Contains(const std::string& Name); + static bool Contains(const std::vector& IDs); + static bool Contains(const std::vector& Names); + + static bool ContainsOnly(std::int32_t ID); + static bool ContainsOnly(const std::string& Name); + static bool ContainsOnly(const std::vector& IDs); + static bool ContainsOnly(const std::vector& Names); + + static bool UnequipItem(SLOTS Slot); + static bool UnequipItem(std::int32_t ID); + static bool UnequipItem(const std::string& Name); +}; + +/** @} */ + +#endif // EQUIPMENT_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Friends.hpp b/Include/Game/Interfaces/GameTabs/Friends.hpp new file mode 100644 index 0000000..1385621 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Friends.hpp @@ -0,0 +1,21 @@ +#ifndef FRIENDS_HPP_INCLUDED +#define FRIENDS_HPP_INCLUDED + +#include "../../../Core/Classes/Friend.hpp" +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Friends +{ + public: + static bool IsOpen(); + static bool Open(); + static std::vector GetAll(); + static std::vector GetAll(const std::function& Filter); +}; + +/** @} */ + +#endif // FRIENDS_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Ignores.hpp b/Include/Game/Interfaces/GameTabs/Ignores.hpp new file mode 100644 index 0000000..22ef5ca --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Ignores.hpp @@ -0,0 +1,21 @@ +#ifndef IGNORES_HPP_INCLUDED +#define IGNORES_HPP_INCLUDED + +#include "../../../Core/Classes/Ignore.hpp" +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Ignores +{ + public: + static bool IsOpen(); + static bool Open(); + static std::vector GetAll(); + static std::vector GetAll(const std::function& Filter); +}; + +/** @} */ + +#endif // IGNORES_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Inventory.hpp b/Include/Game/Interfaces/GameTabs/Inventory.hpp new file mode 100644 index 0000000..6a17eb9 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Inventory.hpp @@ -0,0 +1,98 @@ +#ifndef INVENTORY_HPP_INCLUDED +#define INVENTORY_HPP_INCLUDED + +#include "../../../Core/Types/Box.hpp" +#include "../../../Core/Types/Convex.hpp" +#include +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Inventory +{ + public: + + static bool IsOpen(); + static bool Open(); + + static std::vector GetItemIDs(); + static std::vector GetItemNames(); + static std::vector GetItemAmounts(); + + static std::int32_t GetItemAmount(std::int32_t ID); + static std::int32_t GetItemAmount(const std::string& Name); + + static bool IsEmpty(); + static bool IsFull(); + + static bool IsItemSelected(); + static bool IsItemSelected(std::int32_t ID); + static bool IsItemSelected(const std::string& Name); + + static std::string GetItemSelectedName(); + + static std::int32_t Count(std::int32_t ID); + static std::int32_t Count(const std::string& Name); + static std::int32_t Count(const std::vector& IDs); + static std::int32_t Count(const std::vector& Names); + + static std::int32_t CountOccupied(); + static std::int32_t CountEmpty(); + + 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 + + static std::vector GetIndicesOf(std::int32_t ID); + static std::vector GetIndicesOf(const std::string& Name); + + static Convex GetConvexOf(std::int32_t SlotIndex); + + static Box GetBoxOf(std::int32_t ID); + static Box GetBoxOf(const std::string& Name); + static Box GetBoxOf(const std::vector& IDs); // Returns first found ID box + static Box GetBoxOf(const std::vector& Names); // Returns first found Name box + + static std::vector GetSlotBoxes(); + static std::vector GetBoxesOf(std::int32_t ID); + static std::vector GetBoxesOf(const std::string& Name); + + static bool Contains(std::int32_t ID); + static bool Contains(const std::string& Name); + static bool Contains(const std::vector& IDs); + static bool Contains(const std::vector& Names); + + static bool ContainsAny(const std::vector& IDs); + static bool ContainsAny(const std::vector& Names); + + static bool ContainsOnly(std::int32_t ID); + static bool ContainsOnly(const std::string& Name); + static bool ContainsOnly(const std::vector& IDs); + static bool ContainsOnly(const std::vector& Names); + + static bool InteractItemByIndex(std::int32_t Index); + static bool InteractItemByIndex(std::int32_t Index, const std::string& Action); + static bool InteractItemByIndex(std::int32_t Index, const std::vector& Actions); + + static bool InteractItem(std::int32_t ID, const std::string& Action = ""); + static bool InteractItem(const std::string& Name, const std::string& Action = ""); + static bool InteractItem(const std::vector& IDs, const std::vector& Actions); //Interacts with first found ID and Action + static bool InteractItem(const std::vector& Names, const std::vector& Actions); //Interacts with first found Name and Action + + static bool DropItemByIndex(std::int32_t Index, bool AllowShiftClick = true); + + static bool DropItem(std::int32_t ID, bool AllowShiftClick = true); + static bool DropItem(const std::string& Name, bool AllowShiftClick = true); + + static bool UseItem(std::int32_t ID); + static bool UseItem(const std::string& Name); + + static bool UseItemOn(std::int32_t PrimaryID, std::int32_t SecondaryID); + static bool UseItemOn(const std::string& PrimaryName, const std::string& SecondaryName); +}; + +/** @} */ + +#endif // INVENTORY_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Logout.hpp b/Include/Game/Interfaces/GameTabs/Logout.hpp new file mode 100644 index 0000000..3b4d7dd --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Logout.hpp @@ -0,0 +1,38 @@ +#ifndef LOGOUT_HPP_INCLUDED +#define LOGOUT_HPP_INCLUDED + +#include "../../../Core/Types/Box.hpp" +#include "../../../Core/Classes/World.hpp" +#include "../../../Core/Classes/Widget.hpp" +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Logout +{ + public: + static bool IsOpen(); + static bool Open(); + static bool LogoutPlayer(); + + static bool IsWorldSwitcherOpen(); + + static bool OpenWorldSwitcher(); + static bool OpenWorldSwitcher(bool OpenInventory); + + static bool WorldSwitcherScrollTo(World World); + static bool WorldSwitcherScrollTo(std::int32_t WorldID); + + static bool SwitchWorld(World World); + static bool SwitchWorld(std::int32_t WorldID); + + static std::vector GetFavoriteWorlds(); + + static Widget GetWorldWidget(World World); + static Widget GetWorldWidget(std::int32_t WorldID); +}; + +/** @} */ + +#endif // LOGOUT_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Magic.hpp b/Include/Game/Interfaces/GameTabs/Magic.hpp new file mode 100644 index 0000000..c6ccab8 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Magic.hpp @@ -0,0 +1,172 @@ +#ifndef MAGIC_HPP_INCLUDED +#define MAGIC_HPP_INCLUDED + +#include +#include + +/** @addtogroup GameTabs +* @{ */ +class Magic +{ + public: + + typedef enum SPELLS + { + 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_TELEOTHER_FALADOR, + NORMAL_TELE_BLOCK, + NORMAL_TELEPORT_TO_BOUNTY_TARGET, + NORMAL_LVL6_ENCHANT, + NORMAL_TELEOTHER_CAMELOT, + NORMAL_LVL7_ENCHANT, + + 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 + } SPELLS; + + + static bool IsOpen(); + static bool Open(); + + static bool HasLevel(SPELLS Spell); + + static bool IsSpellSelected(); + static bool IsSpellSelected(SPELLS Spell); + static bool IsSpellSelected(const std::string& Name); + static std::string GetSelectedSpellName(); + + static bool SelectSpell(SPELLS Spell); +}; + +/** @} */ + +#endif // MAGIC_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Music.hpp b/Include/Game/Interfaces/GameTabs/Music.hpp new file mode 100644 index 0000000..3caaf63 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Music.hpp @@ -0,0 +1,15 @@ +#ifndef MUSIC_HPP_INCLUDED +#define MUSIC_HPP_INCLUDED + +/** @addtogroup GameTabs +* @{ */ +class Music +{ + public: + static bool IsOpen(); + static bool Open(); +}; + +/** @} */ + +#endif // MUSIC_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Options.hpp b/Include/Game/Interfaces/GameTabs/Options.hpp new file mode 100644 index 0000000..954382d --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Options.hpp @@ -0,0 +1,21 @@ +#ifndef OPTIONS_HPP_INCLUDED +#define OPTIONS_HPP_INCLUDED + +/** @addtogroup GameTabs +* @{ */ +class Options +{ + public: + static bool IsOpen(); + static bool Open(); + + static bool GetAcceptAid(); + static bool ToggleAcceptAid(bool Toggle); + + static bool GetRunMode(); + static bool ToggleRunMode(bool Toggle); +}; + +/** @} */ + +#endif // OPTIONS_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Prayer.hpp b/Include/Game/Interfaces/GameTabs/Prayer.hpp new file mode 100644 index 0000000..a35e01e --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Prayer.hpp @@ -0,0 +1,58 @@ +#ifndef PRAYER_HPP_INCLUDED +#define PRAYER_HPP_INCLUDED + +#include + +/** @addtogroup GameTabs +* @{ */ +class 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 WaitPrayer(std::uint32_t Duration, std::uint32_t Step, PRAYERS Prayer, bool Active); + static bool Activate(PRAYERS Prayer); + static bool Deactivate(PRAYERS Prayer); + +}; + +/** @} */ + +#endif // PRAYER_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Quests.hpp b/Include/Game/Interfaces/GameTabs/Quests.hpp new file mode 100644 index 0000000..94d1263 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Quests.hpp @@ -0,0 +1,15 @@ +#ifndef QUESTS_HPP_INCLUDED +#define QUESTS_HPP_INCLUDED + +/** @addtogroup GameTabs +* @{ */ +class Quests +{ + public: + static bool IsOpen(); + static bool Open(); +}; + +/** @} */ + +#endif // QUESTS_HPP_INCLUDED diff --git a/Include/Game/Interfaces/GameTabs/Stats.hpp b/Include/Game/Interfaces/GameTabs/Stats.hpp new file mode 100644 index 0000000..a602a97 --- /dev/null +++ b/Include/Game/Interfaces/GameTabs/Stats.hpp @@ -0,0 +1,52 @@ +#ifndef STATS_HPP_INCLUDED +#define STATS_HPP_INCLUDED + +#include + +/** @addtogroup GameTabs +* @{ */ +class 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 + } 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::int32_t GetExperience(SKILLS Skill); + static std::int32_t GetExperienceTo(SKILLS Skill, std::int32_t Level); + +}; + +/** @} */ + +#endif // STATS_HPP_INCLUDED diff --git a/Include/Game/Interfaces/Login.hpp b/Include/Game/Interfaces/Login.hpp new file mode 100644 index 0000000..86749c9 --- /dev/null +++ b/Include/Game/Interfaces/Login.hpp @@ -0,0 +1,85 @@ +#ifndef LOGIN_HPP_INCLUDED +#define LOGIN_HPP_INCLUDED + +#include "../../Core/Types/Box.hpp" +#include "../../Core/Classes/World.hpp" + +#include +#include +#include + +/** @addtogroup Interfaces +* @{ */ +class Login +{ + public: + + typedef enum LOGIN_STATE + { + WELCOME_SCREEN, + ENTER_CREDENTIALS, + INVALID_CREDENTIALS, + FORGOTTEN_PASSWORD, + RUNESCAPE_UPDATED, + TEMP_BANNED, + PERM_BANNED, + ACCOUNT_LOCKED, + WORLD_SELECT, + CONNECTING, + LOADING, + LOBBY_SCREEN, + LOGGED_IN + } LOGIN_STATE; + + static LOGIN_STATE GetState(); + + static bool IsLoggedIn(); + static bool IsWorldSelectOpen(); + static bool CloseWorldSelect(); + + static std::int32_t LoginPlayer(); + static bool EnterCredentials(); + + static bool SelectWorld(); + static bool SelectWorld(World World); + static bool SelectWorld(std::int32_t WorldID); + static bool OpenWorldSelect(); + static bool OpenWorldSelect(bool Close); + + /** + * @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; + */ + static std::int32_t GetCaretState(); + + /** + * @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 vector of World Boxes found in the World Select screen + */ + static std::vector GetWorldBoxes(); + +}; + +/** @} */ + +#endif // LOGIN_HPP_INCLUDED diff --git a/Include/Game/Interfaces/Mainscreen.hpp b/Include/Game/Interfaces/Mainscreen.hpp new file mode 100644 index 0000000..42991a8 --- /dev/null +++ b/Include/Game/Interfaces/Mainscreen.hpp @@ -0,0 +1,53 @@ +#ifndef MAINSCREEN_HPP_INCLUDED +#define MAINSCREEN_HPP_INCLUDED + +#include "../../Core/Types/Box.hpp" +#include "../../Core/Classes/Character.hpp" +#include +#include +#include + +/** @addtogroup Interfaces +* @{ */ +class Mainscreen +{ + public: + typedef enum SCREEN_STATE + { + LOGIN_SCREEN, + LOBBY_SCREEN, + CONNECTING, + LOADING, + HOPPING, + PLAYING + } SCREEN_STATE; + + static Mainscreen::SCREEN_STATE GetState(); + + static bool IsLoggedIn(); + static bool IsPlaying(); + + 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 Character GetInteractingByIndex(std::uint32_t Index); + static Character GetInteracting(); //Returns the Character interacting with the Local Player + static Character GetInteractingWith(const Character& C); //Returns the Character interactinng with the Character + + static bool IsInteracting(const Character& A, const Character& B); // True if A is interacting with B + + static std::int32_t GetCameraX(); + static std::int32_t GetCameraY(); + static std::int32_t GetCameraZ(); + static std::int32_t GetCameraPitch(); + static std::int32_t GetCameraYaw(); +}; + +/** @} */ + +#endif // MAINSCREEN_HPP_INCLUDED diff --git a/Include/Game/Interfaces/Menu.hpp b/Include/Game/Interfaces/Menu.hpp new file mode 100644 index 0000000..929dbc9 --- /dev/null +++ b/Include/Game/Interfaces/Menu.hpp @@ -0,0 +1,51 @@ +#ifndef MENU_HPP_INCLUDED +#define MENU_HPP_INCLUDED + +#include "../../Core/Types/Box.hpp" +#include +#include +#include + +/** @addtogroup Interfaces +* @{ */ +class Menu +{ + public: + + static bool IsOpen(); + static bool Open(); + + static std::int32_t GetCount(); + static std::vector GetActions(); + static std::vector GetTargetsRaw(); + static std::vector GetTargets(); + static std::vector GetOptions(); + + static std::int32_t IndexOf(const std::string& Action); + static std::int32_t IndexOf(const std::string& Action, const std::string& Target); + static std::int32_t IndexOf(const std::vector& PossibleActions); + static std::int32_t IndexOf(const std::vector& PossibleActions, const std::vector& PossibleTargets); + + static bool Contains(const std::string& Action); + static bool Contains(const std::string& Action, const std::string& Target); + static bool Contains(const std::vector& PossibleActions); + static bool Contains(const std::vector& PossibleActions, const std::vector& Targets); + + static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::string& Action); + static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::string& Action, const std::string& Target); + static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::vector& PossibleActions); // Waits until the Menu contains at least one of these actions + static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::vector& PossibleActions, const std::vector& PossibleTargets); // Waits until the Menu contains at least one of these actions and Targets + + static bool Select(std::uint32_t Index); + static bool Select(const std::string& Action); + static bool Select(const std::string& Action, const std::string& Target); + static bool Select(const std::vector& PossibleActions); + static bool Select(const std::vector& PossibleActions, const std::vector& PossibleTargets); + + static std::vector GetBoxes(); + static Box GetBox(); +}; + +/** @} */ + +#endif // MENU_HPP_INCLUDED diff --git a/Include/Game/Interfaces/Minimap.hpp b/Include/Game/Interfaces/Minimap.hpp new file mode 100644 index 0000000..7d82482 --- /dev/null +++ b/Include/Game/Interfaces/Minimap.hpp @@ -0,0 +1,35 @@ +#ifndef MINIMAP_HPP_INCLUDED +#define MINIMAP_HPP_INCLUDED + +#include "../../Core/Types/Tile.hpp" +#include "../../Core/Types/Point.hpp" +#include "../../Core/Classes/Region.hpp" +#include + +/** @addtogroup Interfaces +* @{ */ +class Minimap +{ + public: + static Point GetMiddle(); + static Tile GetPosition(); + static Tile GetDestination(); + + static std::int32_t GetPlane(); + static std::int32_t GetPositionX(); + static std::int32_t GetPositionY(); + + + static std::int32_t GetDestinationX(); + static std::int32_t GetDestinationY(); + + static bool CloseTo(Tile T, std::int32_t Distance); + static bool TileOnMM(Tile T); + + static double GetCompassAngle(); + static void RotateCompass(std::int32_t Degrees); +}; + +/** @} */ + +#endif // MINIMAP_HPP_INCLUDED diff --git a/Include/Game/Models/GroundItems.hpp b/Include/Game/Models/GroundItems.hpp new file mode 100644 index 0000000..cdb7e9d --- /dev/null +++ b/Include/Game/Models/GroundItems.hpp @@ -0,0 +1,37 @@ +#ifndef GROUNDITEMS_HPP_INCLUDED +#define GROUNDITEMS_HPP_INCLUDED + +#include "../../Core/Classes/GroundItem.hpp" +#include "../../Core/Types/Tile.hpp" +#include "../../Core/Types/Convex.hpp" +#include +#include +#include +#include + +/** @addtogroup Models +* @{ */ +class GroundItems +{ + public: + static std::vector GetAll(); + static std::vector GetAll(Tile T); + static std::vector GetAll(std::int32_t ID); + static std::vector GetAll(const std::string& Name); + static std::vector GetAll(const std::vector& IDs); + static std::vector GetAll(const std::vector& Names); + static std::vector GetAll(const std::function& Filter); + + static GroundItem Get(Tile T); + static GroundItem Get(std::int32_t ID); + static GroundItem Get(const std::string& Name); + static GroundItem Get(const std::vector& IDs); + static GroundItem Get(const std::vector& Names); + + static Tile GetTileOf(GroundItem G); + + static Convex GetConvexOf(GroundItem G); +}; +/** @} */ + +#endif // GROUNDITEMS_HPP_INCLUDED diff --git a/Include/Game/Models/NPCs.hpp b/Include/Game/Models/NPCs.hpp new file mode 100644 index 0000000..28e9eb9 --- /dev/null +++ b/Include/Game/Models/NPCs.hpp @@ -0,0 +1,40 @@ +#ifndef NPCS_HPP_INCLUDED +#define NPCS_HPP_INCLUDED + +#include "../../Core/Classes/NPC.hpp" +#include "../../Core/Types/Tile.hpp" +#include "../../Core/Types/Convex.hpp" +#include +#include +#include +#include + + +/** @addtogroup Models +* @{ */ +class NPCs +{ + public: + static std::vector GetAll(); + static std::vector GetAll(const Tile& Tile); + static std::vector GetAll(std::int32_t ID); + static std::vector GetAll(const std::string& Name); + static std::vector GetAll(const std::vector& IDs); + static std::vector GetAll(const std::vector& Names); + static std::vector GetAll(const std::function& Filter); + + static NPC Get(); + static NPC Get(const Tile& Tile); + static NPC Get(std::int32_t ID); + static NPC Get(const std::string& Name); + static NPC Get(const std::vector& IDs); + static NPC Get(const std::vector& Names); + static NPC Get(const std::function& Filter); + + static Tile GetTileOf(NPC NPC); + + static Convex GetConvexOf(NPC NPC); +}; +/** @} */ + +#endif // NPCS_HPP_INCLUDED diff --git a/Include/Game/Models/Players.hpp b/Include/Game/Models/Players.hpp new file mode 100644 index 0000000..59c3105 --- /dev/null +++ b/Include/Game/Models/Players.hpp @@ -0,0 +1,37 @@ +#ifndef PLAYERS_HPP_INCLUDED +#define PLAYERS_HPP_INCLUDED + +#include "../../Core/Classes/Player.hpp" +#include "../../Core/Types/Tile.hpp" +#include "../../Core/Types/Convex.hpp" +#include +#include +#include +#include + +/** @addtogroup Models +* @{ */ +class Players +{ + public: + static Player GetLocal(); + static std::vector GetAll(); + static std::vector GetAll(const Tile& Tile); + static std::vector GetAll(const std::string& Name); + static std::vector GetAll(const std::vector& Names); + static std::vector GetAll(const std::function& Filter); + + static Player Get(); + static Player Get(const Tile& Tile); + static Player Get(const std::string& Name); + static Player Get(const std::vector& Names); + static Player Get(const std::function& Filter); + + static Tile GetTileOf(Player Player); + + static Convex GetConvexOf(Player Player); +}; + +/** @} */ + +#endif // PLAYERS_HPP_INCLUDED diff --git a/Include/Game/Models/SceneObjects.hpp b/Include/Game/Models/SceneObjects.hpp new file mode 100644 index 0000000..4e5d000 --- /dev/null +++ b/Include/Game/Models/SceneObjects.hpp @@ -0,0 +1,67 @@ +#ifndef SCENEOBJECTS_HPP_INCLUDED +#define SCENEOBJECTS_HPP_INCLUDED + +#include "../../Core/Classes/GameModel.hpp" +#include "../../Core/Classes/DecorativeModel.hpp" +#include "../../Core/Classes/GroundModel.hpp" +#include "../../Core/Classes/WallModel.hpp" +#include "../../Core/Types/Tile.hpp" +#include "../../Core/Types/Convex.hpp" +#include +#include +#include +#include + +/** @addtogroup Models +* @{ */ +class SceneObjects +{ + public: + + + typedef enum MODEL_TYPE + { + GAME_MODEL = (1 << 1), + DECORATIVE_MODEL = (1 << 2), + GROUND_MODEL = (1 << 3), + WALL_MODEL = (1 << 4), + ALL = (GAME_MODEL | DECORATIVE_MODEL | GROUND_MODEL | WALL_MODEL) + } MODEL_TYPE; + + static std::vector GetAll(MODEL_TYPE ModelTypes = ALL); + static std::vector GetAll(const Tile& T, MODEL_TYPE ModelTypes = ALL); + static std::vector GetAll(std::int32_t ID, MODEL_TYPE ModelTypes = ALL); + static std::vector GetAll(const std::string& Name, MODEL_TYPE ModelTypes = ALL); + static std::vector GetAll(const std::vector& PossibleIDs, MODEL_TYPE ModelTypes = ALL); + static std::vector GetAll(const std::vector& PossibleNames, MODEL_TYPE ModelTypes = ALL); + + static std::vector GetAll(const std::function& Filter); + static std::vector GetAll(const std::function& Filter); + static std::vector GetAll(const std::function& Filter); + static std::vector GetAll(const std::function& Filter); + + static Object Get(const Tile& T, MODEL_TYPE ModelTypes = ALL); + static Object Get(std::int32_t ID, MODEL_TYPE ModelTypes = ALL); + static Object Get(const std::string& Name, MODEL_TYPE ModelTypes = ALL); + static Object Get(const std::vector& PossibleIDs, MODEL_TYPE ModelTypes = ALL); + static Object Get(const std::vector& PossibleNames, MODEL_TYPE ModelTypes = ALL); + + static GameModel Get(const std::function& Filter); + static DecorativeModel Get(const std::function& Filter); + static GroundModel Get(const std::function& Filter); + static WallModel Get(const std::function& Filter); + + static Tile GetTileOf(const GameModel& G); + static Tile GetTileOf(const DecorativeModel& D); + static Tile GetTileOf(const GroundModel& G); + static Tile GetTileOf(const WallModel& W); + + static Convex GetConvexOf(const GameModel& G); + static Convex GetConvexOf(const DecorativeModel& D); + static Convex GetConvexOf(const GroundModel& G); + static Convex GetConvexOf(const WallModel& W); +}; + +/** @} */ + +#endif // SCENEOBJECTS_HPP_INCLUDED diff --git a/Include/Game/Tools/BreakHandler.hpp b/Include/Game/Tools/BreakHandler.hpp new file mode 100644 index 0000000..f5437fc --- /dev/null +++ b/Include/Game/Tools/BreakHandler.hpp @@ -0,0 +1,18 @@ +#ifndef BREAKHANDLER_HPP_INCLUDED +#define BREAKHANDLER_HPP_INCLUDED + +#include "../../Core/Types/Timer.hpp" +#include "../../Core/Types/Counter.hpp" + +class BreakHandler +{ + public: + static Counter GetBreakCounter(); + static Timer GetBreakTimer(); + + static bool ShortBreak(bool Logout = true); + static bool LongBreak(bool Logout = true); + static bool Break(bool Logout = true); +}; + +#endif // BREAKHANDLER_HPP_INCLUDED diff --git a/Include/Game/Tools/Interact.hpp b/Include/Game/Tools/Interact.hpp new file mode 100644 index 0000000..7ccbeae --- /dev/null +++ b/Include/Game/Tools/Interact.hpp @@ -0,0 +1,77 @@ +#ifndef INTERACT_HPP_INCLUDED +#define INTERACT_HPP_INCLUDED + +#include "../../Core/Input.hpp" +#include "../../Core/Internal.hpp" +#include +#include +#include + +/** @addtogroup Tools +* @{ */ +class Interact +{ + public: + static bool MoveMouse(Point P); + static bool MoveMouse(Box B); + + static bool Scroll(ScrollDirection Direction); + static bool Scroll(Point P, ScrollDirection Direction); + static bool Scroll(Box B, ScrollDirection Direction); + static bool ScrollUntil(ScrollDirection Direction, std::int32_t Duration, const std::function& Func); + + static bool Click(Button Button = BUTTON_LEFT); + + static bool Click(Point P, Button Button = BUTTON_LEFT); + static bool Click(Point P, const std::string& Action, const std::string& Target = ""); + static bool Click(Point P, const std::vector& PossibleActions, const std::vector& PossibleTargets = {""}); + + static bool Click(Box B, Button Button = BUTTON_LEFT); + static bool Click(Box B, const std::string& Action, const std::string& Target = ""); + static bool Click(Box B, const std::vector& PossibleActions, const std::vector& PossibleTargets = {""}); + + static bool Click(Widget W, Button Button = BUTTON_LEFT); + static bool Click(Widget W, const std::string& Action, const std::string& Target = ""); + static bool Click(Widget W, const std::vector& PossibleActions, const std::vector& PossibleTargets = {""}); + + static bool Click(Convex C, Button Button = BUTTON_LEFT); + static bool Click(Convex C, const std::string& Action, const std::string& Target = ""); + static bool Click(Convex C, const std::vector& PossibleActions, const std::vector& PossibleTargets = {""}); + + static bool Click(GroundItem G, Button Button = BUTTON_LEFT); + static bool Click(GroundItem G, const std::string& Action); + static bool Click(GroundItem G, const std::vector& PossibleActions); + + static bool Click(NPC N, Button Button = BUTTON_LEFT); + static bool Click(NPC N, const std::string& Action); + static bool Click(NPC N, const std::vector& PossibleActions); + + static bool Click(Player P, Button Button = BUTTON_LEFT); + static bool Click(Player P, const std::string& Action); + static bool Click(Player P, const std::vector& PossibleActions); + + static bool Click(GameModel G, Button Button = BUTTON_LEFT); + static bool Click(GameModel G, const std::string& Action); + static bool Click(GameModel G, const std::vector& PossibleActions); + + static bool Click(GroundModel G, Button Button = BUTTON_LEFT); + static bool Click(GroundModel G, const std::string& Action); + static bool Click(GroundModel G, const std::vector& PossibleActions); + + static bool Click(WallModel W, Button Button = BUTTON_LEFT); + static bool Click(WallModel W, const std::string& Action); + static bool Click(WallModel W, const std::vector& PossibleActions); + + 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); +}; + +/** @} */ + +#endif // INTERACT_HPP_INCLUDED diff --git a/Include/Game/Tools/Profile.hpp b/Include/Game/Tools/Profile.hpp new file mode 100644 index 0000000..146bf94 --- /dev/null +++ b/Include/Game/Tools/Profile.hpp @@ -0,0 +1,82 @@ +#ifndef PROFILE_HPP_INCLUDED +#define PROFILE_HPP_INCLUDED + +#include "../../Core/Types/Timer.hpp" +#include +#include + +/** @addtogroup Tools +* @{ */ +class Profile +{ + public: + static std::string GetUsername(); + static std::string GetPassword(); + static std::string GetBankPin(); + static std::int32_t GetWorld(); + + static bool GetIsMember(); + static bool GetHasPin(); + + static std::int32_t GetActionDelayMean(); + static double GetActionDelayDeviation(); + + static std::int32_t GetMoveDelayMean(); + static double GetMoveDelayDeviation(); + + static std::int32_t GetMouseDownDelayMean(); + static double GetMouseDownDelayDeviation(); + + static std::int32_t GetMouseUpDelayMean(); + static double GetMouseUpDelayDeviation(); + + static std::int32_t GetKeyDownDelayMean(); + static double GetKeyDownDelayDeviation(); + + static std::int32_t GetKeyUpDelayMean(); + static double GetKeyUpDelayDeviation(); + + static std::int32_t GetScrollDelayMean(); + static double GetScrollDelayDeviation(); + + static double GetStandardDeviationX(); + static double GetStandardDeviationY(); + + static double GetBoxProbabilityX(); + static double GetBoxProbabilityY(); + + static double GetConvexProbabilityX(); + static double GetConvexProbabilityY(); + + static double GetItemProbabilityX(); + static double GetItemProbabilityY(); + + static double GetMenuProbabilityX(); + static double GetMenuProbabilityY(); + + static double GetWidgetProbabilityX(); + static double GetWidgetProbabilityY(); + + static double GetMissFollowUp(); + + static double GetFatigue(); + static double GetFatigueGain(); + static double GetFatigueLoss(); + static double GetFatigueMax(); + + static bool GetShortBreakEnabled(); + static double GetShortBreakEvery(); + static double GetShortBreakEveryDeviation(); + static double GetShortBreakFor(); + static double GetShortBreakForDeviation(); + + static bool GetLongBreakEnabled(); + static double GetLongBreakEvery(); + static double GetLongBreakEveryDeviation(); + static double GetLongBreakFor(); + static double GetLongBreakForDeviation(); +}; + +/** @} */ + +#endif // PROFILE_HPP_INCLUDED diff --git a/Include/Game/Tools/RandomHandler.hpp b/Include/Game/Tools/RandomHandler.hpp new file mode 100644 index 0000000..69ea84d --- /dev/null +++ b/Include/Game/Tools/RandomHandler.hpp @@ -0,0 +1,17 @@ +#ifndef RANDOMHANDLER_HPP_INCLUDED +#define RANDOMHANDLER_HPP_INCLUDED + +#include "../../Core/Types/Counter.hpp" +#include "../../Core/Types/Countdown.hpp" +#include + +class RandomHandler +{ + public: + static void SetCheckDelay(std::int64_t Time); + static Countdown GetCheckCountdown(); + static Counter GetRandomsCounter(); + static bool Check(); +}; + +#endif // RANDOMHANDLER_HPP_INCLUDED diff --git a/Include/Game/Tools/Settings.hpp b/Include/Game/Tools/Settings.hpp new file mode 100644 index 0000000..175a40c --- /dev/null +++ b/Include/Game/Tools/Settings.hpp @@ -0,0 +1,22 @@ +#ifndef SETTINGS_HPP_INCLUDED +#define SETTINGS_HPP_INCLUDED + +#include +#include + +/** @addtogroup Tools +* @{ */ +class Settings +{ + public: + static 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); + static std::int32_t GetScreenType(); +}; + +/** @} */ + +#endif // SETTINGS_HPP_INCLUDED diff --git a/Include/Game/Tools/Tools.hpp b/Include/Game/Tools/Tools.hpp new file mode 100644 index 0000000..4223831 --- /dev/null +++ b/Include/Game/Tools/Tools.hpp @@ -0,0 +1,20 @@ +#ifndef TOOLS_HPP_INCLUDED +#define TOOLS_HPP_INCLUDED + +#include "../../Core/Classes/ItemInfo.hpp" +#include "../../Core/Classes/ItemContainer.hpp" +#include +#include + +/** @addtogroup Tools +* @{ */ +class Tools +{ + public: + + +}; + +/** @} */ + +#endif // TOOLS_HPP_INCLUDED diff --git a/Include/Game/Tools/Widgets.hpp b/Include/Game/Tools/Widgets.hpp new file mode 100644 index 0000000..b6f4b2d --- /dev/null +++ b/Include/Game/Tools/Widgets.hpp @@ -0,0 +1,81 @@ +#ifndef WIDGETS_HPP_INCLUDED +#define WIDGETS_HPP_INCLUDED + +#include "../../Core/Types/Box.hpp" +#include "../../Core/Classes/Widget.hpp" +#include +#include +#include + +/** @addtogroup Tools +* @{ */ +class Widgets +{ + public: + /** + * @brief Returns true if the Widget, or it's Parent, is Hidden + * @code + * Widget Inventory = Widgets::GetWidget(149, 0); + * bool InventoryHidden = Widgets::IsHidden(Inventory); + * @endcode + */ + static bool IsHidden(Widget W); + /** + * @brief Returns the Box of the passed Widget + * @code + * Widget BankInventory = Widgets::GetWidget(15, 3); + * Box BankInventoryBox = Widgets::GetBox(BankInventory); + * @endcode + */ + static Box GetBox(Widget W); + /** + * @brief Returns the absolute X of the passed Widget + * @code + * Widget BankInventory = Widgets::GetWidget(15, 3); + * std::int32_t BankInventoryX = Widgets::GetX(BankInventory); + * @endcode + */ + static std::int32_t GetX(Widget W); + /** + * @brief Returns the absolute Y of the passed Widget + * @code + * Widget BankInventory = Widgets::GetWidget(15, 3); + * std::int32_t BankInventoryY = Widgets::GetX(BankInventory); + * @endcode + */ + static std::int32_t GetY(Widget W); + + /** + * @brief Returns a vector of All Loaded Widgets + * @code std::vector Widgets = Widgets::GetAll(); @endcode + */ + static std::vector GetAll(); + /** + * @brief Returns the specified Widget by Parent ID + * @code Widget BankParent = Widgets::Get(15); @endcode + */ + static Widget Get(std::int32_t Parent); + /** + * @brief Returns the specified Widget by Parent, and Child ID + * @code Widget BankInventory = Widgets::Get(15, 3); @endcode + */ + static Widget Get(std::int32_t Parent, std::int32_t Child); + /** + * @brief Returns the specified Widget by Parent, and Child, and Grandchild ID + * @code Widget BankCloseButton = Widgets::Get(12, 3, 11); @endcode + */ + static Widget Get(std::int32_t Parent, std::int32_t Child, std::int32_t Grandchild); + /** + * @brief Returns a vector of all Widgets that pass the specified Filter @see LibraryFilterLambdas + * @code + * auto const WTextEquals = [](const Widget& W){ return W.GetText() == "Enter Amount"; }; + * std::vector Widgets = Widgets::Get(WTextEquals); @endcode + * Will return all Widgets whose Text equals Enter Amount + */ + static std::vector Get(const std::function& Filter); + +}; + +/** @} */ + +#endif // WIDGETS_HPP_INCLUDED diff --git a/Include/Game/Tools/Worlds.hpp b/Include/Game/Tools/Worlds.hpp new file mode 100644 index 0000000..69c441c --- /dev/null +++ b/Include/Game/Tools/Worlds.hpp @@ -0,0 +1,39 @@ +#ifndef WORLDS_HPP_INCLUDED +#define WORLDS_HPP_INCLUDED + +#include "../../Core/Classes/World.hpp" +#include +#include +#include +#include + +/** @addtogroup Tools +* @{ */ +class Worlds +{ + public: + static bool Refresh(); + static bool Refresh(bool ExitWorldSelection); + + static bool SwitchWorld(World World); + static bool SwitchWorld(std::int32_t WorldID); + + static std::int32_t GetCurrent(); + static std::vector GetAll(); + + static std::int32_t GetIndexOf(World World); + static std::int32_t GetIndexOf(std::int32_t WorldID); + + static std::vector GetF2P(); + static std::vector GetP2P(); + + static bool IsP2P(World World); + static bool IsP2P(std::int32_t WorldID); + + static World GetBy(std::int32_t WorldID); + static std::vector GetBy(const std::function& Filter); +}; + +/** @} */ + +#endif // WORLDS_HPP_INCLUDED diff --git a/Library/libAlpacaLibrary.a b/Library/libAlpacaLibrary.a new file mode 100644 index 0000000000000000000000000000000000000000..27b3cf4b1d3af8a357816c1791350b9b305cc1aa GIT binary patch literal 2349688 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

Ia(MktFnz!>I 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 z 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

  • 0`~W-O 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 O8gdLs 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šWe8Qw7-M05(XqWQd7>r)q@^NHyIcQ$xJ1A!0>3v?}0MVmkIYoRr0pV=OielxqB(vbX_P-AKrx+ylx0T-~8O1Ik}K zl)r;Q$7%Sb@zh+t~+pty0m4)@x{r-GhFlYo=Rc}mGCVxBUb z{m1VVPd(`qU0Kil>>;Q5I>1^WDZ?R?@K7Bz@KI(Nik4IFquk=7tTz-& z3tNjcG*vBHzzSJ9^~XFs6!xNzvdcqJazu=gbL44?z!dPbELJHwIUVQWA^r<}l*@dS zW*=plk8-Pza<_*PZjLn9H@79|{7VlH1-|5??DkQPCnx1Y+i<>*vfM|x)kj(DqdelH zJm;gFK^4N2dXbNEk&kkPkJ9L)bonUX^iaZe(a4g9HnMi7#ROHBpz z@@b-nGhxD^H%4NhH>P`PVnRGmkSEsu?+?H49r>!Gk!vgJZTHsdp>R0TQa7gwd$7%| zxU8eSI*M(!8auFmTU~oaP1wc;Z1^~*Gh)xNi}1KgoA>N(bCl|Q>_#67QS5NE9s6f> zRDfhx*YQ8wuC~KY@$P>Xd0XCw#tuw=q)mj3>wJovi&qz7mt=d9+h(vy3$~f5YYI2g zu4UMuprQ(F*bK?GC%4V0ab~7R^{s77?W%f6THuI6 z0ncmcq}}+iqkK5p8eY;7ZO3M96$h|kqg`*?HQ}l$ja4lTSUh+}Q=TT4tHM2nh|mYjfCY zkCoj4JO$k?BXKIaD@;#GcSvUQPZudsE#F3c~|auDS@R zO*1Q%4zm(;n6(!jW+j-0Hi0#*BFW)9D(%Z>E?mkG46I0`4fOB$>qB z%%&g@=;k(q?jk7KX{Ba^*{XWnKI>(#%j)Q~5;Tg~N)Y{du$i4_X%9R3%%ubEYq)e$ z`GlHq&E-`#x@Xg;);7)b-X*B(gXqe($2WGg*NqPqvG+SYCRL#N{xG?~UZgk+ z3Ki@Ac0EeX_u%%-1q+lkY-@z9pykG$t*&7~XGb&)&uFXISI^2*fR5U@50T1r8?^04 z{GX0{7;Yu4Z5_CyV5i4++&7xrxQkYi!hjRJ79{(T*vYUO_4#00-0#Z6HKA}#o;F`; zvC0N+-fgXI!(}kdt*ySq&+$; z1>(v~L3kE=%EM9?l8L-rc42rDIuW8Xwq^}?v<|=S!{$gR1ycxl*tm+M5Z&260D1gaOplkYHW!=8nH!qZ z*d2`Uq#b_hM5BeKoZJr6dG>AR+YZ{|X z3H#amtDNd2d$+w8w){y=*h5^eA*7xKIVdkz)-LkaTN;Rp9&96Dgx1!{Ps)T2q?zBR zSl7rOx=aT&-X*Qf!Nk=D^mgXekd*88r@BUt#gj$|6`Y#x|feVv|aa@VI5`^1&39nOI4lmlh|rdLva96^gY{2$~TVW+)qNG)NC%U0&q>M>(B#J3FA_( z(d7RfXr~8$*HSdju&XoBu7_O@s1L=%isR?i*M}oZ>LYDYbhb@83??|4vSDN_t zgvR3Gh&3{v&nR(RTf$|qni=!}vv7OIhlSbG95cyy4n(74&+yZcgK(5LyWg z0i&P9FYj^RoZHG>(Hbus-O)Q5lX6a1FUTh6ac?=?jCaM0!)D-`(nQC#q_MRljI}-^ z1r->zHg5pD1JcE4D{9dFmTosaC*lS4{Pxzx;igE-yy*OJq`kehonCyCP?c_7HTA)H zynMRH+>=5&z-zIN&gKXSC`D?QHa5(QL>uM7WU7)_zi5u?_^X0clERk|sxJd9dij)+OUx&&|on z2^EG4a!d0Hi;Ht|a&fKCq1@b}qN1Ff($Y`~lXGStJ}n><$-DPI9i z$~Fh_6@YJ5qJ9NMo_vs>UI4zeiZ2bEp2D&B-oEd>=Xx*S6RX^gO~Dr(i(R&2wc8{K?C3Wlc15u3 zL##oJb&!u*5ga-kdx>YnHpTw%&f560?QsOBKQXyvkJ%WU_Z7ZzXCGAJMQc|AK=oCJ z^S?XRqqW+{&Z{+8RFt;1Yloem;O*A}S>5y@I<}WUZZj#jNlHeQ0qx1cN%CeXhX4)+ zAV}?GN`>XxXYWlUB^!qD3d0Iy}_WFpskZ-@PEw9XAG*pT zGZT9rVJ%jP_St+agK1kk+qp)+Z zqwK>${(wz&JcYVfXZadZEsxf-vyg$5Bg|%JA%Zn@tvJh#ESGdu4t0Sp_*Bl~aTPd@ zOMZgm7(daD!zq(%9gO49TI@+$9Qx7+o^vvaavz@a26hZ_YO>37sQLIrp7R~-!J|Bf zKGJeEG2Og75A8|hG#~rj#0;7gEl+rMH&P6Qu|2@yS10}|7&T0U-%$frJ*GJ2g z#v<#mrhKnWn^$qefo+~qHTDeNhaIorGxqYV?)Nx8Z~x8BM(U=}8U+5N-6e+fDtyy*y@9l+(i3hFTEyU$&F z_O{E1HK_?-g6PNHoW_<#krq6mEH#wHt?ey2_(}sqW9peW2k!`?WJlfmbFDi59gw*M z^s3`i<}9*_7Yg&CAL?aP@RP43UZn(SIZE6<{~hd#-_!+~g#A_Fcwkg`s^5sE%oCaQ-5G8P-OeCACL^%9!>v&XUI4 zKq6&4YGggGvaQ8H664E2WuRqPJwT%0oj?+I8&HH}`~_$t^U;oNg2n;O<p1 z{Qd+;a`_9OGK6MWv>v$V_Z*Pq@-V0=r9dliOk}=u45|f^TrLHYTz(CR#$GZk+NBeJ zK;Okb$>qa93qZ@ZzJR-`k&<$z>&wKoCqYji~>n6 zzYHX~yxpMtf#z~9w*t*$^j|ZmjJ~QUWdBs_9er2v zko8lo?DSK^qa_b0imaJHV@HbMLe$#PfvN?`V{q1*I%vD$(URX*6ta3MeGVma;&4{t zIzds$H&f;GEX5Nr_M!b0=%6}~O2f+y4{4~^arzEokQ`CAQSs1~P^jHr=i&J_DF5_O z{-k1&SEO1c>0Bys97hb*vSCt(@)js`9BFcK zl2kxmRVXc>f`!SH?pcb5OFYH;C+8`iqY*dN`Y?1qpo8jKs`X*6Q9RU+q>^*3;-SIK zRO_*HD;}!D$<{Uj*}7fv9KRQyKE-na^Qa4ojDt$u{pJJ(gtX}0Nh1ZD!~NETN-vEV z6At$q6ZWV;5+=lXK&gO4Ag3%rig%3^YW30ro`HJ9Pxo9ps0B<5d=_Wrm_)?kUfYCT zD5P53gznRHPz#w%9}3&9c&J4Z@1-3(=%AKFC?6;a)n%d3z8!SXu(ME(Ruu9>q0m4C z9prUFIa5){$AprvDCAK>DN_{kAE8t#3VDlAE>jfp4WUF7g*-thZHi){HVK7#BXVfU zcYGA;o#;biQIA9)LJ3kss1Bjz`6zlVM@b#8M3by8ve3lR`rP27e9cF>$3ubSgtbIe zT1r1H`B$D;6!?OV@}`e+0XZ@sTF%uz$|4`-8$QZUJQV+08JiKV=jq{XFkT){>1@Fl z$M~>lKE7FQinLeIGh7u-H>A(o@Tl3kkk&$=1rsK;EDbl*Me95g3LFVEEdrmtO~k)& zb6pE|slti@B+lkfN)*YS>6Qh_1vIC%BwQ&m@MRk(D*)_?`%-(ULsX06@ zfO3$Qo zDg^26T$vi9{ay=oUpo$AzC$M|p!6mPzZ_1uPW-%=3OvD>&Xjom zY8D&^FmuoQNkx8%W5xX!mr$$41@>2`BtqPl#0(-?*Co-!hG{}mlbQx&NSNaiDpI9k zU)$N(){G&*WK1E&G!5f_9G*A@H&v+`&-&MFvXVFGi7l?4s;TM|EL@{13Pa_gG+Rlv z%!K%sCp10s$qZbH6kTR&@r7x7Ij+Oxn(+wf(y$KO6wcMRZdw2&<&?*R zpBb5uG)?hq!$Sp}b;xv6!tRAG5pc6tfePPijO{kYcK3f=rnmrV7?Q zQSH;1u~%{_)_S5I(}D%iPurjUN6j=Wt#T6ZPb6a$&RMNf0B(IuYYHGDNqR$XK zXKzwdU5m_l%i+V!e8c>0f37`;zb5_NfsnQzl*NWyjSOtmC4-!22+E_&p_K~IUymt^K! zH~45*FFNQcLiqeM-);lnQS`us!|)}U`L+Rkr}_B2GvCS~V>9^N2hSKwGV^UD20@Av zmE-#^|8OM93>UH_tmmX*B4xYW7Wv&)6kl<{R;?rNI~1!FIv?Nf(KC zSr`Bxt#wQXMG?NzA|~h)47L&v+O%UC9b|6iEAq}%%K?2Q9;Ex|F%$>+MGnoVOfut+ zX7FuMe3TEiUr}BG#nT5pNcGc$x$7vS8Fxhm`7RQVp>Iga=bynh0KS)0y5t8U&p(5Y z)`)f=!dL3kZwvTn4>mfCyyB2gzpcsS73b$lOgYn7#y0ScK;5N-#z;8b;(}r(s1xz+ z1YeGiugFtwWWU`>)5Vvmu7k!JXb9qqiSkNvJ^B&fNbp_d;|qE8BfcE)UFYM=_vlv! zzFgG?0rEk9k2k8a-?y{bGlgNs-L3fNn{nr!TUQ>>e!L7!@$|8!?Ux9@cx9#6tcA7$p?1!?|Zb=S^p>^F}&fh@7>vFzAZ*=s(@Tp4NvF<0he zc>X@-%ABcY=QUvxL{`t)h`{2@du#jRnVurc9uu2};zG$W$0nY^MuWD!_8{gR#O!S} zwT8yokaPaW^Y5t99DIQ%=54uz=G4UO&BS<`Fw!WTOs}C@HAp*<)5I*#{2FSnIL*CG z;Uh(u$C>!^Gm!Q+Gb<0_YGxMC;A3@N4ydQ@Jx){i8Zq0V>!BsE(jj^V-+WvwE|fWZ zd&cyPfjF7pXzlo^!GRt3Fedv3)bz)pWikh&$;{&;rHLbY{ZL)1=~-%?UgxQMdZn%@=N2`qnz0(hR^KId;yUTLlf+Xz_Am`#}YNAfVe z!OXmfPe>T6Yc?VY5EYu+wqsBA(6L@DDQ z&!(~F1XR!5BSJ6fmwb6QNyY>A|5>@e~cnvU`K{Sv?P z@H-8^F=)xC$NfG0PRDO8e$?dbZN?Az?M$?>=U<%}JtCeK`$N~G!962~c3q~u^fI1S z_6o$nJ-1PJZj(JoZ?$6)c-i(|`!T1aM#k&`xKpVej9!n@LO{H7V3WPscnzE)80@kK zf>*jZhm-oT9&;fuq9@1K-RLp{z%p@ zo*%op=Xp4FRuAnLcjGdeR)0#?%@c9awQPfx)pH@xCVL}k3SUn{=1?uAx>fc=VU(F_ z4L~E|BO5~y>B)Bjut0AUEMho>$X3rlRyVa9 zI*&UZ#Dy*i6djes=<;Z!yc4QG+x0_7VRr2%dp+2!p%GL-G;NOsb}d_v1_k+wSN3DF z+{mG0;;bJU6jO*@%QjkYD~AAGQ~ujz)xSkF$=gEl;Jj=&&A z!J)@$^tFt{IN`*j!wAcWjF(3AeI3IwJ8d=+k=bb%Gotr2+2dZPfH-RK?Zv%&L?@Jwo*c=|0k%@pc;dg0kyN_?*Wk=vaJVzB;5fZs-YRyCLr>G3~L7v8fox- z7WG>sF8~tzwF8ae(CZ9ZXF{Jg=oJ(CSA+g;LXSkEO)TYPpgD}b2y`YR`Y7XCMst8> z17%n=dqS+%1~i#zHv);({tZa%{36g&j+>3!TPLFepmP~50FrcRW}Bo-&6~_SqI*vb zeliEDmJvP2&%-Zq4ix!THa}I)GJN!IT=>LREbF#!D{A4#wvFT?d$#^Wru{}zy>_7D)|N_N8(^f9g_UD^#(@{idM86ri6BxP}&Vs^rPJ{ zML*gNQ}m;ckfd(WZkVF!2&7StpUl0wjx`{wiJj@OhQ2P##!t`cB2rq13yeM<|)oC!sX=PxPbqNoc}H^2l=%=apT}!T6C*{1dXB7{s4CIiv!Sw1N+tX1oDWTpp=V<<5$)TemJTB+u7{ior9hTy|qvx-92NHve^CB<_n^Nhh+YwDoC8XhhA zLq#F0r_yI6nE^-8(y?+B1Wc?cpj?0$)WV2mu2ejSvz+8Qw;3KvUC%V5 zt^i3EIm;CfT?u6sC<7jzpMpX)(us9C3gJ3M5nC0B6Z5XGspg(7H$2)JkArfXN6zmR z4|#d2J=cz>g2F*F%_Q|pKsgiT;b^#A@f-!dR6DG_Xn3@ou~e8is69(dvBTQ84UdjR zyMNA7sf#|PpwQv$-bnLk={N?zRCCW-6c4pWspiXlS@BQ{m1=(4R}~Mn1*y{dp5i&) z@Hjp%eqdSa70(IGqY4I?4$bqp;-Qu^)m*sWE1nbg!m~s1(0wr3{5^i-jxajlFyOff zURg$$<`~Yoa33gr=wDi3ib+EQ_qznHl>zAu=y3f%lPV|4ib`qbDhjoJLOEYisQnR2xuTF~3Z+(2$Pa}QRuu9&p)@KA`It}^DGGU% zP`VU_{6{EXRTT0Tq1>q`_1Ud^zHuoXA5ODnVM# zQDcWM zt(bg~T~qBetIE;Mb|eYc|07ck6Bh!Xs#XFo*~d!YMS6{A$}c8D$?QH?dp`{G3x{Q< zBbP`);w;YtYuVmKwb6y00qhVjO+ zZ%YnyVp6GX9;0Gs$Y2GKrNJ!>n#=$1)2QlbLrv zXRhvJ9Z+6}(&@!^s1+E^5|L(c(EsU)tvo%|U3HyVw!CEJURS8}EozA+D`{6IStFE| ztkkn;vBqUnlVmz^?k`VyJ$zDY^PIYdrNBGKl17%+f$tR`Ur8~7%t3scY52%> zu>A_Xt0bO@@a@U?;CHU5Jcl+DgHL}}>C#Y&ly4}{%|`{b6?`>0LZvY_<}1nb$lD3} zRt!}AQ}NL#7W-+EIkb;q`0Axo!GMG8!sSttU%&))qCw)#G|c5X%4iO4iFcJw;@bkg z?MfchmAR)S{yC*vlgcY8bS1&>Ww#~cE6w%Th0+~N%9j^Pl(!3fyA$;*E%4ZnhJ|*6 zFY`2sP2o^4i7CYf-V{zvlNn z=gggZ@BWcLYRj*W`^nv$d*;lUGc#xY+_`7YJW7>i{*So0B&(t+lRjJ@mz*+L>Ugbb z%WSio?N2-)@`Ur*rm4^gU@JrzxIk`FHI|$GS!KqN5h&9=N-M+Pdh;z8{Qx_xT(WML z$!wc9mC60>u2gl%_D%5%8GqfBN#@hhuHM$Ie(U_u%i&xyFcS-$#6c^^YZ=-5`WtJi zpCF4g@)=ribe5E{kpc66R5Ja^SU4-Xy*t=$zWmyc&ELGa(|l%Z^sT(uh|^$;yf8mz z?2msNhC^nKW$ZVv3RpSj?Xd49zoW{k33%&V^D6&VxI>C==}!`EK7v0`GR8Q9#qry) zQ?>0~^IA^tp$eTW#8b3;joU)pWpP|V-X5uU5`$Fw^c4RG@{;1SkL!LvTTyy__CZdm z?0=0-@$XOwM`2Uk7g8RZP4Pl77Q0`&jE~8t_`4`7mrd~mIFCGGY>J~@i(wO}YzRAy zcKQGWE4fjqeX|zUldE8zX&PH%#%f!EJB&4KLl;6et}s^RH9y8t*is-~0_$s(k?~+& z^C6(&9TsNk0s1yZ=IPf$FTn;JboU_?e)I$?gdpxPh|PDym3comR>6Yur^Lb_p7?i= z|A8URS)jC2i7))e!f2lC7r`G0;S#HeLz?({c$i#jJP3}qH@~IEcM*`dcB}DVR$?5R zD6U0zEn^M(jE|Q`@)0w>grhNGpgeqbc{o4sw5BBwy4<*0#wy8?wkvcM6;c$-?Yp{G zLZGEo(5qN>qwQi6-B@!!K8M49Vykf%7xZeEv%n5^YKv(+=vtZmW{7izaaUgRUj#{E z@lB`)DywK-^RMuX{MpUeV4pJa(2Y6;u+=PvE|{?^6(|);WDz@Z)XOH z!tU7Z$Z1|nFZ^ybqQ1m1{AMMBO-rI~n|k%Mk7KE=1Eg0{Ob`v4*K8~7QX?w009|KW zZAIlU}MJ75diNGLyoI zZPVif!Z4rJEBxKzlu4S=9E`$Cy!My313gy%a-irMSnqAX96@?SU*GaTBd@p zS)dAAch8kDt%i))heU?iP#+jQ8*$iiquo$yY+k=ZZCzvI{LT)eQ$n`HZ}>ZO0S;3q z<3AXMjP}TBDyOq4r&VNKj@gKx^MNfPf3#SRY-1fVr>kB|b8TXi^kaocLCS`^z^UMm z{UVTbjVaj@)#TdHJsCQ?ZQMARgsKCZqI4n{@T5bdA)YiSJVaDX(jlv*_y%;DM^Zm~ zpODiTZj4WUgUUf_i#7_~hUWv{21m5C=;Nf_Im!(4>Ylj8$xmKXb?tf$Z!_jMsq^HPEGii1scdcSDr)?0pU> zf)l`dE&2>+pA2@u1nlP&@3qi?tfSpW1JgB!YYutBMQhb>3|zi+f&i2U>50O~j;qZ3 zYIw1)NF6HdyMd&E){-^#)3`r}dl2rb1+_&ZW;V?IOmXq-*~P_IPMTjk6Q_(9jSPpU z&%9;CLEBXj2#)i;ET7UE>8S-uHX3q=@) zb(f9#+*2UoKB|MpMZP+EqH|FYby;+QGN1mr_jPsrie^fW67lQbi&f@>hBlo&h-aU9 z4#hOjp+IKu+WUmFQ>ZQSoRR8?`VTBFIU7=CN0(dBlM7(Fut3J;(PPAkw%T-&=qzrW=T$X^guKkkriGfM^6Q@GaHQ zMjg6GLtQ%bJq`6ldlfF90Mx`>E(0XBH3pEB#yCJy8WRDDq;-I#G=2d{@=Km#mob+= zX}VVcAwlGWyv9n7&cn1f#&pGiM1n;cG66Ml=n6n0%Z~twEb9S@EWZRKvXH-Tk>xB* zE~X)Fj<27F$Oos$w-}I=codMNYXOq-`?`j<=+G{Wds{B0wTDdHpdt z#(F@b82S|;k>zbbUuWDDO!*{ln*m80`vI-s&{qLX1C-;tDA(pU7SK`-y$z7WXayuv zEe9lNtkk$Q8utPq;nxeZP@yARWr=&4#$5xbiPNYCBxUsnJm1Z@3-CJ!x9t3@V+ew( zePhTP@6amnQ4f4OZrS;FGoZ}g&xNipXr%1>Yl!B(f-BKbsfI>qh)PW8R%&RKhT1f= zT0?6zv{pj{0JY*S;4>du7($^bEjb&IXbI)*Gq`hnm*F>pyMTS5OP$|}XBt>#C!zGL z-^BCR822E4?_uZ>{5CPvj$bL~JV2t8=K_+{Xs<#UZg@$@ucSt=tdiQ}fM`6EorD6t zhi6Hb_AN<1XeXgaMLP*4ly(wIDD5N^`DiDh$VWQ~o0v20By47gb`pxDXW&^RJqM6T zdJ&)*xN~^tqewak&o?mcO8nl7yTE7QS8D5XfWE=FO8g4l7c?|WLtg?U5|9>7!=1xz z$fd%&mJV%Xh(f6*j|K)f zKYo%D#zp@!?S7o8X|T@$T9EE)Q#3u9&!zZv2z#gqr%)iSo<4iO1dW<>k)CJT6L_1V z!Jq~jY9%&52O_`ibmeHy|EVw+0Go+3`F5uZLm6oL;5U^so!LRxDVj5#-9ZlfuWDdvfEJc3DPTyv;VLM6(=r-5A9mKSotnmuH4K%|hB9(ek5aYZIt!e$eKiAXh6eGp4mU|5 zy7~h}Lp^w=9i+cdG}KpS+Ckc(XwKC%0MsQZp-m{7^MFscW0S}eil&fhlzLGBE}PFk z6wUdBqoq?_mJZFCq)NCxhC9>+2(=Q#9Zr!_>;^kzP&Zr4RLY)r0jP-&!9 z2k9&q6=+a$E0lEobcpK`O7QiVuy6 z*;xtvQq4J++Y{v3Kxf)zI$QB6Vwy7ire0rEG&EX?hTpC*G|C9(D+)vXykJ%+3~8od zzN0Xthk{w7FeJNR9#I(5F~N`@NxDd*1oK;kA^j1|3kpNpBAEYC7-whfYYIb}AT;kO zj8C^*I!#)xB1Lmq3TBMP*nH|!F!!clew~7eYYe3Y)AKaDOb>f#NV4;&E8@$R@RAhF z=oHM<6ihe;6Z2poPtv|qC1FzPYdx_j@EH%LW?t>Qne*l+#d^y_LxH)}S@LD)YkCUi zt`yAb6wH$;n7^c8dQzkDq*a)Lxg-Tsnt~}$!Cddbr0#JIBiyxp1-nMb3-bT@b0a2& zYri;lrZE8?v2Uu6z}9_nFj!MlTR(lqTsY*OJ$CAXMmp@Grfxya%sJB=$4;&>u-OaW znj*Ev3}YzF;A!8%#BtaPm|+vxq``DLMv!9Hgd5>~dcjzr4BBLhe}*y1sBu?J1}-y` zdCVjZ*uR$Ks@`42N7%WgR+{NaEm(^7eYfq>aVW^CyPi?f^$m^lrq8Xxh7cTB(txv0KsIR*D96mdX0nn# z-LBoFBS6IcynCzDH8XCmof&o=_i^$_kQ3uX8Vn`>$9L@xm0dU=(!SjZid~TR#YVyn z6Klix5D(9qvKi~2vagrUITClC#>AU%9$2@aar(gE;9&!2l9j;x#)kO=gV-2=svjR5 zJo=i7Q6tgeP5%6NV-jzSvU4y9d&w%MFD|d0J~uo^q_=ZNTguYmIoHZ!K@1kW@q(pe z7kGlPX)TGOc*B*@H@d{|o=+6SW+akK^&9qfdlxDgn%r>HO>=8Udiui|?pQX7r*}{% zkSNBbw6`^U>)hH=LwH(>?!l$zAJTM6iuglf<`OT1&ZOO}eq3`i5&WN$j9nktbizN#|6=O1WOKeD=Q<_t1n0vYQQb$_OFv=Ar113cf*?)GCSpc5zII{lTw}td znxT`%jU7LJ61Ao;*hE7>G&<7Qhy&Hq)2Wfm+4c?}0%Pmxt#4)+hq=|wyv0x?@AoF3 zxoJ--ts!}ictli&M2C)wgu^&4^9U?t02!ww4N_T;tSILkQylMMU%cVpnAZ@lU2ydK{fCu?N{aZR z{rQ(53G8Uk$qEWV$r_{kMUR z>{95`{04dV`_ppAdvNO6Q0qWf zs`yd)30)}Yj!Q+iAsxRG&vtPBZcVmM?u+@Ac(#Kx-L|xJp6%dF*9p4u$?}y99pX-d zig!2YrYSo5Iwa|q4oarm54t;&>4p@i6e)e-i0kHW?`+L%Ne#8OX`a#zd; zIZ^7byrLnd&- zWjP?>@=ZXJqlW6IWd>1RD>+mGDvEvw` z(5V_%p>d?OLN|dSs+Gz#q1WipYjx-s7@``T#1P3hUgLz0_)!TZ+t5yA9EDO1zP}Bv zdWTH1p}mR<1{bBD$%dA_KrjvLI-t$zt|t{AG8N5qf=GX=a$JrL?SCi?m47Bn*ZUO> z)kr3r)t_n_+w!DcVQAiwiSsjxhRiNA*`w~)G&bkg6oyJYlRT$TapH1L5IIj_#1@X` z;fjq5x>V6P)`On~hBTB~h|o_~G&DKSBr~0)L{~2#$!uH9{uCJEEPQTNH1s4G6PR`n z&BMTuCB74@x3UB#9nEBGI$P7&CH62d-g8HOrD*6Z5J}y(IwoVOOg50V9Ws|*2Ajhk z(s23ImS zX1=1yWVgv*3=p3#R2le?)2G4wZ2uge4J2_(z3x)-&`Ydnf|tg^NgytQEA&nADK-qhf{s`tAg&}PbOp(HnZU|<8!Z_BIr3!;Ns-n3j z1v5JZbEn4GoPU^t=}f`U-Z}dcc|JuQAzzd_mQB;xKo0iM5b?wm4DF|r%g)6eDVVRP zVAgstNd2fR9-s2WqEu}wdZ!ErlWOy2%QMM?Nwo}|i*VPMyOWlIwTr`YX2mgo$S#H< z%B;Et^BWeB`3o27N%OH;b88#fLhc9_U}yzonsq`OrYadf%Hv&5@IxPl%7oncVvQmh z|L=M1!{85Q)#B|8L~}l1k3vjT1vq9WsYV6KRdmv*fREZyM!6`&$;up;LG^W$<^YpD z{`l3AIf552?o2f4q!WJVq4UxIgmS{~`dF<$PG|V+{?UHxPya>yi;=qd^I)f-K8kA( z_@SbrV*c_izro_-p+koj6%7g&55hlO^hJCC&+EoqijzheO7le=lk(n}>rO3V0^b_^ z<1eQFgfHU#<%7K>OzCFufL{u__{Bm-Z)r@I=8O0&(7mSUXwEKlsb9pypv$>L_-VQ{ zU&L2}?qex*UeDrvz-A5T2By#r4M_^}OYcxSKsPFdE>*t0pqr9RH#j&XnV+vWEFDtl zN@!V7UnE~X=C0@_=lx{odzMsU;{k}{* z%21*ELHC%Vqj$tI-?XyJO9p%78v%SDEWX~|mtx7gKiBUN@0WNIZ5rs7CDRQp@ze*s zrQZ&^ZzR(V8#IXc+ZP4zphaKT#p#y9gw=Hw0X_t}HpLH%64H*+c<86o7q+?57N z_#Z(0LeROdGWO7qNrvkpx+2i+RQyPvh0gm$oapS+9PH>q=lvp1bj4}YEu{rIeUZMD zrlSj`>S=jex)M)0(@NXav~)O2%XN`_v(nOeEfk1uF6jQ;S0d|jK}YE}QJ{3gpnF@< z(YhFy3q16@GfZ?%peyVr{9JS;?uJQp%Ro0Ym2Q|j!$h|dbdyu*JVyu+-D=P^rqBgF z4UY1=4s`BI@(~>5R(z_r4WL_|%FkmmLUh|e_v2JLPlXWOZqV&Wr3)3igdw^(=w3;o z8x$OtM0Xf;0gPF6IpsWPu)98pU!VxR|q=yh4w}k9^^L>et)ZS;WaUQ zcH^nhw|Yd*u+B;ZI`~^>qKBCuY-ca{(XO<%AdiBnS-aOXcEybK@C+KKMBqACJDMY} z^1ac)!4{+t|NdQUL98set;=}kfd$u--V+l-&n!GEYiH=01-UIdA4TEZnOFXdnQ!^Z z>@pLt(>S02hYjR+prlZYBdG_)KT>Qmtmuz_T)=RK8!PW`W}D*z)}Y`{vm`&d*<o zf8-5woIkoH|N0x%IRWG)Fg_{Tb-QV-j~OdEjJ3?lSV!L!P)%*<6U^F;wh%F67kMka z5rO38)mW*k5h1aPy@Dj+Sd3W3F7a1Q@r+$W3<~xUy^=bc_@%&9TGe}l?N-&k;P!qm zYZrE@a6qFqI1 zNuT&1h)2~y%jgPi4xb)v_eWuN5q>?mC(+|)S>~(pGZ7x$Qq;N|rAp^PWGqu!|3#S| zLVNuP%k)`Tn0%yV`bi{U8R^RO6of#FGM8yJmuc@l@w=Eu7ddTy-YQuh|1AtzP=@9~ zRfZ^kP5VQxLx=W(RN6>aaF433ONet-mt`CjC)`hjPlLjRa=#tU8J&1F`cyY+tVVIL zYb?3%q6L50v3&twrc(N@m?2)-r3X8mWh2kis94tfTcFZNAAZf@@!K@k#b1M;XII~6 z8SA!-gG+dr?jnL`*b($P;X!SL6;k}sLcxi7{2ZXmw&&d|=a=9BkyvDJv}**NAOZ~? zjQm)qS)={Ioz{}Q{kFmRI67R**w^ncgPp^xc7@Lg?ipU)iPG?YE#$vH+-r2=;Hbo( zwHA+q6wxgsNQ;#>Tz4B_8IdL9U~nh%M^iY%>ixCh)q!yK=*TIf5`XdDwCvzuj6N`{hQf0Y)INRX_|9yhSm;RmTakdZB)8@7k^GkKa4xz~`X0pP zZyxS^+L*Y;&~dD3*Y4d6ho#MI~pS`0}Rr z#FsPZ#21y&Zg|c=wuCaB`BKD+yz6|t5uG|6tDVuZ&kcg111O`zw@mz2@@ zeb0OuMM<_S22=XR6@M2EM4kCET8GetCH_Z*z-KxRlVH{7C^VjN=^yWzFErEXP)_TO zc0BM&6f~*C#3DdLBpRuR=NhFphz(u*4YTQR<}$xl)|$0I;~aqiO+(1{U$i}kY8FS2aQ}IXM~y^T*&Ofs`}jHWg|vr^TwWf& zpgeqfdH7=Tc;C*XANVK{Jzu!1i;7PQ%Q@JkjI+Mx9efg}qEwR=@tAC%P%?xMM(9i` zzbHD|YpI~X0o73^Q^m3XKl%Fvs2v#2$t(7ODgo=h+o^{rG^hH_-93rSeAzUbsDrL< zG9RagZB7kX+*~bww5oPR+XLn)meGl`ALI-MD@KG!fI9&TJ?F%UQI1n+-A6&8>ZZtJ zU>d9FL`qzi9WC<_K=N5tTW~6bIz)qzc~SEEYcT6qqJa4bnMTv7gP@jn z^E_nHyv}b`?KZCqgwHgMPIbb9vHQS7oZxQY4%`ng6luz9{ssW6dRJ)MV`L~`-ba0I z7>9T@S(Sm%z4Wy33X6MUhz$xZEtJ|1Jx=-(F0lBp9p)3|Q&|cV zFCll_*onEysmc|OlEI8U*JdS$NOW>w0*57uJeaq|KX#aon%ELw`x?rC(*`3Xs1BAu z$UO*g9neEMr6%%dTgfxKsVvFv&!Jw9FteM9j^-947n(xH>tq{U_6a-X{;X$kwuw0& z=M>OsH!|&8gB~99xys7;9DD`ZUAO1qhaP$;^iuef;Aui5(FNYJwJ?h`olCB{J#y+*P}Rhq=+oWi zTk)6BF<_=dlWIAsF1a-5Jr48SQCKKALTP-OG?S;Ic7`h;xo4i+>(!)uC(m;a9L$t& zocJfq<8MOuWS)!S01hV(;e3$99=mi5d)A9AZ$hskv)(-@C7P9H*R@j-sktv5Qez`J zhga_k55DD{!r(Q zU&ApgOO0KwnWwy>^r2bpP?{P(AD;)B=$1ag_Uq+5398TPy}w3B15Gxg9da5WPPd5%yQ5nR6TghU zNz-FW{cnd*0kwzB!+HjPS63@|^4M&@*Uth1RrpK1i_$wNzxCVtgZFuEuIrEu8k_IQ zYo=2bWo(u~cqRAemw|Fw_gmO};peSNSC-LU#o4?OGL?KR)mlb|C-Z!khYw& z$#SMYHK(eB4ME-Ko&Hne$hkiFr4xRjnV$cs8DMh>+XE}Lepo!?8B=5X8R5QjJOo)( z!MH#tvD5S5l#ZrcQV;rRtc5S3V>kfFcU?nceUV{*XN7E6oeJNexXGI=?ba;8-5dAB z+IbBNYkj_Y7-+WQZo<77cLnYO+%KWyDS+nFy$kR~_)m8LJlk=nyDt60gpf`<7_6$V zB|*l9Yv&!O(+Hz#?m{?-quo1$k>CTkX?=Y)?h@R|*GG105mq&R!=pZ(Ig91Z&--y2 zEY<~fn@_*_?1a!uc~@=4Ea`me=~Tyn-GFMaZ)uNUf{rzcEqo9yj(wFe@@P&vqD6V{ z4y3(6aLb}&xhV8VJCNY>Y5L4LwdB!nLc^?DUvMzh$LNOo@btR++D2a~J&vuP-2h&; zEeO>yUH1Rufsglu7EbsWey$!p`ii2yi%W;r3@sS|)5E&O0~Xvo_vQhOwF`s&i$+E2 z=7x)A+*(voSAX?&1FjodQUs4!hLRZ=W8em=w}>y4}RA(bRT{%XJ{RMA7%)1dWEBr^AX0qgx^-& zIli~?E3!}@BeI+dNF*o*BwWS=`US_G2}op_184)|OhBYU1wJ}CP@p#e3FmhK3FmCI zFUjQ@fFzB+fF9$xp8@nshG^djecCSYJ*uHU021lrfJCaXm`F$(w4X`RxDJq{F$0jK zaXTPM<7TlM7}s6X(_kl+G(r@w3+F)1A2m?J5RSm_iLyN5I*;!edJ>V z6@DKFw1sgcfJEl8fSzPr6`-vQkw0kB#70d=-kyaYd2p7z{RGg%9AgI{$=mM%N#4jG zv*axSNb)u^&yG70wigij(LV~sQ@IpF%M8X^Sc9(#AwmbLx4o@ zI{``D*8pA4G2R9wC7yq_jk^Gl;EDlBK86F5yj21cNv{JWlHLeN(ro}FlC}a8jkphx zXv8l83FjvONxeM{NI3shhrX>ta|>(<{tS74&N9<@v;w#6$-I}L)9_0phwQaPl>nko zUq4|89VVYSB4^%6XfNQ-<4`Z%H-Qs62_-s_)JwNg(>eSuNyG13Y3QWv9e&hl{X+poFLmx~NdjI=|w&_sHeR8@F=un6Ae=&}vTEh_K{695L=mK~q z9g=;n1v*sHpit68_byoC_dUi@C~2L9_GgGfzt0eblI}`qABHIO2MkdtX`+PE+zw|N z&90kU3y7|NbYu5*mVR3q=-y&`h}htwf0_2z4#jMOF24^ujj{wz{#~GG=wGJ&wJ&HI zd&klUDSFO%rd_ZViY5!GQ~Sqtio6%0GgX)yfT4>>Gwpe8&@^`HOBALr$3h2h^LIi2 zp=jt|rv0oBXd0XIe<=*rOeT4DXc{}#eue4BvC_*!b1k|~#hpo>-jpn^Q>nffDp45f z12f4pPSe=2sukukj+I`XMnyyYb|!gDO=EMWxgK5AiZaQwLDSf=Iu+(pj+I`XgrYf} zX{e=02>{SgfC>*6?e3M(B89<3BBMM*G>sk0P#9{hnY4E*Xh>etUP)^{Fl1HcXm5++ z!#T=IFY~uG4e_z}Oz%~krCmIvXy{2Wj{)gTlUxlPfxG?d))+&t3JrwXF)R|LabneG2l%s>G0ESLWaWG#3hE6AOFi!#Vvs#JHnwOh1iTsW6vm%nuaiQjOWDFf_sn=j{qZEmttVR~Txif_YJ4 zs8tH)6@{TTD3~`ChFY9pdQnl~qV^@23l)Y+PcQ=&hT4u`hAT{w#*`}zwF{w{q%aq0 z%p8Rwofn!V3PTz$m}Lq>`Yf1lDGX_^U{))P4?UY;ewl*VnSx1ZjLqj9QUP@dpAjjT z*(sQ>Y7C{0-IHlNE8Op)p(K8lf_XXx^GXV)+k;VQDT(d87m`x&rQ}KSwLn3`JT!!v zkb?Q52b2DEsg)iY;`8$q%=Q$_1*D{W*)m_5f~icw%um5YQ!w|WU>@{fQoTWJMEJj} zH;AM!LF|fJ=QTO7*!JK+z995BB5xcA?V(Qk!sLyU9O#LuzCTHf^uE?f9GlD?_uuUx z4qY+hG9Im!(INM+nGN&iPj9THlN;RHe9YVLGaV(t!hKY(J(4uheTr0)^0AS?Gcw=oB2}g6<)<+96e+G=1!gz$9Zz;u4)2d<%~#ZsK0k& zxO@KzNi9S(PltCUlN9WTm=rL^PC6Z4ch$PV>Eyi_SHe2LNm8S9VqT0+CaKBm#M0qi zNhSq52`2^UXqebh~R3|n!D;$|P!qte5%N;gj&SBIupT%%5G8&u*xu?_o!y=BG+Ua+ms zm<6iLodO*;c7ZW(J|B^m6srWsWKgV;^BN-c;nbLPwwrLJ<3)x{8h_1Xb-IYdJxDH2 z9446wiP@yN4dH8MtK&~H^N{0FobXa*k+dKsrW1nF3MZ9gav=?}*<4dU_tq3vL2qz6 zezt<281qR~=7}MQT`b3Om|M~jt)!pF-nh~-v321%_@z5x&gJjwgHF0BlOL4F2PyJQ z6ZhjR{12JkAUd#;4ySC4%nXmM#4)~f2JbM;Nd^_qZfIOIy>XU4l(r^3{U+5x79VfV zoO*^`F`tL&8j&1-V(xLuYr>kjf23oYsDGR=eO|5iG$L0L!Jv!EKC&nyPghrZe2$uu zd&Zzt8ZF($cF)HTeB%1bPR>A0sXCNZU# zyIw%zlGwJ5>H`h$8y{T>ij`&ML zSJgK<0VwAQm{{RZyv5V)(-&t)>iJN;Bb>fSONmE5r1AgD;~bMc7uxUFM>w*P55x8- zq`cycOVXhi7ElD(!($VqB)X1`=RBW<2sTt zxsLd}#j6_YYU^h?2QF&wlBMarO9qQeL*j3eyi3yeOjumvqp^HnPW3KHTco$(gK?NX zL*pvLT}0>c{S&-Pj`x}^Wb`gM6?BK_6F4q>0?+7OvKe&$P;~TdvxvM^22;H^t^nOx zWEzA^)1~n)xdC(+r_g!NTPz2UZJ={s@Lrboyv2Oj*IbdrPXjjX$W-kNXQbniBCF#6HqFVzx_r>K>f>j*XwFB@L(5+DXD2mXP4t0@nfh~s# zNDpPlLdDH=LvWb6>nZ}g9M(f?6&=|muwJF{wzv*-yA&PegUfFy-i%xqS>>!()=xIN zjJz!l9aL&R(|@Adn3m4#b(83}fbJ!gF6n{r8(IudUqnZH65N;24IAdh5#6q|bRkdq z5#3(Uy_THrFt1leva;C^x*TQjL3TEr?l7~HXJ$9HT`wgJ5 zqdn(w3~1rouMGcW)Az}99*^OiN4VxIASYk&F@OT}MYj}~yWv~_b&~l6$oJ5aj^OR7 zFLsJ&J^|8QWgp}O$X&D_-SC_MNd`9XctGY7t`i_1X2KKe1jr}h(BLS1LG?vWj?EX; zTrmCszMz^>R#J4-Va9KSo01d87nJO_w?_J@rCV9{R%I(2yO`OH9V8|l77b4BRmu>E zUS%}qLr3sNLTt!M1pQBPZ3GW>rm+^j8sS;bs#+JSTASCrhRJiIivzw$uI;~sqLLRD zlGGqaH2Ag3?BMQBxY+nC(y+?mj1If6*I^qrd0G%}FBEwqLZfB=K%$U%n7QKD(h0Au zj2i0#2NuDF1G|&j2yZdu?vGnVMOSh_%pHw<|0k(G^K!LcU;oRN4GUK}!cEAXj_c+q&gfr9IJ z49KtI9*Fx_xUax{5pLSmPd0-O;O>KaHSSO0e%~`WA=gCov%{-%;Q%Vzd_MX_pgTWt zaH_4TQ`w2iUa*0R?xQJPhY_#FKeHB^wqG1_aTjeF`KHkhWeORA@a?EEQmu-1IQ*cp zU=k=sAP_a$1Bu|)q zZF9K{* z%e!ZD-p}C=vSlX}JFn#$5Z<+fTpC@N_mxq2h%VXS%WL^8pbldrNeX?>M&{5orO8#S zLl#hHs$3}JE?);IMjzw=iQgt6M`Q4<#6<1nB!>%!${186Czl0CAh!+{Hma2H(9)jQ zOnrx)#{-Yy!LA8Z9o0nd@^EcAoI{ed>l0^`M^5c9)`QGPE>fsgRQW`gtVgGUd|4Ii zEFW|RzGg^1bSk0e;DpS{;PL zXU~cRboOjLDCF$f28LRJo6pdLfTjV;@jV1c`27Ts-I3UVjf$vWmdJmAKOJ|TuKFI&0NYw~PLZdqLtAIql z{{$rR{RoiAw;hnQt;2vs(jG{o9JlQ3y$z7;$d-~U#PgRJhaVr64Xq3Ld@~t>x~Q{& z2{%jQu4jmFwHo&Yh64D#fg$|3La$>Sh0^Ro(wNNh z5_%&;6nc&h?aff?u4Q|r)4gXIYaZDk$3^L9+O>SQrh%M`Mv|FT5yrpX4=!aNYmJ* zLB4cWKtY_Gb}Aau^6V_CHRrNxNzv*NBps( zIsbiVHYpmK!=;m%4Vn-}7Ze6GUxrqe(WAcH-%?0Y)L_araK-|f*zmDv99wb$?IbR+%*wp-OpObo&(_?$eHN+VPo)muc7FYl;ueJF>INTq!ujWI-P>zOnc?+ zOK8FxL#g9adYV0X%^n(x|6mH{XDOK9rC|1_VBYg!kb0UOc)h99<;x|Z3q#-l4-H|; zQZV-@qY)irHNx{65f_Wze^9kzU`C^&jsB&>#*o7I2aF-EdCM&NaoQvz`@KGK- z>)mQVX6-sW=t&%DI0FBnI2g@cKnQD z1NLn-vjjJ`a;Qud#lo_r#>tadGeqj^>g&RFFe16Fb{1?h=ie$Uf`e;nButQ%;}oOH zNrPa=Ho3S)3^s>)INJ8Oik7V2ib0Kvuc(0|)46jSX2S4pL2YAr?B^zOkg;$Aq`j#= zLN+L%tEq2joHu>0w*DMT%E3vFnSae>l~}SV5n1}!Yax!Y)e+6XWSPVj!Co(MP}-cw zg-VX5Ep!~3fd-JX9LT?Rl~cgP@Uf z=ej%F4{2|}G4FLvJ+IoX7uz;mtIe@@yOihSjg_HS9aCZ~6vOzEVIM)aE)tUg-~Vr8 zgh-yD)IP+qD4iaYJ$b2ZLJ6bOiF*8n+Nanv+Y071e5d0%F-Noy#kSWT>QI2rz|9Z* zC4(TBy{?S6LhCZ!)k8CrJ4AXo<`^dpX3_DSphuOnA*>quWM8jRjDNKW>jc$k9XXE2 zMimq6AvHDOIgJgAu+wx_jomBM%)~@k@|)I*b?i-;1J|apVhx?NVpT7f{Et>+PFk_T zYWJiS>q#qCvhE#r(ux%)RF6ToaMFsE3ZZJh*~9!oAo|Y#VJlYpsCLqd^`sRm*UK_Av7WSIg&FNhE7p@% ztmq9+TCq|YoU~%i@tw3{&Ed0)E=8+wTX~=_E*eKb?k*Q{lisqyh>;EAuR`ojP7_(u7 z`Zu>?wX=LeTd^u3kH?BtqUvrJ6?!yQtZ8FudrS$nd({ugidC4VcIzVXF(YN#I>RIv3x+B^PPJkc0(M}WYQ<{D9=qV0`L*?A%dH25lUA(k^Lg?l z$3S(Gz0Cx=Ir*d&Yfa7khPrwzF60n;wwA$%9hh- z16)1v3dlY){|UZWcaM}b?cXBuojQ#CdpK8rfcrsr+YG@`Hkd9rY_LNmJ|FW(!ID+c zAsdP=)fa0K=vF4vrSZi&26Ssv=t?{Sl7+%#(6y(~4GksBw-|K0Qs`3UYXx0AnQpMx zS0`ERt_9t@DRf?+qa@!((B;n*X?oxvm*3#j^4kZxJ}Gpe5{W6l#P1;JN|WhIQspZc z4L>+3bc2T`^Xmh;X(@C=hPmlhqTDA@I5^M)^t^mOOpmSekWGx&l!B#xyBDyZn{oEy=qQik$&P8;G((?x1at zO-nb#)8O(!=dW=16C~*lDRC{O6O_7M7J1pQ&Q=MB=c(qT{xA_Dab5Q?jc79 z;4HBa29N=g-Mj&wP`ibSB&1ak0Lfe1h_9vbYuat#Wpk@25 zxiG7ysB!uUJ+ttvtev4}7UZ_}^TWlm(rqh*J&gW_};oz#iJk1Tlw zOYtKs{uH~JeL3v)L6Iu32_bU;+*OdcDa?6vD~Jx%ia7A>ZpAk zBPr|n7vO*XKJ)RP#kHyevGVz5wmB|f4GQiwOY)*iWXfTZs^OvK1uB#!|#8 z_D>W5@r?aM3<|i#MNAsG;+FwaX;pLu+pVgD{eH9Q?H-}d@YV3kYL(n&ecUXGmL>km z1-8~S+AL!Yilt|HI5+P!aAwAd0Qt`q&$?~NB5BXMs}Ul_VgzEfhgma4*OT&2!>-Qz z{ZR0aFz=Vcljnz!_fB}1wv2Rn|2aZXiy8AC>56t0QGl(at@=byH$S z9B$8Vhu_thv7*CRi%LLyUPoSk(9U{bPG{C?->UF0&h@;KRqqP0j~ROf!+O_;9Hdrs zT2;HCRMmSsjOE16)~ymN5(t&t70IziM6;GGFH0n%PZnCns#pa)+%Att;auA?mb((5 z$gzsO@j8TnC_bJ38!MbbT^`+X`}H^0psz#8WXwwu*dQ-m@0XW)X6??)R4QD!q>gk3 zw_8i>yjX?gnRoZ5!#zx6nPu$icaXu>;T6lmR|a?{~O4r|C?FH@==Lb zMke-oa{8@zGUfD6giuZw(f^D&#W+z79VjM8^^Xv*iY};7u-z``)1;uoIc14gquaX8 z=iz8L-iH(2AKg-{H3=#xE|cRwpx)t$vT$K6(nVT%J=aB-`Kr}>W&D-5Sq0$>pGFlf zX$Y`4+BE{{kPJbVVXsxS&$`2J4P`ORs$HQs!{-Luha0=Xy{vOX1$Tu{BYC#^6Mt4h z?TUXDtWk>5EhD%Z!5hwUl}u+trn2pM_ll<8)zwPcU>ruT;PjUlbJcE}8nC+#ts7PF zCXD`RKdS4p9#lukU1k@J7U&CEaT{0;^15sqE2-Ae6RonUR)wlohR3j%^A+snyv?d= z3stQMUur_hS6OF;^20e%qs^cA3zEX{M9l2|6`-#&@!wHnl|QkbdTyF~=^;$|V4{g( zlb62_MnXR~PCEy7FN^=^e>o^*w4uk%yAO|3-XcYje%RH|EH&EHDCczAdF7E_)KPy5 zQOKXN9WAxvN>{g4h-FpmwG6J?bIB<+RDW0KIn?dnhexPxdxZQy3Flsgy4{Sr4gNjR z^H)?3=JWA&he>lrmM@LQ>mH6w= zvJyRld(aEs#EhI?@H%P&q=BSLadUurz((m`-HpN@9*wr=%X=Z9Vn=aP$Z@!^~} zXysra)RUIzmfm*WqFqx-bKSnai>bzq_*@L@?7Dmd>2Hz)^Y#u>f+WZKP!pc;xZG^R z%QQTjn>}Kch32&ZxSckuHo^}+<_SC(+{7AENt+dbuf*iaVkQO)ZbbXFteiDyMyho{n-4?n>%BT z-O+#KnUVbq&%#_KxHG=!4fHqJma*R)P3_bSV;YDS0%!1gvasJe+Z^rR>hFO)KK-eT zWzM9|=!g%1UgFe%UZemdKq3!i)(QY>*8s69&D~b@yKu9OJ_Wk6FWNPRNFPHGCD^+U zrN=Qv3y246!5G^M{bKe)zmWnkGaJMIwvqofnwRh#%@LNRj~TmxLG#z80!*x8pCGxP zA!d~^L!o#Yb_1wE)T-KetYSAybySUdpJbgIwM0v8)X0CD(@Vy4c2@r6bjr>u(^wH} z2}2M&M{?!`=Ob{)eR|31keL%rJD*?Up3ir*%mo8l6hih?v&$VW@4;@X73U}b8SwSOAjwVF=Ly&LpU^)6w}aQD+|CaulZ*{#f%LY z{eKFm!`Omfs!jd}1)$eCun9nj{-_{HOV?DaVuLV>*SvOA=aZ}eyJI__BnON?!1*NK z#e_?Q7F`0j6XtvpbkWA)ySiu!=*%l`paNHO%?*9vY11>i+{I00CF|W@j zW<+J(M0DT8sL@<#MVdpA<&l>_O$~Xz^cWpR6H#EAYZ<%yb<)sfH04DTNY*l%EdSln z!_d7D9z{jz6%MRfxhZ1I*g@PF=_ocPQ@0pRg_uQU=fooM&}$@R^>WJ>8y7$a7B)iL zFg`|>TQ>&G`))@W(GZ5`mUi=8+9*E7Z&k(3DS_~rCI;&kqA-p4fqOZ@IB*A+0t{6z z&uhL5fK|OewCyqSuxnPghI26UwkiXms@8?WETa|DA^w%cerunNkJaVxrHWly{%pfnauv5b}7eOl-xMcx#IFICbqlugAlevTT;3KOp& z3%Wy4*-=tpc89?%*A`3WMEf`}k#7rt7v=b?Z;}e`iXWi-r+G8k75^PVJo9w>6_s^QdD(;p)=R2T47bRSp`e8s#bOz zZHeE?+diqL(H1}ScS^5KBw(2+L7GUu@K4O6I_?Q&KYiRQ`oZ9pL3Th2aW zzPF%#d-L7Ng^yK>Rg}JZrKI^eX5=(szsy+S%6u~^9!=p(G;p^3tuMct4eF7r?e`TVe)U~el4qFIhR(qu`2Ojo+8_XSxx#P z`@#Q8k=+jpPmwK`84As3m+TGhp&9LnKJj1C>qymJOltc*yXha~7 zI{dEpkFKP5J?DL_3h|uxF_DoD_)Obs%+e(64gH5B8UKK74?ipU) z8NT3_Ckip+^P5#Wyjj>0Ic;>}#pu?;#50nQ`Ivin@{#^6uu0Ub0WOb|CT2-*fp#0= zR^{ll;dvJvNpC!?TB+}X*LdFrS5ONZLY))$b<|k68)D`Z zP4)eRbU{Z^+mX{pTU9$$ZR1t!tyW`KyoqK*&T@eLK5Fa@{+(I|N_RE7WUR&@;ePKR zO*_F|q+XZb@@%1+XU2M;hxY)KI(qtv;j>BeT{C`kem$>B>{yqD#U)DiR7o~gd&q7t zl;7&TzovRqFPWE7!WdU0d+F^Lsg zyGg}=8GVypLa{m%H(y1q)gCgjII7mNGM??m=eZrYDBj)8wSrzYx~0ik4{3!cstM3C z$+qEG$Fr3(RuPA~<&xUte?a~B^M8LI{^xpiK@Or_`5C5J?I;-NGZhbKo`<0TRz%Ev zIuxn1ClQ!cZK?r9R+{rM$%;b~3^<5*iXHLVsL_^hEoloaS*a#jadWXuvM?T!m{hjZ zN@yB``0iE&3gk(UuDMlQE$rx-6%iRSHAou;uM~=lo-lBf<(#(;gJ$)}E)Td=u{fv- z!%oho!~T%5A}{Kr!a%{&=X#Qu{v$q37EJ;e@VXSzRL_{fX+UMsfpV{&H z_Yjkl#jGbga(dKQPBTZ4`4ZXPnEV(k4%~{W;%U(uOxm!_vvScmtj=Rvv;|Zcgpm|; zppl5XB|Ye)@bvT+FmY9sm=eW*`#*L^AQB`BZCNlQ5IW3>YIs?c5&;KN8V<23Tzw8o z3d{X!{K>dByBad!?d%!&%J;kp(9njAa{@d6OieG>!pUD)TgLR!*k#E=ROt8NscJ?L zGM3}x1!l)rghu=%QmWUb`K_T7vnkXEl{2qb^H&h(Edkv?W&F#aNrbzN<%#vQMzor$ zl#-_^RsY>>MOZL*Do4~}Vwf!Q@(gUHd@bok%WZq(m(pww%erkS;&cr zy^$XEoQ6(QV6^WmaDKoMW|EEQ-1xLbENx=Sly-K6x1n6M;u5hu4_fxSRC{fyrZK`~uJ50YC#JK340R{t!ve=#Z(L3Mer`*J#afzqR-_zjRBl=E{@LAD! zvco;cMb1y;69-yojh1$YbLD^Jl0*-)6Q30?j7{~2Ucjf3;nD8ya8I+8!k_Rb5?J%a z#9<$e=TBiIz4MRV-NboIe`oGWU#*6q1wKX{>-K(|&CYb5pf+-8@9w;i8U&5e`2Oou zR@(IfTX#2b70pG`SgQpayx7yKv{ez8cl%8XZbbVC`Im-!b{p};f7>G&-bps-4xlpe zC$6Q9eBR;)T}xf@hyPn@iQXvh2b}uNnO>?|5aJbC^fKAw6?O9X-u`sa@#b>|ru*sg zspiI^O$+L8*^X~8xmmxV;luv6jwvnY{;6Zk{f{tJAswaMKd>)T?!N-6qsjda$$jT1 z)8;<6!{`D5%IBc`J4FAm2!g2^4Ylt2iea9DzN_jGG8u?fby2qP3C30#(>O@#!Q-d2 zR?(7Tyc|$X56S3Gni=_Y8XI}+ShZ<(fT#}H)q>c+v#j4ocaYFjV^-6Z$d#9aDoN2jTmeulH< zbhh^Aq+KsL75g~|Lw(mM7OKr9CRG5H*Y`n96h%bo`7X|D2Fc~Xb1Gxoe|_qR$r2XsQBemJtMh_AH$npbV=^V^S<&to-JdG zRh1hZu^da6+wmN$ST9`3Y?8Z0dDJuQW*qGL6vCixG)E#l{`+}F5p$=Qa{_CuVxz>R zM#!uv?%jAmh?+lcG+XAAUIR&3lRqBtlXWizpm7#h_s%5<%<+^DX)UAE^3yaM(*crR z9-#R&pBGj}92p^n`2VhWmC`cF^BgSfPVAB+}#+1WGJZ6qP}6{`TClW4n$`-(N+y_EV2blIz8MzdXi9Y!msRJxm5 zeV{w<-pxguTkoY3$ZKwZrqQ&N>vuOrY2by}9VDgEDt(A7#G(MWCRGrrsH&|UmGP0Z z9$v8R2e9yHkGt=*V>-p__V-)t{ebnan7>9)P#rx*i z5fZ&^X7-oTtz2Qg0}q4I-baYg=Alz@#YZ#iL#4%^X1Bb^abLWlPwyAGQUDda*g`yz zaXjSWwwEKeM7#Rp>wuJq?#a+B@G*zA*J#z<3lw@sEA!@DHnF1lBG;i{bWB$%h#1dr zfBC?RyB7{Zm!6sql9>qE`K>}ka2k1W+8896H-@Y6yQL#N<08=wN4_N|ZlE@@q!r5y z%jDb7B3d7ZY-k=%SvzsQitJ?~?H`k791T0|< zS$W~W^dq2j3e5M0KX`PT>M^gm7^+AnnS6{m^*!;gABL97Y>HC`e_wnpzcS)8U#Ff9 z31^pv@2ia0@cW}PqOhKyfw!t#i~tr)_GR;Hhs4xXjjGret5`!NpsG*^SYI~Dl%P^~ z$MIVk(=If+n$dVFsXL*n0z77qvD>BBsv&WHD2lWtDuEa8n}**##$KU*@xG~eWG;z5 z5GsBerzU)37400dmD_;tz#(o^6k%^nc+oGDxcDGbs!g?{|C9D3ZHiKsHbp#;|D-mx zp4$}9Yguxwp;BVJ3d8{csv^ocTGqZ+mX05r9w&i(k=asMI=-u9L>|?+uH->2O@c9F z%|w|3I@KPaD65M`$pD37 zKr8G^t&oZ(aZ3Ej189sFgKr|AQSKBjait(FQ|j5W`#LE;@K=q~Gvq8~D!YBQA~}pY zo^_J(+(b82U5+NoU-wbfECdhzT$E}tkAy{Q$gocG$O{?QN%qlzRI#fSmZF~r6-}ar zmtHDaYT#=czpbP$m0XM{@4r+cZ(}r>HE1mX!)g0u&egW{FyrF4u{O%K$MUCXNt-Wx zH8pCOGLUiKg=q8cg;6xrzChqSrR7b4`44*ivwP z^#RHoYC|l&Ty(pzLgS|UoY19Txw}C$@^9FP@qsk*Q@cqc?ZOu$lv{V9TJRZGS#4hR zme$N)KX=TUxeQT`Ml-p|;hT=FoU=qZzY7y4uTF{@RJqishVqcC1_<}XANQ((>y4DF zOKKYo$shpqm?I|FFx6=K8n{_%;EUK=^MPvMfoD@|U^`ZlTs5!-ALmrx@EK4;V3yXk zp#FY+LoY-*o*JM%FCE6VJ|#!4ffp$cA7Ks1_m#W4Xno9VnT7TjYZ-&zj+PtnOEuTg zLSyk_5}AARPhcyo`8|H0R$XLGuFdX`3Z;O~fnZ%NU|DPyNtE#vXeY#D*yMKdkVEr$Lu7;kME1tk7a z4fqZ;Bc2D9l?X58uvR8a%tirnQi>{3We1N014UGfZ&oZSQ#L)$yi@7IG*wn46x&A# z$w<@VEEXXoImLt!tsKST+~|@-bT#i#;iA0=XKG2@{yZ-|&PwFf^X|Kh6vkLnPzt?H ze)qNOk6!`o7hx~}2h3RaksRtJmyi>wx2K9kwQ`7~qQ(YTtO`=U;M(n)EK-@A_2MS1 zGlI6&XyPo`MWeeWHPLpxpf5F=)bwSU2`fUQ72gp0vF-joWT zJ~Os63WQI~@yHXc%Wu(Uj8a#mwa(?0oh6dV=faHG5p_wdkgNpxc?i=jhk@)0rzilZ*$#W8VLUj zxEpX+;l3L8O}J}tf5CN+X>6G9t6ET-l=bQJ;f-pRuV}!PMevt_Da!)f&A7jZ`%Ab- z;jY46iK`deOFQ;RN^7f%^VtcZm-4RKihlfj znjffP#iG4vDvbzi()%4$n~1Q%h5E(ordZOeMyOYfe+m=5NN&mCY$%(-0pn&gz0R$oj30E zM$pD6SmR`6{Ug+w*ZfuRv#t$mw+!IA1o3qrOcg_A=m)DHJ5!0X zvD+x`%MBO;krvyyCt^rr0k#trV>^*DjNKgI@}4viCalA&b7h;CteqtOHWk}|mh|k}Y}N{d^Pxo@e)H;g z%{%-DzKsax;mdN&C$JlgKPxsr$cVV5Q`?HH~XxS5~4(_zFEbRZI9fG~A z9MV%1l>SH!BMLGvB-Of#r^GCYb%xo2{Qyvy)9fO`W6b|;^IW8DUKL1O@JmV}=D&{w zH+lXeF#&E)ECVy%autpH?Oj*c+s2cvy%eLv*td)S#j7cPZCCP^wtN%2&|ooP1j4tI z($lw__72xxw#ujx$d4NB`H9{9in+ry)W$R{C|pJx&h%#|Y-r<#Y2@2_0Y+%(qS$}| z3Y@wr&9w&(Y_R&k^(ht=o_%`z!2>oCLopz!ydYCb4H5G(8mKI?`lEe{{yd`-cFV>F zWG(NW&3Qk^?!}g!F#E`BsR7|#OXy`MFYhZ8@ep0I!I#%^4IuU64l{skWX@Pe8cpT0 z4q0%fl9UHmPeCUSfeIuTs8myKN9nE?qIUfzBuhivNKURvkkC#*`$b9ENF5W;_%zB8 zpo)!F)p|1kqfHC>scOg4cNXpCaFyJ4G!wg$P^;U}oAoXaf1#W#7?F|ni8IP0r*;_Y z!O=%=(O_#AU3AHMU!)iE$SEhzvRH5=<*MC{EDLg&p-zbzLQ$mhh5#E5Dqe^SS(Cz` zMF;*9@1#=C%7%8Ve>nUwKo#?}Sfl;<6BGHQR%jrq`@kB{Xg}>3jK=fP5!=2wVE)d+ zqc^1tGE9m@4}8)!{s-s*m+cf#`~>=Z!NH@a&zw^`ea76{2@SJq@jNzMJ5LS!wT-?~ zdK_CnyMf}$9KmOwt8MeN{}cZY0?Q%VULM5rqrR>lJ^G5GzKctT)(kBfFu!3z-QocY zZk~JdfX3Q|!Tv>~B6V}aMKf+Ks;H~K`nmzv4J|2}-`H?-?aXk$qG1CE4J^id4>n)8 zb9^wt^ZkvXPviF~h6dpGAnpR+Wc3=k%f2(7>`&36lYQ}Ek^p*s9ZKJEl0T)qYJ3=sa$XEfJ7tq0Fs>l5s*lK0FX$J7bPYArGP|pt^xEr<}wSAr1lj+`7FUV0iDUv zgMiLr=;weWwQYbzmcr98n`bU#0iDfs69GwSL;+QCXbh0Z{Cz+o>5l+Ch0q+|dO#xS zlYpe0UjkIX{9Xri4nt?+g;ltm59kxjxep+bevA&S)S)u~iKG!glJ4z*p5k<)fF#{- z0+Mte1tcwg6ClaQHVx4U1=8aGrg5j9Zqo$;oy(F|0XmPNd4MF1Fd(Qe^7|z~s7^rl z0V-s=oq&GJxC_p(+y2FXB)-(&=_TJ~roEcE0_xAt(?twXZ&a>BA`+J{# zzSicH_5;1irTZ3;8HW}CNt*97+(sbD(YrvBg4t*5 zcmqIlIaTdI68ek@eZhntGNEIJTh>z6r~r~Os0NZUs0ETTSPUd(@MR!6-)33Q14*0w z5a>MS&OOJ%-6{$l4akz6&I=opY|XTm>X8 z_9h@{u}wgdk7Yp8Vk1D(V!sL`sd^Yl;{C2cy+Bf?FB$GvKvMR92aw(1bH-W_Rqd;Q$2_UijQ=pf)?9V!1j|Ue5iIqyj`GF*k$rotLl|W*-21qOi zfyD9)Kr7kuAg|UP4kVVx07?1^fW*ppAhA*jBv!r+BsuQ|5_<46iBRG2_#k~0Ev~&Ko_P_ z-hKph5u-PNE@t#DP&T8JF2PKY(V0M(GP)S(GDh=&Ml$LE8pY@ipaRZi6iE8aVIw!_ zQp>uW<)#3Mt{+Hrml<>?kXTs@Bx!jR=nB^D1scuhB_sD+pevahaG7O|VKf40ETc<+ zau{6$l*?!`P#&Y{KoZ+chO0GPJJ2|m`v#DVAm1{f-vg3d{@8FkfF!nEKoZ9u6FOw1 zuD3iOsr_j{Qg1VWq~2}-dJZL-ZY=_mdV3K_`tWBqjbFkd*k}fuzKTqbW)Gj}UuLY74j{=FtcY&_u67Mx! zzv12k5-VwAG&&tf(svG!q;C??Pr21i1)9TUa1)T|)*93XB)Yc)iS7eHQuYr6Nz2|2 zBxV1fK>x{>UjdS`-v=aR{|=Cp_=K@K-U=YG(qXuJfFzEu0KLif9t0B0n}EdfPk_Yo zJ|Mb+&$12yO<*)Q2hSlGodqQModP8Jon^SY4fhDpB-Z$;;a&%lwEPiBQaUSFr|M=P zNmU(?q^cF@5SQuQKrb=+HIT&n2cW+&H!M$c*+3FU5zw2Q-%kUHWgn1Ot_BjzHv>tI z?gbLdUj`D(-!t6PKw^0hkXU{lNG$&WNGu-)63Zu#(`mjLNG#U_iRHD1djv=9Z1qVG+$dj4@fNM8g3GhSZ)9k%WXhnc?FPIjsc0~F9C_={|0)A zOZNlAoq}QiZ_IrPNaRKX)iF22p!-c|KTsLBgAahD2Y3o~nui#aWzeUA#PU+ZJqRSa z+YR?~gZ^O9y9Q+z>71VpBxQdIkd)9AASsRMKvEhrfuuAR07+@w4kTB6Yk}nY{4v8l zYq&ljiQ^CuCVuEWM+|2bYwi>vNx>CBqET!@eTKWOF0l}Y4YGjeu5&}8D$w-(1zN9zn)Z_oyVHX5|apv?wtF=(qnPZ;!+K|Ka- zH)w}JI}O@p&~AhF7)1G(H19KLzd?Nl9W;pAo@g94i0VhU4-BF!Ug7ADq#(L(7DU&% zf`%GIZCNVLDfJK8Zz7i27Mi94t^4wj8YWG`D{4|B-cWpGw5C*N!8;(RG(Sa5bR|{Is-^X zBGuvMfr~Fpl?|KveIze+48XNDq*VKAAug+gU&o z8})Irlx|^ap~k8`ev5M4<~91TE{zNJ7?E-@g{_#%*K zd;>_*{2d@k^EMz!^Q%BoLcTY?az#;TwXVv$YtR8R1-SPgh~o1^h^^2NJ9Hf zD7B+>ZqK+_SD`evNiGXa=v5~4PbQRVR&+6m0vfZRp)m+V+dn?Udo^k1?V>TYEiDp& z{f3hSQoaYKonm+b1Ju#)jEtA>3&shlg9|8o*aqP@FpYAD=A$-k=Pn}yI~>-h7);8b zHI(*B$42id8EPE^=_a&EmyL#;ENbbNwtTK)@>wgndK zsnXM6WVF^DilJIemDBY~hW?~V&yz+*TYgzFgO8G)J|m;G-d9Y~QPPu1Cb3bgNR^&T zjf}QjtQhJ)smf=jkX_QYAx2!rTpp%FmYhHkf&F%mFY<;+P^df$u9u`ulZY)?#3wGqqT*19LwZ z+w#3&9*bjo!TdupVrM^?_W?;um_cY1e}ze#IUh_OhBcch1k)VH%m&jL$25bfz#wL8 zJpiTQIxxlPtG3Jw zU}&Rr^T0Hkf1zm9CS_q+v#Cj9%QEG&Pcd|U8kk1sCb!n*)FiQ;X|zIM?pLu(ef26C zn*9t+yAFG|9eRpK+gZjAJ+GtfZ2ShM(OJ;mbeg|mWOSXrp_t*YBe7@Wl)E!7J>Q~} zFt&5>8<_S>?CA_7o3{Lxk*` z7^w|`xyb9ZJOPRIUg%_QqU2+v@*J4< z0`_Q3YSVE&YGia=hZRHjE(WH(fsCu>jAO0!SxP>(^HK7`J*yZb5?ZC$Ygro&poCz% zz-Wyp<|1dBZvc~Vv6K0Z((*z}YWWo~L$jSShro;<>160h-moj2%t|odALC^9fw_0A zlNpHQAI@tve2l*KX6f*G0Tl-UdB`8Z~r*Rmc(L$ce(9bl&BJDJ^Jii@1g zAu#pDPNw!kq&be+35GTlBTC*Ljfj)-!g!!$P_U4pnWSAiTIQgVLBT2+0JUkE50wm! zr~~QS4#%cthEhVXU5cN~WcZMGT85q-(smhssbnTA8B{A|)YONRuxUFtDVb5kalSa1 zcUq=d$y|OEnLCsW8jP|tz!=hY)+(9NEQ3MVq{2oIE14^gBGaQ}&=e6@ay!3PGH9GB zWezDBG}n|e120A(HZ<3iGG{3nG*`&D>y%e1CnMO>@Ee%+1GGO{AJ^W-I9AD}0JO ziYYYA8;U70%v*{Pf}r^4K#80wY6+@=`ngTllVLp@HI`xQg|OPKE{hI*4QJ&K{eBg{*Rp`Iel zUd2$q5axhls22!xSTUC6Rm>?=47_RPA{TSDVYHp=T+A{Tv%$r@=wjYB48@Mc-s>8x zmMn@-&p@gc-W)OxhTw=qndYU+ik;J|<77zdMi;Zl#oXm$e&S+YbTR4FaCpFjY#iY?t&6_Ug%U#TP7c3Dz3C+v=JU4P$$hR%vbZH&@21PE$5D;tlD0qG8fXZ&5#_56@E@PA+UGZ^No}Pz(MBy zscUG%M@>Oz{h|$~NKi^sMYW-(mOyLJS2eBnlO(CgU+u3AwJh^h)xy%EPhx6PKJ}*j zPgFwGGvxzr%2-@-a`XIUL4463TILV5ca&Gm&+(xn`|E@&uNpTo)Zz0jsqrTyf!YY= z&`;+!sO9?TR~^nPY{j?`YVrqaYlCfVetd3^-Wfv02NwE@wN811&sSCBubM_pqcG8S z;Szjz7HTbTK>b26H!s-K(io@>`sW8~7ngr##v-53H>07f<+_@zq=vV>tqg$Y?TjWSkMo#*%YYI6L@9;&P`&YVsK2~tzV2xW9O`4*!hzOsdy6HP zg&3o2s`*<;`hjsmBrA?K)6IGs= zsPfc_LQwqooDR#$5>@U_RJl7*)$*mL!&V|OD>03;Ql}9?snR$rSsG`#(>N<3jkn%< zt8-vE&T})arT*nl>?)1_%&9{wO;o4@$qd9USbHu(sj!dicA=XA=I~*fCW#E4bZw2e zlXXHX;gdFrCgUB^Bm~<@Ob95`Q77ZgRLnFw6Ma16h}ZZ` zxZLC^`y$cK9ha~4Kkj^qCKk0gAHv>@McP_{q^88Y15+ptc%<+va`UUJW|Y_X{Iko; zrub^AlP6uB`|T{|=ITu9)1?x@1ZmNXX$_bp<@i;8N{YtRlAj)Y!rn3_FLxYAVW%fI zXG$>4pZu4#sTSb~%vXUEn#c=~TcD`C&DYctUgpw7HYdX;kc-dFFK?sRs)LQFn_!(w zpn&}i`5F?Esc5>EO2~48pya2yF4%G10+*HCadG)^hjU>lmkdB3cL3oFef!!? zjOey-9EswK$^y*P9RtU>Tzk;{q}PO$z)x!96O?)4b>;CD`iZe(E=*5crNJc5VTJZ3 zT&usap)FiqjT%L#F4W_DQK55u&ndL)_v2skCte#LUy+^|E66{t&ymw{I;RD$b61HP z&h^=3dY~ydv4C&8xK1ptGtbfP(xkj8;!8Z;B%aR_Ph9!e!B?C+F?lNGl;XBjNj4|F zqgkbucZ0<*?v?utTq_`6L=3iz6SqEksK>K$GFjclr(+>O-E~^>uesqlC?Ew;BmLKDHYdE zoKWHSx3$mrms7g!*yC=&IQZOLqzc#8OOoF^fB|}bQ_FWtCN3+d+XU{b@8nX>k@$Fq z!4#uwZmQUhCyvCkOaXa6rh7Feuk#Z`inWBVA$8F4)nKB%+&pLL`*4Tr1Z1%YuAM1^ z?plnG?f4?YQ?!KgGVvXs!31k1D)rYj<3xWvrQuGX!(>C^g-k*XI9s$jL4nHgmmgP3 za8)rO$yG&SHJq3k9-?wSmHWSkgsqO^C^ye8oTU2!+)*A9rhL2NIGTpJvBGDr#Am$p z)DL63eojSDJ%D1E@XUur9S<0l42=Nljw;;WGN~Va$bouTK?m|gnUFk7W==n_;*0O}7It*_ z@mf(^s2Oh(gqQi-7SY3pnaxWZn(O@4iz*iRX9O4G&J-7(lb+e!Y6sjny`U^OzkOlR ztYGVWdO1Z(dOB`;(t9$2`3*~QX~MQZzfwhS(%`j%1)*e;n0NVW8v}T!;;3R|u&v>v zNao@_j}|;%LM{?aPFK}imZ$FGRELWjLT&s|DZd;Kr1WDvyzhbN!u748rT)fX^TKew zKiJwDYNgj_P`uNNtApWiL-WEmehN{IM@7Nr8hTxbpTp6utl1593xi=b@=jB=!Lt%+ z5aneeTODr1TSEzN5#i+@yd0K0PTn>O;Wd_EpsBnTZz$o8p-w|}sIg7XcGcm0tYOet zp5#tfGCMVXycy!7w?Y!DzOB6}NcqbxL=NKmlAJ-NCA9b?51d>gNgq4q7N`jH-9CAK zS)>-In3StdjSaPneM;mwCl1Vs`}8{L7V^hirl!$9ql`O1>%pmc3q9meZec5j|;0;wri*9YoCODBaI zL#>Ira(|??F4$UAk8*FuYhogz8)TEDmx@IaqS6tlHkFsBAK{v2LYF3q*);`eZkqG@ zFLJ%3&+jx&O)C`6&S^mvjf`A5Toy{8r2u5e;|IE>eS`Gk|ur$qwEF^|xXV?xFc6^k%eub!wzj`-7>oZ}`oP|u-M zl$5tk3oa`QEp3+OYm!|=9D>xSZTNzjEy-9JmS|8o{xNBAMQCBDJv=5f)+<|XL2iCd zNnSy5j@OI-*kqrZlT%n&==J91Fpcq4tZ=GeSLbLNdL zqA#87jb4=B0=cv3b0=&_p2c#xMf5S6*@gn`g`8K((RWZHS3;jfnT3Y+g}Z`aS^Pav{FMSEYc@=q117^6BF`v(*4KUSwH6R&u8N^7H7EJG0Rz(DZfZ zjzqbFoVao(A7FbS_ljcEp~vN15MOco!0*H7d8es*AE@QfN&(F_9*Dkr8?EF_`ik=6 z%FheA4O<@m#C?8Ba&sZ~m`koGuHGo#ddN99u~!mTe$vg?=R3Bq^p2-0R!ZPN_&tF_MJkBr~W_(Xx_0{7o>JkV;yW zdrNp6SV`%jG#vL|%*!4fJ!M+OQC^%WPH_fX!!l^GVI>1zzScv)K7cgw>SMF2 zyW6+ZN|;r>zP&_ZbuDVl(R?Y-*rW`sxHO#dLv1EH7mF5QwM^d*lKpU(7VFwxH z`{u3Dm%0wlwJVs~pI)jg#%&O_#3p{xRcy7V$FBYG7tvxZ(Y1Z zHqGd+XJl0R z!;alF5TzC0Ztmear#7Cn)zKIBXmu~0bj(&a83k@vS(sMOy8gHdpBV&iDU3;?0nYa|4=}KsS zs(F{8AazS2>$-U)wm)45_e4laln?YEGSf4#y0`QUZl8DGi7?YUN^ziiNB<4Z==#S{ zSNO?$lnC2!|8U&~`%B}bhoH{UKBbFvZX=B(EqI90#v*B7O(iZ@3&!x&tnzKxF6ul1_jE4YoW@^xmejG`u}*3eX` zfl*Uct&W?LUb6f3cd1opMpi)v<)UdES;%-hvZY#F-w#k?s-4Y4C?vUkuLq5IFn-En zgR4xlb+s@h;Aj#(s#(VmJk(iy`~Ja^9K;@RNt(;DhfrR43`KsjD9DrTMT|&|8IX}? zltABW$XVx#PAfdTa~ri1E1c=f9Ym-dkoo?3JXf(74li^r94@PfOA6J(;gW21u&=KT zG120U+Fs1Hinyby?xBUs)fpX$r}+B@U|@ZL<_mWmr23CrnY{`GR%Y);H*>Abj^$k& zZ#(IZrXh4XQI&l<$)j+5_)AUCx5{pJz8-20!(0+nsH!HY1(BdBXBeQEiHghKyye!!jo;~WBuJ<#SRCV*;BS1PC>4`r&kYHvqxVycdGBXl%5j3?Z>x(;@5(|QV#p-uJ7<3BrS zm9%IOtH^He_HERaDr*Mg`eZLx*d}g7H{v|mUAY&{(X<#05?LaIoO1H7Kky#x-m!uk zF||{XKqNR)nx~kJhRl>?Ri;O+9uN+VXUg}w!`SCpLN!ZEztiO4+5K!te9^T zuhZH-7!h)O{h2%>9PArU7PubvazMj{t0<7D)jUd+AeG}zH!XE17h`t^)Z7fxVb|g`( zGf{BWJV?#Lw}GmXI*Fqy#e%5>IpmJC@GpGcS@{wybXTr(gunt$J((*X=a3B?H61@p z$G&ylmAiD7yW4kR_}GHQq6tl?(c9wC%Rrjg z98Q2exN4N-o~+p!(Z8&U%+ux6xs4!7vx|qyo@92aj1e06*tCim%lsk^iGZSwM&@Y4 z(MT1b2t*?_nl543%L$-ryX~CZp4c`LE!jr8nd^Jr-4o?t(-2ICx;U}8c=-i1lLWtS zWq$rg2wHy1HJO*er~TcJk(_UfRD+#N&H`#$Jk>;5xod`__vo{uo+NfxZcvF>r~dAf#C!n;c1mu;qGWZoai8BP z6XVEyHdjqUiJ93-8h8MB>Ca}4OD9Q3^L`v5XqA}e@_^6H8&)hX8JfhPf!enTY#B55 z*_q)Pm2VSP{idY$`nJFf51MuK*OR>qNg-k+-rJQt_&TSM)+_fEN&v|!3B8qXD zn4t(-(v?)P99RrOPSd*KOEK$te|(Sn9=EUm)9*yl*;afvOiI)Z}WSTkJS9j$q zwOal2xC7eD;nc+SZEEU(Z^LSL_iAiMhIA;@d*A5xQfd!!TjZ!-!A0O}OUZWU7H_pUk85 z(1+A)iupFCyw>1yFsXsAx}C@-aS~At^+crxCD!--1Jond^*xHed;vn!S813sP2e

    sr?oOh*TY~IuXnxQ(8 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

    U=*Mi2BXO_6u?Kw9L02oJH9FdTvzbdn%69Abnm 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 InDpKM0|S+<*#H0l literal 0 HcmV?d00001