Release 0.04

Include/Core/Classes/AttackOption.hpp

@@ -0,0 +1,20 @@
+#ifndef ATTACKOPTION_HPP_INCLUDED
+#define ATTACKOPTION_HPP_INCLUDED
+
+#include "../JavaClass/Object.hpp"
+#include "../JavaClass/Class.hpp"
+#include <cstdint>
+
+class AttackOption : public Object
+{
+    public:
+        AttackOption();
+        AttackOption(const void* Obj);
+        AttackOption(const AttackOption& A);
+        static Class GetClass();
+
+        std::int32_t GetType() const;
+
+};
+
+#endif // ATTACKOPTION_HPP_INCLUDED

Include/Core/Classes/Character.hpp

@@ -19,15 +19,17 @@ class Character : public Renderable
         std::int32_t GetAngle() const;
         std::int32_t GetAnimationDelay() const;
         std::int32_t GetAnimationFrame() const;
-        std::int32_t GetAnimationID() const; // done
+        std::int32_t GetAnimationID() const;
         LinkedList GetCombatInfo() const;
+        std::int32_t GetGraphicsFrame() const;
+        std::int32_t GetGraphicsID() const;
         std::int32_t GetInteractIndex() const;
         std::string GetOverhead() const;
         std::vector<std::int32_t> GetPathX() const;
         std::vector<std::int32_t> GetPathY() const;
-        std::int32_t GetPoseAnimationFrame() const; //done
+        std::int32_t GetPoseAnimationFrame() const;
-        std::int32_t GetPoseAnimationID() const; // done.
+        std::int32_t GetPoseAnimationID() const;
-        std::int32_t GetSubPoseAnimation() const;//
+        std::int32_t GetSubPoseAnimation() const;
         std::int32_t GetX() const;
         std::int32_t GetY() const;
 

Include/Core/Classes/ClanMember.hpp

@@ -1,12 +1,11 @@
 #ifndef CLANMEMBER_HPP_INCLUDED
 #define CLANMEMBER_HPP_INCLUDED
 
-#include "Node.hpp"
+#include "Talkable.hpp"
 #include "../JavaClass/Class.hpp"
-#include <string>
 #include <cstdint>
 
-class ClanMember : public Node
+class ClanMember : public Talkable
 {
     public:
         ClanMember();
@@ -14,10 +13,6 @@ class ClanMember : public Node
         ClanMember(const ClanMember& C);
         static Class GetClass();
 
-        std::string GetName() const;
-        std::int8_t GetRank() const;
-        std::int32_t GetWorld() const;
-
 };
 
 #endif // CLANMEMBER_HPP_INCLUDED

Include/Core/Classes/ClanMemberList.hpp

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

Include/Core/Classes/Friend.hpp

@@ -1,12 +1,11 @@
 #ifndef FRIEND_HPP_INCLUDED
 #define FRIEND_HPP_INCLUDED
 
-#include "../JavaClass/Object.hpp"
+#include "Talkable.hpp"
 #include "../JavaClass/Class.hpp"
-#include <string>
 #include <cstdint>
 
-class Friend : public Object
+class Friend : public Talkable
 {
     public:
         Friend();
@@ -14,11 +13,6 @@ class Friend : public Object
         Friend(const Friend& F);
         static Class GetClass();
 
-        std::string GetName() const;
-        std::string GetPreviousName() const;
-        std::int32_t GetRank() const;
-        std::int32_t GetWorld() const;
-
 };
 
 #endif // FRIEND_HPP_INCLUDED

Include/Core/Classes/FriendList.hpp

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

Include/Core/Classes/Ignore.hpp

@@ -1,11 +1,10 @@
 #ifndef IGNORE_HPP_INCLUDED
 #define IGNORE_HPP_INCLUDED
 
-#include "../JavaClass/Object.hpp"
+#include "Nameable.hpp"
 #include "../JavaClass/Class.hpp"
-#include <string>
 
-class Ignore : public Object
+class Ignore : public Nameable
 {
     public:
         Ignore();
@@ -13,9 +12,6 @@ class Ignore : public Object
         Ignore(const Ignore& I);
         static Class GetClass();
 
-        std::string GetName() const;
-        std::string GetPreviousName() const;
-
 };
 
 #endif // IGNORE_HPP_INCLUDED

Include/Core/Classes/IgnoreList.hpp

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

Include/Core/Classes/NamePair.hpp

@@ -0,0 +1,21 @@
+#ifndef NAMEPAIR_HPP_INCLUDED
+#define NAMEPAIR_HPP_INCLUDED
+
+#include "../JavaClass/Object.hpp"
+#include "../JavaClass/Class.hpp"
+#include <string>
+
+class NamePair : public Object
+{
+    public:
+        NamePair();
+        NamePair(const void* Obj);
+        NamePair(const NamePair& N);
+        static Class GetClass();
+
+        std::string GetCleanName() const;
+        std::string GetName() const;
+
+};
+
+#endif // NAMEPAIR_HPP_INCLUDED

Include/Core/Classes/Nameable.hpp

@@ -0,0 +1,21 @@
+#ifndef NAMEABLE_HPP_INCLUDED
+#define NAMEABLE_HPP_INCLUDED
+
+#include "../JavaClass/Object.hpp"
+#include "../JavaClass/Class.hpp"
+#include "NamePair.hpp"
+
+class Nameable : public Object
+{
+    public:
+        Nameable();
+        Nameable(const void* Obj);
+        Nameable(const Nameable& N);
+        static Class GetClass();
+
+        NamePair GetNamePair() const;
+
+};
+
+
+#endif // NAMEABLE_HPP_INCLUDED

Include/Core/Classes/NameableContainer.hpp

@@ -0,0 +1,22 @@
+#ifndef NAMEABLECONTAINER_HPP_INCLUDED
+#define NAMEABLECONTAINER_HPP_INCLUDED
+
+#include "../JavaClass/Object.hpp"
+#include "../JavaClass/Class.hpp"
+#include <vector>
+#include "Nameable.hpp"
+
+class NameableContainer : public Object
+{
+    public:
+        NameableContainer();
+        NameableContainer(const void* Obj);
+        NameableContainer(const NameableContainer& N);
+        static Class GetClass();
+
+        std::vector<Nameable> GetNameables() const;
+        std::int32_t GetSize() const;
+
+};
+
+#endif // NAMEABLECONTAINER_HPP_INCLUDED

Include/Core/Classes/Player.hpp

@@ -7,6 +7,7 @@
 #include <string>
 #include <cstdint>
 #include "PlayerInfo.hpp"
+#include "NamePair.hpp"
 
 class Player : public Character
 {
@@ -20,7 +21,7 @@ class Player : public Character
         std::int32_t GetCombatLevel() const;
         bool GetHidden() const;
         PlayerInfo GetInfo() const;
-        std::string GetName() const;
+        NamePair GetNamePair() const;
         std::int32_t GetOverheadIcon() const;
         std::int32_t GetSkullIcon() const;
         std::int32_t GetTeam() const;

Include/Core/Classes/PlayerManager.hpp

@@ -0,0 +1,22 @@
+#ifndef PLAYERMANAGER_HPP_INCLUDED
+#define PLAYERMANAGER_HPP_INCLUDED
+
+#include "../JavaClass/Object.hpp"
+#include "../JavaClass/Class.hpp"
+#include "FriendList.hpp"
+#include "IgnoreList.hpp"
+
+class PlayerManager : public Object
+{
+    public:
+        PlayerManager();
+        PlayerManager(const void* Obj);
+        PlayerManager(const PlayerManager& P);
+        static Class GetClass();
+
+        FriendList GetFriendList() const;
+        IgnoreList GetIgnoreList() const;
+
+};
+
+#endif // PLAYERMANAGER_HPP_INCLUDED

Include/Core/Classes/Preferences.hpp

@@ -5,6 +5,7 @@
 #include "../JavaClass/Class.hpp"
 #include "../JavaClass/LinkedHashMap.hpp"
 #include <cstdint>
+#include <string>
 
 class Preferences : public Object
 {
@@ -18,6 +19,8 @@ class Preferences : public Object
         bool GetMuted() const;
         LinkedHashMap GetPreferences() const;
         std::int32_t GetScreenType() const;
+        std::string GetUsernameCached() const;
+        bool GetUsernameHidden() const;
 
 };
 

Include/Core/Classes/Talkable.hpp

@@ -0,0 +1,21 @@
+#ifndef TALKABLE_HPP_INCLUDED
+#define TALKABLE_HPP_INCLUDED
+
+#include "Nameable.hpp"
+#include "../JavaClass/Class.hpp"
+#include <cstdint>
+
+class Talkable : public Nameable
+{
+    public:
+        Talkable();
+        Talkable(const void* Obj);
+        Talkable(const Talkable& T);
+        static Class GetClass();
+
+        std::int32_t GetRank() const;
+        std::int32_t GetWorld() const;
+
+};
+
+#endif // TALKABLE_HPP_INCLUDED

Include/Core/Internal.hpp

@@ -29,11 +29,13 @@
 #include "JavaClass/Object.hpp"
 
 #include "Classes/Animation.hpp"
+#include "Classes/AttackOption.hpp"
 #include "Classes/Cache.hpp"
 #include "Classes/CacheableNode.hpp"
 #include "Classes/Character.hpp"
 #include "Classes/ChatLineBuffer.hpp"
 #include "Classes/ClanMember.hpp"
+#include "Classes/ClanMemberList.hpp"
 #include "Classes/DecorativeObject.hpp"
 #include "Classes/Deque.hpp"
 #include "Classes/DynamicObject.hpp"
@@ -42,6 +44,7 @@
 #include "Classes/FrameMap.hpp"
 #include "Classes/Frames.hpp"
 #include "Classes/Friend.hpp"
+#include "Classes/FriendList.hpp"
 #include "Classes/GameObject.hpp"
 #include "Classes/GameShell.hpp"
 #include "Classes/GraphicsObject.hpp"
@@ -49,17 +52,22 @@
 #include "Classes/GroundObject.hpp"
 #include "Classes/HashTable.hpp"
 #include "Classes/Ignore.hpp"
+#include "Classes/IgnoreList.hpp"
 #include "Classes/ItemContainer.hpp"
 #include "Classes/ItemInfo.hpp"
 #include "Classes/LinkedList.hpp"
 #include "Classes/MessageNode.hpp"
 #include "Classes/Model.hpp"
+#include "Classes/Nameable.hpp"
+#include "Classes/NameableContainer.hpp"
+#include "Classes/NamePair.hpp"
 #include "Classes/Node.hpp"
 #include "Classes/NPC.hpp"
 #include "Classes/NPCInfo.hpp"
 #include "Classes/ObjectInfo.hpp"
 #include "Classes/Player.hpp"
 #include "Classes/PlayerInfo.hpp"
+#include "Classes/PlayerManager.hpp"
 #include "Classes/Preferences.hpp"
 #include "Classes/Queue.hpp"
 #include "Classes/Region.hpp"
@@ -67,6 +75,7 @@
 #include "Classes/SceneTile.hpp"
 #include "Classes/SpotAnimation.hpp"
 #include "Classes/Sprite.hpp"
+#include "Classes/Talkable.hpp"
 #include "Classes/Varbit.hpp"
 #include "Classes/WallObject.hpp"
 #include "Classes/Widget.hpp"
@@ -82,33 +91,33 @@ std::int32_t GetCameraY();
 std::int32_t GetCameraYaw();
 std::int32_t GetCameraZ();
 Map GetChatLineCache();
-std::vector<ClanMember> GetClanMembers();
 std::int32_t GetClientPlane();
 Preferences GetClientPreferences();
 std::int32_t GetClientX();
 std::int32_t GetClientY();
 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::vector<Friend> GetFriends();
 std::int32_t GetGameState();
 std::int32_t GetGameTick();
 Deque GetGraphicsObjects();
 std::vector<std::vector<std::vector<Deque>>> GetGroundItems();
-std::vector<Ignore> GetIgnores();
 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();
@@ -126,12 +135,15 @@ bool GetMenuVisible();
 std::int32_t GetMenuWidth();
 std::int32_t GetMenuX();
 std::int32_t GetMenuY();
+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();
@@ -160,38 +172,18 @@ ItemInfo GetItemInfo(std::int32_t ID);
 NPCInfo GetNPCInfo(std::int32_t ID);
 ObjectInfo GetObjectInfo(std::int32_t ID);
 bool LoadWorlds();
-void SetWorld(World W);
+void SetWorld(const World& W);
 
 
 Widget GetWidget(std::int32_t Container, std::int32_t Component);
-Widget GetWidgetParent(Widget W);
+Widget GetWidgetParent(const Widget& W);
-std::int32_t GetWidgetX(Widget W);
+std::int32_t GetWidgetX(const Widget& W);
-std::int32_t GetWidgetY(Widget W);
+std::int32_t GetWidgetY(const Widget& W);
-bool GetWidgetHidden(Widget W);
+bool GetWidgetHidden(const Widget& W);
-Box GetWidgetBox(Widget W);
+Box GetWidgetBox(const Widget& W);
 ItemContainer GetItemContainer(std::int32_t ID);
 NPC GetNPC(std::int32_t Index);
-std::int32_t GetTileHeight(std::int32_t X, std::int32_t Y, std::int32_t Z,
+std::vector<Point> ProjectModel(const Model& M, std::int32_t LocalX, std::int32_t LocalY,
-                           std::vector<std::vector<std::vector<std::int32_t>>>& TileHeights,
-                           std::vector<std::vector<std::vector<std::int8_t>>>& TileSettings);
-Point WorldToScreen(std::int32_t X, std::int32_t Y, std::int32_t Z,
-                    std::vector<std::vector<std::vector<std::int32_t>>>& TileHeights,
-                    std::vector<std::vector<std::vector<std::int8_t>>>& TileSettings,
-                    std::int32_t CameraX, std::int32_t CameraY, std::int32_t CameraZ,
-                    std::int32_t Pitch, std::int32_t Yaw, std::int32_t Scale,
-                    std::int32_t ViewportWidth, std::int32_t ViewportHeight,
-                    std::int32_t ScreenType, std::int32_t Plane);
-Point WorldToScreenEx(std::int32_t X, std::int32_t Y, std::int32_t Z,
-                      std::vector<std::vector<std::vector<std::int32_t>>>& TileHeights,
-                      std::vector<std::vector<std::vector<std::int8_t>>>& TileSettings,
-                      std::int32_t CameraX, std::int32_t CameraY, std::int32_t CameraZ,
-                      std::int32_t Pitch, std::int32_t Yaw, std::int32_t Scale,
-                      std::int32_t ViewportWidth, std::int32_t ViewportHeight,
-                      std::int32_t ScreenType, std::int32_t Plane,
-                      std::int32_t PositionX, std::int32_t PositionY);
-void RotateVertices(std::vector<std::int32_t>& X, std::vector<std::int32_t>& Y,
-                    std::vector<std::int32_t>& Z, std::int32_t Angle);
-std::vector<Point> ProjectModel(Model M, std::int32_t LocalX, std::int32_t LocalY,
                                 std::int32_t LocalZ, std::int32_t Angle);
 Model GetPlayerModel(std::int64_t ID);
 Model GetNPCModel(std::int32_t ID);
@@ -202,23 +194,23 @@ Model GetItemModel(std::int32_t ID);
 Model GetItemModel(std::int32_t ID, std::int32_t Amount);
 SpotAnimation GetSpotAnimation(std::int32_t ID);
 Model GetSpotAnimationModel(std::int32_t ID);
-Model GetGameObjectModel(GameObject O);
+Model GetGameObjectModel(const GameObject& O);
-Model GetWallObjectModel(WallObject O);
+Model GetWallObjectModel(const WallObject& O);
-Model GetDecorativeObjectModel(DecorativeObject O);
+Model GetDecorativeObjectModel(const DecorativeObject& O);
-Model GetGroundObjectModel(GroundObject O);
+Model GetGroundObjectModel(const GroundObject& O);
 Model GetDynamicObjectModel(std::int32_t ID);
 std::vector<std::vector<Deque>> GetGroundItems(std::int32_t Plane);
 Deque GetGroundItems(std::int32_t X, std::int32_t Y);
 Deque GetGroundItems(std::int32_t X, std::int32_t Y, std::int32_t Plane);
-std::vector<Point> GetPlayerModel(Player P);
+std::vector<Point> GetPlayerModel(const Player& P);
-std::vector<Point> GetNPCModel(NPC N);
+std::vector<Point> GetNPCModel(const NPC& N);
-std::vector<Point> GetGraphicsObjectModel(GraphicsObject O);
+std::vector<Point> GetGraphicsObjectModel(const GraphicsObject& O);
 SceneTile GetSceneTile(std::int32_t X, std::int32_t Y, std::int32_t Plane);
 std::vector<std::vector<SceneTile>> GetSceneTiles(std::int32_t Plane);
-Point TileToMinimap(Tile T);
+Point TileToMinimap(const Tile& T);
 std::int32_t GetTileItemHeight(std::int32_t X, std::int32_t Y, std::int32_t Plane);
 Sprite GetItemSprite(std::int32_t ID, std::int32_t Amount, std::int32_t BorderThickness,
                      std::int32_t ShadowColor, std::int32_t StackType);
-Convex GetItemSpriteConvex(Sprite S);
+Convex GetItemSpriteConvex(const Sprite& S);
 
 #endif // INTERNAL_HPP_INCLUDED

Include/Core/Script.hpp

@@ -5,6 +5,10 @@
 #include <vector>
 #include "Types/Timer.hpp"
 
+extern void Setup();
+extern bool OnStart();
+extern bool Loop();
+
 typedef struct
 {
     std::string Name = "";
@@ -27,6 +31,8 @@ typedef struct
     bool UseProxy;
     std::string ProxyHost;
     std::string ProxyPort;
+    std::string ProxyUsername;
+    std::string ProxyPassword;
     std::int32_t ActionDelayMean;
     float ActionDelayDeviation;
     std::int32_t MoveDelayMean;

Include/Game/Models/NPCs.hpp

@@ -31,9 +31,9 @@ class NPCs
         static NPC Get(const std::vector<std::string>& Names);
         static NPC Get(const std::function<bool (NPC&)>& Filter);
 
-        static Tile GetTileOf(NPC NPC);
+        static Tile GetTileOf(const NPC& NPC);
 
-        static Convex GetConvexOf(NPC NPC);
+        static Convex GetConvexOf(const NPC& NPC);
 };
 /** @} */
 

Include/Game/Models/Players.hpp

@@ -27,9 +27,9 @@ class Players
         static Player Get(const std::vector<std::string>& Names);
         static Player Get(const std::function<bool (Player&)>& Filter);
 
-        static Tile GetTileOf(Player Player);
+        static Tile GetTileOf(const Player& P);
 
-        static Convex GetConvexOf(Player Player);
+        static Convex GetConvexOf(const Player& P);
 };
 
 /** @} */

Include/Game/Models/SceneObjects.hpp

@@ -19,32 +19,32 @@ class SceneObjects
     public:
 
 
-        typedef enum MODEL_TYPE
+        typedef enum OBJECT_TYPE
         {
-            GAME_MODEL = (1 << 1),
+            GAME_OBJECT = (1 << 1),
-            DECORATIVE_MODEL = (1 << 2),
+            DECORATIVE_OBJECT = (1 << 2),
-            GROUND_MODEL =  (1 << 3),
+            GROUND_OBJECT =  (1 << 3),
-            WALL_MODEL =  (1 << 4),
+            WALL_OBJECT =  (1 << 4),
-            ALL = (GAME_MODEL | DECORATIVE_MODEL | GROUND_MODEL | WALL_MODEL)
+            ALL = (GAME_OBJECT | DECORATIVE_OBJECT | GROUND_OBJECT | WALL_OBJECT)
-        } MODEL_TYPE;
+        } OBJECT_TYPE;
 
-        static std::vector<Object> GetAll(MODEL_TYPE ModelTypes = ALL);
+        static std::vector<Object> GetAll(OBJECT_TYPE ObjectTypes = ALL);
-        static std::vector<Object> GetAll(const Tile& T, MODEL_TYPE ModelTypes = ALL);
+        static std::vector<Object> GetAll(const Tile& T, OBJECT_TYPE ObjectTypes = ALL);
-        static std::vector<Object> GetAll(std::int32_t ID, MODEL_TYPE ModelTypes = ALL);
+        static std::vector<Object> GetAll(std::int32_t ID, OBJECT_TYPE ObjectTypes = ALL);
-        static std::vector<Object> GetAll(const std::string& Name, MODEL_TYPE ModelTypes = ALL);
+        static std::vector<Object> GetAll(const std::string& Name, OBJECT_TYPE ObjectTypes = ALL);
-        static std::vector<Object> GetAll(const std::vector<std::int32_t>& PossibleIDs, MODEL_TYPE ModelTypes = ALL);
+        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, MODEL_TYPE ModelTypes = ALL);
+        static std::vector<Object> GetAll(const std::vector<std::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL);
 
         static std::vector<GameObject> GetAll(const std::function<bool (GameObject&)>& Filter);
         static std::vector<DecorativeObject> GetAll(const std::function<bool (DecorativeObject&)>& Filter);
         static std::vector<GroundObject> GetAll(const std::function<bool (GroundObject&)>& Filter);
         static std::vector<WallObject> GetAll(const std::function<bool (WallObject&)>& Filter);
 
-        static Object Get(const Tile& T, MODEL_TYPE ModelTypes = ALL);
+        static Object Get(const Tile& T, OBJECT_TYPE ObjectTypes = ALL);
-        static Object Get(std::int32_t ID, MODEL_TYPE ModelTypes = ALL);
+        static Object Get(std::int32_t ID, OBJECT_TYPE ObjectTypes = ALL);
-        static Object Get(const std::string& Name, MODEL_TYPE ModelTypes = ALL);
+        static Object Get(const std::string& Name, OBJECT_TYPE ObjectTypes = ALL);
-        static Object Get(const std::vector<std::int32_t>& PossibleIDs, MODEL_TYPE ModelTypes = ALL);
+        static Object Get(const std::vector<std::int32_t>& PossibleIDs, OBJECT_TYPE ObjectTypes = ALL);
-        static Object Get(const std::vector<std::string>& PossibleNames, MODEL_TYPE ModelTypes = ALL);
+        static Object Get(const std::vector<std::string>& PossibleNames, OBJECT_TYPE ObjectTypes = ALL);
 
         static GameObject Get(const std::function<bool (GameObject&)>& Filter);
         static DecorativeObject Get(const std::function<bool (DecorativeObject&)>& Filter);

Include/Game/Tools/Profile.hpp

@@ -75,6 +75,12 @@ class Profile
         static double GetLongBreakEveryDeviation();
         static double GetLongBreakFor();
         static double GetLongBreakForDeviation();
+
+        static bool UseProxy();
+        static std::string GetProxyHost();
+        static std::string GetProxyPort();
+        static std::string GetProxyUsername();
+        static std::string GetProxyPassword();
 };
 
 /** @} */