Release 1.90

Include/Core/Classes/Animation.hpp

@@ -24,6 +24,7 @@ namespace Internal
             std::vector<std::int32_t> GetFrameIDs() const;
             std::vector<std::int32_t> GetInterleave() const;
             std::int32_t GetLeftHandItem() const;
+            std::int32_t GetModelID() const;
             std::int32_t GetRightHandItem() const;
 
     };

Include/Core/Classes/AnimationSet.hpp

@@ -0,0 +1,35 @@
+#ifndef ANIMATIONSET_HPP_INCLUDED
+#define ANIMATIONSET_HPP_INCLUDED
+
+#include "CacheableNode.hpp"
+#include "../JavaClass/Class.hpp"
+#include <vector>
+#include <cstdint>
+#include "Skin.hpp"
+#include "FrameAngles.hpp"
+
+namespace Internal
+{
+    class AnimationSet : public CacheableNode
+    {
+        public:
+            AnimationSet(const void* Obj);
+
+            AnimationSet() = default;
+            AnimationSet(AnimationSet&& Obj) = default;
+            AnimationSet(const AnimationSet& Obj) = default;
+            AnimationSet& operator=(AnimationSet&& Obj) = default;
+            AnimationSet& operator=(const AnimationSet& Obj) = default;
+
+            static Class GetClass();
+
+            std::vector<std::vector<FrameAngles>> GetFrameAngles() const;
+            std::vector<FrameAngles> GetFrameAngles(std::int32_t I) const;
+            FrameAngles GetFrameAngles(std::int32_t I, std::int32_t II) const;
+            Skin GetSkin() const;
+            std::int32_t GetMatrixIndex() const;
+
+    };
+}
+
+#endif // ANIMATIONSET_HPP_INCLUDED

Include/Core/Classes/Frame.hpp

@@ -5,7 +5,7 @@
 #include "../JavaClass/Class.hpp"
 #include <vector>
 #include <cstdint>
-#include "FrameMap.hpp"
+#include "Skin.hpp"
 
 namespace Internal
 {
@@ -24,7 +24,7 @@ namespace Internal
 
             std::vector<std::int32_t> GetIndices() const;
             bool GetShowing() const;
-            FrameMap GetSkin() const;
+            Skin GetSkin() const;
             std::vector<std::int32_t> GetTranslatorX() const;
             std::vector<std::int32_t> GetTranslatorY() const;
             std::vector<std::int32_t> GetTranslatorZ() const;

Include/Core/Classes/FrameAngles.hpp

@@ -0,0 +1,33 @@
+#ifndef FRAMEANGLES_HPP_INCLUDED
+#define FRAMEANGLES_HPP_INCLUDED
+
+#include "../JavaClass/Class.hpp"
+#include <cstdint>
+#include <vector>
+
+namespace Internal
+{
+    class FrameAngles : public Object
+    {
+        public:
+            FrameAngles(const void* Obj);
+
+            FrameAngles() = default;
+            FrameAngles(FrameAngles&& Obj) = default;
+            FrameAngles(const FrameAngles& Obj) = default;
+            FrameAngles& operator=(FrameAngles&& Obj) = default;
+            FrameAngles& operator=(const FrameAngles& Obj) = default;
+
+            static Class GetClass();
+
+            std::vector<float> GetAngles() const;
+
+            float GetMaxAngle() const;
+            std::int32_t GetMaxFrame() const;
+            float GetMinAngle() const;
+            std::int32_t GetMinFrame() const;
+
+    };
+}
+
+#endif // FRAMEANGLES_HPP_INCLUDED

Include/Core/Classes/FrameMap.hpp

@@ -1,30 +0,0 @@
-#ifndef FRAMEMAP_HPP_INCLUDED
-#define FRAMEMAP_HPP_INCLUDED
-
-#include "Node.hpp"
-#include "../JavaClass/Class.hpp"
-#include <vector>
-#include <cstdint>
-
-namespace Internal
-{
-    class FrameMap : public Node
-    {
-        public:
-            FrameMap(const void* Obj);
-
-            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;
-            std::vector<std::int32_t> GetTypes() const;
-
-    };
-}
-
-#endif // FRAMEMAP_HPP_INCLUDED

Include/Core/Classes/Matrix.hpp

@@ -0,0 +1,27 @@
+#ifndef MATRIX_HPP_INCLUDED
+#define MATRIX_HPP_INCLUDED
+
+#include "../JavaClass/Class.hpp"
+#include <vector>
+
+namespace Internal
+{
+    class Matrix : public Object
+    {
+        public:
+            Matrix(const void* Obj);
+
+            Matrix() = default;
+            Matrix(Matrix&& Obj) = default;
+            Matrix(const Matrix& Obj) = default;
+            Matrix& operator=(Matrix&& Obj) = default;
+            Matrix& operator=(const Matrix& Obj) = default;
+
+            static Class GetClass();
+
+            std::vector<float> GetValues() const;
+
+    };
+}
+
+#endif // MATRIX_HPP_INCLUDED

Include/Core/Classes/Model.hpp

@@ -31,6 +31,9 @@ namespace Internal
             std::vector<std::int32_t> GetVerticesY() const;
             std::vector<std::int32_t> GetVerticesZ() const;
 
+            std::vector<std::vector<std::int32_t>> GetInt2DArray1() const;
+            std::vector<std::vector<std::int32_t>> GetInt2DArray2() const;
+
     };
 }
 

Include/Core/Classes/Skin.hpp

@@ -0,0 +1,34 @@
+#ifndef SKIN_HPP_INCLUDED
+#define SKIN_HPP_INCLUDED
+
+#include "Node.hpp"
+#include "../JavaClass/Class.hpp"
+#include <vector>
+#include <cstdint>
+#include "SkinAnimation.hpp"
+
+namespace Internal
+{
+    class Skin : public Node
+    {
+        public:
+            Skin(const void* Obj);
+
+            Skin() = default;
+            Skin(Skin&& Obj) = default;
+            Skin(const Skin& Obj) = default;
+            Skin& operator=(Skin&& Obj) = default;
+            Skin& operator=(const Skin& Obj) = default;
+
+            static Class GetClass();
+
+            std::vector<std::vector<std::int32_t>> GetList() const;
+            std::vector<std::int32_t> GetTypes() const;
+            SkinAnimation GetSkinAnimation() const;
+
+
+
+    };
+}
+
+#endif // SKIN_HPP_INCLUDED

Include/Core/Classes/SkinAnimation.hpp

@@ -0,0 +1,30 @@
+#ifndef SKINANIMATION_HPP_INCLUDED
+#define SKINANIMATION_HPP_INCLUDED
+
+#include "../JavaClass/Class.hpp"
+#include <cstdint>
+#include <vector>
+#include "SkinAnimationFrame.hpp"
+
+namespace Internal
+{
+    class SkinAnimation : public Object
+    {
+        public:
+            SkinAnimation(const void* Obj);
+
+            SkinAnimation() = default;
+            SkinAnimation(SkinAnimation&& Obj) = default;
+            SkinAnimation(const SkinAnimation& Obj) = default;
+            SkinAnimation& operator=(SkinAnimation&& Obj) = default;
+            SkinAnimation& operator=(const SkinAnimation& Obj) = default;
+
+            static Class GetClass();
+
+            std::vector<SkinAnimationFrame> GetFrames() const;
+            //std::int32_t GetIntField1() const;
+
+    };
+}
+
+#endif // SKINANIMATION_HPP_INCLUDED

Include/Core/Classes/SkinAnimationFrame.hpp

@@ -0,0 +1,30 @@
+#ifndef SKINANIMATIONFRAME_HPP_INCLUDED
+#define SKINANIMATIONFRAME_HPP_INCLUDED
+
+#include "../JavaClass/Class.hpp"
+#include <vector>
+#include "Matrix.hpp"
+
+namespace Internal
+{
+    class SkinAnimationFrame : public Object
+    {
+        public:
+            SkinAnimationFrame(const void* Obj);
+
+            SkinAnimationFrame() = default;
+            SkinAnimationFrame(SkinAnimationFrame&& Obj) = default;
+            SkinAnimationFrame(const SkinAnimationFrame& Obj) = default;
+            SkinAnimationFrame& operator=(SkinAnimationFrame&& Obj) = default;
+            SkinAnimationFrame& operator=(const SkinAnimationFrame& Obj) = default;
+
+            static Class GetClass();
+
+            //std::vector<std::vector<float>> Get2DFloatField1() const;
+            std::int32_t GetRedirectIndex() const;
+            std::vector<Matrix> GetMatrices() const;
+
+    };
+}
+
+#endif // SKINANIMATIONFRAME_HPP_INCLUDED

Include/Core/Internal.hpp

@@ -37,6 +37,7 @@
 #include "Classes/AbstractBufferProvider.hpp"
 #include "Classes/AbstractByteBuffer.hpp"
 #include "Classes/Animation.hpp"
+#include "Classes/AnimationSet.hpp"
 #include "Classes/AttackOption.hpp"
 #include "Classes/Cache.hpp"
 #include "Classes/CacheableNode.hpp"
@@ -57,7 +58,6 @@
 #include "Classes/FontName.hpp"
 #include "Classes/Fonts.hpp"
 #include "Classes/Frame.hpp"
-#include "Classes/FrameMap.hpp"
 #include "Classes/Frames.hpp"
 #include "Classes/Friend.hpp"
 #include "Classes/FriendList.hpp"
@@ -102,6 +102,9 @@
 #include "Classes/Region.hpp"
 #include "Classes/Renderable.hpp"
 #include "Classes/SceneTile.hpp"
+#include "Classes/Skin.hpp"
+#include "Classes/SkinAnimation.hpp"
+#include "Classes/SkinAnimationFrame.hpp"
 #include "Classes/SpotAnimation.hpp"
 #include "Classes/Sprite.hpp"
 #include "Classes/Talkable.hpp"
@@ -144,6 +147,7 @@ namespace Internal
     std::vector<std::int32_t> GetExperiences();
     bool GetFocused();
     Cache GetFramesCache();
+    Cache GetAnimationSetCache();
     std::int32_t GetGameState();
     std::int32_t GetGameTick();
     Deque GetGraphicsObjects();
@@ -271,6 +275,7 @@ namespace Internal
     VarbitInfo GetVarbitInfo(std::int32_t ID);
     Animation GetAnimation(std::int32_t ID);
     Frames GetFrames(std::int32_t ID);
+    AnimationSet GetAnimationSet(std::int32_t ID);
     Model GetItemModel(std::int32_t ID);
     Model GetItemModel(std::int32_t ID, std::int32_t Amount);
     SpotAnimation GetSpotAnimation(std::int32_t ID);

Include/Game/Interactable/NPC.hpp

@@ -29,6 +29,7 @@ namespace Interactable
 
             std::int32_t GetID() const;
             std::string GetName() const;
+            std::int32_t GetGraphicsID() const;
             Internal::NPCInfo GetInfo() const;
 
             std::vector<Point> GetModel() const;