Release 0.02

Include/Core/Classes/Character.hpp

@@ -17,17 +17,17 @@ class Character : public Renderable
         static Class GetClass();
 
         std::int32_t GetAngle() const;
-        std::int32_t GetAnimation() const;
         std::int32_t GetAnimationDelay() const;
         std::int32_t GetAnimationFrame() const;
+        std::int32_t GetAnimationID() const; // done
         LinkedList GetCombatInfo() 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 GetPoseAnimation() const;
-        std::int32_t GetSubAnimationFrame() const;
-        std::int32_t GetSubPoseAnimation() const;
+        std::int32_t GetPoseAnimationFrame() const; //done
+        std::int32_t GetPoseAnimationID() const; // done.
+        std::int32_t GetSubPoseAnimation() const;//
         std::int32_t GetX() const;
         std::int32_t GetY() const;
 

Include/Core/Classes/DecorativeObject.hpp

@@ -1,17 +1,17 @@
-#ifndef DECORATIVEMODEL_HPP_INCLUDED
-#define DECORATIVEMODEL_HPP_INCLUDED
+#ifndef DECORATIVEOBJECT_HPP_INCLUDED
+#define DECORATIVEOBJECT_HPP_INCLUDED
 
 #include "../JavaClass/Object.hpp"
 #include "../JavaClass/Class.hpp"
 #include <cstdint>
 #include "Renderable.hpp"
 
-class DecorativeModel : public Object
+class DecorativeObject : public Object
 {
     public:
-        DecorativeModel();
-        DecorativeModel(const void* Obj);
-        DecorativeModel(const DecorativeModel& D);
+        DecorativeObject();
+        DecorativeObject(const void* Obj);
+        DecorativeObject(const DecorativeObject& D);
         static Class GetClass();
 
         std::int32_t GetAngle() const;
@@ -27,4 +27,4 @@ class DecorativeModel : public Object
 
 };
 
-#endif // DECORATIVEMODEL_HPP_INCLUDED
+#endif // DECORATIVEOBJECT_HPP_INCLUDED

Include/Core/Classes/DynamicModel.hpp

@@ -1,21 +0,0 @@
-#ifndef DYNAMICMODEL_HPP_INCLUDED
-#define DYNAMICMODEL_HPP_INCLUDED
-
-#include "Renderable.hpp"
-#include "../JavaClass/Class.hpp"
-#include <cstdint>
-
-class DynamicModel : public Renderable
-{
-    public:
-        DynamicModel();
-        DynamicModel(const void* Obj);
-        DynamicModel(const DynamicModel& D);
-        static Class GetClass();
-
-        std::int32_t GetID() const;
-        std::int32_t GetOrientation() const;
-        std::int32_t GetType() const;
-};
-
-#endif // DYNAMICMODEL_HPP_INCLUDED

Include/Core/Classes/DynamicObject.hpp

@@ -0,0 +1,21 @@
+#ifndef DYNAMICOBJECT_HPP_INCLUDED
+#define DYNAMICOBJECT_HPP_INCLUDED
+
+#include "Renderable.hpp"
+#include "../JavaClass/Class.hpp"
+#include <cstdint>
+
+class DynamicObject : public Renderable
+{
+    public:
+        DynamicObject();
+        DynamicObject(const void* Obj);
+        DynamicObject(const DynamicObject& D);
+        static Class GetClass();
+
+        std::int32_t GetID() const;
+        std::int32_t GetOrientation() const;
+        std::int32_t GetType() const;
+};
+
+#endif // DYNAMICOBJECT_HPP_INCLUDED

Include/Core/Classes/GameObject.hpp

@@ -1,17 +1,17 @@
-#ifndef GAMEMODEL_HPP_INCLUDED
-#define GAMEMODEL_HPP_INCLUDED
+#ifndef GAMEOBJECT_HPP_INCLUDED
+#define GAMEOBJECT_HPP_INCLUDED
 
 #include "../JavaClass/Object.hpp"
 #include "../JavaClass/Class.hpp"
 #include <cstdint>
 #include "Renderable.hpp"
 
-class GameModel : public Object
+class GameObject : public Object
 {
     public:
-        GameModel();
-        GameModel(const void* Obj);
-        GameModel(const GameModel& G);
+        GameObject();
+        GameObject(const void* Obj);
+        GameObject(const GameObject& G);
         static Class GetClass();
 
         std::int32_t GetAngle() const;
@@ -29,4 +29,4 @@ class GameModel : public Object
 
 };
 
-#endif // GAMEMODEL_HPP_INCLUDED
+#endif // GAMEOBJECT_HPP_INCLUDED

Include/Core/Classes/GraphicsObject.hpp

@@ -0,0 +1,28 @@
+#ifndef GRAPHICSOBJECT_HPP_INCLUDED
+#define GRAPHICSOBJECT_HPP_INCLUDED
+
+#include "Renderable.hpp"
+#include "../JavaClass/Class.hpp"
+#include "Animation.hpp"
+#include <cstdint>
+
+class GraphicsObject : public Renderable
+{
+    public:
+        GraphicsObject();
+        GraphicsObject(const void* Obj);
+        GraphicsObject(const GraphicsObject& G);
+        static Class GetClass();
+
+        Animation GetAnimation() const;
+        std::int32_t GetAnimationFrame() const;
+        bool GetFinished() const;
+        std::int32_t GetHeight() const;
+        std::int32_t GetID() const;
+        std::int32_t GetPlane() const;
+        std::int32_t GetX() const;
+        std::int32_t GetY() const;
+
+};
+
+#endif // GRAPHICSOBJECT_HPP_INCLUDED

Include/Core/Classes/GroundObject.hpp

@@ -1,17 +1,17 @@
-#ifndef GROUNDMODEL_HPP_INCLUDED
-#define GROUNDMODEL_HPP_INCLUDED
+#ifndef GROUNDOBJECT_HPP_INCLUDED
+#define GROUNDOBJECT_HPP_INCLUDED
 
 #include "../JavaClass/Object.hpp"
 #include "../JavaClass/Class.hpp"
 #include <cstdint>
 #include "Renderable.hpp"
 
-class GroundModel : public Object
+class GroundObject : public Object
 {
     public:
-        GroundModel();
-        GroundModel(const void* Obj);
-        GroundModel(const GroundModel& G);
+        GroundObject();
+        GroundObject(const void* Obj);
+        GroundObject(const GroundObject& G);
         static Class GetClass();
 
         std::int32_t GetHash() const;
@@ -23,4 +23,4 @@ class GroundModel : public Object
 
 };
 
-#endif // GROUNDMODEL_HPP_INCLUDED
+#endif // GROUNDOBJECT_HPP_INCLUDED

Include/Core/Classes/NPCInfo.hpp

@@ -22,8 +22,8 @@ class NPCInfo : public CacheableNode
         bool GetMinimapVisible() const;
         std::vector<std::int32_t> GetModelIDs() const;
         std::string GetName() const;
-        std::int32_t GetResizeX() const;
-        std::int32_t GetResizeY() const;
+        std::int32_t GetScaleX() const;
+        std::int32_t GetScaleY() const;
         std::int32_t GetSettingID() const;
         std::int32_t GetVarbitID() const;
         bool GetVisible() const;

Include/Core/Classes/Region.hpp

@@ -4,7 +4,7 @@
 #include "../JavaClass/Object.hpp"
 #include "../JavaClass/Class.hpp"
 #include <vector>
-#include "GameModel.hpp"
+#include "GameObject.hpp"
 #include "SceneTile.hpp"
 
 class Region : public Object
@@ -15,7 +15,7 @@ class Region : public Object
         Region(const Region& R);
         static Class GetClass();
 
-        std::vector<GameModel> GetGameModels() const;
+        std::vector<GameObject> GetGameObjects() const;
         std::vector<std::vector<std::vector<SceneTile>>> GetSceneTiles() const;
 
 };

Include/Core/Classes/SceneTile.hpp

@@ -3,12 +3,12 @@
 
 #include "Node.hpp"
 #include "../JavaClass/Class.hpp"
-#include "DecorativeModel.hpp"
+#include "DecorativeObject.hpp"
 #include <vector>
-#include "GameModel.hpp"
-#include "GroundModel.hpp"
+#include "GameObject.hpp"
+#include "GroundObject.hpp"
 #include <cstdint>
-#include "WallModel.hpp"
+#include "WallObject.hpp"
 
 class SceneTile : public Node
 {
@@ -18,11 +18,11 @@ class SceneTile : public Node
         SceneTile(const SceneTile& G);
         static Class GetClass();
 
-        DecorativeModel GetDecorativeModel() const;
-        std::vector<GameModel> GetGameModels() const;
-        GroundModel GetGroundModel() const;
+        DecorativeObject GetDecorativeObject() const;
+        std::vector<GameObject> GetGameObjects() const;
+        GroundObject GetGroundObject() const;
         std::int32_t GetPlane() const;
-        WallModel GetWallModel() const;
+        WallObject GetWallObject() const;
         std::int32_t GetX() const;
         std::int32_t GetY() const;
 

Include/Core/Classes/SpotAnimation.hpp

@@ -0,0 +1,24 @@
+#ifndef SPOTANIMATION_HPP_INCLUDED
+#define SPOTANIMATION_HPP_INCLUDED
+
+#include "CacheableNode.hpp"
+#include "../JavaClass/Class.hpp"
+#include <cstdint>
+
+class SpotAnimation : public CacheableNode
+{
+    public:
+        SpotAnimation();
+        SpotAnimation(const void* Obj);
+        SpotAnimation(const SpotAnimation& S);
+        static Class GetClass();
+
+        std::int32_t GetAngle() const;
+        std::int32_t GetAnimationID() const;
+        std::int32_t GetID() const;
+        std::int32_t GetScaleX() const;
+        std::int32_t GetScaleY() const;
+
+};
+
+#endif // SPOTANIMATION_HPP_INCLUDED

Include/Core/Classes/WallObject.hpp

@@ -1,17 +1,17 @@
-#ifndef WALLMODEL_HPP_INCLUDED
-#define WALLMODEL_HPP_INCLUDED
+#ifndef WALLOBJECT_HPP_INCLUDED
+#define WALLOBJECT_HPP_INCLUDED
 
 #include "../JavaClass/Object.hpp"
 #include "../JavaClass/Class.hpp"
 #include <cstdint>
 #include "Renderable.hpp"
 
-class WallModel : public Object
+class WallObject : public Object
 {
     public:
-        WallModel();
-        WallModel(const void* Obj);
-        WallModel(const WallModel& W);
+        WallObject();
+        WallObject(const void* Obj);
+        WallObject(const WallObject& W);
         static Class GetClass();
 
         std::int32_t GetAngle() const;
@@ -25,4 +25,4 @@ class WallModel : public Object
 
 };
 
-#endif // WALLMODEL_HPP_INCLUDED
+#endif // WALLOBJECT_HPP_INCLUDED

Include/Core/Internal.hpp

@@ -35,18 +35,18 @@
 #include "Classes/Character.hpp"
 #include "Classes/ChatLineBuffer.hpp"
 #include "Classes/ClanMember.hpp"
-#include "Classes/DecorativeModel.hpp"
+#include "Classes/DecorativeObject.hpp"
 #include "Classes/Deque.hpp"
-#include "Classes/DynamicModel.hpp"
+#include "Classes/DynamicObject.hpp"
 #include "Classes/ExchangeOffer.hpp"
 #include "Classes/Frame.hpp"
 #include "Classes/FrameMap.hpp"
 #include "Classes/Frames.hpp"
 #include "Classes/Friend.hpp"
-#include "Classes/GameModel.hpp"
+#include "Classes/GameObject.hpp"
 #include "Classes/GameShell.hpp"
 #include "Classes/GroundItem.hpp"
-#include "Classes/GroundModel.hpp"
+#include "Classes/GroundObject.hpp"
 #include "Classes/HashTable.hpp"
 #include "Classes/Ignore.hpp"
 #include "Classes/ItemContainer.hpp"
@@ -67,7 +67,7 @@
 #include "Classes/SceneTile.hpp"
 #include "Classes/Sprite.hpp"
 #include "Classes/Varbit.hpp"
-#include "Classes/WallModel.hpp"
+#include "Classes/WallObject.hpp"
 #include "Classes/Widget.hpp"
 #include "Classes/WidgetNode.hpp"
 #include "Classes/World.hpp"
@@ -88,7 +88,7 @@ std::int32_t GetClientX();
 std::int32_t GetClientY();
 std::vector<std::int32_t> GetCurrentLevels();
 std::int32_t GetCurrentWorld();
-Cache GetDynamicModelCache();
+Cache GetDynamicObjectCache();
 std::vector<ExchangeOffer> GetExchangeOffers();
 std::vector<std::int32_t> GetExperiences();
 bool GetFocused();
@@ -96,6 +96,7 @@ 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();
@@ -124,7 +125,6 @@ bool GetMenuVisible();
 std::int32_t GetMenuWidth();
 std::int32_t GetMenuX();
 std::int32_t GetMenuY();
-Cache GetModelCache();
 std::vector<std::int32_t> GetNPCIndices();
 Cache GetNPCModelCache();
 std::vector<NPC> GetNPCs();
@@ -136,6 +136,8 @@ std::string GetSelectedItemName();
 std::string GetSelectedSpellName();
 std::vector<std::int32_t> GetSettings();
 bool GetSpellSelected();
+Cache GetSpotAnimationCache();
+Cache GetSpotAnimationModelCache();
 std::vector<std::vector<std::vector<std::int32_t>>> GetTileHeights();
 std::vector<std::vector<std::vector<std::int8_t>>> GetTileSettings();
 std::string GetUsername();
@@ -197,11 +199,11 @@ Animation GetAnimation(std::int32_t ID);
 Frames GetFrames(std::int32_t ID);
 Model GetItemModel(std::int32_t ID);
 Model GetItemModel(std::int32_t ID, std::int32_t Amount);
-Model GetGameModel(GameModel O);
-Model GetWallModel(WallModel O);
-Model GetDecorativeModel(DecorativeModel O);
-Model GetGroundModel(GroundModel O);
-Model GetDynamicModel(std::int32_t ID);
+Model GetGameObjectModel(GameObject O);
+Model GetWallObjectModel(WallObject O);
+Model GetDecorativeObjectModel(DecorativeObject O);
+Model GetGroundObjectModel(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);

Include/Game/Models/SceneObjects.hpp

@@ -1,10 +1,10 @@
 #ifndef SCENEOBJECTS_HPP_INCLUDED
 #define SCENEOBJECTS_HPP_INCLUDED
 
-#include "../../Core/Classes/GameModel.hpp"
-#include "../../Core/Classes/DecorativeModel.hpp"
-#include "../../Core/Classes/GroundModel.hpp"
-#include "../../Core/Classes/WallModel.hpp"
+#include "../../Core/Classes/GameObject.hpp"
+#include "../../Core/Classes/DecorativeObject.hpp"
+#include "../../Core/Classes/GroundObject.hpp"
+#include "../../Core/Classes/WallObject.hpp"
 #include "../../Core/Types/Tile.hpp"
 #include "../../Core/Types/Convex.hpp"
 #include <functional>
@@ -35,10 +35,10 @@ class SceneObjects
         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::string>& PossibleNames, MODEL_TYPE ModelTypes = ALL);
 
-        static std::vector<GameModel> GetAll(const std::function<bool (GameModel&)>& Filter);
-        static std::vector<DecorativeModel> GetAll(const std::function<bool (DecorativeModel&)>& Filter);
-        static std::vector<GroundModel> GetAll(const std::function<bool (GroundModel&)>& Filter);
-        static std::vector<WallModel> GetAll(const std::function<bool (WallModel&)>& Filter);
+        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(std::int32_t ID, MODEL_TYPE ModelTypes = ALL);
@@ -46,20 +46,20 @@ class SceneObjects
         static Object Get(const std::vector<std::int32_t>& PossibleIDs, MODEL_TYPE ModelTypes = ALL);
         static Object Get(const std::vector<std::string>& PossibleNames, MODEL_TYPE ModelTypes = ALL);
 
-        static GameModel Get(const std::function<bool (GameModel&)>& Filter);
-        static DecorativeModel Get(const std::function<bool (DecorativeModel&)>& Filter);
-        static GroundModel Get(const std::function<bool (GroundModel&)>& Filter);
-        static WallModel Get(const std::function<bool (WallModel&)>& Filter);
+        static GameObject Get(const std::function<bool (GameObject&)>& Filter);
+        static DecorativeObject Get(const std::function<bool (DecorativeObject&)>& Filter);
+        static GroundObject Get(const std::function<bool (GroundObject&)>& Filter);
+        static WallObject Get(const std::function<bool (WallObject&)>& Filter);
 
-        static Tile GetTileOf(const GameModel& G);
-        static Tile GetTileOf(const DecorativeModel& D);
-        static Tile GetTileOf(const GroundModel& G);
-        static Tile GetTileOf(const WallModel& W);
+        static Tile GetTileOf(const GameObject& G);
+        static Tile GetTileOf(const DecorativeObject& D);
+        static Tile GetTileOf(const GroundObject& G);
+        static Tile GetTileOf(const WallObject& W);
 
-        static Convex GetConvexOf(const GameModel& G);
-        static Convex GetConvexOf(const DecorativeModel& D);
-        static Convex GetConvexOf(const GroundModel& G);
-        static Convex GetConvexOf(const WallModel& W);
+        static Convex GetConvexOf(const GameObject& G);
+        static Convex GetConvexOf(const DecorativeObject& D);
+        static Convex GetConvexOf(const GroundObject& G);
+        static Convex GetConvexOf(const WallObject& W);
 };
 
 /** @} */

Include/Game/Tools/Interact.hpp

@@ -50,17 +50,17 @@ class Interact
         static bool Click(Player P, const std::string& Action);
         static bool Click(Player P, const std::vector<std::string>& PossibleActions);
 
-        static bool Click(GameModel G, Button Button = BUTTON_LEFT);
-        static bool Click(GameModel G, const std::string& Action);
-        static bool Click(GameModel G, const std::vector<std::string>& PossibleActions);
+        static bool Click(GameObject G, Button Button = BUTTON_LEFT);
+        static bool Click(GameObject G, const std::string& Action);
+        static bool Click(GameObject G, const std::vector<std::string>& PossibleActions);
 
-        static bool Click(GroundModel G, Button Button = BUTTON_LEFT);
-        static bool Click(GroundModel G, const std::string& Action);
-        static bool Click(GroundModel G, const std::vector<std::string>& PossibleActions);
+        static bool Click(GroundObject G, Button Button = BUTTON_LEFT);
+        static bool Click(GroundObject G, const std::string& Action);
+        static bool Click(GroundObject G, const std::vector<std::string>& PossibleActions);
 
-        static bool Click(WallModel W, Button Button = BUTTON_LEFT);
-        static bool Click(WallModel W, const std::string& Action);
-        static bool Click(WallModel W, const std::vector<std::string>& PossibleActions);
+        static bool Click(WallObject W, Button Button = BUTTON_LEFT);
+        static bool Click(WallObject W, const std::string& Action);
+        static bool Click(WallObject W, const std::vector<std::string>& PossibleActions);
 
         static bool UpKey(std::int32_t Key);
         static bool DownKey(std::int32_t Key);