Release 0.14

Include/Core/Classes/Animation.hpp

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

Include/Core/Classes/AttackOption.hpp

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

Include/Core/Classes/Cache.hpp

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

Include/Core/Classes/CacheableNode.hpp

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

Include/Core/Classes/Character.hpp

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

Include/Core/Classes/ChatLineBuffer.hpp

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

Include/Core/Classes/ClanMember.hpp

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

Include/Core/Classes/ClanMemberList.hpp

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

Include/Core/Classes/DecorativeObject.hpp

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

Include/Core/Classes/Deque.hpp

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

Include/Core/Classes/DynamicObject.hpp

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

Include/Core/Classes/ExchangeOffer.hpp

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

Include/Core/Classes/Frame.hpp

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

Include/Core/Classes/FrameMap.hpp

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

Include/Core/Classes/Frames.hpp

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

Include/Core/Classes/Friend.hpp

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

Include/Core/Classes/FriendList.hpp

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

Include/Core/Classes/GameObject.hpp

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

Include/Core/Classes/GameShell.hpp

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

Include/Core/Classes/GraphicsObject.hpp

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

Include/Core/Classes/GroundItem.hpp

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

Include/Core/Classes/GroundObject.hpp

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

Include/Core/Classes/HashTable.hpp

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

Include/Core/Classes/Ignore.hpp

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

Include/Core/Classes/IgnoreList.hpp

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

Include/Core/Classes/ItemContainer.hpp

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

Include/Core/Classes/ItemInfo.hpp

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

Include/Core/Classes/LinkedList.hpp

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

Include/Core/Classes/MessageNode.hpp

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

Include/Core/Classes/Model.hpp

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

Include/Core/Classes/NPC.hpp

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

Include/Core/Classes/NPCInfo.hpp

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

Include/Core/Classes/NamePair.hpp

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

Include/Core/Classes/Nameable.hpp

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

Include/Core/Classes/NameableContainer.hpp

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

Include/Core/Classes/Node.hpp

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

Include/Core/Classes/ObjectInfo.hpp

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

Include/Core/Classes/Player.hpp

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

Include/Core/Classes/PlayerInfo.hpp

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

Include/Core/Classes/PlayerManager.hpp

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

Include/Core/Classes/Preferences.hpp

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

Include/Core/Classes/Queue.hpp

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

Include/Core/Classes/Region.hpp

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

Include/Core/Classes/Renderable.hpp

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

Include/Core/Classes/SceneTile.hpp

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

Include/Core/Classes/SpotAnimation.hpp

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

Include/Core/Classes/Sprite.hpp

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

Include/Core/Classes/Talkable.hpp

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

Include/Core/Classes/Varbit.hpp

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

Include/Core/Classes/WallObject.hpp

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

Include/Core/Classes/Widget.hpp

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

Include/Core/Classes/WidgetNode.hpp

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

Include/Core/Classes/World.hpp

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

Include/Core/Internal.hpp

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

Include/Game/Core.hpp

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

Include/Game/Interactable/GameObject.hpp

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

Include/Game/Interfaces/Chat.hpp

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

Include/Game/Interfaces/GameTabs/Clan.hpp

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

Include/Game/Interfaces/GameTabs/Friends.hpp

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

Include/Game/Interfaces/GameTabs/Ignores.hpp

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

Include/Game/Interfaces/GameTabs/Logout.hpp

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

Include/Game/Interfaces/Login.hpp

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

Include/Game/Interfaces/Mainscreen.hpp

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

Include/Game/Models/GroundItems.hpp

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

Include/Game/Models/NPCs.hpp

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

Include/Game/Models/Players.hpp

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

Include/Game/Models/SceneObjects.hpp

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

Include/Game/Tools/Interact.hpp

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

Include/Game/Tools/Widgets.hpp

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

Include/Game/Tools/Worlds.hpp

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