Release 1.17

Include/Core/Classes/AbstractBufferProvider.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class AbstractBufferProvider : public Object
     {
         public:
-            AbstractBufferProvider();
             AbstractBufferProvider(const void* Obj);
-            AbstractBufferProvider(const AbstractBufferProvider& A);
+
+            AbstractBufferProvider() = default;
+            AbstractBufferProvider(AbstractBufferProvider&& Obj) = default;
+            AbstractBufferProvider(const AbstractBufferProvider& Obj) = default;
+            AbstractBufferProvider& operator=(AbstractBufferProvider&& Obj) = default;
+            AbstractBufferProvider& operator=(const AbstractBufferProvider& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::int32_t> GetPixels() const;

Include/Core/Classes/AbstractByteBuffer.hpp

@@ -9,9 +9,14 @@ namespace Internal
     class AbstractByteBuffer : public Object
     {
         public:
-            AbstractByteBuffer();
             AbstractByteBuffer(const void* Obj);
-            AbstractByteBuffer(const AbstractByteBuffer& A);
+
+            AbstractByteBuffer() = default;
+            AbstractByteBuffer(AbstractByteBuffer&& Obj) = default;
+            AbstractByteBuffer(const AbstractByteBuffer& Obj) = default;
+            AbstractByteBuffer& operator=(AbstractByteBuffer&& Obj) = default;
+            AbstractByteBuffer& operator=(const AbstractByteBuffer& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/Animation.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class Animation : public CacheableNode
     {
         public:
-            Animation();
             Animation(const void* Obj);
-            Animation(const Animation& A);
+
+            Animation() = default;
+            Animation(Animation&& Obj) = default;
+            Animation(const Animation& Obj) = default;
+            Animation& operator=(Animation&& Obj) = default;
+            Animation& operator=(const Animation& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::int32_t> GetFrameIDs() const;

Include/Core/Classes/AttackOption.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class AttackOption : public Object
     {
         public:
-            AttackOption();
             AttackOption(const void* Obj);
-            AttackOption(const AttackOption& A);
+
+            AttackOption() = default;
+            AttackOption(AttackOption&& Obj) = default;
+            AttackOption(const AttackOption& Obj) = default;
+            AttackOption& operator=(AttackOption&& Obj) = default;
+            AttackOption& operator=(const AttackOption& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetType() const;

Include/Core/Classes/Cache.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class Cache : public Object
     {
         public:
-            Cache();
             Cache(const void* Obj);
-            Cache(const Cache& C);
+
+            Cache() = default;
+            Cache(Cache&& Obj) = default;
+            Cache(const Cache& Obj) = default;
+            Cache& operator=(Cache&& Obj) = default;
+            Cache& operator=(const Cache& Obj) = default;
+
             static Class GetClass();
 
             HashTable GetHashTable() const;

Include/Core/Classes/CacheableNode.hpp

@@ -9,9 +9,14 @@ namespace Internal
     class CacheableNode : public Node
     {
         public:
-            CacheableNode();
             CacheableNode(const void* Obj);
-            CacheableNode(const CacheableNode& C);
+
+            CacheableNode() = default;
+            CacheableNode(CacheableNode&& Obj) = default;
+            CacheableNode(const CacheableNode& Obj) = default;
+            CacheableNode& operator=(CacheableNode&& Obj) = default;
+            CacheableNode& operator=(const CacheableNode& Obj) = default;
+
             static Class GetClass();
 
             CacheableNode GetNext() const;

Include/Core/Classes/Character.hpp

@@ -13,9 +13,14 @@ namespace Internal
     class Character : public Renderable
     {
         public:
-            Character();
             Character(const void* Obj);
-            Character(const Character& C);
+
+            Character() = default;
+            Character(Character&& Obj) = default;
+            Character(const Character& Obj) = default;
+            Character& operator=(Character&& Obj) = default;
+            Character& operator=(const Character& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAngle() const;

Include/Core/Classes/ChatLineBuffer.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class ChatLineBuffer : public Object
     {
         public:
-            ChatLineBuffer();
             ChatLineBuffer(const void* Obj);
-            ChatLineBuffer(const ChatLineBuffer& C);
+
+            ChatLineBuffer() = default;
+            ChatLineBuffer(ChatLineBuffer&& Obj) = default;
+            ChatLineBuffer(const ChatLineBuffer& Obj) = default;
+            ChatLineBuffer& operator=(ChatLineBuffer&& Obj) = default;
+            ChatLineBuffer& operator=(const ChatLineBuffer& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetLength() const;

Include/Core/Classes/ClanMember.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class ClanMember : public Talkable
     {
         public:
-            ClanMember();
             ClanMember(const void* Obj);
-            ClanMember(const ClanMember& C);
+
+            ClanMember() = default;
+            ClanMember(ClanMember&& Obj) = default;
+            ClanMember(const ClanMember& Obj) = default;
+            ClanMember& operator=(ClanMember&& Obj) = default;
+            ClanMember& operator=(const ClanMember& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/ClanMemberList.hpp

@@ -9,9 +9,9 @@ namespace Internal
     class ClanMemberList : public NameableContainer
     {
         public:
-            ClanMemberList();
             ClanMemberList(const void* Obj);
-            ClanMemberList(const ClanMemberList& C);
+
+
             static Class GetClass();
 
     };

Include/Core/Classes/CollisionData.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class CollisionData : public Object
     {
         public:
-            CollisionData();
             CollisionData(const void* Obj);
-            CollisionData(const CollisionData& C);
+
+            CollisionData() = default;
+            CollisionData(CollisionData&& Obj) = default;
+            CollisionData(const CollisionData& Obj) = default;
+            CollisionData& operator=(CollisionData&& Obj) = default;
+            CollisionData& operator=(const CollisionData& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::vector<std::int32_t>> GetFlags() const;

Include/Core/Classes/CombatInfo.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class CombatInfo : public Node
     {
         public:
-            CombatInfo();
             CombatInfo(const void* Obj);
-            CombatInfo(const CombatInfo& C);
+
+            CombatInfo() = default;
+            CombatInfo(CombatInfo&& Obj) = default;
+            CombatInfo(const CombatInfo& Obj) = default;
+            CombatInfo& operator=(CombatInfo&& Obj) = default;
+            CombatInfo& operator=(const CombatInfo& Obj) = default;
+
             static Class GetClass();
 
             LinkedList GetHealthBar() const;

Include/Core/Classes/DecorativeObject.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class DecorativeObject : public Object
     {
         public:
-            DecorativeObject();
             DecorativeObject(const void* Obj);
-            DecorativeObject(const DecorativeObject& D);
+
+            DecorativeObject() = default;
+            DecorativeObject(DecorativeObject&& Obj) = default;
+            DecorativeObject(const DecorativeObject& Obj) = default;
+            DecorativeObject& operator=(DecorativeObject&& Obj) = default;
+            DecorativeObject& operator=(const DecorativeObject& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAngle() const;

Include/Core/Classes/Deque.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Deque : public Object
     {
         public:
-            Deque();
             Deque(const void* Obj);
-            Deque(const Deque& D);
+
+            Deque() = default;
+            Deque(Deque&& Obj) = default;
+            Deque(const Deque& Obj) = default;
+            Deque& operator=(Deque&& Obj) = default;
+            Deque& operator=(const Deque& Obj) = default;
+
             static Class GetClass();
 
             Node GetHead() const;

Include/Core/Classes/DirectByteBuffer.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class DirectByteBuffer : public AbstractByteBuffer
     {
         public:
-            DirectByteBuffer();
             DirectByteBuffer(const void* Obj);
-            DirectByteBuffer(const DirectByteBuffer& D);
+
+            DirectByteBuffer() = default;
+            DirectByteBuffer(DirectByteBuffer&& Obj) = default;
+            DirectByteBuffer(const DirectByteBuffer& Obj) = default;
+            DirectByteBuffer& operator=(DirectByteBuffer&& Obj) = default;
+            DirectByteBuffer& operator=(const DirectByteBuffer& Obj) = default;
+
             static Class GetClass();
 
             ByteBuffer GetBuffer() const;

Include/Core/Classes/DynamicObject.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class DynamicObject : public Renderable
     {
         public:
-            DynamicObject();
             DynamicObject(const void* Obj);
-            DynamicObject(const DynamicObject& D);
+
+            DynamicObject() = default;
+            DynamicObject(DynamicObject&& Obj) = default;
+            DynamicObject(const DynamicObject& Obj) = default;
+            DynamicObject& operator=(DynamicObject&& Obj) = default;
+            DynamicObject& operator=(const DynamicObject& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetID() const;

Include/Core/Classes/ExchangeOffer.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class ExchangeOffer : public Object
     {
         public:
-            ExchangeOffer();
             ExchangeOffer(const void* Obj);
-            ExchangeOffer(const ExchangeOffer& E);
+
+            ExchangeOffer() = default;
+            ExchangeOffer(ExchangeOffer&& Obj) = default;
+            ExchangeOffer(const ExchangeOffer& Obj) = default;
+            ExchangeOffer& operator=(ExchangeOffer&& Obj) = default;
+            ExchangeOffer& operator=(const ExchangeOffer& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAmountTraded() const;

Include/Core/Classes/Font.hpp

@@ -9,9 +9,14 @@ namespace Internal
     class Font : public FontFamily
     {
         public:
-            Font();
             Font(const void* Obj);
-            Font(const Font& F);
+
+            Font() = default;
+            Font(Font&& Obj) = default;
+            Font(const Font& Obj) = default;
+            Font& operator=(Font&& Obj) = default;
+            Font& operator=(const Font& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/FontFamily.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class FontFamily : public Rasterizer2D
     {
         public:
-            FontFamily();
             FontFamily(const void* Obj);
-            FontFamily(const FontFamily& F);
+
+            FontFamily() = default;
+            FontFamily(FontFamily&& Obj) = default;
+            FontFamily(const FontFamily& Obj) = default;
+            FontFamily& operator=(FontFamily&& Obj) = default;
+            FontFamily& operator=(const FontFamily& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::int32_t> GetGlyphHeightOffsets() const;

Include/Core/Classes/FontName.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class FontName : public Object
     {
         public:
-            FontName();
             FontName(const void* Obj);
-            FontName(const FontName& F);
+
+            FontName() = default;
+            FontName(FontName&& Obj) = default;
+            FontName(const FontName& Obj) = default;
+            FontName& operator=(FontName&& Obj) = default;
+            FontName& operator=(const FontName& Obj) = default;
+
             static Class GetClass();
 
             std::string GetName() const;

Include/Core/Classes/Fonts.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Fonts : public Object
     {
         public:
-            Fonts();
             Fonts(const void* Obj);
-            Fonts(const Fonts& F);
+
+            Fonts() = default;
+            Fonts(Fonts&& Obj) = default;
+            Fonts(const Fonts& Obj) = default;
+            Fonts& operator=(Fonts&& Obj) = default;
+            Fonts& operator=(const Fonts& Obj) = default;
+
             static Class GetClass();
 
             Map GetFontMap() const;

Include/Core/Classes/Frame.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class Frame : public Object
     {
         public:
-            Frame();
             Frame(const void* Obj);
-            Frame(const Frame& F);
+
+            Frame() = default;
+            Frame(Frame&& Obj) = default;
+            Frame(const Frame& Obj) = default;
+            Frame& operator=(Frame&& Obj) = default;
+            Frame& operator=(const Frame& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::int32_t> GetIndices() const;

Include/Core/Classes/FrameMap.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class FrameMap : public Node
     {
         public:
-            FrameMap();
             FrameMap(const void* Obj);
-            FrameMap(const FrameMap& F);
+
+            FrameMap() = default;
+            FrameMap(FrameMap&& Obj) = default;
+            FrameMap(const FrameMap& Obj) = default;
+            FrameMap& operator=(FrameMap&& Obj) = default;
+            FrameMap& operator=(const FrameMap& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::vector<std::int32_t>> GetList() const;

Include/Core/Classes/Frames.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class Frames : public CacheableNode
     {
         public:
-            Frames();
             Frames(const void* Obj);
-            Frames(const Frames& F);
+
+            Frames() = default;
+            Frames(Frames&& Obj) = default;
+            Frames(const Frames& Obj) = default;
+            Frames& operator=(Frames&& Obj) = default;
+            Frames& operator=(const Frames& Obj) = default;
+
             static Class GetClass();
 
             std::vector<Frame> GetSkeletons() const;

Include/Core/Classes/Friend.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Friend : public Talkable
     {
         public:
-            Friend();
             Friend(const void* Obj);
-            Friend(const Friend& F);
+
+            Friend() = default;
+            Friend(Friend&& Obj) = default;
+            Friend(const Friend& Obj) = default;
+            Friend& operator=(Friend&& Obj) = default;
+            Friend& operator=(const Friend& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/FriendList.hpp

@@ -9,9 +9,14 @@ namespace Internal
     class FriendList : public NameableContainer
     {
         public:
-            FriendList();
             FriendList(const void* Obj);
-            FriendList(const FriendList& F);
+
+            FriendList() = default;
+            FriendList(FriendList&& Obj) = default;
+            FriendList(const FriendList& Obj) = default;
+            FriendList& operator=(FriendList&& Obj) = default;
+            FriendList& operator=(const FriendList& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/GameObject.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class GameObject : public Object
     {
         public:
-            GameObject();
             GameObject(const void* Obj);
-            GameObject(const GameObject& G);
+
+            GameObject() = default;
+            GameObject(GameObject&& Obj) = default;
+            GameObject(const GameObject& Obj) = default;
+            GameObject& operator=(GameObject&& Obj) = default;
+            GameObject& operator=(const GameObject& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAngle() const;

Include/Core/Classes/GameShell.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class GameShell : public Object
     {
         public:
-            GameShell();
             GameShell(const void* Obj);
-            GameShell(const GameShell& G);
+
+            GameShell() = default;
+            GameShell(GameShell&& Obj) = default;
+            GameShell(const GameShell& Obj) = default;
+            GameShell& operator=(GameShell&& Obj) = default;
+            GameShell& operator=(const GameShell& Obj) = default;
+
             static Class GetClass();
 
             Canvas GetCanvas() const;

Include/Core/Classes/GraphicsObject.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class GraphicsObject : public Renderable
     {
         public:
-            GraphicsObject();
             GraphicsObject(const void* Obj);
-            GraphicsObject(const GraphicsObject& G);
+
+            GraphicsObject() = default;
+            GraphicsObject(GraphicsObject&& Obj) = default;
+            GraphicsObject(const GraphicsObject& Obj) = default;
+            GraphicsObject& operator=(GraphicsObject&& Obj) = default;
+            GraphicsObject& operator=(const GraphicsObject& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAnimationFrame() const;

Include/Core/Classes/GroundItem.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class GroundItem : public Renderable
     {
         public:
-            GroundItem();
             GroundItem(const void* Obj);
-            GroundItem(const GroundItem& G);
+
+            GroundItem() = default;
+            GroundItem(GroundItem&& Obj) = default;
+            GroundItem(const GroundItem& Obj) = default;
+            GroundItem& operator=(GroundItem&& Obj) = default;
+            GroundItem& operator=(const GroundItem& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAmount() const;

Include/Core/Classes/GroundObject.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class GroundObject : public Object
     {
         public:
-            GroundObject();
             GroundObject(const void* Obj);
-            GroundObject(const GroundObject& G);
+
+            GroundObject() = default;
+            GroundObject(GroundObject&& Obj) = default;
+            GroundObject(const GroundObject& Obj) = default;
+            GroundObject& operator=(GroundObject&& Obj) = default;
+            GroundObject& operator=(const GroundObject& Obj) = default;
+
             static Class GetClass();
 
             std::int64_t GetHash() const;

Include/Core/Classes/HashTable.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class HashTable : public Object
     {
         public:
-            HashTable();
             HashTable(const void* Obj);
-            HashTable(const HashTable& H);
+
+            HashTable() = default;
+            HashTable(HashTable&& Obj) = default;
+            HashTable(const HashTable& Obj) = default;
+            HashTable& operator=(HashTable&& Obj) = default;
+            HashTable& operator=(const HashTable& Obj) = default;
+
             static Class GetClass();
 
             std::vector<Node> GetBuckets() const;

Include/Core/Classes/HealthBar.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class HealthBar : public Node
     {
         public:
-            HealthBar();
             HealthBar(const void* Obj);
-            HealthBar(const HealthBar& H);
+
+            HealthBar() = default;
+            HealthBar(HealthBar&& Obj) = default;
+            HealthBar(const HealthBar& Obj) = default;
+            HealthBar& operator=(HealthBar&& Obj) = default;
+            HealthBar& operator=(const HealthBar& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetHealthRatio() const;

Include/Core/Classes/HealthInfo.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class HealthInfo : public CacheableNode
     {
         public:
-            HealthInfo();
             HealthInfo(const void* Obj);
-            HealthInfo(const HealthInfo& H);
+
+            HealthInfo() = default;
+            HealthInfo(HealthInfo&& Obj) = default;
+            HealthInfo(const HealthInfo& Obj) = default;
+            HealthInfo& operator=(HealthInfo&& Obj) = default;
+            HealthInfo& operator=(const HealthInfo& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetScale() const;

Include/Core/Classes/Ignore.hpp

@@ -9,9 +9,14 @@ namespace Internal
     class Ignore : public Nameable
     {
         public:
-            Ignore();
             Ignore(const void* Obj);
-            Ignore(const Ignore& I);
+
+            Ignore() = default;
+            Ignore(Ignore&& Obj) = default;
+            Ignore(const Ignore& Obj) = default;
+            Ignore& operator=(Ignore&& Obj) = default;
+            Ignore& operator=(const Ignore& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/IgnoreList.hpp

@@ -9,9 +9,14 @@ namespace Internal
     class IgnoreList : public NameableContainer
     {
         public:
-            IgnoreList();
             IgnoreList(const void* Obj);
-            IgnoreList(const IgnoreList& I);
+
+            IgnoreList() = default;
+            IgnoreList(IgnoreList&& Obj) = default;
+            IgnoreList(const IgnoreList& Obj) = default;
+            IgnoreList& operator=(IgnoreList&& Obj) = default;
+            IgnoreList& operator=(const IgnoreList& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/IndexableData.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class IndexableData : public Object
     {
         public:
-            IndexableData();
             IndexableData(const void* Obj);
-            IndexableData(const IndexableData& IndexableData);
+
+            IndexableData() = default;
+            IndexableData(IndexableData&& Obj) = default;
+            IndexableData(const IndexableData& Obj) = default;
+            IndexableData& operator=(IndexableData&& Obj) = default;
+            IndexableData& operator=(const IndexableData& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::vector<Object>> GetChildren() const;

Include/Core/Classes/ItemContainer.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class ItemContainer : public Node
     {
         public:
-            ItemContainer();
             ItemContainer(const void* Obj);
-            ItemContainer(const ItemContainer& I);
+
+            ItemContainer() = default;
+            ItemContainer(ItemContainer&& Obj) = default;
+            ItemContainer(const ItemContainer& Obj) = default;
+            ItemContainer& operator=(ItemContainer&& Obj) = default;
+            ItemContainer& operator=(const ItemContainer& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::int32_t> GetItemAmounts() const;

Include/Core/Classes/ItemInfo.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class ItemInfo : public CacheableNode
     {
         public:
-            ItemInfo();
             ItemInfo(const void* Obj);
-            ItemInfo(const ItemInfo& I);
+
+            ItemInfo() = default;
+            ItemInfo(ItemInfo&& Obj) = default;
+            ItemInfo(const ItemInfo& Obj) = default;
+            ItemInfo& operator=(ItemInfo&& Obj) = default;
+            ItemInfo& operator=(const ItemInfo& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::string> GetGroundActions() const;

Include/Core/Classes/LinkedList.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class LinkedList : public Object
     {
         public:
-            LinkedList();
             LinkedList(const void* Obj);
-            LinkedList(const LinkedList& L);
+
+            LinkedList() = default;
+            LinkedList(LinkedList&& Obj) = default;
+            LinkedList(const LinkedList& Obj) = default;
+            LinkedList& operator=(LinkedList&& Obj) = default;
+            LinkedList& operator=(const LinkedList& Obj) = default;
+
             static Class GetClass();
 
             Node GetHead() const;

Include/Core/Classes/MessageNode.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class MessageNode : public CacheableNode
     {
         public:
-            MessageNode();
             MessageNode(const void* Obj);
-            MessageNode(const MessageNode& M);
+
+            MessageNode() = default;
+            MessageNode(MessageNode&& Obj) = default;
+            MessageNode(const MessageNode& Obj) = default;
+            MessageNode& operator=(MessageNode&& Obj) = default;
+            MessageNode& operator=(const MessageNode& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetID() const;

Include/Core/Classes/Model.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class Model : public Renderable
     {
         public:
-            Model();
             Model(const void* Obj);
-            Model(const Model& M);
+
+            Model() = default;
+            Model(Model&& Obj) = default;
+            Model(const Model& Obj) = default;
+            Model& operator=(Model&& Obj) = default;
+            Model& operator=(const Model& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::vector<std::int32_t>> GetFrameMapIndices() const;

Include/Core/Classes/NPC.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class NPC : public Character
     {
         public:
-            NPC();
             NPC(const void* Obj);
-            NPC(const NPC& N);
+
+            NPC() = default;
+            NPC(NPC&& Obj) = default;
+            NPC(const NPC& Obj) = default;
+            NPC& operator=(NPC&& Obj) = default;
+            NPC& operator=(const NPC& Obj) = default;
+
             static Class GetClass();
 
             NPCInfo GetNPCInfo() const;

Include/Core/Classes/NPCInfo.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class NPCInfo : public CacheableNode
     {
         public:
-            NPCInfo();
             NPCInfo(const void* Obj);
-            NPCInfo(const NPCInfo& N);
+
+            NPCInfo() = default;
+            NPCInfo(NPCInfo&& Obj) = default;
+            NPCInfo(const NPCInfo& Obj) = default;
+            NPCInfo& operator=(NPCInfo&& Obj) = default;
+            NPCInfo& operator=(const NPCInfo& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::string> GetActions() const;

Include/Core/Classes/NamePair.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class NamePair : public Object
     {
         public:
-            NamePair();
             NamePair(const void* Obj);
-            NamePair(const NamePair& N);
+
+            NamePair() = default;
+            NamePair(NamePair&& Obj) = default;
+            NamePair(const NamePair& Obj) = default;
+            NamePair& operator=(NamePair&& Obj) = default;
+            NamePair& operator=(const NamePair& Obj) = default;
+
             static Class GetClass();
 
             std::string GetCleanName() const;

Include/Core/Classes/Nameable.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Nameable : public Object
     {
         public:
-            Nameable();
             Nameable(const void* Obj);
-            Nameable(const Nameable& N);
+
+            Nameable() = default;
+            Nameable(Nameable&& Obj) = default;
+            Nameable(const Nameable& Obj) = default;
+            Nameable& operator=(Nameable&& Obj) = default;
+            Nameable& operator=(const Nameable& Obj) = default;
+
             static Class GetClass();
 
             NamePair GetNamePair() const;

Include/Core/Classes/NameableContainer.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class NameableContainer : public Object
     {
         public:
-            NameableContainer();
             NameableContainer(const void* Obj);
-            NameableContainer(const NameableContainer& N);
+
+            NameableContainer() = default;
+            NameableContainer(NameableContainer&& Obj) = default;
+            NameableContainer(const NameableContainer& Obj) = default;
+            NameableContainer& operator=(NameableContainer&& Obj) = default;
+            NameableContainer& operator=(const NameableContainer& Obj) = default;
+
             static Class GetClass();
 
             std::vector<Nameable> GetNameables() const;

Include/Core/Classes/Node.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Node : public Object
     {
         public:
-            Node();
             Node(const void* Obj);
-            Node(const Node& N);
+
+            Node() = default;
+            Node(Node&& Obj) = default;
+            Node(const Node& Obj) = default;
+            Node& operator=(Node&& Obj) = default;
+            Node& operator=(const Node& Obj) = default;
+
             static Class GetClass();
 
             Node GetNext() const;

Include/Core/Classes/ObjectInfo.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class ObjectInfo : public CacheableNode
     {
         public:
-            ObjectInfo();
             ObjectInfo(const void* Obj);
-            ObjectInfo(const ObjectInfo& O);
+
+            ObjectInfo() = default;
+            ObjectInfo(ObjectInfo&& Obj) = default;
+            ObjectInfo(const ObjectInfo& Obj) = default;
+            ObjectInfo& operator=(ObjectInfo&& Obj) = default;
+            ObjectInfo& operator=(const ObjectInfo& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::string> GetActions() const;

Include/Core/Classes/Player.hpp

@@ -14,9 +14,14 @@ namespace Internal
     class Player : public Character
     {
         public:
-            Player();
             Player(const void* Obj);
-            Player(const Player& P);
+
+            Player() = default;
+            Player(Player&& Obj) = default;
+            Player(const Player& Obj) = default;
+            Player& operator=(Player&& Obj) = default;
+            Player& operator=(const Player& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::string> GetActions() const;

Include/Core/Classes/PlayerInfo.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class PlayerInfo : public Object
     {
         public:
-            PlayerInfo();
             PlayerInfo(const void* Obj);
-            PlayerInfo(const PlayerInfo& P);
+
+            PlayerInfo() = default;
+            PlayerInfo(PlayerInfo&& Obj) = default;
+            PlayerInfo(const PlayerInfo& Obj) = default;
+            PlayerInfo& operator=(PlayerInfo&& Obj) = default;
+            PlayerInfo& operator=(const PlayerInfo& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::int32_t> GetEquipment() const;

Include/Core/Classes/PlayerManager.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class PlayerManager : public Object
     {
         public:
-            PlayerManager();
             PlayerManager(const void* Obj);
-            PlayerManager(const PlayerManager& P);
+
+            PlayerManager() = default;
+            PlayerManager(PlayerManager&& Obj) = default;
+            PlayerManager(const PlayerManager& Obj) = default;
+            PlayerManager& operator=(PlayerManager&& Obj) = default;
+            PlayerManager& operator=(const PlayerManager& Obj) = default;
+
             static Class GetClass();
 
             FriendList GetFriendList() const;

Include/Core/Classes/Preferences.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class Preferences : public Object
     {
         public:
-            Preferences();
             Preferences(const void* Obj);
-            Preferences(const Preferences& P);
+
+            Preferences() = default;
+            Preferences(Preferences&& Obj) = default;
+            Preferences(const Preferences& Obj) = default;
+            Preferences& operator=(Preferences&& Obj) = default;
+            Preferences& operator=(const Preferences& Obj) = default;
+
             static Class GetClass();
 
             bool GetHideRoofs() const;

Include/Core/Classes/Projectile.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Projectile : public Renderable
     {
         public:
-            Projectile();
             Projectile(const void* Obj);
-            Projectile(const Projectile& P);
+
+            Projectile() = default;
+            Projectile(Projectile&& Obj) = default;
+            Projectile(const Projectile& Obj) = default;
+            Projectile& operator=(Projectile&& Obj) = default;
+            Projectile& operator=(const Projectile& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAnimationFrame() const;

Include/Core/Classes/Queue.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Queue : public Object
     {
         public:
-            Queue();
             Queue(const void* Obj);
-            Queue(const Queue& Q);
+
+            Queue() = default;
+            Queue(Queue&& Obj) = default;
+            Queue(const Queue& Obj) = default;
+            Queue& operator=(Queue&& Obj) = default;
+            Queue& operator=(const Queue& Obj) = default;
+
             static Class GetClass();
 
             CacheableNode GetHead() const;

Include/Core/Classes/Rasterizer2D.hpp

@@ -9,9 +9,14 @@ namespace Internal
     class Rasterizer2D : public CacheableNode
     {
         public:
-            Rasterizer2D();
             Rasterizer2D(const void* Obj);
-            Rasterizer2D(const Rasterizer2D& R);
+
+            Rasterizer2D() = default;
+            Rasterizer2D(Rasterizer2D&& Obj) = default;
+            Rasterizer2D(const Rasterizer2D& Obj) = default;
+            Rasterizer2D& operator=(Rasterizer2D&& Obj) = default;
+            Rasterizer2D& operator=(const Rasterizer2D& Obj) = default;
+
             static Class GetClass();
 
     };

Include/Core/Classes/Region.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class Region : public Object
     {
         public:
-            Region();
             Region(const void* Obj);
-            Region(const Region& R);
+
+            Region() = default;
+            Region(Region&& Obj) = default;
+            Region(const Region& Obj) = default;
+            Region& operator=(Region&& Obj) = default;
+            Region& operator=(const Region& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetEntityCount() const;

Include/Core/Classes/Renderable.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Renderable : public CacheableNode
     {
         public:
-            Renderable();
             Renderable(const void* Obj);
-            Renderable(const Renderable& R);
+
+            Renderable() = default;
+            Renderable(Renderable&& Obj) = default;
+            Renderable(const Renderable& Obj) = default;
+            Renderable& operator=(Renderable&& Obj) = default;
+            Renderable& operator=(const Renderable& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetModelHeight() const;

Include/Core/Classes/SceneTile.hpp

@@ -15,9 +15,14 @@ namespace Internal
     class SceneTile : public Node
     {
         public:
-            SceneTile();
             SceneTile(const void* Obj);
-            SceneTile(const SceneTile& G);
+
+            SceneTile() = default;
+            SceneTile(SceneTile&& Obj) = default;
+            SceneTile(const SceneTile& Obj) = default;
+            SceneTile& operator=(SceneTile&& Obj) = default;
+            SceneTile& operator=(const SceneTile& Obj) = default;
+
             static Class GetClass();
 
             DecorativeObject GetDecorativeObject() const;

Include/Core/Classes/SpotAnimation.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class SpotAnimation : public CacheableNode
     {
         public:
-            SpotAnimation();
             SpotAnimation(const void* Obj);
-            SpotAnimation(const SpotAnimation& S);
+
+            SpotAnimation() = default;
+            SpotAnimation(SpotAnimation&& Obj) = default;
+            SpotAnimation(const SpotAnimation& Obj) = default;
+            SpotAnimation& operator=(SpotAnimation&& Obj) = default;
+            SpotAnimation& operator=(const SpotAnimation& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAngle() const;

Include/Core/Classes/Sprite.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class Sprite : public Object
     {
         public:
-            Sprite();
             Sprite(const void* Obj);
-            Sprite(const Sprite& S);
+
+            Sprite() = default;
+            Sprite(Sprite&& Obj) = default;
+            Sprite(const Sprite& Obj) = default;
+            Sprite& operator=(Sprite&& Obj) = default;
+            Sprite& operator=(const Sprite& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetHeight() const;

Include/Core/Classes/Talkable.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Talkable : public Nameable
     {
         public:
-            Talkable();
             Talkable(const void* Obj);
-            Talkable(const Talkable& T);
+
+            Talkable() = default;
+            Talkable(Talkable&& Obj) = default;
+            Talkable(const Talkable& Obj) = default;
+            Talkable& operator=(Talkable&& Obj) = default;
+            Talkable& operator=(const Talkable& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetRank() const;

Include/Core/Classes/Varbit.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class Varbit : public CacheableNode
     {
         public:
-            Varbit();
             Varbit(const void* Obj);
-            Varbit(const Varbit& V);
+
+            Varbit() = default;
+            Varbit(Varbit&& Obj) = default;
+            Varbit(const Varbit& Obj) = default;
+            Varbit& operator=(Varbit&& Obj) = default;
+            Varbit& operator=(const Varbit& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetLSB() const;

Include/Core/Classes/WallObject.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class WallObject : public Object
     {
         public:
-            WallObject();
             WallObject(const void* Obj);
-            WallObject(const WallObject& W);
+
+            WallObject() = default;
+            WallObject(WallObject&& Obj) = default;
+            WallObject(const WallObject& Obj) = default;
+            WallObject& operator=(WallObject&& Obj) = default;
+            WallObject& operator=(const WallObject& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetAngle() const;

Include/Core/Classes/Widget.hpp

@@ -12,9 +12,14 @@ namespace Internal
     class Widget : public Node
     {
         public:
-            Widget();
             Widget(const void* Obj);
-            Widget(const Widget& W);
+
+            Widget() = default;
+            Widget(Widget&& Obj) = default;
+            Widget(const Widget& Obj) = default;
+            Widget& operator=(Widget&& Obj) = default;
+            Widget& operator=(const Widget& Obj) = default;
+
             static Class GetClass();
 
             std::vector<std::string> GetActions() const;

Include/Core/Classes/WidgetNode.hpp

@@ -10,9 +10,14 @@ namespace Internal
     class WidgetNode : public Node
     {
         public:
-            WidgetNode();
             WidgetNode(const void* Obj);
-            WidgetNode(const WidgetNode& W);
+
+            WidgetNode() = default;
+            WidgetNode(WidgetNode&& Obj) = default;
+            WidgetNode(const WidgetNode& Obj) = default;
+            WidgetNode& operator=(WidgetNode&& Obj) = default;
+            WidgetNode& operator=(const WidgetNode& Obj) = default;
+
             static Class GetClass();
 
             std::int32_t GetID() const;

Include/Core/Classes/World.hpp

@@ -11,9 +11,14 @@ namespace Internal
     class World : public Object
     {
         public:
-            World();
             World(const void* Obj);
-            World(const World& W);
+
+            World() = default;
+            World(World&& Obj) = default;
+            World(const World& Obj) = default;
+            World& operator=(World&& Obj) = default;
+            World& operator=(const World& Obj) = default;
+
             static Class GetClass();
 
             std::string GetActivity() const;

Include/Core/Debug.hpp

@@ -15,26 +15,25 @@
 #define DEBUG_VERBOSE_FAIL_NOINFO           --Debug::Verbose << __PRETTY_FUNCTION__ << " > Failed" << std::endl;
 #define DEBUG_VERBOSE_FAIL_EOF              --Debug::Verbose << __PRETTY_FUNCTION__ << " > Failed > Reached end of function" << std::endl
 
-class Debug
+namespace Debug
 {
-    public:
+    extern Logger Info;
-        static Logger Info;
+    extern Logger Verbose;
-        static Logger Verbose;
+    extern Logger Warning;
-        static Logger Warning;
+    extern Logger Error;
-        static Logger Error;
+    extern Logger Fatal;
-        static Logger Fatal;
+    extern Logger Internal;
-        static Logger Internal;
+    extern Logger Paint;
-        static Logger Paint;
 
-        static void ShowConsole();
+    void ShowConsole();
-        static void HideConsole();
+    void HideConsole();
-        static void SetVerbose(bool Toggle);
+    void SetVerbose(bool Toggle);
 
-        static void EnableInput();
+    void EnableInput();
-        static void DisableInput();
+    void DisableInput();
 
-        static void Clear();
+    void Clear();
-        static void Screenshot(const std::string& Path);
+    void Screenshot(const std::string& Path);
 };
 
 

Include/Core/JavaClass/ByteBuffer.hpp

@@ -3,17 +3,23 @@
 
 #include "Object.hpp"
 #include <cstdint>
-
+namespace Internal
-class ByteBuffer : public Object
 {
+    class ByteBuffer : public Object
+    {
         public:
-        ByteBuffer();
+            ByteBuffer(const void* Obj);
-        ByteBuffer(void* Obj);
+
-        ByteBuffer(const ByteBuffer& B);
+            ByteBuffer() = default;
+            ByteBuffer(ByteBuffer&& Obj) = default;
+            ByteBuffer(const ByteBuffer& Obj) = default;
+            ByteBuffer& operator=(ByteBuffer&& Obj) = default;
+            ByteBuffer& operator=(const ByteBuffer& Obj) = default;
 
             std::int32_t GetCapacity() const;
             std::int8_t Get(std::int32_t Index) const;
 
-};
+    };
+}
 
 #endif // BYTEBUFFER_HPP_INCLUDED

Include/Core/JavaClass/Canvas.hpp

@@ -4,15 +4,23 @@
 #include <cstdint>
 #include "Object.hpp"
 
-class Canvas : public Object
+namespace Internal
 {
+    class Canvas : public Object
+    {
         public:
-        Canvas();
+            Canvas(const void* Obj);
-        Canvas(void* Obj);
+
-        Canvas(const Canvas& C);
+            Canvas() = default;
+            Canvas(Canvas&& Obj) = default;
+            Canvas(const Canvas& Obj) = default;
+            Canvas& operator=(Canvas&& Obj) = default;
+            Canvas& operator=(const Canvas& Obj) = default;
+
             void DispatchEvent(Object Event) const;
             std::int32_t GetWidth() const;
             std::int32_t GetHeight() const;
-};
+    };
+}
 
 #endif // CANVAS_HPP_INCLUDED

Include/Core/JavaClass/Class.hpp

@@ -3,12 +3,19 @@
 
 #include "Object.hpp"
 
-class Class : public Object
+namespace Internal
 {
+    class Class : public Object
+    {
         public:
-        Class();
             Class(const void* Obj);
-        Class(const Class& C);
+
-};
+            Class() = default;
+            Class(Class&& Obj) = default;
+            Class(const Class& Obj) = default;
+            Class& operator=(Class&& Obj) = default;
+            Class& operator=(const Class& Obj) = default;
+    };
+}
 
 #endif // CLASS_HPP_INCLUDED

Include/Core/JavaClass/FocusEvent.hpp

@@ -4,13 +4,20 @@
 #include <cstdint>
 #include "Object.hpp"
 
-class FocusEvent : public Object
+namespace Internal
 {
+    class FocusEvent : public Object
+    {
         public:
-        FocusEvent();
+            FocusEvent(const void* Object);
-        FocusEvent(void* Object);
-        FocusEvent(const FocusEvent& M);
             FocusEvent(Object Source, std::int32_t ID);
-};
+
+            FocusEvent() = default;
+            FocusEvent(FocusEvent&& Obj) = default;
+            FocusEvent(const FocusEvent& Obj) = default;
+            FocusEvent& operator=(FocusEvent&& Obj) = default;
+            FocusEvent& operator=(const FocusEvent& Obj) = default;
+    };
+}
 
 #endif // FOCUSEVENT_HPP_INCLUDED

Include/Core/JavaClass/Integer.hpp

@@ -4,14 +4,22 @@
 #include <cstdint>
 #include "Object.hpp"
 
-class Integer : public Object
+namespace Internal
 {
+    class Integer : public Object
+    {
         public:
-        Integer();
+            Integer(const void* Obj);
-        Integer(void* Obj);
-        Integer(const Integer& I);
             Integer(std::int32_t Value);
+
+            Integer() = default;
+            Integer(Integer&& Obj) = default;
+            Integer(const Integer& Obj) = default;
+            Integer& operator=(Integer&& Obj) = default;
+            Integer& operator=(const Integer& Obj) = default;
+
             std::int32_t GetIntValue() const;
-};
+    };
+}
 
 #endif // INTEGER_HPP_INCLUDED

Include/Core/JavaClass/KeyEvent.hpp

@@ -4,14 +4,21 @@
 #include <cstdint>
 #include "Object.hpp"
 
-class KeyEvent : public Object
+namespace Internal
 {
+    class KeyEvent : public Object
+    {
         public:
-        KeyEvent();
+            KeyEvent(const void* Obj);
-        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);
-};
+
+            KeyEvent() = default;
+            KeyEvent(KeyEvent&& Obj) = default;
+            KeyEvent(const KeyEvent& Obj) = default;
+            KeyEvent& operator=(KeyEvent&& Obj) = default;
+            KeyEvent& operator=(const KeyEvent& Obj) = default;
+    };
+}
 
 #endif // KEYEVENT_HPP_INCLUDED

Include/Core/JavaClass/LinkedHashMap.hpp

@@ -3,13 +3,21 @@
 
 #include "Object.hpp"
 
-class LinkedHashMap : public Object
+namespace Internal
 {
+    class LinkedHashMap : public Object
+    {
         public:
-        LinkedHashMap();
+            LinkedHashMap(const void* Obj);
-        LinkedHashMap(void* Obj);
+
-        LinkedHashMap(const LinkedHashMap& L);
+            LinkedHashMap() = default;
+            LinkedHashMap(LinkedHashMap&& Obj) = default;
+            LinkedHashMap(const LinkedHashMap& Obj) = default;
+            LinkedHashMap& operator=(LinkedHashMap&& Obj) = default;
+            LinkedHashMap& operator=(const LinkedHashMap& Obj) = default;
+
             Object GetValue(Object Key) const;
-};
+    };
+}
 
 #endif // LINKEDHASHMAP_HPP_INCLUDED

Include/Core/JavaClass/Map.hpp

@@ -5,14 +5,22 @@
 #include "Object.hpp"
 #include "Set.hpp"
 
-class Map : public Object
+namespace Internal
 {
+    class Map : public Object
+    {
         public:
-        Map();
+            Map(const void* Obj);
-        Map(void* Obj);
+
-        Map(const Map& M);
+            Map() = default;
+            Map(Map&& Obj) = default;
+            Map(const Map& Obj) = default;
+            Map& operator=(Map&& Obj) = default;
+            Map& operator=(const Map& Obj) = default;
+
             Object GetValue(Object Key) const;
             Set GetKeySet() const;
-};
+    };
+}
 
 #endif // MAP_HPP_INCLUDED

Include/Core/JavaClass/MouseEvent.hpp

@@ -4,15 +4,22 @@
 #include <cstdint>
 #include "Object.hpp"
 
-class MouseEvent : public Object
+namespace Internal
 {
+    class MouseEvent : public Object
+    {
         public:
-        MouseEvent();
+            MouseEvent(const void* Object);
-        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);
-};
+
+            MouseEvent() = default;
+            MouseEvent(MouseEvent&& Obj) = default;
+            MouseEvent(const MouseEvent& Obj) = default;
+            MouseEvent& operator=(MouseEvent&& Obj) = default;
+            MouseEvent& operator=(const MouseEvent& Obj) = default;
+    };
+}
 
 #endif // MOUSEEVENT_HPP_INCLUDED

Include/Core/JavaClass/MouseWheelEvent.hpp

@@ -4,15 +4,22 @@
 #include <cstdint>
 #include "Object.hpp"
 
-class MouseWheelEvent : public Object
+namespace Internal
 {
+    class MouseWheelEvent : public Object
+    {
         public:
-        MouseWheelEvent();
+            MouseWheelEvent(const void* Object);
-        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);
-};
+
+            MouseWheelEvent() = default;
+            MouseWheelEvent(MouseWheelEvent&& Obj) = default;
+            MouseWheelEvent(const MouseWheelEvent& Obj) = default;
+            MouseWheelEvent& operator=(MouseWheelEvent&& Obj) = default;
+            MouseWheelEvent& operator=(const MouseWheelEvent& Obj) = default;
+    };
+}
 
 #endif // MOUSEWHEELEVENT_HPP_INCLUDED

Include/Core/JavaClass/Object.hpp

@@ -1,25 +1,29 @@
 #ifndef OBJECT_HPP_INCLUDED
 #define OBJECT_HPP_INCLUDED
 
-class Class;
+namespace Internal
-
-class Object
 {
+    class Class;
+    class Object
+    {
         public:
             void* Obj = nullptr;
-        Object();
+
-        Object(const void* Obj);
+            Object(const void* Obj = nullptr);
-        Object(const Object& O);
+            Object(Object&& Obj);
-        Object(Object&& O);
+            Object(const Object& Obj);
-        Object& operator=(const Object& O);
+            Object& operator=(Object&& Obj);
-        Object& operator=(Object&& O);
+            Object& operator=(const Object& Obj);
+
             bool operator==(const Object& O) const;
             bool operator!=(const Object& O) const;
-        bool Equals(Object O) const;
-        bool InstanceOf(Class C) const;
             operator bool() const;
             operator void*() const;
-        ~Object();
+
-};
+            bool Equals(Object O) const;
+            bool InstanceOf(Class C) const;
+            virtual ~Object();
+    };
+}
 
 #endif // OBJECT_HPP_INCLUDED

Include/Core/JavaClass/Set.hpp

@@ -4,13 +4,21 @@
 #include <vector>
 #include "Object.hpp"
 
-class Set : public Object
+namespace Internal
 {
+    class Set : public Object
+    {
         public:
-        Set();
+            Set(const void* Obj);
-        Set(void* Obj);
+
-        Set(const Set& S);
+            Set() = default;
+            Set(Set&& Obj) = default;
+            Set(const Set& Obj) = default;
+            Set& operator=(Set&& Obj) = default;
+            Set& operator=(const Set& Obj) = default;
+
             std::vector<Object> ToArray() const;
-};
+    };
+}
 
 #endif // SET_HPP_INCLUDED

Include/Core/Paint.hpp

@@ -5,34 +5,34 @@
 #include "Types/Convex.hpp"
 #include "Types/Tile.hpp"
 
-struct Pixel
+
+/** @addtogroup Core
+* @{ */
+namespace Paint
 {
+    struct Pixel
+    {
         std::uint8_t Red;
         std::uint8_t Green;
         std::uint8_t Blue;
         std::uint8_t Alpha;
-};
+    };
 
-/** @addtogroup Core
+    std::uint32_t* GetPixels();
-* @{ */
+    void Clear();
-class Paint
+    void DrawDot(const Point& P, double Radius, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-{
+    void DrawPoint(const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-    public:
+    void DrawPoints(const std::vector<Point>& Points, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static std::uint32_t* GetPixels();
+    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 Clear();
+    void DrawLines(const std::vector<Point>& A, const std::vector<Point>& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawDot(const Point& P, double Radius, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
+    void DrawBox(const Box& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawPoint(const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
+    void DrawSquare(const Box& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawPoints(const std::vector<Point>& Points, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
+    void DrawConvex(const Convex& C, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        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);
+    void DrawTile(const Tile& T, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawLines(const std::vector<Point>& A, const std::vector<Point>& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
+    void DrawModel(const std::vector<Point>& Model, 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);
+    void DrawString(const std::string& String, const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawSquare(const Box& B, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
+    void DrawPixels(const std::vector<Pixel> Pixels, std::uint32_t Width, std::uint32_t Height, const Point& P);
-        static void DrawConvex(const Convex& C, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
+    void SwapBuffer();
-        static void DrawTile(const Tile& T, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawModel(const std::vector<Point>& Model, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawString(const std::string& String, const Point& P, std::uint8_t Red, std::uint8_t Green, std::uint8_t Blue, std::uint8_t Alpha);
-        static void DrawPixels(const std::vector<Pixel> Pixels, std::uint32_t Width, std::uint32_t Height, const Point& P);
-        static void SwapBuffer();
 };
 
 /** @} */

Include/Game/Interactable/DecorativeObject.hpp

@@ -18,7 +18,12 @@ namespace Interactable
     {
         public:
             DecorativeObject(const Internal::DecorativeObject& D);
-            DecorativeObject(const DecorativeObject& D);
+
+            DecorativeObject() = default;
+            DecorativeObject(DecorativeObject&& Obj) = default;
+            DecorativeObject(const DecorativeObject& Obj) = default;
+            DecorativeObject& operator=(DecorativeObject&& Obj) = default;
+            DecorativeObject& operator=(const DecorativeObject& Obj) = default;
 
             std::int32_t GetID() const;
             std::string GetName() const;
@@ -44,7 +49,6 @@ namespace Interactable
             bool Interact(const std::string& Option, bool CheckTarget = true) const;
             bool Interact(const std::vector<std::string>& Options, bool CheckTarget = true) const;
 
-            operator Internal::DecorativeObject() const;
     };
 }
 

Include/Game/Interactable/GameObject.hpp

@@ -18,7 +18,12 @@ namespace Interactable
     {
         public:
             GameObject(const Internal::GameObject& G);
-            GameObject(const GameObject& G);
+
+            GameObject() = default;
+            GameObject(GameObject&& Obj) = default;
+            GameObject(const GameObject& Obj) = default;
+            GameObject& operator=(GameObject&& Obj) = default;
+            GameObject& operator=(const GameObject& Obj) = default;
 
             std::int32_t GetID() const;
             std::string GetName() const;
@@ -46,7 +51,6 @@ namespace Interactable
             bool Interact(const std::string& Option, bool CheckTarget = true) const;
             bool Interact(const std::vector<std::string>& Options, bool CheckTarget = true) const;
 
-            operator Internal::GameObject() const;
     };
 }
 

Include/Game/Interactable/GroundItem.hpp

@@ -19,10 +19,14 @@ namespace Interactable
         private:
             Tile LocalTile;
         public:
-            GroundItem();
             GroundItem(const Internal::GroundItem& G);
             GroundItem(const Internal::GroundItem& G, const Tile& LocalTile);
-            GroundItem(const GroundItem& G);
+
+            GroundItem() = default;
+            GroundItem(GroundItem&& Obj) = default;
+            GroundItem(const GroundItem& Obj) = default;
+            GroundItem& operator=(GroundItem&& Obj) = default;
+            GroundItem& operator=(const GroundItem& Obj) = default;
 
             std::string GetName() const;
             Internal::ItemInfo GetInfo() const;
@@ -48,7 +52,6 @@ namespace Interactable
             bool Interact(const std::string& Option, bool CheckTarget = true) const;
             bool Interact(const std::vector<std::string>& Options, bool CheckTarget = true) const;
 
-            operator Internal::GroundItem() const;
     };
 }
 

Include/Game/Interactable/GroundObject.hpp

@@ -18,7 +18,12 @@ namespace Interactable
     {
         public:
             GroundObject(const Internal::GroundObject& G);
-            GroundObject(const GroundObject& G);
+
+            GroundObject() = default;
+            GroundObject(GroundObject&& Obj) = default;
+            GroundObject(const GroundObject& Obj) = default;
+            GroundObject& operator=(GroundObject&& Obj) = default;
+            GroundObject& operator=(const GroundObject& Obj) = default;
 
             std::int32_t GetID() const;
             std::string GetName() const;

Include/Game/Interactable/Item.hpp

@@ -51,7 +51,6 @@ namespace Interactable
             bool Valid() const;
             operator bool() const;
 
-            virtual ~Item();
         private:
             std::int32_t Index;
             std::int32_t ID;

Include/Game/Interactable/NPC.hpp

@@ -18,7 +18,12 @@ namespace Interactable
     {
         public:
             NPC(const Internal::NPC& N);
-            NPC(const NPC& N);
+
+            NPC() = default;
+            NPC(NPC&& Obj) = default;
+            NPC(const NPC& Obj) = default;
+            NPC& operator=(NPC&& Obj) = default;
+            NPC& operator=(const NPC& Obj) = default;
 
             std::int32_t GetID() const;
             std::string GetName() const;
@@ -48,7 +53,6 @@ namespace Interactable
             bool Interact(const std::string& Option, bool CheckTarget = true) const;
             bool Interact(const std::vector<std::string>& Options, bool CheckTarget = true) const;
 
-            operator Internal::NPC() const;
     };
 }
 

Include/Game/Interactable/Player.hpp

@@ -18,7 +18,12 @@ namespace Interactable
     {
         public:
             Player(const Internal::Player& P);
-            Player(const Player& P);
+
+            Player() = default;
+            Player(Player&& Obj) = default;
+            Player(const Player& Obj) = default;
+            Player& operator=(Player&& Obj) = default;
+            Player& operator=(const Player& Obj) = default;
 
             std::string GetName() const;
             Internal::PlayerInfo GetInfo() const;
@@ -47,7 +52,6 @@ namespace Interactable
             bool Interact(const std::string& Option, bool CheckTarget = true) const;
             bool Interact(const std::vector<std::string>& Options, bool CheckTarget = true) const;
 
-            operator Internal::Player() const;
     };
 }
 

Include/Game/Interactable/Projectile.hpp

@@ -13,7 +13,12 @@ namespace Interactable
     {
         public:
             Projectile(const Internal::Projectile& P);
-            Projectile(const Projectile& P);
+
+            Projectile() = default;
+            Projectile(Projectile&& Obj) = default;
+            Projectile(const Projectile& Obj) = default;
+            Projectile& operator=(Projectile&& Obj) = default;
+            Projectile& operator=(const Projectile& Obj) = default;
 
             std::vector<Point> GetModel() const;
             Tile GetTile() const;

Include/Game/Interactable/WallObject.hpp

@@ -18,7 +18,12 @@ namespace Interactable
     {
         public:
             WallObject(const Internal::WallObject& W);
-            WallObject(const WallObject& W);
+
+            WallObject() = default;
+            WallObject(WallObject&& Obj) = default;
+            WallObject(const WallObject& Obj) = default;
+            WallObject& operator=(WallObject&& Obj) = default;
+            WallObject& operator=(const WallObject& Obj) = default;
 
             std::int32_t GetID() const;
             std::string GetName() const;
@@ -44,7 +49,6 @@ namespace Interactable
             bool Interact(const std::string& Option, bool CheckTarget = true) const;
             bool Interact(const std::vector<std::string>& Options, bool CheckTarget = true) const;
 
-            operator Internal::WallObject() const;
     };
 }
 

Include/Game/Interactable/Widget.hpp

@@ -16,7 +16,12 @@ namespace Interactable
     {
         public:
             Widget(const Internal::Widget& W);
-            Widget(const Widget& W);
+
+            Widget() = default;
+            Widget(Widget&& Obj) = default;
+            Widget(const Widget& Obj) = default;
+            Widget& operator=(Widget&& Obj) = default;
+            Widget& operator=(const Widget& Obj) = default;
 
             bool IsHidden() const;
             bool IsVisible() const;
@@ -31,7 +36,6 @@ namespace Interactable
             bool Interact(const std::string& Option) const;
             bool Interact(const std::vector<std::string>& Options) const;
 
-            operator Internal::Widget() const;
     };
 }
 

Include/Game/Interfaces/Bank.hpp

@@ -11,10 +11,8 @@
 /** @addtogroup Interfaces
 * @{
 */
-class Bank
+namespace Bank
 {
-    public:
-
     enum BANK_AMOUNT
     {
         ALL         = -1,
@@ -38,83 +36,83 @@ class Bank
         BANK_OPEN
     } PIN_STEP;
 
-        static bool IsOpen();
+    bool IsOpen();
-        static bool Close(bool AllowEsc = true);
+    bool Close(bool AllowEsc = true);
 
-        static std::vector<std::int32_t> GetItemIDs();
+    std::vector<std::int32_t> GetItemIDs();
-        static std::vector<std::string> GetItemNames();
+    std::vector<std::string> GetItemNames();
-        static std::vector<std::int32_t> GetItemAmounts();
+    std::vector<std::int32_t> GetItemAmounts();
 
-        static std::vector<Interactable::Item> GetItems();
+    std::vector<Interactable::Item> GetItems();
-        static std::vector<Interactable::Item> GetItems(std::int32_t ID);
+    std::vector<Interactable::Item> GetItems(std::int32_t ID);
-        static std::vector<Interactable::Item> GetItems(const std::string& Name);
+    std::vector<Interactable::Item> GetItems(const std::string& Name);
-        static std::vector<Interactable::Item> GetItems(const std::vector<std::int32_t>& IDs);
+    std::vector<Interactable::Item> GetItems(const std::vector<std::int32_t>& IDs);
-        static std::vector<Interactable::Item> GetItems(const std::vector<std::string>& Names);
+    std::vector<Interactable::Item> GetItems(const std::vector<std::string>& Names);
-        static std::vector<Interactable::Item> GetItems(const std::function<bool (const Interactable::Item&)>& Filter);
+    std::vector<Interactable::Item> GetItems(const std::function<bool (const Interactable::Item&)>& Filter);
 
-        static Interactable::Item GetItem(std::int32_t ID);
+    Interactable::Item GetItem(std::int32_t ID);
-        static Interactable::Item GetItem(const std::string& Name);
+    Interactable::Item GetItem(const std::string& Name);
-        static Interactable::Item GetItem(const std::vector<std::int32_t>& IDs);
+    Interactable::Item GetItem(const std::vector<std::int32_t>& IDs);
-        static Interactable::Item GetItem(const std::vector<std::string>& Names);
+    Interactable::Item GetItem(const std::vector<std::string>& Names);
-        static Interactable::Item GetItem(const std::function<bool (const Interactable::Item&)>& Filter);
+    Interactable::Item GetItem(const std::function<bool (const Interactable::Item&)>& Filter);
 
-        static std::int32_t Count(std::int32_t ID);
+    std::int32_t Count(std::int32_t ID);
-        static std::int32_t Count(const std::string& Name);
+    std::int32_t Count(const std::string& Name);
-        static std::int32_t Count(const Interactable::Item& Item);
+    std::int32_t Count(const Interactable::Item& Item);
 
-        static std::int32_t GetIndexOf(std::int32_t ID);
+    std::int32_t GetIndexOf(std::int32_t ID);
-        static std::int32_t GetIndexOf(const std::string& Name);
+    std::int32_t GetIndexOf(const std::string& Name);
 
-        static bool Contains(std::int32_t ID);
+    bool Contains(std::int32_t ID);
-        static bool Contains(const std::string& Name);
+    bool Contains(const std::string& Name);
-        static bool Contains(const Interactable::Item& Item);
+    bool Contains(const Interactable::Item& Item);
-        static bool Contains(const std::vector<std::int32_t>& IDs); // true if all items are found at least once
+    bool Contains(const std::vector<std::int32_t>& IDs); // true if all items are found at least once
-        static bool Contains(const std::vector<std::string>& Names); // true if all items are found at least once
+    bool Contains(const std::vector<std::string>& Names); // true if all items are found at least once
-        static bool Contains(const std::vector<Interactable::Item>& Items);
+    bool Contains(const std::vector<Interactable::Item>& Items);
 
-        static bool ContainsAny(const std::vector<std::int32_t>& IDs);
+    bool ContainsAny(const std::vector<std::int32_t>& IDs);
-        static bool ContainsAny(const std::vector<std::string>& Names);
+    bool ContainsAny(const std::vector<std::string>& Names);
-        static bool ContainsAny(const std::vector<Interactable::Item>& Items);
+    bool ContainsAny(const std::vector<Interactable::Item>& Items);
 
-        static std::int32_t GetCurrentTab();
+    std::int32_t GetCurrentTab();
-        static std::int32_t GetTabOf(std::int32_t ID);
+    std::int32_t GetTabOf(std::int32_t ID);
-        static std::int32_t GetTabOf(const std::string& Name);
+    std::int32_t GetTabOf(const std::string& Name);
-        static std::int32_t GetTabOf(const Interactable::Item& Item);
+    std::int32_t GetTabOf(const Interactable::Item& Item);
-        static bool OpenTab(std::int32_t Tab);
+    bool OpenTab(std::int32_t Tab);
 
-        static bool ScrollTo(std::int32_t ID, bool OpenRespectiveTab = false);
+    bool ScrollTo(std::int32_t ID, bool OpenRespectiveTab = false);
-        static bool ScrollTo(const std::string& Name, bool OpenRespectiveTab = false);
+    bool ScrollTo(const std::string& Name, bool OpenRespectiveTab = false);
-        static bool ScrollTo(const Interactable::Item& Item, bool OpenRespectiveTab = false);
+    bool ScrollTo(const Interactable::Item& Item, bool OpenRespectiveTab = false);
 
     // -1 = all, 0 = all-but-one
-        static bool Withdraw(std::int32_t ID, std::int32_t Amount, bool OpenRespectiveTab = false);
+    bool Withdraw(std::int32_t ID, std::int32_t Amount, bool OpenRespectiveTab = false);
-        static bool Withdraw(const std::string& Name, std::int32_t Amount, bool OpenRespectiveTab = false);
+    bool Withdraw(const std::string& Name, std::int32_t Amount, bool OpenRespectiveTab = false);
-        static bool Withdraw(const Interactable::Item& Item, std::int32_t Amount, bool OpenRespectiveTab = false);
+    bool Withdraw(const Interactable::Item& Item, std::int32_t Amount, bool OpenRespectiveTab = false);
 
     // -1 = all
-        static bool Deposit(std::int32_t ID, std::int32_t Amount);
+    bool Deposit(std::int32_t ID, std::int32_t Amount);
-        static bool Deposit(const std::string& Name, std::int32_t Amount);
+    bool Deposit(const std::string& Name, std::int32_t Amount);
-        static bool Deposit(const Interactable::Item& Item, std::int32_t Amount);
+    bool Deposit(const Interactable::Item& Item, std::int32_t Amount);
 
-        static bool DepositAllExcept(std::int32_t ID, double DepsositAllChance = 0.00); // DepositAllChance = the chance it will click deposit all on the individual item, instead of left clicking if possible. Will deposit all if the current default quantity is not enough to one click it
+    bool DepositAllExcept(std::int32_t ID, double DepsositAllChance = 0.00); // DepositAllChance = the chance it will click deposit all on the individual item, instead of left clicking if possible. Will deposit all if the current default quantity is not enough to one click it
-        static bool DepositAllExcept(const std::string& Name, double DepsositAllChance = 0.00);
+    bool DepositAllExcept(const std::string& Name, double DepsositAllChance = 0.00);
-        static bool DepositAllExcept(const Interactable::Item& Item, double DepsositAllChance = 0.00);
+    bool DepositAllExcept(const Interactable::Item& Item, double DepsositAllChance = 0.00);
-        static bool DepositAllExcept(const std::vector<std::int32_t>& IDs, double DepsositAllChance = 0.00);
+    bool DepositAllExcept(const std::vector<std::int32_t>& IDs, double DepsositAllChance = 0.00);
-        static bool DepositAllExcept(const std::vector<std::string>& Names, double DepsositAllChance = 0.00);
+    bool DepositAllExcept(const std::vector<std::string>& Names, double DepsositAllChance = 0.00);
-        static bool DepositAllExcept(const std::vector<Interactable::Item>& Items, double DepsositAllChance = 0.00);
+    bool DepositAllExcept(const std::vector<Interactable::Item>& Items, double DepsositAllChance = 0.00);
 
-        static bool DepositAll();
+    bool DepositAll();
-        static bool DepositEquipment();
+    bool DepositEquipment();
 
-        static WITHDRAW_MODE GetWithdrawMode();
+    WITHDRAW_MODE GetWithdrawMode();
-        static bool SetWithdrawMode(WITHDRAW_MODE Mode);
+    bool SetWithdrawMode(WITHDRAW_MODE Mode);
 
-        static PIN_STEP GetEnterPinStep();
+    PIN_STEP GetEnterPinStep();
-        static bool IsEnterPinOpen();
+    bool IsEnterPinOpen();
-        static bool EnterPin(bool Terminate = true);
+    bool EnterPin(bool Terminate = true);
 
-        static std::int32_t GetDefaultWithdrawQuantity();
+    std::int32_t GetDefaultWithdrawQuantity();
-        static bool SetDefaultWithdrawQuantity(std::int32_t Amount);
+    bool SetDefaultWithdrawQuantity(std::int32_t Amount);
 };
 
 /** @} */

Include/Game/Interfaces/Chat.hpp

@@ -8,11 +8,8 @@
 
 /** @addtogroup Interfaces
 * @{ */
-class Chat
+namespace Chat
 {
-
-    public:
-
     typedef enum DIALOGUE_STATE
     {
         IDLE,
@@ -51,26 +48,26 @@ class Chat
         UNKNOWN = -1
     } CHAT_TYPE;
 
-        static std::vector<Internal::MessageNode> GetMessages(CHAT_TYPE Type, bool Sort = true);
+    std::vector<Internal::MessageNode> GetMessages(CHAT_TYPE Type, bool Sort = true);
-        static std::vector<Internal::MessageNode> GetMessages(const std::vector<CHAT_TYPE>& Type, bool Sort = true);
+    std::vector<Internal::MessageNode> GetMessages(const std::vector<CHAT_TYPE>& Type, bool Sort = true);
-        static Internal::MessageNode GetLastMessage(CHAT_TYPE Type);
+    Internal::MessageNode GetLastMessage(CHAT_TYPE Type);
 
-        static DIALOGUE_STATE GetDialogueState();
+    DIALOGUE_STATE GetDialogueState();
-        static std::vector<std::string> GetDialogueOptions();
+    std::vector<std::string> GetDialogueOptions();
-        static std::string GetDialogueTitle();
+    std::string GetDialogueTitle();
-        static std::string GetDialogueContent();
+    std::string GetDialogueContent();
 
-        static std::int32_t GetDialogueOptionIndexOf(const std::string& Option);
+    std::int32_t GetDialogueOptionIndexOf(const std::string& Option);
-        static std::int32_t GetDialogueOptionIndexOf(const std::vector<std::string>& Options);
+    std::int32_t GetDialogueOptionIndexOf(const std::vector<std::string>& Options);
 
-        static bool ClickContinue(bool UseKeyboard = false);
+    bool ClickContinue(bool UseKeyboard = false);
-        static bool EnterAmount(std::int32_t Amount);
+    bool EnterAmount(std::int32_t Amount);
 
-        static bool SelectDialogueOption(std::int32_t Index, bool UseKeyboard = false); // Index starts at 0
+    bool SelectDialogueOption(std::int32_t Index, bool UseKeyboard = false); // Index starts at 0
-        static bool SelectDialogueOption(const std::string& Option, bool UseKeyboard = false);
+    bool SelectDialogueOption(const std::string& Option, bool UseKeyboard = false);
-        static bool SelectDialogueOption(const std::vector<std::string>& Options, bool UseKeyboard = false);
+    bool SelectDialogueOption(const std::vector<std::string>& Options, bool UseKeyboard = false);
 
-        static bool WaitDialogueState(std::uint32_t Duration, std::uint32_t Step, Chat::DIALOGUE_STATE State, bool Result = true); // Waits until the current chat state equals State
+    bool WaitDialogueState(std::uint32_t Duration, std::uint32_t Step, Chat::DIALOGUE_STATE State, bool Result = true); // Waits until the current chat state equals State
 };
 
 /** @} */

Include/Game/Interfaces/DepositBox.hpp

@@ -3,15 +3,14 @@
 
 /** @addtogroup Interfaces
 * @{ */
-class DepositBox
+namespace DepositBox
 {
-    public:
+    bool IsOpen();
-        static bool IsOpen();
+    bool Close(bool AllowEsc = true);
-        static bool Close(bool AllowEsc = true);
 
-        static bool DepositAll();
+    bool DepositAll();
-        static bool DepositEquipment();
+    bool DepositEquipment();
-        static bool DepositLoot();
+    bool DepositLoot();
 };
 
 /** @} */

Include/Game/Interfaces/Exchange.hpp

@@ -9,10 +9,8 @@
 
 /** @addtogroup Interfaces
 * @{ */
-class Exchange
+namespace Exchange
 {
-    public:
-
     typedef std::int32_t SLOT;
 
     typedef enum SLOT_STATE
@@ -47,56 +45,56 @@ class Exchange
         BANK
     } COLLECT_METHOD;
 
-        static bool IsOpen();
+    bool IsOpen();
-        static bool Open();
+    bool Open();
-        static bool Close();
+    bool Close();
-        static SLOT_STATE GetSlotState(const Exchange::SLOT Slot);
+    SLOT_STATE GetSlotState(const Exchange::SLOT Slot);
-        static bool SlotOccupied(const Exchange::SLOT Slot);
+    bool SlotOccupied(const Exchange::SLOT Slot);
-        static std::vector<SLOT_STATE> GetAllSlotStates();
+    std::vector<SLOT_STATE> GetAllSlotStates();
-        static bool AllSlotsOccupied();
+    bool AllSlotsOccupied();
-        static std::int32_t GetOfferIndex();
+    std::int32_t GetOfferIndex();
 
-        static SLOT_MODE GetOfferMode();
+    SLOT_MODE GetOfferMode();
-        static std::int32_t GetOfferItemID();
+    std::int32_t GetOfferItemID();
-        static std::string GetOfferItemName();
+    std::string GetOfferItemName();
-        static std::int32_t GetOfferAmount();
+    std::int32_t GetOfferAmount();
-        static std::int32_t GetOfferPrice();
+    std::int32_t GetOfferPrice();
-        static bool IsOfferOpen();
+    bool IsOfferOpen();
-        static bool CloseOffer();
+    bool CloseOffer();
-        static bool IsOffersOpen();
+    bool IsOffersOpen();
-        static bool SlotUsable(const Exchange::SLOT Slot);
+    bool SlotUsable(const Exchange::SLOT Slot);
-        static bool CanCollect();
+    bool CanCollect();
 
-        static bool CollectAll(const bool Inventory = true);
+    bool CollectAll(const bool Inventory = true);
-        static bool Collect(const Exchange::COLLECT_METHOD Method = Exchange::BANK);
+    bool Collect(const Exchange::COLLECT_METHOD Method = Exchange::BANK);
 
-        static bool IsBuyOfferOpen();
+    bool IsBuyOfferOpen();
-        static bool IsSellOfferOpen();
+    bool IsSellOfferOpen();
-        static bool OpenBuyOffer(const Exchange::SLOT Slot = -1);
+    bool OpenBuyOffer(const Exchange::SLOT Slot = -1);
-        static bool OpenSellOffer(const Exchange::SLOT Slot = -1);
+    bool OpenSellOffer(const Exchange::SLOT Slot = -1);
 
-        static Exchange::SLOT GetBuyOffer(std::int32_t ID);
+    Exchange::SLOT GetBuyOffer(std::int32_t ID);
-        static Exchange::SLOT GetBuyOffer(const std::string& Name);
+    Exchange::SLOT GetBuyOffer(const std::string& Name);
-        static Exchange::SLOT GetBuyOffer(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
+    Exchange::SLOT GetBuyOffer(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
-        static std::vector<Exchange::SLOT> GetBuyOffers(std::int32_t ID);
+    std::vector<Exchange::SLOT> GetBuyOffers(std::int32_t ID);
-        static std::vector<Exchange::SLOT> GetBuyOffers(const std::string& Name);
+    std::vector<Exchange::SLOT> GetBuyOffers(const std::string& Name);
-        static std::vector<Exchange::SLOT> GetBuyOffers(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
+    std::vector<Exchange::SLOT> GetBuyOffers(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
 
-        static Exchange::SLOT GetSellOffer(std::int32_t ID);
+    Exchange::SLOT GetSellOffer(std::int32_t ID);
-        static Exchange::SLOT GetSellOffer(const std::string& Name);
+    Exchange::SLOT GetSellOffer(const std::string& Name);
-        static Exchange::SLOT GetSellOffer(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
+    Exchange::SLOT GetSellOffer(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
-        static std::vector<Exchange::SLOT> GetSellOffers(std::int32_t ID);
+    std::vector<Exchange::SLOT> GetSellOffers(std::int32_t ID);
-        static std::vector<Exchange::SLOT> GetSellOffers(const std::string& Name);
+    std::vector<Exchange::SLOT> GetSellOffers(const std::string& Name);
-        static std::vector<Exchange::SLOT> GetSellOffers(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
+    std::vector<Exchange::SLOT> GetSellOffers(const std::function<bool (const Internal::ExchangeOffer&)>& Filter);
 
 
-        static bool SetSellItem(const std::string& Name);
+    bool SetSellItem(const std::string& Name);
-        static bool SetSellItem(std::int32_t ID);
+    bool SetSellItem(std::int32_t ID);
-        static bool SetBuyItem(const std::string& Name);
+    bool SetBuyItem(const std::string& Name);
-        static bool SetOfferAmount(std::uint32_t Amount);
+    bool SetOfferAmount(std::uint32_t Amount);
-        static bool SetOfferPrice(std::uint32_t Price);
+    bool SetOfferPrice(std::uint32_t Price);
-        static bool SetOfferGuidePrice();
+    bool SetOfferGuidePrice();
-        static bool ConfirmOffer();
+    bool ConfirmOffer();
 
 
     typedef enum COLLECT_SLOT
@@ -105,14 +103,13 @@ class Exchange
         TWO
     } COLLECT_SLOT;
 
-        static std::string GetCollectSlotName(Exchange::COLLECT_SLOT Slot);
+    std::string GetCollectSlotName(Exchange::COLLECT_SLOT Slot);
-        static std::int32_t GetCollectSlotID(Exchange::COLLECT_SLOT Slot);
+    std::int32_t GetCollectSlotID(Exchange::COLLECT_SLOT Slot);
-        static std::int32_t GetCollectSlotAmount(Exchange::COLLECT_SLOT Slot);
+    std::int32_t GetCollectSlotAmount(Exchange::COLLECT_SLOT Slot);
 
-        static bool AbortOffer(const Exchange::SLOT Slot = -1);
+    bool AbortOffer(const Exchange::SLOT Slot = -1);
-
-        static bool OpenOffer(const Exchange::SLOT Slot);
 
+    bool OpenOffer(const Exchange::SLOT Slot);
 };
 
 /** @} */

Include/Game/Interfaces/GameTabs/Clan.hpp

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

Include/Game/Interfaces/GameTabs/Combat.hpp

@@ -6,30 +6,29 @@
 
 /** @addtogroup GameTabs
 * @{ */
-class Combat
+namespace Combat
 {
-    public:
+    bool IsOpen();
-        static bool IsOpen();
+    bool Open();
-        static bool Open();
 
-        static std::int32_t GetHealth();
+    std::int32_t GetHealth();
-        static std::int32_t GetMaxHealth();
+    std::int32_t GetMaxHealth();
 
-        static std::int32_t GetSpecialAttack();
+    std::int32_t GetSpecialAttack();
-        static bool IsSpecialAttacking();
+    bool IsSpecialAttacking();
-        static bool ToggleSpecialAttack(bool Toggle);
+    bool ToggleSpecialAttack(bool Toggle);
 
-        static bool IsPoisoned();
+    bool IsPoisoned();
-        static bool HasPoisonImmunity();
+    bool HasPoisonImmunity();
 
-        static bool IsAutoRetaliating();
+    bool IsAutoRetaliating();
-        static bool ToggleAutoRetaliate(bool Toggle);
+    bool ToggleAutoRetaliate(bool Toggle);
 
-        static std::int32_t GetStyleIndex();
+    std::int32_t GetStyleIndex();
-        static std::string GetStyleString();
+    std::string GetStyleString();
 
-        static bool SetStyle(const std::string& Style);
+    bool SetStyle(const std::string& Style);
-        static bool SetStyle(std::int32_t Index);
+    bool SetStyle(std::int32_t Index);
 };
 
 /** @} */

Include/Game/Interfaces/GameTabs/Emotes.hpp

@@ -3,11 +3,10 @@
 
 /** @addtogroup GameTabs
 * @{ */
-class Emotes
+namespace Emotes
 {
-    public:
+    bool IsOpen();
-        static bool IsOpen();
+    bool Open();
-        static bool Open();
 };
 
 /** @} */

Include/Game/Interfaces/GameTabs/Equipment.hpp

@@ -9,9 +9,8 @@
 
 /** @addtogroup GameTabs
 * @{ */
-class Equipment
+namespace Equipment
 {
-    public:
     typedef enum SLOT
     {
         HEAD,
@@ -27,61 +26,61 @@ class Equipment
         AMMO
     } SLOT;
 
-        static bool IsOpen();
+    bool IsOpen();
-        static bool Open();
+    bool Open();
-        static bool IsEmpty();
+    bool IsEmpty();
 
-        static std::vector<int32_t> GetItemIDs();
+    std::vector<int32_t> GetItemIDs();
-        static std::vector<std::string> GetItemNames();
+    std::vector<std::string> GetItemNames();
-        static std::vector<std::int32_t> GetItemAmounts();
+    std::vector<std::int32_t> GetItemAmounts();
 
-        static std::vector<Interactable::Item> GetItems();
+    std::vector<Interactable::Item> GetItems();
-        static std::vector<Interactable::Item> GetItems(std::int32_t ID);
+    std::vector<Interactable::Item> GetItems(std::int32_t ID);
-        static std::vector<Interactable::Item> GetItems(const std::string& Name);
+    std::vector<Interactable::Item> GetItems(const std::string& Name);
-        static std::vector<Interactable::Item> GetItems(const std::vector<SLOT>& Slots);
+    std::vector<Interactable::Item> GetItems(const std::vector<SLOT>& Slots);
-        static std::vector<Interactable::Item> GetItems(const std::vector<std::int32_t>& IDs);
+    std::vector<Interactable::Item> GetItems(const std::vector<std::int32_t>& IDs);
-        static std::vector<Interactable::Item> GetItems(const std::vector<std::string>& Names);
+    std::vector<Interactable::Item> GetItems(const std::vector<std::string>& Names);
-        static std::vector<Interactable::Item> GetItems(const std::function<bool (const Interactable::Item&)>& Filter);
+    std::vector<Interactable::Item> GetItems(const std::function<bool (const Interactable::Item&)>& Filter);
 
-        static Interactable::Item GetItem(SLOT Slot);
+    Interactable::Item GetItem(SLOT Slot);
-        static Interactable::Item GetItem(std::int32_t ID);
+    Interactable::Item GetItem(std::int32_t ID);
-        static Interactable::Item GetItem(const std::string& Name);
+    Interactable::Item GetItem(const std::string& Name);
-        static Interactable::Item GetItem(const std::vector<std::int32_t>& IDs);
+    Interactable::Item GetItem(const std::vector<std::int32_t>& IDs);
-        static Interactable::Item GetItem(const std::vector<std::string>& Names);
+    Interactable::Item GetItem(const std::vector<std::string>& Names);
-        static Interactable::Item GetItem(const std::function<bool (const Interactable::Item&)>& Filter);
+    Interactable::Item GetItem(const std::function<bool (const Interactable::Item&)>& Filter);
 
-        static std::int32_t Count(SLOT Slot);
+    std::int32_t Count(SLOT Slot);
-        static std::int32_t Count(std::int32_t ID);
+    std::int32_t Count(std::int32_t ID);
-        static std::int32_t Count(const std::string& Name);
+    std::int32_t Count(const std::string& Name);
-        static std::int32_t Count(const Interactable::Item& Item);
+    std::int32_t Count(const Interactable::Item& Item);
-        static std::int32_t Count(const std::vector<std::int32_t>& IDs);
+    std::int32_t Count(const std::vector<std::int32_t>& IDs);
-        static std::int32_t Count(const std::vector<std::string>& Names);
+    std::int32_t Count(const std::vector<std::string>& Names);
-        static std::int32_t Count(const std::vector<Interactable::Item>& Items);
+    std::int32_t Count(const std::vector<Interactable::Item>& Items);
 
-        static SLOT GetSlotOf(std::int32_t ID);
+    SLOT GetSlotOf(std::int32_t ID);
-        static SLOT GetSlotOf(const std::string& Name);
+    SLOT GetSlotOf(const std::string& Name);
 
-        static bool Contains(std::int32_t ID);
+    bool Contains(std::int32_t ID);
-        static bool Contains(const std::string& Name);
+    bool Contains(const std::string& Name);
-        static bool Contains(const Interactable::Item& Item);
+    bool Contains(const Interactable::Item& Item);
-        static bool Contains(const std::vector<std::int32_t>& IDs); // true if all items are found at least once
+    bool Contains(const std::vector<std::int32_t>& IDs); // true if all items are found at least once
-        static bool Contains(const std::vector<std::string>& Names); // true if all items are found at least once
+    bool Contains(const std::vector<std::string>& Names); // true if all items are found at least once
-        static bool Contains(const std::vector<Interactable::Item>& Items);
+    bool Contains(const std::vector<Interactable::Item>& Items);
 
-        static bool ContainsAny(const std::vector<std::int32_t>& IDs);
+    bool ContainsAny(const std::vector<std::int32_t>& IDs);
-        static bool ContainsAny(const std::vector<std::string>& Names);
+    bool ContainsAny(const std::vector<std::string>& Names);
-        static bool ContainsAny(const std::vector<Interactable::Item>& Items);
+    bool ContainsAny(const std::vector<Interactable::Item>& Items);
 
-        static bool ContainsOnly(std::int32_t ID);
+    bool ContainsOnly(std::int32_t ID);
-        static bool ContainsOnly(const std::string& Name);
+    bool ContainsOnly(const std::string& Name);
-        static bool ContainsOnly(const Interactable::Item& Item);
+    bool ContainsOnly(const Interactable::Item& Item);
-        static bool ContainsOnly(const std::vector<std::int32_t>& IDs);
+    bool ContainsOnly(const std::vector<std::int32_t>& IDs);
-        static bool ContainsOnly(const std::vector<std::string>& Names);
+    bool ContainsOnly(const std::vector<std::string>& Names);
-        static bool ContainsOnly(const std::vector<Interactable::Item>& Items);
+    bool ContainsOnly(const std::vector<Interactable::Item>& Items);
 
-        static bool Unequip(std::int32_t ID);
+    bool Unequip(std::int32_t ID);
-        static bool Unequip(const std::string& Name);
+    bool Unequip(const std::string& Name);
-        static bool Unequip(const Interactable::Item& Item);
+    bool Unequip(const Interactable::Item& Item);
 };
 
 /** @} */

Include/Game/Interfaces/GameTabs/Friends.hpp

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