diff --git a/LiteLoader/Header/MC/AABB.hpp b/LiteLoader/Header/MC/AABB.hpp index 3aba9b4..81ec27c 100644 --- a/LiteLoader/Header/MC/AABB.hpp +++ b/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]; diff --git a/LiteLoader/Header/MC/Actor.hpp b/LiteLoader/Header/MC/Actor.hpp index d0370cc..85a6177 100644 --- a/LiteLoader/Header/MC/Actor.hpp +++ b/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 +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 mQueue; +}; #undef BEFORE_EXTRA class Actor { +public: + OwnerPtrT 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 mDimensionId; + bool mAdded; + ActorDefinitionGroup* mDefinitions; + std::unique_ptr mCurrentDescription; + ActorUniqueID mUniqueID; + std::shared_ptr 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 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 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 mRiderIDs; + std::vector 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 mAttributes; + std::unique_ptr mEconomyTradeableComponent; + std::shared_ptr mAnimationComponent; + AABBShapeComponent mAABBComponent; + StateVectorComponent mStateVectorComponent; + ActorUniqueID mTargetId; + float mRestrictRadius; + BlockPos mRestrictCenter; + ActorUniqueID mInLovePartner; + std::vector mMobEffects; + bool mEffectsDirty; + bool mLootDropped; + bool mPersistingTrade; + std::unique_ptr mPersistingTradeOffers; + int mPersistingTradeRiches; + ActorRuntimeID mRuntimeID; + mce::Color mHurtColor; + std::unique_ptr 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 mArmor;//1400 + std::unique_ptr mHand; + bool mIsKnockedBackOnDeath; + std::vector 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 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(this,100); + // return dAccess(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(this, 316) & actorCategory) !=0; + // return (dAccess(this, 316) & actorCategory) !=0; + return mCategories != 0; }; inline BlockSource & getRegion() { - //VanillaServerGameplayEventListener::onBlockPlacedByPlayer Line35 - return dAccess(this,100); + // VanillaServerGameplayEventListener::onBlockPlacedByPlayer Line35 + // return dAccess(this,100); + return *mRegion; }; inline AABB const & getAABB() const{ //FollowMobGoal::_setWantedMob Line52 - return dAccess(this,1112); + //return dAccess(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(this, 65); + //return dAccess(this, 65); + return mRot; }; ActorDefinitionIdentifier getActorIdentifier() const{ //ServerPlayer::handleActorPickRequestOnServer Line144 1048-128-8 = 912; - return dAccess(this, 912); + //return dAccess(this, 912); + return mActorIdentifier; } #undef AFTER_EXTRA diff --git a/LiteLoader/Header/MC/ActorDefinitionGroup.hpp b/LiteLoader/Header/MC/ActorDefinitionGroup.hpp index a49ef5f..55d6e23 100644 --- a/LiteLoader/Header/MC/ActorDefinitionGroup.hpp +++ b/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> mList; + }; +public: + void** __vftable /*VFT*/; + std::unordered_set mRegisteredPtrs; + std::unordered_map> mDefinitions; + std::unordered_map mTemplateMap; + ResourcePackManager* mResourcePackManager; + std::mutex mReferenceMutex; + IMinecraftEventing* mEventing; + ActorComponentFactory* mComponentFactory; + std::unique_ptr mResponseFactory; #undef AFTER_EXTRA #ifndef DISABLE_CONSTRUCTOR_PREVENTION_ACTORDEFINITIONGROUP public: diff --git a/LiteLoader/Header/MC/ActorTerrainInterlockData.hpp b/LiteLoader/Header/MC/ActorTerrainInterlockData.hpp index 21634ca..9603da6 100644 --- a/LiteLoader/Header/MC/ActorTerrainInterlockData.hpp +++ b/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>> mCreationTime; + bool mHasBeenDelayedDeleted; #undef AFTER_EXTRA #ifndef DISABLE_CONSTRUCTOR_PREVENTION_ACTORTERRAININTERLOCKDATA diff --git a/LiteLoader/Header/MC/AnimatePacket.hpp b/LiteLoader/Header/MC/AnimatePacket.hpp index 4a61630..44e8ab9 100644 --- a/LiteLoader/Header/MC/AnimatePacket.hpp +++ b/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: diff --git a/LiteLoader/Header/MC/BlockInstance.hpp b/LiteLoader/Header/MC/BlockInstance.hpp index d1de390..e572e3c 100644 --- a/LiteLoader/Header/MC/BlockInstance.hpp +++ b/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(); diff --git a/LiteLoader/Header/MC/ChunkPos.hpp b/LiteLoader/Header/MC/ChunkPos.hpp index c881757..9288238 100644 --- a/LiteLoader/Header/MC/ChunkPos.hpp +++ b/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); diff --git a/LiteLoader/Header/MC/DataItem.hpp b/LiteLoader/Header/MC/DataItem.hpp index 7df286b..972b618 100644 --- a/LiteLoader/Header/MC/DataItem.hpp +++ b/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 + inline T const& getData() const; + template + inline T& getData(); + template + inline bool setData(T const& value); + + DataItem(DataItemType type, unsigned short id) + : mId(id) + , mType(type) { + } + + template + inline static std::unique_ptr create(unsigned short key, T const& value); + + template + inline static std::unique_ptr create(ActorDataIDs key, T const& value); + #undef AFTER_EXTRA #ifndef DISABLE_CONSTRUCTOR_PREVENTION_DATAITEM public: diff --git a/LiteLoader/Header/MC/HashedString.hpp b/LiteLoader/Header/MC/HashedString.hpp index 24ba0d1..b0029aa 100644 --- a/LiteLoader/Header/MC/HashedString.hpp +++ b/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(this, 8); +// return dAccess(this, 8); + return mStr; }; #undef AFTER_EXTRA diff --git a/LiteLoader/Header/MC/ItemStackBase.hpp b/LiteLoader/Header/MC/ItemStackBase.hpp index a085881..93e071f 100644 --- a/LiteLoader/Header/MC/ItemStackBase.hpp +++ b/LiteLoader/Header/MC/ItemStackBase.hpp @@ -33,10 +33,13 @@ private: std::unique_ptr mChargedItem; public: -LIAPI int getCount() const; -inline void setAuxValue(short a1){ - this->mAuxValue = a1; -}; + LIAPI int getCount() const; + inline void setAuxValue(short a1){ + this->mAuxValue = a1; + }; + inline Block const * getBlock() const{ + return this->mBlock; + }; #undef AFTER_EXTRA public: diff --git a/LiteLoader/Header/MC/MolangVariableMap.hpp b/LiteLoader/Header/MC/MolangVariableMap.hpp index a9e3a47..077db2d 100644 --- a/LiteLoader/Header/MC/MolangVariableMap.hpp +++ b/LiteLoader/Header/MC/MolangVariableMap.hpp @@ -10,6 +10,12 @@ class MolangVariableMap { #define AFTER_EXTRA +public: + std::vector mMapFromVariableIndexToVariableArrayOffset; + std::vector> mVariables; + bool mHasPublicVariables; + bool mHasVariablesThatShouldSync; + bool mHasVariablesThatShouldSave; #undef AFTER_EXTRA #ifndef DISABLE_CONSTRUCTOR_PREVENTION_MOLANGVARIABLEMAP diff --git a/LiteLoader/Header/MC/OwnerStorageEntity.hpp b/LiteLoader/Header/MC/OwnerStorageEntity.hpp index e475860..cfa41ee 100644 --- a/LiteLoader/Header/MC/OwnerStorageEntity.hpp +++ b/LiteLoader/Header/MC/OwnerStorageEntity.hpp @@ -7,10 +7,46 @@ #undef BEFORE_EXTRA +using EntityId = unsigned int; + +template +struct EnableGetWeakRef { +}; + +struct EntityRefTraits { +}; + +struct __declspec(align(8)) EntityRegistryBase { + struct ICanModifyComponentPoolDuringView { + }; + +public: + entt::basic_registry* mRegistry; + EntityId mViewedEntity; + std::unique_ptr mCanModifyDuringView; + bool mViewUsesViewedContext; + +}; + + +struct __declspec(align(8)) EntityContextBase { + EntityRegistryBase* mRegistry; + const EntityId mEntity; +}; + +struct EntityContext : EntityContextBase, EnableGetWeakRef { + +}; + class OwnerStorageEntity { #define AFTER_EXTRA + struct EntityContextOwned : EntityContext { + }; + +private: + std::optional mContext; #undef AFTER_EXTRA #ifndef DISABLE_CONSTRUCTOR_PREVENTION_OWNERSTORAGEENTITY public: diff --git a/LiteLoader/Header/MC/SynchedActorData.hpp b/LiteLoader/Header/MC/SynchedActorData.hpp index 52870cf..52b35f9 100644 --- a/LiteLoader/Header/MC/SynchedActorData.hpp +++ b/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::vector> mItemsArray; // 0 +//private: +// unsigned short mMinDirtyId; // 24 +// unsigned short mMaxDirtyId; // 26 +public: + template + MCAPI void define(unsigned short, T const&); + template + MCAPI void set(unsigned short, T const&); + inline std::vector>& getItemArray() { + return mItemsArray; + } #undef AFTER_EXTRA #ifndef DISABLE_CONSTRUCTOR_PREVENTION_SYNCHEDACTORDATA public: