补全Actor类

LiteLoader/Header/MC/AABB.hpp

@@ -49,6 +49,10 @@ public:
     MCAPI class AABB shrink(class Vec3 const &) const;
     MCAPI static class AABB const EMPTY;
 
+    inline Vec3 getCenter() const{
+        return (min + max)/2;
+    };
+
     inline Vec3& operator[](int index) {
         if (index < 0 || index > 1) {
             return (&min)[0];

LiteLoader/Header/MC/Actor.hpp

@@ -10,6 +10,53 @@
 #include "ActorDamageSource.hpp"
 #include "SimpleContainer.hpp"
 #include "ActorDefinitionIdentifier.hpp"
+#include "OwnerStorageEntity.hpp"
+#include "ActorDefinitionGroup.hpp"
+#include "ActorDefinitionDescriptor.hpp"
+#include "RopeSystem.hpp"
+#include "SynchedActorData.hpp"
+#include "SpatialActorNetworkData.hpp"
+#include "BaseAttributeMap.hpp"
+#include "EconomyTradeableComponent.hpp"
+#include "Dimension.hpp"
+#include "AnimationComponent.hpp"
+#include "ActorDefinitionDiffList.hpp"
+#include "ActorTerrainInterlockData.hpp"
+#include "MolangVariableMap.hpp"
+#include "AnimationComponent.hpp"
+#include "CompoundTag.hpp"
+
+template <typename T>
+class  OwnerPtrT : OwnerStorageEntity {
+};
+
+const class VariantParameterList
+{
+    struct Parameter {
+        unsigned __int64 type;
+        void* data;
+    };
+
+private:
+    VariantParameterList::Parameter parameters[8];
+};
+class PredictedMovementComponent {
+public:
+    class PredictedMovementComponent& operator=(class PredictedMovementComponent const&) = delete;
+    PredictedMovementComponent(class PredictedMovementComponent const&) = delete;
+    PredictedMovementComponent() = delete;
+};
+
+class PredictedMovementValues {
+public:
+    bool mUseAggressiveTickInterval;
+    unsigned __int64 mInterpolationWindowSizeInTicks;
+
+    class PredictedMovementValues& operator=(class PredictedMovementValues const&) = delete;
+    PredictedMovementValues(class PredictedMovementValues const&) = delete;
+    PredictedMovementValues() = delete;
+};
+
 class Actor;
 class Player;
 class NetworkIdentifier;
@@ -115,14 +162,227 @@ enum ActorFlags : int{
     CELEBRATING = 0x5B,
     Count_7 = 0x5C,
 };
+enum class FocusImpact : __int8 {
+    Neutral = 0x0,
+    ActivateFocus = 0x1,
+    DeactivateFocus = 0x2,
+};
 
+class _declspec(align(4)) ActionEvent {
+    int mActionId;
+    enum class ActionState : int {
+        Start = 0x1,
+        Stop = 0x2,
+    } mActionState;
+
+    bool mIsExclusive;
+    FocusImpact mFocusImpact;
+};
+
+
+const struct AABBShapeComponent {
+public:
+    AABB mAABB;
+    Vec2 mBBDim;
+};
+
+const struct StateVectorComponent {
+public:
+    Vec3 mPos;
+    Vec3 mPosPrev;
+    Vec3 mPosDelta;
+};
+
+struct ActionQueue {
+    std::deque<ActionEvent> mQueue;
+};
 #undef BEFORE_EXTRA
 
 class Actor {
+public:
+    OwnerPtrT<EntityRefTraits> mEntity;
+    enum class InitializationMethod : unsigned char {
+        INVALID = 0x0,
+        LOADED = 0x1,
+        SPAWNED = 0x2,
+        BORN = 0x3,
+        TRANSFORMED = 0x4,
+        UPDATED = 0x5,
+        EVENT = 0x6,
+        LEGACY = 0x7,
+    } mInitMethod;
+    std::string mCustomInitEventName;
+    VariantParameterList mInitParams;
+    bool mForceInitMethodToSpawnOnReload;
+    AutomaticID<Dimension, int> mDimensionId;
+    bool mAdded;
+    ActorDefinitionGroup* mDefinitions;
+    std::unique_ptr<ActorDefinitionDescriptor> mCurrentDescription;
+    ActorUniqueID mUniqueID;
+    std::shared_ptr<RopeSystem> mLeashRopeSystem;
+    Vec2 mRot;//256
+    Vec2 mRotPrev;
+    float mSwimAmount;
+    float mSwimPrev;
+    ChunkPos mChunkPos;
+    Vec3 mRenderPos;
+    Vec2 mRenderRot;
+    int mCategories;
+    int mAmbientSoundTime;
+    int mLastHurtByPlayerTime;
+    SynchedActorData mEntityData;
+    std::unique_ptr<SpatialActorNetworkData> mNetworkData;
+    Vec3 mSentDelta;
+    bool mSentOnGround;
+    float mScale;
+    float mScalePrev;
+    unsigned __int64 mNameTagHash;
+    const Block* mInsideBlock;
+    BlockPos mInsideBlockPos;
+    float mFallDistance;
+    bool mOnGround; //416
+    bool mWasOnGround;
+    bool mHorizontalCollision;
+    bool mVerticalCollision;
+    bool mCollision;
+    bool mIgnoreLighting;
+    bool mFilterLighting;
+    mce::Color mTintColor;
+    mce::Color mTintColor2;
+    float mStepSoundVolume;
+    float mStepSoundPitch;
+    AABB* mLastHitBB;
+    std::vector<AABB> mSubBBs;
+    float mTerrainSurfaceOffset;
+    float mHeightOffset;
+    float mExplosionOffset;
+    float mShadowOffset;
+    float mMaxAutoStep;
+    float mPushthrough;
+    float mWalkDistPrev;
+    float mWalkDist;
+    float mMoveDist;
+    float mBlockMovementSlowdownMultiplier;
+    float mNextStep;
+    bool mImmobile;
+    bool mWasInWater;
+    bool mHasEnteredWater;
+    bool mHeadInWater;
+    bool mIsWet;
+    Vec2 mSlideOffset;
+    Vec3 mHeadOffset;
+    Vec3 mEyeOffset;
+    Vec3 mBreathingOffset;
+    Vec3 mMouthOffset;
+    Vec3 mDropOffset;
+    bool mFirstTick;
+    int mTickCount;
+    int mInvulnerableTime;
+    int mLastHealth;
+    bool mFallDamageImmune;
+    bool mHurtMarked;
+    bool mWasHurtLastFrame;
+    bool mInvulnerable;
+    int mOnFire;//636
+    int mFlameTexFrameIndex;
+    int mClientSideFireTransitionStartTick;
+    float mFlameFrameIncrementTime;
+    bool mOnHotBlock;
+    bool mClientSideFireTransitionLatch;
+    bool mAlwaysFireImmune;
+    int mPortalCooldown;
+    BlockPos mPortalBlockPos;
+    uint8_t mPortalEntranceAxis[4];
+    int mInsidePortalTime;
+    std::vector<ActorUniqueID> mRiderIDs;
+    std::vector<ActorUniqueID> mRiderIDsToRemove;
+    ActorUniqueID mRidingID;
+    ActorUniqueID mRidingPrevID;
+    ActorUniqueID mPushedByID;
+    bool mInheritRotationWhenRiding;
+    bool mRidersChanged;
+    bool mBlocksBuilding;
+    bool mUsesOneWayCollision;
+    bool mForcedLoading;
+    bool mPrevPosRotSetThisTick;
+    bool mTeleportedThisTick;
+    bool mForceSendMotionPacket;
+    float mSoundVolume;
+    int mShakeTime;
+    float mWalkAnimSpeedMultiplier;
+    float mWalkAnimSpeedO;
+    float mWalkAnimSpeed;
+    float mWalkAnimPos;
+    ActorUniqueID mLegacyUniqueID;
+    bool mHighlightedThisFrame;
+    bool mInitialized;
+    BlockSource* mRegion;
+    Dimension* mDimension;
+    Level* mLevel;//816
+    HashedString mActorRendererId;
+    HashedString mActorRendererIdThatAnimationComponentWasInitializedWith;
+    bool mChanged;
+    bool mRemoved;
+    bool mGlobal;
+    bool mAutonomous;
+    ActorType mActorType;
+    ActorDefinitionIdentifier mActorIdentifier;
+    std::unique_ptr<BaseAttributeMap> mAttributes;
+    std::unique_ptr<EconomyTradeableComponent> mEconomyTradeableComponent;
+    std::shared_ptr<AnimationComponent> mAnimationComponent;
+    AABBShapeComponent mAABBComponent;
+    StateVectorComponent mStateVectorComponent;
+    ActorUniqueID mTargetId;
+    float mRestrictRadius;
+    BlockPos mRestrictCenter;
+    ActorUniqueID mInLovePartner;
+    std::vector<MobEffectInstance> mMobEffects;
+    bool mEffectsDirty;
+    bool mLootDropped;
+    bool mPersistingTrade;
+    std::unique_ptr<CompoundTag> mPersistingTradeOffers;
+    int mPersistingTradeRiches;
+    ActorRuntimeID mRuntimeID;
+    mce::Color mHurtColor;
+    std::unique_ptr<ActorDefinitionDiffList> mDefinitionList;
+    bool mIsMovedByScript;
+    bool mHasLimitedLife;
+    int mLimitedLifeTicks;
+    int mForceVisibleTimerTicks;
+    float mRidingExitDistance;
+    std::string mFilteredNameTag;
+    bool mIsSafeToSleepNear;
+    bool mIsStuckItem;
+    ActorTerrainInterlockData mTerrainInterlockData;
+    float mArmorDropChance[4];
+    float mHandDropChance[2];
+    std::unique_ptr<SimpleContainer> mArmor;//1400
+    std::unique_ptr<SimpleContainer> mHand;
+    bool mIsKnockedBackOnDeath;
+    std::vector<AABB> mOnewayPhysicsBlocks;
+    bool mStuckInCollider;
+    bool mPenetratingLastFrame;
+    bool mCollidableMobNear;
+    bool mCollidableMob;
+    bool mCanPickupItems;
+    bool mChainedDamageEffects;
+    bool mWasInBubbleColumn;
+    bool mWasInWallLastTick;
+    int mTicksInWall;
+    int mDamageNearbyMobsTick;
+    enum class SpawnRuleEnum : int {
+        Undefined = 0xFF,
+        NoSpawnRules = 0x0,
+        HasSpawnRules = 0x1,
+    } mSpawnRulesEnum;
+    std::unique_ptr<ActionQueue> mActionQueue;
+    MolangVariableMap mMolangVariables;
+    CompoundTag mCachedComponentData;
+    ActorUniqueID mFishingHookID;
 
 #define AFTER_EXTRA
 public:
-    enum InitializationMethod;
+//    enum InitializationMethod;
 
     LIAPI std::string getTypeName() const;
     LIAPI Vec3 getFeetPosition() const;
@@ -168,22 +428,26 @@ public:
         return getPosOld();
     }
     inline BlockSource const & getRegionConst() const{
-        return dAccess<BlockSource>(this,100);
+        // return dAccess<BlockSource>(this,100);
+        return *mRegion;
     };
     inline bool isMoving() const{
         return getStatusFlag(ActorFlags::MOVING);
     };
     inline bool hasCategory(enum ActorCategory actorCategory) const{
         // IDA Player::take Line123
-        return (dAccess<ActorCategory>(this, 316) & actorCategory) !=0;
+        // return (dAccess<ActorCategory>(this, 316) & actorCategory) !=0;
+        return mCategories != 0;
     };
     inline BlockSource & getRegion() {
-        //VanillaServerGameplayEventListener::onBlockPlacedByPlayer Line35
+        // VanillaServerGameplayEventListener::onBlockPlacedByPlayer Line35
-        return dAccess<BlockSource>(this,100);
+        // return dAccess<BlockSource>(this,100);
+        return *mRegion;
     };
     inline AABB const & getAABB() const{
         //FollowMobGoal::_setWantedMob Line52
-        return dAccess<AABB>(this,1112);
+        //return dAccess<AABB>(this,1112);
+        return mAABBComponent.mAABB;
     };
     inline bool isDancing(){
         return getStatusFlag(ActorFlags::DANCING);
@@ -192,13 +456,15 @@ public:
         return getTradingPlayer() != nullptr;
     };
 
-    Vec2 getRotation() const{
+    inline Vec2 getRotation() const{
         // Actor::getMapDecorationRotation
-        return dAccess<Vec2>(this, 65);
+        //return dAccess<Vec2>(this, 65);
+        return mRot;
     };
     ActorDefinitionIdentifier getActorIdentifier() const{
         //ServerPlayer::handleActorPickRequestOnServer Line144 1048-128-8 = 912;
-        return dAccess<ActorDefinitionIdentifier>(this, 912);
+        //return dAccess<ActorDefinitionIdentifier>(this, 912);
+        return mActorIdentifier;
     }
 
 #undef AFTER_EXTRA

LiteLoader/Header/MC/ActorDefinitionGroup.hpp

@@ -6,13 +6,38 @@
 #include "Json.hpp"
 
 #define BEFORE_EXTRA
-
+#include "ActorDefinition.hpp"
+#include "ResourcePackManager.hpp"
+#include "ActorDefinitionPtr.hpp"
+#include "ActorComponentFactory.hpp"
 #undef BEFORE_EXTRA
 
+class ActorEventResponseFactory {
+public:
+    class ActorEventResponseFactory& operator=(class ActorEventResponseFactory const &) = delete;
+    ActorEventResponseFactory(class ActorEventResponseFactory const &) = delete;
+    ActorEventResponseFactory() = delete;
+};
+
 class ActorDefinitionGroup {
 
 #define AFTER_EXTRA
+public:
+    struct LoadActorResult;
+    struct EDLWrapper {
+        std::unordered_map<std::string, std::unique_ptr<ActorDefinition>> mList;
+    };
 
+public:
+    void** __vftable /*VFT*/;
+    std::unordered_set<ActorDefinitionPtr*> mRegisteredPtrs;
+    std::unordered_map<std::string, std::unique_ptr<ActorDefinition>> mDefinitions;
+    std::unordered_map<std::string, ActorDefinitionGroup::EDLWrapper> mTemplateMap;
+    ResourcePackManager* mResourcePackManager;
+    std::mutex mReferenceMutex;
+    IMinecraftEventing* mEventing;
+    ActorComponentFactory* mComponentFactory;
+    std::unique_ptr<ActorEventResponseFactory> mResponseFactory;
 #undef AFTER_EXTRA
 #ifndef DISABLE_CONSTRUCTOR_PREVENTION_ACTORDEFINITIONGROUP
 public:

LiteLoader/Header/MC/ActorTerrainInterlockData.hpp

@@ -7,9 +7,19 @@
 
 #undef BEFORE_EXTRA
 
-class ActorTerrainInterlockData {
+class __declspec(align(8)) ActorTerrainInterlockData {
 
 #define AFTER_EXTRA
+public:
+    enum class VisibilityState : unsigned char {
+        InitialNotVisible = 0x0,
+        Visible = 0x1,
+        DelayedDestructionNotVisible = 0x2,
+    };
+
+    VisibilityState mRenderVisibilityState;
+    std::chrono::time_point<std::chrono::steady_clock, std::chrono::duration<__int64, std::ratio<1, 1000000000>>> mCreationTime;
+    bool mHasBeenDelayedDeleted;
 
 #undef AFTER_EXTRA
 #ifndef DISABLE_CONSTRUCTOR_PREVENTION_ACTORTERRAININTERLOCKDATA

LiteLoader/Header/MC/AnimatePacket.hpp

@@ -11,7 +11,20 @@
 class AnimatePacket : public Packet {
 
 #define AFTER_EXTRA
-
+public:
+    enum Action
+    {
+        NoAction = 0,
+        Swing = 1,
+        WakeUp = 3,
+        CriticalHit = 4,
+        // MagicCriticalHit=5,
+        RowRight = 128,
+        RowLeft = 129,
+    };
+    ActorRuntimeID mRuntimeId;
+    Action mAction;
+    float mData;
 #undef AFTER_EXTRA
 #ifndef DISABLE_CONSTRUCTOR_PREVENTION_ANIMATEPACKET
 public:

LiteLoader/Header/MC/BlockInstance.hpp

@@ -26,7 +26,7 @@ public:
     LIAPI BlockSource* getBlockSource();
     LIAPI int getDimensionId();
 
-    //LIAPI bool hasBlockEntity();
+    LIAPI bool hasBlockEntity();
     LIAPI BlockActor* getBlockEntity();
     LIAPI bool hasContainer();
     LIAPI Container* getContainer();

LiteLoader/Header/MC/ChunkPos.hpp

@@ -12,6 +12,7 @@ class ChunkPos {
 #define AFTER_EXTRA
     // Add Member There
 public:
+    __int64 packed;
     int       x, z;
     long long hash() {
         return *((long long*)this);

LiteLoader/Header/MC/DataItem.hpp

@@ -5,12 +5,186 @@
 
 #define BEFORE_EXTRA
 
+enum class ActorDataIDs : unsigned short {
+    FLAGS = 0,                      // Int64
+    HEALTH = 1,                     // Int
+    VARIANT = 2,                    // Int
+    COLOR = 3,                      // Byte
+    NAMETAG = 4,                    // String
+    OWNER = 5,                      // Int64
+    TARGET = 6,                     // Int64
+    AIR = 7,                        // Short
+    POTION_COLOR = 8,               // Int (ARGB!)
+    POTION_AMBIENT = 9,             // Byte
+    JUMP_DURATION = 10,             // Byte (not Int64?)
+    HURT_TIME = 11,                 // Int (minecart/boat)
+    HURT_DIRECTION = 12,            // Int (minecart/boat)
+    PADDLE_TIME_LEFT = 13,          // Float
+    PADDLE_TIME_RIGHT = 14,         // Float
+    EXPERIENCE_VALUE = 15,          // Int (xp orb)
+    DISPLAY_ITEM = 16,              // Byte    Int    CompoundTag
+    HORSE_FLAGS = 16,               // Int, old
+    WITHER_SKULL_IS_DANGEROUS = 16, // Byte, old
+    MINECART_DISPLAY_OFFSET = 17,   // Int    Int64    Vec3
+    ARROW_SHOOTER_ID = 17,          // Int64, old
+    MINECART_HAS_DISPLAY = 18,      // Byte    Int64
+    HORSE_TYPE = 19,                // Byte
+    SWELL = 19,                     // old
+    OLD_SWELL = 20,                 // old
+    SWELL_DIR = 21,                 // old
+    CHARGE_AMOUNT = 22,             // Byte
+    ENDERMAN_HELD_RUNTIME_ID = 23,  // Int, (not Short?)
+    ACTOR_AGE = 24,                 // Byte, (not Short?)
+    // UNKNOWN_25                          = 25,  // 25 Byte Int
+    PLAYER_FLAGS = 26,                       // Byte
+    PLAYER_INDEX = 27,                       // Int
+    PLAYER_BED_POSITION = 28,                // BlockPos
+    FIREBALL_POWER_X = 29,                   // Float
+    FIREBALL_POWER_Y = 30,                   // Float
+    FIREBALL_POWER_Z = 31,                   // Float
+    AUX_POWER = 32,                          // old
+    FISH_X = 33,                             // old
+    FISH_Z = 34,                             // old
+    FISH_ANGLE = 35,                         // old
+    POTION_AUX_VALUE = 36,                   // Short
+    LEAD_HOLDER = 37,                        // Int64
+    SCALE = 38,                              // Float
+    INTERACTIVE_TAG = 39,                    // Byte, (not String?)
+    NPC_SKIN_ID = 40,                        // String
+    URL_TAG = 41,                            // String
+    MAX_AIR = 42,                            // Short
+    MARK_VARIANT = 43,                       // Int
+    CONTAINER_TYPE = 44,                     // Byte
+    CONTAINER_BASE_SIZE = 45,                // Int
+    CONTAINER_EXTRA_SLOTS_PER_STRENGTH = 46, // Int
+    BLOCK_TARGET = 47,                       // BlockPos (ENDER CRYSTAL)
+    WITHER_INVULNERABLE_TICKS = 48,          // Int
+    WITHER_TARGET_1 = 49,                    // Int64
+    WITHER_TARGET_2 = 50,                    // Int64
+    WITHER_TARGET_3 = 51,                    // Int64
+    AERIAL_ATTACK = 52,                      // Short
+    BOUNDING_BOX_WIDTH = 53,                 // Float
+    BOUNDING_BOX_HEIGHT = 54,                // Float
+    FUSE_LENGTH = 55,                        // Int
+    RIDER_SEAT_POSITION = 56,                // Vec3
+    RIDER_ROTATION_LOCKED = 57,              // Byte
+    RIDER_MAX_ROTATION = 58,                 // Float
+    RIDER_MIN_ROTATION = 59,                 // Byte, (not Float?)
+    // UNKNOWN_60                          = 60,  // Float
+    AREA_EFFECT_CLOUD_RADIUS = 61,      // Float
+    AREA_EFFECT_CLOUD_WAITING = 62,     // Int
+    AREA_EFFECT_CLOUD_PARTICLE_ID = 63, // Int
+    SHULKER_PEEK_ID = 64,               // Int
+    SHULKER_ATTACH_FACE = 65,           // Byte
+    SHULKER_ATTACHED = 66,              // Short
+    SHULKER_ATTACH_POS = 67,            // BlockPos
+    TRADING_PLAYER_EID = 68,            // Int64
+    TRADING_CAREER = 69,
+    HAS_COMMAND_BLOCK = 70,             // Byte
+    COMMAND_BLOCK_COMMAND = 71,         // String
+    COMMAND_BLOCK_LAST_OUTPUT = 72,     // String
+    COMMAND_BLOCK_TRACK_OUTPUT = 73,    // Byte
+    CONTROLLING_RIDER_SEAT_NUMBER = 74, // Byte
+    STRENGTH = 75,                      // Int
+    MAX_STRENGTH = 76,                  // Int
+    SPELL_CASTING_COLOR = 77,           // Int
+    LIMITED_LIFE = 78,                  // Int
+    ARMOR_STAND_POSE_INDEX = 79,        // Int
+    ENDER_CRYSTAL_TIME_OFFSET = 80,     // Int
+    ALWAYS_SHOW_NAMETAG = 81,           // Byte
+    COLOR_2 = 82,                       // Byte
+    NAME_AUTHOR = 83,
+    SCORE_TAG = 84,               // String
+    BALLOON_ATTACHED_ENTITY = 85, // Int64
+    PUFFERFISH_SIZE = 86,         // Byte
+    BUBBLE_TIME = 87,
+    AGENT = 88,                   // Int64
+    SITTING_AMOUNT = 89,          // Float
+    SITTING_AMOUNT_PREVIOUS = 90, // Float
+    EATING_COUNTER = 91,          // Int
+    FLAGS_EXTENDED = 92,          // Int64
+    LAYING_AMOUNT = 93,           // Float
+    LAYING_AMOUNT_PREVIOUS = 94,  // Float
+    DURATION = 95,
+    SPAWN_TIME = 96,
+    CHANGE_RATE = 97,
+    CHANGE_ON_PICKUP = 98,
+    PICKUP_COUNT = 99,
+    INTERACT_TEXT = 100,                       // String
+    TRADE_TIER = 101,                          // Int
+    MAX_TRADE_TIER = 102,                      // Int
+    TRADE_EXPERIENCE = 103,                    // Int
+    SKIN_ID = 104,                             // Int
+    SPAWNING_FRAMES = 105,                     // Int
+    COMMAND_BLOCK_TICK_DELAY = 106,            // Int
+    COMMAND_BLOCK_EXECUTE_ON_FIRST_TICK = 107, // Byte
+    AMBIENT_SOUND_INTERVAL = 108,              // Float
+    // UNKNOWN_109                         = 109, // Float
+    // UNKNOWN_110                         = 110, // String
+    // UNKNOWN_111                         = 111, // Float
+    // UNKNOWN_112                         = 112, // String
+    // UNKNOWN_113                         = 113, // Byte
+    // UNKNOWN_114                         = 114, // Int
+    // UNKNOWN_115                         = 115, // Int
+    // UNKNOWN_116                         = 116, // Int
+    // UNKNOWN_117                         = 117, // Int
+    // UNKNOWN_118                         = 118, // CompoundTag
+    // UNKNOWN_119                         = 119, // Byte
+    // UNKNOWN_120                         = 120, // CompoundTag
+    // UNKNOWN_121                         = 121, // Float
+    // UNKNOWN_122                         = 122, // String
+    // UNKNOWN_123                         = 123, // Int
+    // UNKNOWN_124                         = 124, // String
+
+    /*
+    AMBIENT_SOUND_EVENT_NAME            = 109,
+    FALL_DAMAGE_MULTIPLIER              = 110,
+    NAME_RAW_TEXT                       = 111,
+    CAN_RIDE_TARGET                     = 112,
+    */
+};
+
+enum class DataItemType : unsigned char {
+    Byte = 0,
+    Short = 1,
+    Int = 2,
+    Float = 3,
+    String = 4,
+    CompoundTag = 5,
+    BlockPos = 6,
+    Int64 = 7,
+    Vec3 = 8,
+};
+
 #undef BEFORE_EXTRA
 
 class DataItem {
 
 #define AFTER_EXTRA
 
+public:
+    DataItemType mType; // 8
+    unsigned short mId; // 10
+    bool mDirty = true; // 12
+
+    template <typename T>
+    inline T const& getData() const;
+    template <typename T>
+    inline T& getData();
+    template <typename T>
+    inline bool setData(T const& value);
+
+    DataItem(DataItemType type, unsigned short id)
+            : mId(id)
+            , mType(type) {
+    }
+
+    template <typename T>
+    inline static std::unique_ptr<DataItem> create(unsigned short key, T const& value);
+
+    template <typename T>
+    inline static std::unique_ptr<DataItem> create(ActorDataIDs key, T const& value);
+
 #undef AFTER_EXTRA
 #ifndef DISABLE_CONSTRUCTOR_PREVENTION_DATAITEM
 public:

LiteLoader/Header/MC/HashedString.hpp

@@ -10,9 +10,13 @@
 class HashedString {
 
 #define AFTER_EXTRA
-public: 
+public:
+    unsigned __int64 mStrHash;
+    std::string mStr;
+//    const HashedString* mLastMatch;
     inline std::string const & getString()const{
-        return dAccess<std::string>(this, 8);
+//        return dAccess<std::string>(this, 8);
+        return mStr;
     };
 
 #undef AFTER_EXTRA

LiteLoader/Header/MC/ItemStackBase.hpp

@@ -33,10 +33,13 @@ private:
     std::unique_ptr<ItemInstance> mChargedItem;
 
 public:
-LIAPI int getCount() const;
+    LIAPI int getCount() const;
-inline void setAuxValue(short a1){
+    inline void setAuxValue(short a1){
-    this->mAuxValue = a1;
+        this->mAuxValue = a1;
-};
+    };
+    inline Block const * getBlock() const{
+        return this->mBlock;
+    };
 
 #undef AFTER_EXTRA
 public:

LiteLoader/Header/MC/MolangVariableMap.hpp

@@ -10,6 +10,12 @@
 class MolangVariableMap {
 
 #define AFTER_EXTRA
+public:
+    std::vector<short> mMapFromVariableIndexToVariableArrayOffset;
+    std::vector<std::unique_ptr<class MolangVariable>> mVariables;
+    bool mHasPublicVariables;
+    bool mHasVariablesThatShouldSync;
+    bool mHasVariablesThatShouldSave;
 
 #undef AFTER_EXTRA
 #ifndef DISABLE_CONSTRUCTOR_PREVENTION_MOLANGVARIABLEMAP

LiteLoader/Header/MC/OwnerStorageEntity.hpp

@@ -7,10 +7,46 @@
 
 #undef BEFORE_EXTRA
 
+using EntityId = unsigned int;
+
+template <typename T>
+struct EnableGetWeakRef {
+};
+
+struct EntityRefTraits {
+};
+
+struct  __declspec(align(8)) EntityRegistryBase {
+    struct ICanModifyComponentPoolDuringView {
+    };
+
+public:
+    entt::basic_registry<EntityId>* mRegistry;
+    EntityId mViewedEntity;
+    std::unique_ptr<EntityRegistryBase::ICanModifyComponentPoolDuringView> mCanModifyDuringView;
+    bool mViewUsesViewedContext;
+
+};
+
+
+struct __declspec(align(8)) EntityContextBase {
+    EntityRegistryBase* mRegistry;
+    const EntityId mEntity;
+};
+
+struct EntityContext : EntityContextBase, EnableGetWeakRef<EntityRefTraits> {
+
+};
+
 class OwnerStorageEntity {
 
 #define AFTER_EXTRA
+    struct EntityContextOwned : EntityContext {
 
+    };
+
+private:
+    std::optional<OwnerStorageEntity::EntityContextOwned> mContext;
 #undef AFTER_EXTRA
 #ifndef DISABLE_CONSTRUCTOR_PREVENTION_OWNERSTORAGEENTITY
 public:

LiteLoader/Header/MC/SynchedActorData.hpp

@@ -4,13 +4,147 @@
 #include "../Global.h"
 
 #define BEFORE_EXTRA
+#include "DataItem.hpp"
+#define ACTOR_DATA_KEY_VALUE(key) constexpr int16_t key = (unsigned short)ActorDataIDs::key
+namespace ActorDataKeys {
+ACTOR_DATA_KEY_VALUE(FLAGS);                     // Int64
+ACTOR_DATA_KEY_VALUE(HEALTH);                    // Int (minecart/boat)
+ACTOR_DATA_KEY_VALUE(VARIANT);                   // Int
+ACTOR_DATA_KEY_VALUE(COLOR);                     // Byte
+ACTOR_DATA_KEY_VALUE(NAMETAG);                   // String
+ACTOR_DATA_KEY_VALUE(OWNER);                     // Int64
+ACTOR_DATA_KEY_VALUE(TARGET);                    // Int64
+ACTOR_DATA_KEY_VALUE(AIR);                       // Short
+ACTOR_DATA_KEY_VALUE(POTION_COLOR);              // Int (ARGB!)
+ACTOR_DATA_KEY_VALUE(POTION_AMBIENT);            // Byte
+ACTOR_DATA_KEY_VALUE(JUMP_DURATION);             // Int64
+ACTOR_DATA_KEY_VALUE(HURT_TIME);                 // Int (minecart/boat)
+ACTOR_DATA_KEY_VALUE(HURT_DIRECTION);            // Int (minecart/boat)
+ACTOR_DATA_KEY_VALUE(PADDLE_TIME_LEFT);          // Float
+ACTOR_DATA_KEY_VALUE(PADDLE_TIME_RIGHT);         // Float
+ACTOR_DATA_KEY_VALUE(EXPERIENCE_VALUE);          // Int (xp orb)
+ACTOR_DATA_KEY_VALUE(DISPLAY_ITEM);              // Int (id | (data << 16))
+ACTOR_DATA_KEY_VALUE(HORSE_FLAGS);               // Int
+ACTOR_DATA_KEY_VALUE(WITHER_SKULL_IS_DANGEROUS); // Byte
+ACTOR_DATA_KEY_VALUE(MINECART_DISPLAY_OFFSET);   // Int
+ACTOR_DATA_KEY_VALUE(ARROW_SHOOTER_ID);          // Int64
+ACTOR_DATA_KEY_VALUE(MINECART_HAS_DISPLAY);      // Byte (must be 1 for minecart to show block inside)
+ACTOR_DATA_KEY_VALUE(HORSE_TYPE);
+ACTOR_DATA_KEY_VALUE(SWELL);
+ACTOR_DATA_KEY_VALUE(OLD_SWELL);
+ACTOR_DATA_KEY_VALUE(SWELL_DIR);
+ACTOR_DATA_KEY_VALUE(CHARGE_AMOUNT);
+ACTOR_DATA_KEY_VALUE(ENDERMAN_HELD_RUNTIME_ID); // Short
+ACTOR_DATA_KEY_VALUE(ACTOR_AGE);                // Short
+ACTOR_DATA_KEY_VALUE(PLAYER_FLAGS);             // Byte
+ACTOR_DATA_KEY_VALUE(PLAYER_INDEX);
+ACTOR_DATA_KEY_VALUE(PLAYER_BED_POSITION); // BlockPos
+ACTOR_DATA_KEY_VALUE(FIREBALL_POWER_X);    // Float
+ACTOR_DATA_KEY_VALUE(FIREBALL_POWER_Y);    // Float
+ACTOR_DATA_KEY_VALUE(FIREBALL_POWER_Z);    // Float
+ACTOR_DATA_KEY_VALUE(AUX_POWER);
+ACTOR_DATA_KEY_VALUE(FISH_X);
+ACTOR_DATA_KEY_VALUE(FISH_Z);
+ACTOR_DATA_KEY_VALUE(FISH_ANGLE);
+ACTOR_DATA_KEY_VALUE(POTION_AUX_VALUE);                   // Short
+ACTOR_DATA_KEY_VALUE(LEAD_HOLDER);                        // Int64
+ACTOR_DATA_KEY_VALUE(SCALE);                              // Float
+ACTOR_DATA_KEY_VALUE(INTERACTIVE_TAG);                    // String
+ACTOR_DATA_KEY_VALUE(NPC_SKIN_ID);                        // String
+ACTOR_DATA_KEY_VALUE(URL_TAG);                            // String
+ACTOR_DATA_KEY_VALUE(MAX_AIR);                            // Short
+ACTOR_DATA_KEY_VALUE(MARK_VARIANT);                       // Int
+ACTOR_DATA_KEY_VALUE(CONTAINER_TYPE);                     // Byte
+ACTOR_DATA_KEY_VALUE(CONTAINER_BASE_SIZE);                // Int
+ACTOR_DATA_KEY_VALUE(CONTAINER_EXTRA_SLOTS_PER_STRENGTH); // Int
+ACTOR_DATA_KEY_VALUE(BLOCK_TARGET);                       // BlockPos (ENDER CRYSTAL)
+ACTOR_DATA_KEY_VALUE(WITHER_INVULNERABLE_TICKS);          // Int
+ACTOR_DATA_KEY_VALUE(WITHER_TARGET_1);                    // Int64
+ACTOR_DATA_KEY_VALUE(WITHER_TARGET_2);                    // Int64
+ACTOR_DATA_KEY_VALUE(WITHER_TARGET_3);                    // Int64
+ACTOR_DATA_KEY_VALUE(AERIAL_ATTACK);
+ACTOR_DATA_KEY_VALUE(BOUNDING_BOX_WIDTH);            // Float
+ACTOR_DATA_KEY_VALUE(BOUNDING_BOX_HEIGHT);           // Float
+ACTOR_DATA_KEY_VALUE(FUSE_LENGTH);                   // Int
+ACTOR_DATA_KEY_VALUE(RIDER_SEAT_POSITION);           // Vec3
+ACTOR_DATA_KEY_VALUE(RIDER_ROTATION_LOCKED);         // Byte
+ACTOR_DATA_KEY_VALUE(RIDER_MAX_ROTATION);            // Float
+ACTOR_DATA_KEY_VALUE(RIDER_MIN_ROTATION);            // Float
+ACTOR_DATA_KEY_VALUE(AREA_EFFECT_CLOUD_RADIUS);      // Float
+ACTOR_DATA_KEY_VALUE(AREA_EFFECT_CLOUD_WAITING);     // Int
+ACTOR_DATA_KEY_VALUE(AREA_EFFECT_CLOUD_PARTICLE_ID); // Int
+ACTOR_DATA_KEY_VALUE(SHULKER_PEEK_ID);               // Int
+ACTOR_DATA_KEY_VALUE(SHULKER_ATTACH_FACE);           // Byte
+ACTOR_DATA_KEY_VALUE(SHULKER_ATTACHED);              // Short
+ACTOR_DATA_KEY_VALUE(SHULKER_ATTACH_POS);            // BlockPos
+ACTOR_DATA_KEY_VALUE(TRADING_PLAYER_EID);            // Int64
+ACTOR_DATA_KEY_VALUE(TRADING_CAREER);
+ACTOR_DATA_KEY_VALUE(HAS_COMMAND_BLOCK);
+ACTOR_DATA_KEY_VALUE(COMMAND_BLOCK_COMMAND);         // String
+ACTOR_DATA_KEY_VALUE(COMMAND_BLOCK_LAST_OUTPUT);     // String
+ACTOR_DATA_KEY_VALUE(COMMAND_BLOCK_TRACK_OUTPUT);    // Byte
+ACTOR_DATA_KEY_VALUE(CONTROLLING_RIDER_SEAT_NUMBER); // Byte
+ACTOR_DATA_KEY_VALUE(STRENGTH);                      // Int
+ACTOR_DATA_KEY_VALUE(MAX_STRENGTH);                  // Int
+ACTOR_DATA_KEY_VALUE(SPELL_CASTING_COLOR);           // Int
+ACTOR_DATA_KEY_VALUE(LIMITED_LIFE);
+ACTOR_DATA_KEY_VALUE(ARMOR_STAND_POSE_INDEX);    // Int
+ACTOR_DATA_KEY_VALUE(ENDER_CRYSTAL_TIME_OFFSET); // Int
+ACTOR_DATA_KEY_VALUE(ALWAYS_SHOW_NAMETAG);       // Byte
+ACTOR_DATA_KEY_VALUE(COLOR_2);                   // Byte
+ACTOR_DATA_KEY_VALUE(NAME_AUTHOR);
+ACTOR_DATA_KEY_VALUE(SCORE_TAG);               // String
+ACTOR_DATA_KEY_VALUE(BALLOON_ATTACHED_ENTITY); // Int64
+ACTOR_DATA_KEY_VALUE(PUFFERFISH_SIZE);
+ACTOR_DATA_KEY_VALUE(BUBBLE_TIME);
+ACTOR_DATA_KEY_VALUE(AGENT);
+ACTOR_DATA_KEY_VALUE(SITTING_AMOUNT);
+ACTOR_DATA_KEY_VALUE(SITTING_AMOUNT_PREVIOUS);
+ACTOR_DATA_KEY_VALUE(EATING_COUNTER);
+ACTOR_DATA_KEY_VALUE(FLAGS_EXTENDED);
+ACTOR_DATA_KEY_VALUE(LAYING_AMOUNT);
+ACTOR_DATA_KEY_VALUE(LAYING_AMOUNT_PREVIOUS);
+ACTOR_DATA_KEY_VALUE(DURATION);
+ACTOR_DATA_KEY_VALUE(SPAWN_TIME);
+ACTOR_DATA_KEY_VALUE(CHANGE_RATE);
+ACTOR_DATA_KEY_VALUE(CHANGE_ON_PICKUP);
+ACTOR_DATA_KEY_VALUE(PICKUP_COUNT);
+ACTOR_DATA_KEY_VALUE(INTERACT_TEXT);
+ACTOR_DATA_KEY_VALUE(TRADE_TIER);
+ACTOR_DATA_KEY_VALUE(MAX_TRADE_TIER);
+ACTOR_DATA_KEY_VALUE(TRADE_EXPERIENCE);
+ACTOR_DATA_KEY_VALUE(SKIN_ID); // Int
+ACTOR_DATA_KEY_VALUE(SPAWNING_FRAMES);
+ACTOR_DATA_KEY_VALUE(COMMAND_BLOCK_TICK_DELAY);
+ACTOR_DATA_KEY_VALUE(COMMAND_BLOCK_EXECUTE_ON_FIRST_TICK);
+ACTOR_DATA_KEY_VALUE(AMBIENT_SOUND_INTERVAL);
+/*
+ACTOR_DATA_KEY_VALUE(AMBIENT_SOUND_EVENT_NAME);
+ACTOR_DATA_KEY_VALUE(FALL_DAMAGE_MULTIPLIER);
+ACTOR_DATA_KEY_VALUE(NAME_RAW_TEXT);
+ACTOR_DATA_KEY_VALUE(CAN_RIDE_TARGET);
+*/
+} // namespace ActorDataKeys
 
 #undef BEFORE_EXTRA
 
 class SynchedActorData {
 
 #define AFTER_EXTRA
-
+    // Add Member Therepublic:
+    // using DataList = std::vector<std::unique_ptr<DataItem>>;
+    std::vector<std::unique_ptr<DataItem>> mItemsArray; // 0
+//private:
+//    unsigned short mMinDirtyId; // 24
+//    unsigned short mMaxDirtyId; // 26
+public:
+    template <typename T>
+    MCAPI void define(unsigned short, T const&);
+    template <typename T>
+    MCAPI void set(unsigned short, T const&);
+    inline std::vector<std::unique_ptr<DataItem>>& getItemArray() {
+        return mItemsArray;
+    }
 #undef AFTER_EXTRA
 #ifndef DISABLE_CONSTRUCTOR_PREVENTION_SYNCHEDACTORDATA
 public: